networking - syn - protocolo tcp

analizar el encabezado IP y TCP(especialmente las opciones de encabezado tcp comunes) de los paquetes capturados por libpcap

Question

Quiero usar libpcap para capturar paquetes IP, y quiero analizar el encabezado IP y el encabezado tcp. `

hay cabeceras IP y estructuras de encabezado TCP en <netinet/ip.h> y <netinet/tcp.h> Cabecera IP es relativamente más fácil de analizar, pero para el encabezado TCP, dado que hay opciones tcp, las opciones comunes son MSS, SACK (acuse de recibo selectivo), marca de tiempo, escalado de ventana y NOP.

Quiero tener una función parse_pkt ():

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

entonces, después de llamar a la función, si quiero saber la dirección IP de origen, el número de secuencia y el MSS,

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

¿Hay códigos / fragmentos de código fuente similares que puedan satisfacer mis requisitos? ¡Gracias!

Answer 1

(Primer ejemplo a continuación) Aquí hay algo que tengo en preparación (en C ++ 11). Esto es para paquetes UDP, pero podría adaptarlo para paquetes TCP agregando la estructura relacionada y la plantilla Net::load() como la siguiente.

(Segundo ejemplo a continuación) No especificó un idioma objetivo en la pregunta, pero si está buscando C, entonces puede usar #pragma pack en las estructuras y luego convertir el puntero + desplazamiento como un puntero a la estructura y luego llama a ntohs / ntohl en los campos apropiados. Hacer eso es probablemente la solución más rápida, pero depende del #pragma pack , que no es estándar.

Estilo C ++ 11

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

Código de cliente en el controlador de captura de paquetes:

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

alternativa (estilo C):

(Perdón por cualquier error. Escribí esto de memoria, y no intenté compilar o ejecutar, pero creo que comprenderá la idea básica):

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)

código de cliente en controlador de paquetes:

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

Notas de encabezado TCP

según netinet/tcp.h , el encabezado TCP es aproximadamente:

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;

Cargue esta estructura en la memoria utilizando el método que prefiera y no olvide corregir el orden de bytes (ntohs / ntohl) para tipos enteros de múltiples bytes como se indicó anteriormente.

Las opciones TCP siguen, que no se pueden cargar en una estructura como esta. Vea la sección sobre opciones de TCP en este enlace . Para MSS, querrá analizar cada opción hasta que encuentre la opción con kind == 2. Basándose en el ejemplo C de arriba:

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