analyser IP et TCP en-tête (particulièrement fréquent en-tête tcp options)de paquets capturés par libpcap

(Premier exemple ci-dessous), Voici quelque chose que j'ai dans les œuvres (en C++11). C'est pour les paquets UDP, mais vous pouvez l'adapter pour les paquets TCP en ajoutant liés à la structure et Net::load() modèle comme celui ci-dessous.

(Deuxième exemple ci-dessous) Vous ne spécifiez pas une langue cible dans la question, mais si vous êtes à la recherche pour le C, alors vous pourriez utiliser #pragma pack sur les structures puis coulé le pointeur+offset comme un pointeur vers une struct et ensuite appeler ah/ntohl sur les champs appropriés. Cela est probablement la solution la plus rapide, mais elle repose sur #pragma pack, qui n'est pas standard.

C++11 style

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;
}
}

Code Client dans la capture des paquets gestionnaire de:

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 (type C):

(Désolé pour les éventuelles erreurs. J'ai tapé ce à partir de la mémoire, et ne pas essayer de compiler ou exécuter--mais je pense que vous comprendrez l'idée de base):

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)

code client dans le gestionnaire de paquets:

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);

En-Tête TCP Notes

selon netinet/tcp.h, l'en-tête TCP est à peu près de:

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;

Charge de cette structure en mémoire en utilisant la méthode que vous préférez et n'oubliez pas de fixer l'ordre des octets (ah/ntohl) pour le multi-byte integer types comme ci-dessus.

Les options TCP, ce qui ne peut pas être chargé dans une structure de ce genre. Voir la section sur les options TCP à ce lien. Pour le SMS, vous voulez analyser chaque option jusqu'à ce que vous trouver l'option avec l'aimable == 2. Bâtiment sur le C exemple ci-dessus:

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;
} 

OriginalL'auteur