example/diameter/pcapDecoder/main.cpp

   1 // ANNA - Anna is Not Nothingness Anymore                                                         //
   2 //                                                                                                //
   3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
   4 //                                                                                                //
   5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
   6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
   7
   8
   9 #include <pcap.h>
  10 #include <stdlib.h>
  11 #include <netinet/ip.h>
  12 #include <arpa/inet.h>
  13 #include <iostream>
  14 #include <fstream>
  15
  16 // STL
  17 #include <string>
  18 #include <map>
  19
  20 #include <anna/core/DataBlock.hpp>
  21 #include <anna/core/functions.hpp>
  22 #include <anna/core/tracing/Logger.hpp>
  23 #include <anna/core/tracing/TraceWriter.hpp>
  24 #include <anna/core/RuntimeException.hpp>
  25
  26
  27 using namespace anna;
  28
  29 // Payload and frame metadata /////////////////////////////////////////////////////////////////////////////
  30 class Payload {
  31
  32   std::string _sourceIP;
  33   std::string _destinationIP;
  34   time_t _timestamp;
  35   int _timestampU; // usecs
  36   std::string _data;
  37   size_t _diameterLength;
  38
  39 public:
  40   Payload() {
  41     reset();
  42   }
  43
  44   void setDiameterLength(size_t dl) {
  45     if(_diameterLength == -1) {
  46       _diameterLength = dl;
  47       LOGDEBUG(
  48         Logger::debug(anna::functions::asString("Diameter message length: %d bytes", dl), ANNA_FILE_LOCATION));
  49     }
  50   }
  51
  52   void setSourceIP(const std::string &srcIP) throw() {
  53     _sourceIP = srcIP;
  54   }
  55   void setDestinationIP(const std::string &dstIP) throw() {
  56     _destinationIP = dstIP;
  57   }
  58   void setTimestamp(time_t ts) throw() {
  59     _timestamp = ts;
  60   }
  61   void setTimestampU(int tsu) throw() {
  62     _timestampU = tsu;
  63   }
  64   // Returns true if completed:
  65   bool appendData(const char *data, size_t size) throw(RuntimeException) {
  66     LOGDEBUG(
  67       Logger::debug(anna::functions::asString("Appending %d bytes", size), ANNA_FILE_LOCATION));
  68     _data.append(data, size);
  69
  70     if(_data.size() > _diameterLength)
  71       throw RuntimeException(
  72         "Data overflow (unexpected offset exceed diameter message length)",
  73         ANNA_FILE_LOCATION);
  74
  75     if(_data.size() < _diameterLength)
  76       return false;
  77
  78     LOGDEBUG(anna::Logger::debug("Completed!", ANNA_FILE_LOCATION));
  79     return true;
  80   }
  81
  82   void reset() throw() {
  83     _sourceIP = "";
  84     _destinationIP = "";
  85     _timestamp = 0;
  86     _timestampU = 0;
  87     _data = "";
  88     _diameterLength = -1; // not calculated yet
  89   }
  90
  91   const std::string &getSourceIP() const throw() {
  92     return _sourceIP;
  93   }
  94   const std::string &getDestinationIP() const throw() {
  95     return _destinationIP;
  96   }
  97   time_t getTimestamp() const throw() {
  98     return _timestamp;
  99   }
 100   int getTimestampU() const throw() {
 101     return _timestampU;
 102   }
 103   const std::string &getData() const throw() {
 104     return _data;
 105   }
 106   std::string getDataAsHex() const throw() {
 107     return anna::functions::asHexString(
 108              anna::DataBlock(_data.c_str(), _data.size()));
 109   }
 110 };
 111
 112 // Data maps //////////////////////////////////////////////////////////////////////////////////////////////
 113 typedef std::map < int /* frame */, Payload > payloads_t;
 114 typedef std::map < int /* frame */, Payload >::const_iterator payloads_it;
 115 payloads_t G_payloads;
 116
 117 // Sniffing structures ////////////////////////////////////////////////////////////////////////////////////
 118
 119 /* ethernet headers are always exactly 14 bytes */
 120 #define SIZE_ETHERNET 14
 121 /* Ethernet addresses are 6 bytes */
 122 #define ETHER_ADDR_LEN  6
 123
 124 /* Ethernet header */
 125 struct sniff_ethernet {
 126   u_char ether_dhost[ETHER_ADDR_LEN]; /* Destination host address */
 127   u_char ether_shost[ETHER_ADDR_LEN]; /* Source host address */
 128   u_short ether_type; /* IP? ARP? RARP? etc */
 129 };
 130
 131 /* IP header */
 132 struct sniff_ip {
 133   u_char ip_vhl; /* version << 4 | header length >> 2 */
 134   u_char ip_tos; /* type of service */
 135   u_short ip_len; /* total length */
 136   u_short ip_id; /* identification */
 137   u_short ip_off; /* fragment offset field */
 138 #define IP_RF 0x8000    /* reserved fragment flag */
 139 #define IP_DF 0x4000    /* dont fragment flag */
 140 #define IP_MF 0x2000    /* more fragments flag */
 141 #define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
 142   u_char ip_ttl; /* time to live */
 143   u_char ip_p; /* protocol */
 144   u_short ip_sum; /* checksum */
 145   struct in_addr ip_src, ip_dst; /* source and dest address */
 146 };
 147 #define IP_OFF(ip)              (((ip)->ip_off) & IP_OFFMASK)
 148 #define IP_DF_VAL(ip)           ((((ip)->ip_off) & IP_DF) >> 14)
 149 #define IP_MF_VAL(ip)           ((((ip)->ip_off) & IP_MF) >> 13)
 150 #define IP_HL(ip)   (((ip)->ip_vhl) & 0x0f)
 151 #define IP_V(ip)    (((ip)->ip_vhl) >> 4)
 152
 153 /* TCP header */
 154 typedef u_int tcp_seq;
 155
 156 struct sniff_tcp {
 157   u_short th_sport; /* source port */
 158   u_short th_dport; /* destination port */
 159   tcp_seq th_seq; /* sequence number */
 160   tcp_seq th_ack; /* acknowledgement number */
 161   u_char th_offx2; /* data offset, rsvd */
 162 #define TH_OFF(th)  (((th)->th_offx2 & 0xf0) >> 4)
 163   u_char th_flags;
 164 #define TH_FIN 0x01
 165 #define TH_SYN 0x02
 166 #define TH_RST 0x04
 167 #define TH_PUSH 0x08
 168 #define TH_ACK 0x10
 169 #define TH_URG 0x20
 170 #define TH_ECE 0x40
 171 #define TH_CWR 0x80
 172 #define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
 173   u_short th_win; /* window */
 174   u_short th_sum; /* checksum */
 175   u_short th_urp; /* urgent pointer */
 176 };
 177
 178 // Payload extraction /////////////////////////////////////////////////////////////////////////////////////
 179 u_char *getPayload(const u_char* packet, int packetSize, int &payloadSize,
 180                    std::string &srcIp, std::string &dstIp, int &fragmentId, bool &dfFlag,
 181                    bool &mfFlag, int &fragmentOffset) {
 182   const struct sniff_ethernet *ethernet; /* The ethernet header */
 183   const struct sniff_ip *ip; /* The IP header */
 184   const struct sniff_tcp *tcp; /* The TCP header */
 185   u_int size_ip;
 186   u_int size_tcp;
 187   ethernet = (struct sniff_ethernet*)(packet);
 188   ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);
 189   size_ip = IP_HL(ip) * 4; // 4 bytes per 32 bits word
 190
 191   if(size_ip < 20) {
 192     LOGDEBUG(
 193       Logger::debug(anna::functions::asString("Invalid IP header length: %d bytes", size_ip), ANNA_FILE_LOCATION));
 194     return NULL;
 195   }
 196
 197   static char str[INET_ADDRSTRLEN];
 198   inet_ntop(AF_INET, &(ip->ip_src), str, INET_ADDRSTRLEN);
 199   srcIp = str;
 200   inet_ntop(AF_INET, &(ip->ip_dst), str, INET_ADDRSTRLEN);
 201   dstIp = str;
 202   LOGDEBUG(
 203     Logger::debug(anna::functions::asString("ip_id: %d | ip_off: %d", ip->ip_id, ip->ip_off), ANNA_FILE_LOCATION));
 204   fragmentId = ip->ip_id;
 205   dfFlag = IP_DF_VAL(ip);
 206   mfFlag = IP_MF_VAL(ip);
 207   fragmentOffset = IP_OFF(ip);
 208   tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);
 209   size_tcp = TH_OFF(tcp) * 4;
 210
 211   if(size_tcp < 20) {
 212     LOGDEBUG(
 213       Logger::debug(anna::functions::asString("Invalid TCP header length: %d bytes", size_tcp), ANNA_FILE_LOCATION));
 214     return NULL;
 215   }
 216
 217   int payloadOffset = SIZE_ETHERNET + size_ip + size_tcp;
 218   LOGDEBUG(
 219     Logger::debug(anna::functions::asString("PayloadOffset=%d", payloadOffset), ANNA_FILE_LOCATION));
 220   payloadSize = packetSize - payloadOffset;
 221   return ((u_char *)(packet + payloadOffset));
 222 }
 223
 224 // Sniffing callback //////////////////////////////////////////////////////////////////////////////////////
 225 void my_callback(u_char *useless, const struct pcap_pkthdr* pkthdr,
 226                  const u_char* packet) {
 227   static int count = 1;
 228   static Payload auxPayload;
 229   int packetSize = pkthdr->len;
 230   int payloadSize;
 231   std::string srcIp, dstIp;
 232   int fragmentId, fragmentOffset;
 233   bool dfFlag, mfFlag;
 234   const u_char* payload = getPayload(packet, packetSize, payloadSize, srcIp,
 235                                      dstIp, fragmentId, dfFlag, mfFlag, fragmentOffset);
 236
 237   if(payload && (payloadSize > 0)) {
 238     LOGDEBUG(
 239       std::string msg; msg += anna::functions::asString("\nFrame %d:", count); msg += anna::functions::asHexString(anna::DataBlock((const char *)packet, pkthdr->len)); time_t time = pkthdr->ts.tv_sec; msg += "\n"; msg += anna::functions::asString("\ntimestamp %d.%d", pkthdr->ts.tv_sec, pkthdr->ts.tv_usec); msg += anna::functions::asString("\ndate %s", ctime(&time)); msg += anna::functions::asString("\ncaplen %d", pkthdr->caplen); msg += anna::functions::asString("\npacketSize %d", packetSize); msg += anna::functions::asString("\npayloadSize %d", payloadSize); msg += "\nPayload:"; msg += anna::functions::asHexString(anna::DataBlock((const char *)payload, payloadSize)); msg += "\n"; msg += anna::functions::asString("\nsourceIP %s", srcIp.c_str()); msg += anna::functions::asString("\ndestinationIP %s", dstIp.c_str()); msg += "\n"; msg += anna::functions::asString("\nfragmentId %d:", fragmentId); msg += anna::functions::asString("\nDF %s:", (dfFlag ? "1" : "0")); msg += anna::functions::asString("\nMF %s:", (mfFlag ? "1" : "0")); msg += anna::functions::asString("\nfragmentOffset %d:", fragmentOffset);
 240       Logger::debug(msg, ANNA_FILE_LOCATION););
 241     auxPayload.setDiameterLength(
 242       (payload[1] << 16) + (payload[2] << 8) + payload[3]);
 243     auxPayload.setSourceIP(srcIp);
 244     auxPayload.setDestinationIP(dstIp);
 245     auxPayload.setTimestamp(pkthdr->ts.tv_sec);
 246     auxPayload.setTimestampU(pkthdr->ts.tv_usec);
 247     bool completed = auxPayload.appendData((const char *) payload, payloadSize);
 248
 249     if(completed) {
 250       G_payloads[count] = auxPayload;
 251       auxPayload.reset();
 252     }
 253   }
 254
 255   count++;
 256 }
 257
 258 bool getDataBlockFromHexFile(const std::string &pathfile, anna::DataBlock &db) throw() {
 259   // Get hex string
 260   static char buffer[8192];
 261   std::ifstream infile(pathfile.c_str(), std::ifstream::in);
 262
 263   if(infile.is_open()) {
 264     infile >> buffer;
 265     std::string hexString(buffer, strlen(buffer));
 266     // Allow colon separator in hex string: we have to remove them before processing with 'fromHexString':
 267     hexString.erase(std::remove(hexString.begin(), hexString.end(), ':'), hexString.end());
 268     LOGDEBUG(
 269       std::string msg = "Hex string (remove colons if exists): ";
 270       msg += hexString;
 271       anna::Logger::debug(msg, ANNA_FILE_LOCATION);
 272     );
 273     anna::functions::fromHexString(hexString, db);
 274     // Close file
 275     infile.close();
 276     return true;
 277   }
 278
 279   return false;
 280 }
 281
 282
 283 void _exit(const std::string &message, int resultCode = 1) {
 284   if(resultCode)
 285     std::cerr << message << std::endl << std::endl;
 286   else
 287     std::cout << message << std::endl << std::endl;
 288
 289   exit(resultCode);
 290 }
 291
 292
 293 //-------------------------------------------------------------------
 294 int main(int argc, char **argv) {
 295   std::string exec = argv[0];
 296   std::string execBN = exec.substr(exec.find_last_of("/") + 1);
 297   std::string filetrace = execBN + ".trace";
 298   std::cout << std::endl;
 299
 300   //check command line arguments
 301   if(argc < 2) {
 302     std::string msg = "Usage: "; msg += exec;
 303     msg += " <pcap file> [--write-hex: to write hex files] [--debug: activates debug level traces (warning by default)]\n\n";
 304     _exit(msg);
 305   }
 306
 307   // Command-line parameters:
 308   std::string inputFile = argv[1];
 309   bool isHex = (inputFile.substr(inputFile.find_last_of(".") + 1) == "hex");
 310   std::string outputFile = inputFile; // extension will be added later
 311   std::string optionals;
 312   int indx = 2;
 313   while(indx < argc) { optionals += " "; optionals += argv[indx]; indx++; }
 314
 315   bool debug = (optionals.find("--debug") != std::string::npos);
 316   bool writeHex = (optionals.find("--write-hex") != std::string::npos);
 317   Logger::setLevel(debug ? Logger::Debug:Logger::Warning);
 318   Logger::initialize(execBN.c_str(), new TraceWriter(filetrace.c_str(), 2048000));
 319
 320   anna::DataBlock db_aux(true);
 321
 322   // SNIFFING //////////////////////////////////////////////////////////////////////////////////////////////7
 323   //temporary packet buffers
 324   struct pcap_pkthdr header; // The header that pcap gives us
 325   const u_char *packet;      // The actual packet
 326   //------------------
 327   //open the pcap file
 328   pcap_t *handle;
 329   char errbuf[PCAP_ERRBUF_SIZE];        //not sure what to do with this, oh well
 330   handle = pcap_open_offline(inputFile.c_str(), errbuf); //call pcap library function
 331
 332   if(handle == NULL) _exit(errbuf, 2);
 333
 334   // TODO: add filtering. At the moment, pcap must be previously filtered for diameter protocol ('tcp port 3868' or any other filter allowed)
 335   /*
 336   // Filtering:
 337   std::string filter = ?????;
 338   struct bpf_program _fp;
 339   struct bpf_program *fp = &_fp;
 340   bpf_u_int32 netmask = 4294967295; // FFFFFFFF
 341
 342   if (pcap_compile(handle, fp, (char*)(filter.c_str()), 1, netmask) == -1) {
 343         std::cerr << "Couldn't compile the filter " << filter << std::endl;
 344     return(2);
 345   }
 346
 347   if (pcap_setfilter(handle, fp) == -1) {
 348     std::cerr << "Couldn't set the filter " << filter << std::endl;
 349     return(2);
 350   }
 351   */
 352
 353   //begin processing the packets in this particular file
 354   int packets = -1;
 355
 356   try {
 357     while(packets != 0)
 358       packets = pcap_dispatch(handle, -1, (pcap_handler) my_callback, NULL);
 359   } catch(RuntimeException &ex) {
 360     _exit(ex.asString());
 361   }
 362
 363   pcap_close(handle);  //close the pcap file
 364
 365   // Print payloads //////////////////////////////////////////////////////////////////////////////////////////////
 366   // Open output file:
 367   outputFile += ".report";
 368   std::ofstream out(outputFile.c_str(), std::ifstream::out);
 369
 370   for(payloads_it it = G_payloads.begin(); it != G_payloads.end(); it++) {
 371     LOGDEBUG(
 372       Logger::debug(anna::functions::asString("Dumping frame %d", it->first), ANNA_FILE_LOCATION));
 373     time_t ts = (it->second).getTimestamp();
 374     int tsu = (it->second).getTimestampU();
 375     std::string ts_str = ctime(&ts);
 376     ts_str.erase(ts_str.find("\n"));
 377     out << "Frame:           " << anna::functions::asString(it->first) << std::endl;
 378     out << "Date:            " << ts_str << std::endl;
 379     out << "Timestamp:       " << anna::functions::asString((int)ts) << "."
 380         << anna::functions::asString((int)tsu) << std::endl;
 381     out << "Origin IP:       " << (it->second).getSourceIP() << std::endl;
 382     out << "Destination IP:  " << (it->second).getDestinationIP() << std::endl;
 383     out << "Destination IP:  " << (it->second).getDestinationIP() << std::endl;
 384     out << "Hex String:      " << (it->second).getDataAsHex() << std::endl;
 385
 386     // Create hex file:
 387     if (writeHex) {
 388       std::string hexFile =  anna::functions::asString(it->first) + ".hex";
 389       std::ofstream hex(hexFile.c_str(), std::ifstream::out);
 390       hex << (it->second).getDataAsHex();
 391       hex.close();
 392     }
 393
 394     out << std::endl;
 395   }
 396
 397   // Close output file:
 398   out.close();
 399   std::string msg = "Open '"; msg += filetrace; msg += "' in order to see process traces.\n";
 400   msg += "Open '"; msg += outputFile; msg += "' to see decoding results.\n";
 401   if (writeHex) msg += "Open '<frame number>.hex' to see specific frame data.";
 402   _exit(msg, 0);
 403 }
 404