analysieren von IP-und TCP-header (vor allem gemeinsame tcp-header Optionen)der Pakete erfasst, die von libpcap

Will ich mit libpcap capture IP-Paket, und die möchte ich analysieren den IP-header und tcp-header.
`

gibt es IP-header und TCP-header-Strukturen in <netinet/ip.h> und <netinet/tcp.h>
IP-header ist relativ einfach zu Parsen, aber für die TCP-header,da es tcp-Optionen
die gemeinsamen Optionen sind MSS, SACK(selective acknowledgement), timestamp, window scaling und NOP.

Möchte ich eine Funktion haben parse_pkt():

struct tcphdr tcp_hdr;
struct ip ip_hdr;
parse_pkt(u_char *pcap_packet, struct ip* p_ip, struct tcp* p_tcp);

also nach dem Aufruf der Funktion, wenn ich will, um zu wissen, die Quell-ip-Adresse, Sequenznummer und MSS, 

scr_ip = ip_hdr.src_ip
seq = tcp_hdr.seq
mss = tcp_hdr.mss

gibt es ähnliche source-codes/snippets erfüllt meine Anforderungen?
danke!

InformationsquelleAutor user1944267 | 2013-05-13
  1. 18

    (Erstes Beispiel unten) Hier ist etwas, dass ich in der Werke (in C++11). Dies ist für UDP-Pakete, aber man könnte es anpassen, die für TCP-Pakete durch hinzufügen der zugehörigen struct, und Net::load() Vorlage wie die unten.

    (Das zweite Beispiel unten), die Sie nicht geben Sie eine Ziel-Sprache, in der Frage, aber wenn Sie auf der Suche nach C, dann könnten Sie #pragma pack auf die Strukturen und dann warf die pointer+offset als Zeiger auf die struct, und rufen Sie dann ntohs/ntohl auf die entsprechenden Felder. Tun, dass ist wohl die Schnellste Lösung, aber es stützt sich auf #pragma pack, was nicht standard ist.

    C++11 Stil

    net.h:

    namespace Net {
  using addr_t = uint32_t;
  using port_t = uint16_t;

  struct ether_header_t {
    uint8_t  dst_addr[6];
    uint8_t  src_addr[6];
    uint16_t llc_len;
  };

  struct ip_header_t {
    uint8_t  ver_ihl;  //4 bits version and 4 bits internet header length
    uint8_t  tos;
    uint16_t total_length;
    uint16_t id;
    uint16_t flags_fo; //3 bits flags and 13 bits fragment-offset
    uint8_t  ttl;
    uint8_t  protocol;
    uint16_t checksum;
    addr_t   src_addr;
    addr_t   dst_addr;

    uint8_t ihl() const;
    size_t size() const;
  };

  class udp_header_t {
  public:
    port_t   src_port;
    port_t   dst_port;
    uint16_t length;
    uint16_t checksum;
  };

  template< typename T >
  T load( std::istream& stream, bool ntoh = true );
  template<>
  ip_header_t  load( std::istream& stream, bool ntoh );
  template<>
  udp_header_t load( std::istream& stream, bool ntoh );

  std::string to_string( const addr_t& addr );
}

    net.cpp:

    namespace Net {

  uint8_t ip_header_t::ihl() const {
    return (ver_ihl & 0x0F);
  }

  size_t ip_header_t::size() const {
    return ihl() * sizeof(uint32_t);
  }

  template<>
  ip_header_t load( std::istream& stream, bool ntoh ) {
    ip_header_t header;
    stream.read((char*)&header.ver_ihl,      sizeof(header.ver_ihl));
    stream.read((char*)&header.tos,          sizeof(header.tos));
    stream.read((char*)&header.total_length, sizeof(header.total_length));
    stream.read((char*)&header.id,           sizeof(header.id));
    stream.read((char*)&header.flags_fo,     sizeof(header.flags_fo));
    stream.read((char*)&header.ttl,          sizeof(header.ttl));
    stream.read((char*)&header.protocol,     sizeof(header.protocol));
    stream.read((char*)&header.checksum,     sizeof(header.checksum));
    stream.read((char*)&header.src_addr,     sizeof(header.src_addr));
    stream.read((char*)&header.dst_addr,     sizeof(header.dst_addr));
    if( ntoh ) {
      header.total_length = ntohs(header.total_length);
      header.id =           ntohs(header.id);
      header.flags_fo =     ntohs(header.flags_fo);
      header.checksum =     ntohs(header.checksum);
      header.src_addr =     ntohl(header.src_addr);
      header.dst_addr =     ntohl(header.dst_addr);
    }
    return header;
  }

  template<>
  udp_header_t load( std::istream& stream, bool ntoh ) {
    udp_header_t header;
    stream.read((char*)&header.src_port, sizeof(header.src_port));
    stream.read((char*)&header.dst_port, sizeof(header.dst_port));
    stream.read((char*)&header.length,   sizeof(header.length));
    stream.read((char*)&header.checksum, sizeof(header.checksum));
    if( ntoh ) {
      header.src_port = ntohs(header.src_port);
      header.dst_port = ntohs(header.dst_port);
      header.length   = ntohs(header.length);
      header.checksum = ntohs(header.checksum);
    }
    return header;
  }
}

    Client-code in packet capture handler:

    using std::chrono::seconds;
using std::chrono::microseconds;
using clock = std::chrono::system_clock;
using Net::ether_header_t;
using Net::ip_header_t;
using Net::udp_header_t;

auto packet_time = clock::time_point(seconds(header->ts.tv_sec) + microseconds(header->ts.tv_usec));
std::istringstream stream(std::string((char*)packet, header->caplen));
stream.seekg(sizeof(ether_header_t), std::ios_base::beg);
auto ip_header = Net::load<ip_header_t>(stream);
if( ip_header.size() > 20 ) { 
  stream.seekg(ip_header.size() + sizeof(ether_header_t), std::ios_base::beg);
}
auto udp_header = Net::load<udp_header_t>(stream);

    alternative (C-Stil):

    (Sorry für eventuelle Fehler. Ich tippte aus dem Gedächtnis, und nicht versuchen, zu kompilieren oder ausführen-aber ich denke, Sie werden verstehen, die grundlegende Idee):

    net.h:

    typedef uint32_t addr_t;
typedef uint16_t port_t;

#pragma pack(push, 1)
typedef struct {
  uint8_t  dst_addr[6];
  uint8_t  src_addr[6];
  uint16_t llc_len;
} ether_header_t;

typedef struct {
  uint8_t  ver_ihl;  //4 bits version and 4 bits internet header length
  uint8_t  tos;
  uint16_t total_length;
  uint16_t id;
  uint16_t flags_fo; //3 bits flags and 13 bits fragment-offset
  uint8_t  ttl;
  uint8_t  protocol;
  uint16_t checksum;
  addr_t   src_addr;
  addr_t   dst_addr;
} ip_header_t;

typedef struct {
  port_t   src_port;
  port_t   dst_port;
  uint16_t length;
  uint16_t checksum;
} udp_header_t;
#pragma pack(pop)

    client code im Paket-handler:

    ip_header_t   ip_header =  (ip_header_t)*(packet + sizeof(ether_header_t));
ip_header.total_length = ntohs(ip_header.total_length);
ip_header.id           = ntohs(ip_header.id);
ip_header.flags_fo     = ntohs(ip_header.flags_fo);
ip_header.checksum     = ntohs(ip_header.checksum);
ip_header.src_addr     = ntohl(ip_header.src_addr);
ip_header.dst_addr     = ntohl(ip_header.dst_addr);
int ip_size = 4 * (ip_header.ver_ihl & 0x0F);

udp_header_t udp_header = (udp_header_t)*(packet + ip_size + sizeof(ether_header_t));
udp_header.src_port = ntohs(udp_header.src_port);
udp_header.dst_port = ntohs(udp_header.dst_port);
udp_header.length   = ntohs(udp_header.length);
udp_header.checksum = ntohs(udp_header.checksum);

    TCP-Header Hinweise

    laut netinet/tcp.h, der TCP-header ist in etwa so:

    typedef struct {
  uint16_t src_port;
  uint16_t dst_port;
  uint32_t seq;
  uint32_t ack;
  uint8_t  data_offset;  //4 bits
  uint8_t  flags;
  uint16_t window_size;
  uint16_t checksum;
  uint16_t urgent_p;
} tcp_header_t;

    Laden diese Struktur in den Speicher, welche Methode Sie bevorzugen und vergessen Sie nicht, lösen in der Anordnung der Bytes (ntohs/ntohl) für multi-byte-integer-Typen wie oben.

    Den TCP-Optionen Folgen, die nicht geladen werden kann in einer Struktur wie dieser. Siehe den Abschnitt über die TCP-Optionen in diesem link. Für die MSS, werden Sie wollen, um zu analysieren, jede option, bis Sie finden die option mit Art == 2. Aufbauend auf das C-Beispiel oben:

    typedef struct {
  uint8_t kind;
  uint8_t size;
} tcp_option_t;

uint16_t mss;
uint8_t* opt = (uint8_t*)(packet + ip_size + sizeof(ether_header_t) + sizeof(tcp_header_t))
while( *opt != 0 ) {
  tcp_option_t* _opt = (tcp_option_t*)opt;
  if( _opt->kind == 1 /* NOP */ ) {
     ++opt;  //NOP is one byte;
     continue;
  }
  if( _opt->kind == 2 /* MSS */ ) {
    mss = ntohs((uint16_t)*(opt + sizeof(opt)));
  }
  opt += _opt->size;
}
    • er ist daran interessiert, analysieren die TCP-header-option, die ist ein bisschen unordentlich ist(es gibt Regeln, natürlich, aber nicht so einfach, wie die anderen Felder) als die anderen Felder.
    • Es ist nicht so chaotisch, wie Sie vielleicht denken. Check-out im unteren Abschnitt meiner Antwort.
    • Ich denke, dass Sie einen Fehler gemacht, der ++opt wird es +2 eigentlich.
    • Keine Fehler. opt ist ein Zeiger. opt++ inkrementiert den pointer und continue beginnt die nächste iteration.
    • wenn es ist ein NOP, sollte die Adresse 1 hinzufügen, aber ++opt wird es fügen Sie 2, weil tcp_option_t ist 2 bytes
    • Du hast Recht, die Größe der NOP nur ein byte, aber opt ist ein Zeiger und kein array oder iterator, so erwarte ich, dass ++opt erhöht die Speicheradresse um eins.
    • Ich aktualisierte die Antwort zu sein, noch deutlicher, wie weit Sie den Zeiger bewegen. Ich bin mir nicht sicher, ob ++ auf einen Zeiger auf struct funktioniert wie p = p + 1 oder p = p + sizeof(pointer type). Wenn es funktioniert, wie die letztgenannten, dann danke für den catch.
    • Sie bekam auch src_port zeigt zweimal innerhalb tcp_header_t, sollte das zweite dst_port
    • danke, habe es
    • Wenn Sie einen Zeiger-Wert vom Typ "Zeiger auf {type}" ist eine bestimmte Adresse, Zugabe 1 zu diesem Wert addiert sizeof({type}) an die Adresse, so p = p + 1 fügt sizeof({type}) an die darin enthaltene Adresse in p, und den aktuellen code in der Antwort ist richtig, da opt ist vom Typ "Zeiger auf uint8_t".
    • *(opt + sizeof(opt)) holt ein byte, als opt ist vom Typ "Zeiger auf uint8_t", so wird es nicht Holen, den vollen Wert der option. Darüber hinaus, das bedeutet auch sizeof(opt) ist 1, nicht 2, damit es nicht zu überspringen, die option Länge. Also, was Sie wollen, ist mss = ((*(opt + sizeof(_opt)))) << 8 + *(opt + sizeof(_opt) + 1), die Holen beide bytes von rechts-offsets und montieren Sie, auch wenn die Adresse in opt ausgerichtet ist nicht sicher für ein 2-byte Holen.
    • Und wenn Sie wollen, um sicherzustellen, dass Ihr code handles malformed (versehentlich oder absichtlich) die Pakete, sollten Sie 1) überprüfen Sie, ob opt->_size für die MSS-option ist 4, und, wenn nicht, ignorieren Sie die MSS-option oder einen Fehler melden und 2) stellen Sie sicher, dass opt->_size mindestens 2 in alle in Fällen, in denen die option hat eine Größe (wenn es null ist, zum Beispiel, dass der code in eine Endlosschleife).
    • Hoppla, opt + sizeof(_opt) sollte opt + sizeof(*_opt), und sizeof(opt) sollte sizeof(*opt) in meinem zweiten Kommentar oben - wir nicht wollen, dass die Größen von Zeigern, wir wollen, dass die Größen von dem, was Sie zeigen. Ich habe fest den code und fügte auch einige Makros, die angeben, was einige dieser Sequenzen des Codes tun.
    • Ich wünschte, ich könnte Ihnen zwei upvotes. Können Sie direkt Lesen, raw-bytes des gesamten IPV4-Paket in diese drei Strukturen dann tun ntohs oder gleichwertig Funktionen beim Lesen der einzelnen Felder, oder gibt es einen Haken, der?
    • Ich würde wahrscheinlich nicht verwenden Sie genau die gleiche logische Struktur für eine klare Semantik, das ist aber mehr oder weniger, was ich tun würde.

    InformationsquelleAutor
Schreibe einen Kommentar