Блог

Я написал простой исходный файл, который может читать файлы pcap, используя библиотеку libpcap на C. Я могу анализировать пакеты один за другим и анализировать их до определенного момента. Я хочу иметь возможность определить, является ли проанализированный мной TCP-пакет повторной передачей TCP или нет. После тщательного поиска в Интернете я пришел к выводу, что для этого мне нужно отслеживать поведение трафика, а это означает также анализ ранее полученных пакетов.

Чего я на самом деле хочу добиться, так это сделать на базовом уровне то, что tcp.analysis.retransmission делает фильтр в wireshark.

Это MRE, который считывает файл pcap и анализирует TCP-пакеты, отправленные по IPv4. Функция find_retransmissions — это место, где анализируется пакет.

 #include <pcap.h>
#include <stdio.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <net/ethernet.h>
#include <string.h>

void process_packet(u_char *,const struct pcap_pkthdr * , const u_char *);
void find_retransmissions(const u_char * , int );

int main()
{
    pcap_t *handle;
    char errbuff[PCAP_ERRBUF_SIZE];
    handle = pcap_open_offline("smallFlows.pcap", errbuff);
    pcap_loop(handle, -1, process_packet, NULL);
}

void process_packet(u_char *args,
                    const struct pcap_pkthdr * header,
                    const u_char *buffer)
{
    int size = header->len;
    struct ethhdr *eth = (struct ethhdr *)buffer;
    if(eth->h_proto == 8) //Check if IPv4
    {
        struct iphdr *iph = (struct iphdr*)(buffer  sizeof(struct ethhdr));
        if(iph->protocol == 6) //Check if TCP
        {
             find_retransmissions(buffer,size);
        }
    }
}
 

 void find_retransmissions(const u_char * Buffer, int Size)
{
    static struct iphdr  previous_packets[20000];
    static struct tcphdr  previous_tcp[20000];
    static int index = 0;
    static int retransmissions = 0;
    int retransmission = 0;
    
    struct sockaddr_in source,dest;
    unsigned short iphdrlen;
    
    // IP header
    struct iphdr *iph = (struct iphdr *)(Buffer    sizeof(struct ethhdr));
    previous_packets[index] = *iph;
    
    iphdrlen =iph->ihl*4;

    memset(amp;source, 0, sizeof(source));
    source.sin_addr.s_addr = iph->saddr;
    memset(amp;dest, 0, sizeof(dest));
    dest.sin_addr.s_addr = iph->daddr;

    // TCP header
    struct tcphdr *tcph=(struct tcphdr*)(Buffer 
                                    iphdrlen 
                                    sizeof(struct ethhdr));
    previous_tcp[index]=*tcph;
    index  ;
    
    int header_size =  sizeof(struct ethhdr)   iphdrlen   tcph->doff*4;
    unsigned int segmentlength;
    segmentlength = Size - header_size;
    
    /* First check if a same TCP packet has been received */
    for(int i=0;i<index-1;i  )
    {
        // Check if packet has been resent
        unsigned short temphdrlen;
        temphdrlen = previous_packets[i].ihl*4;
        
        // First check IP header
        if ((previous_packets[i].saddr == iph->saddr) // Same source IP address
            amp;amp; (previous_packets[i].daddr == iph->daddr) // Same destination Ip address
            amp;amp; (previous_packets[i].protocol == iph->protocol) //Same protocol
            amp;amp; (temphdrlen == iphdrlen)) // Same header length
        {
            // Then check TCP header
            if((previous_tcp[i].source == tcph->source) // Same source port
                amp;amp; (previous_tcp[i].dest == tcph->dest) // Same destination port
                amp;amp; (previous_tcp[i].th_seq == tcph->th_seq) // Same sequence number
                amp;amp; (previous_tcp[i].th_ack==tcph->th_ack) // Same acknowledge number
                amp;amp; (previous_tcp[i].th_win == tcph->th_win) // Same window
                amp;amp; (previous_tcp[i].th_flags == tcph->th_flags) // Same flags
                amp;amp; (tcph->syn==1 || tcph->fin==1 ||segmentlength>0)) // Check if SYN or FIN are
            {                                                        // set or if tcp.segment 0
                // At this point the packets are almost identical
                //  Now Check previous communication to check for retransmission
                for(int z=index-1;z>=0;z--)
                {   
                    // Find packets going to the reverse direction
                    if ((previous_packets[z].daddr == iph->saddr) // Swapped IP source addresses
                        amp;amp; (previous_packets[z].saddr ==iph->daddr) // Same for IP dest addreses
                        amp;amp; (previous_packets[z].protocol == iph->protocol)) // Same protocol
                    {
                        if((previous_tcp[z].dest==tcph->source) // Swapped ports
                            amp;amp; (previous_tcp[z].source==tcph->dest)
                            amp;amp; (previous_tcp[z].th_seq-1 != tcph->th_ack) // Not Keepalive
                            amp;amp; (tcph->syn==1          // Either SYN is set
                                || tcph->fin==1       // Either FIN is set
                                || (segmentlength>0)) // Either segmentlength >0 
                            amp;amp; (previous_tcp[z].th_seq>tcph->th_seq) // Next sequence number is 
                                                                     // bigger than the expected 
                            amp;amp; (previous_tcp[z].ack  != 1))  // Last seen ACK is set
                        {
                            retransmission = 1;
                            retransmissions  ;
                            break;
                        }
                    }
                }
            }
        }
    }
    
    if (retransmission == 1)
    {
        printf("Retransmission: Truen");
        printf("nn******************IPv4 TCP Packet*************************n"); 
        printf("   |-IP Version       : %dn",(unsigned int)iph->version);
        printf("   |-Source IP        : %sn" , inet_ntoa(source.sin_addr) );
        printf("   |-Destination IP   : %sn" , inet_ntoa(dest.sin_addr) );
        printf("   |-Source Port      : %un",  ntohs(tcph->source));
        printf("   |-Destination Port : %un",  ntohs(tcph->dest));
        printf("   |-Protocol         : %dn",(unsigned int)iph->protocol);
        printf("   |-IP Header Length : %d DWORDS or %d Bytesn",
(unsigned int)iph->ihl,((unsigned int)(iph->ihl))*4);
        printf("   |-Payload Length   : %d Bytesn",Size - header_size);
        
    }
    printf("Total Retransmissions: %dn",retransmissions);
}
 

Этот подход основан на параграфе wireshark wiki о повторной передаче. Я буквально щелкнул по каждой странице, которую Google может предложить о том, как подойти к этому анализу, но это было единственное, что я смог найти.
Результаты, которые я получаю, в некоторой степени верны, некоторые повторные передачи остаются незамеченными, я получаю много пакетов DUP-ACK, а также проходит некоторый обычный трафик (проверено с помощью wireshark). Я использую файл smallFlows.pcap, найденный здесь, и я считаю, что результаты, которые я должен получить, должны совпадать с tcp.analysis.retransmission amp;amp; not tcp.analysis.spurious_retransmission фильтром в wireshark. Что равносильно 88 повторным передачам для этого pcap.
Запуск этого кода дает 45, и я не могу понять, почему.

Извините за беспорядочные инструкции if, я изо всех сил старался их очистить.

Для обнаружения повторной передачи вы должны отслеживать ожидаемый порядковый номер. Если порядковый номер выше, чем ожидалось, пакет является повторно переданным (глава TCP Analysis документации wireshark, https://www.wireshark.org/docs/wsug_html_chunked/ChAdvTCPAnalysis.html )

Повторная передача TCP

Устанавливается, когда все из следующего истинно:

• Это не пакет keepalive.
• В прямом направлении длина сегмента больше нуля или установлен флаг SYN или FIN.
• Следующий ожидаемый порядковый номер больше текущего порядкового номера

Помимо повторной передачи TCP, существует также ложная повторная передача TCP и быстрая повторная передача TCP

По сути, повторная передача необходима только в том случае, если пакет потерян. Анализ несоответствия потерянных сегментов :