• 自己动手写网络抓包工具

    看了太多的“自己动手”，这次咱也“自己动手”一下，写个简单的网络抓包工具吧。要写出像tcpdump和wireshark(ethereal)这样的大牛程序来，咱也没那能耐，呵呵。所以这个工具只能抓取本地IP数据报，同时它还使用了BPF，目的是了解如何进行简单有效的网络抓包。

    当打开一个标准SOCKET套接口时，我们比较熟悉的协议往往是用AF_INET来建立基于TCP(SOCK_STREAM)或UDP(SOCK_DGRAM)的链接。但是这些只用于IP层以上，要想从更底层抓包，我们需要使用AF_PACKET来建立套接字，它支持SOCK_RAW和SOCK_DGRAM，它们都能从底层抓包，不同的是后者得到的数据不包括以太网帧头(最开始的14个字节)。好了，现在我们就知道该怎样建立SOCKET套接口了：
    1. sock = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IP));
    最后一个参数 ETH_P_IP 指出，我们只对IP包感兴趣，而不是ARP，RARP等。之后就可以用recvfrom从套接口读取数据了。

    现在我们可以抓到发往本地的所有IP数据报了，那么有没有办法抓到那些“流经”本地的数据呢？呵呵，当然可以了，这种技术叫网络嗅探(sniff)，它很能威胁网络安全，也非常有用，尤其是当你对网内其他用户的隐私感兴趣时:(  由于以太网数据包是对整个网段广播的，所以网内所有用户都能收到其他用户发出的数据，只是默认的，网卡只接收目的地址是自己或广播地址的数据，而把不是发往自己的数据包丢弃。但是多数网卡驱动会提供一种混杂模式(promiscous mode)，工作在这种模式下的网卡会接收网络内的所有数据，不管它是发给谁的。下面的方法可以把网卡设成混杂模式：
    1.       // set NIC to promiscous mode, so we can recieve all packets of the network
    2.       strncpy(ethreq.ifr_name, "eth0", IFNAMSIZ);
    3.       ioctl(sock, SIOCGIFFLAGS, &ethreq);
    4.       ethreq.ifr_flags |= IFF_PROMISC;
    5.       ioctl(sock, SIOCSIFFLAGS, &ethreq);
    通过ifconfig可以很容易的查看当前网卡是否工作在混杂模式(PROMISC)。但是请注意，程序退出后，网卡的工作模式不会改变，所以别忘了关闭网卡的混杂模式：
    1.       // turn off promiscous mode
    2.       ethreq.ifr_flags &= ~IFF_PROMISC;
    3.       ioctl(sock, SIOCSIFFLAGS, &ethreq);
    现在我们可以抓到本网段的所有IP数据包了，但是问题也来了：那么多的数据，怎么处理？CPU可能会被严重占用，而且绝大多数的数据我们可能根本就不敢兴趣！那怎么办呢？用if语句？可能要n多个，而且丝毫不会降低内核的繁忙程度。最好的办法就是告诉内核，把不感兴趣的数据过滤掉，不要往应用层送。BPF就为此而生。

    BPF(Berkeley Packet Filter)是一种类是汇编的伪代码语言，它也有命令代码和操作数。例如，如果我们只对用户192.168.1.4的数据感兴趣，可以用tcpdump的-d选项生成BPF代码如下：
    1.       $tcpdump -d host 192.168.1.4
    3.       (000) ldh      [12]
    4.       (001) jeq      #0x800           jt 2 jf 6
    5.       (002) ld       [26]
    6.       (003) jeq      #0xc0a80104      jt 12 jf 4
    7.       (004) ld       [30]
    8.       (005) jeq      #0xc0a80104      jt 12 jf 13
    9.       (006) jeq      #0x806           jt 8 jf 7
    10.       (007) jeq      #0x8035          jt 8 jf 13
    11.       (008) ld       [28]
    12.       (009) jeq      #0xc0a80104      jt 12 jf 10
    13.       (010) ld       [38]
    14.       (011) jeq      #0xc0a80104      jt 12 jf 13
    15.       (012) ret      #96
    16.       (013) ret      #0
    其中第一列代表行号，第二列是命令代码，后面是操作数。下面我们采用汇编注释的方式简单的解释一下：

          (000) ldh      [12] ;load h?? (2 bytes) from ABS offset 12 (the TYPE of ethernet header)
          (001) jeq      #0x800           jt 2 jf 6 ;compare and jump, jump to line 2 if true; else jump to line 6
          (002) ld       [26] ;load word (4 bytes) from ABS offset 26 (src IP address of IP header)
          (003) jeq      #0xc0a80104      jt 12 jf 4 ;compare and jump, jump to line 12 if true, else jump to line 4
          (004) ld       [30] ; load word (4 bytes) from ABS offset 30 (dst IP address of IP header)
          (005) jeq      #0xc0a80104      jt 12 jf 13 ;see line 3
          (006) jeq      #0x806           jt 8 jf 7 ;compare with ARP, see line 1
          (007) jeq      #0x8035          jt 8 jf 13 ;compare with RARP, see line 1
          (008) ld       [28] ;src IP address for other protocols
          (009) jeq      #0xc0a80104      jt 12 jf 10 
          (010) ld       [38] ;dst IP address for other protocols
          (011) jeq      #0xc0a80104      jt 12 jf 13 
          (012) ret      #96 ;return 96 bytes to user application
          (013) ret      #0 ;drop the packet

    但是这样的伪代码我们是无法在应用程序里使用的，所以tcpdum提供了一个-dd选项来输出一段等效的C代码：
    1.       $tcpdump -dd host 192.168.1.4
    3.       { 0x28, 0, 0, 0x0000000c },
    4.       { 0x15, 0, 4, 0x00000800 },
    5.       { 0x20, 0, 0, 0x0000001a },
    6.       { 0x15, 8, 0, 0xc0a80104 },
    7.       { 0x20, 0, 0, 0x0000001e },
    8.       { 0x15, 6, 7, 0xc0a80104 },
    9.       { 0x15, 1, 0, 0x00000806 },
    10.       { 0x15, 0, 5, 0x00008035 },
    11.       { 0x20, 0, 0, 0x0000001c },
    12.       { 0x15, 2, 0, 0xc0a80104 },
    13.       { 0x20, 0, 0, 0x00000026 },
    14.       { 0x15, 0, 1, 0xc0a80104 },
    15.       { 0x6, 0, 0, 0x00000060 },
    16.       { 0x6, 0, 0, 0x00000000 },
    该代码对应的数据结构是struct sock_filter，该结构在linux/filter.h中定义如下：
    1.       struct sock_filter  // Filter block
    2.       {
    3.              __u16 code; // Actual filter code
    4.              __u8 jt;    // Jump true
    5.              __u8 jf;    // Jump false
    6.              __u32 k;   // Generic multiuse field
    7.       };
    code对应命令代码；jt是jump if true后面的操作数，注意这里用的是相对行偏移，如2就表示向前跳转2行，而不像伪代码中使用绝对行号；jf为jump if false后面的操作数；k对应伪代码中第3列的操作数。

    了解了BPF伪代码和结构，我们就可以自己定制更加简单有效的BPF filter了，如上例中的6-11行不是针对IP协议的，而我们的套接字已经指定只读取IP数据了，所以就可以把他们删除，不过要注意，行偏移也要做相应的修改。

    另外，tcpdump默认只返回96字节的数据，但对大部分应用来说，96字节是远远不够的，所以tcpdump提供了-s选项用于指定返回的数据长度。

    OK，下面我们就来看看怎样把过滤器安装到套接口上吧：
    1.       $tcpdump ip -d -s 2048 host 192.168.1.2
    2.       (000) ldh      [12] 
    3.       (001) jeq      #0x800           jt 2 jf 7 
    4.       (002) ld       [26] 
    5.       (003) jeq      #0xc0a80102      jt 6 jf 4 
    6.       (004) ld       [30] 
    7.       (005) jeq      #0xc0a80102      jt 6 jf 7 
    8.       (006) ret      #2048
    9.       (007) ret      #0 

    12.       struct sock_filter bpf_code[] = {
    13.             { 0x28, 0, 0, 0x0000000c }, 
    14.             { 0x15, 0, 5, 0x00000800 }, 
    15.             { 0x20, 0, 0, 0x0000001a }, 
    16.             { 0x15, 2, 0, 0xc0a80102 }, 
    17.             { 0x20, 0, 0, 0x0000001e }, 
    18.             { 0x15, 0, 1, 0xc0a80102 }, 
    19.             { 0x6, 0, 0, 0x00000800 }, 
    20.             { 0x6, 0, 0, 0x00000000 }
    21.       };

    24.       struct sock_fprog filter;
    25.       filter.len = sizeof(bpf_code)/sizeof(bpf_code[0]);
    26.       filter.filter = bpf_code;
    27.       setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter));
    最后加上信号处理器，以便能在程序退出前恢复网卡的工作模式。到现在我们已经可以看到一个小聚规模抓包小工具了，呵呵，麻雀虽小，但也五脏俱全啊！下面给出完整的代码。
    1.       #include <sys/types.h>
    2.       #include <sys/time.h>
    3.       #include <sys/ioctl.h>
    4.       #include <sys/socket.h>
    5.       #include <linux/types.h>
    6.       #include <netinet/in.h>
    7.       #include <netinet/udp.h>
    8.       #include <netinet/ip.h>
    9.       #include <netpacket/packet.h>
    10.       #include <net/ethernet.h>
    11.       #include <arpa/inet.h>
    12.       #include <string.h>
    13.       #include <signal.h>
    14.       #include <net/if.h>
    15.       #include <stdio.h>
    16.       #include <sys/uio.h>
    17.       #include <fcntl.h>
    18.       #include <unistd.h>
    19.       #include <linux/filter.h>
    20.       #include <stdlib.h>

    24.       #define ETH_HDR_LEN 14
    25.       #define IP_HDR_LEN 20
    26.       #define UDP_HDR_LEN 8
    27.       #define TCP_HDR_LEN 20

    30.       static int sock;

    33.       void sig_handler(int sig) 
    34.       {
    35.             struct ifreq ethreq;
    36.             if(sig == SIGTERM)
    37.                   printf("SIGTERM recieved, exiting.../n");
    38.             else if(sig == SIGINT)
    39.                   printf("SIGINT recieved, exiting.../n");
    40.             else if(sig == SIGQUIT)
    41.                   printf("SIGQUIT recieved, exiting.../n");
    43.             // turn off the PROMISCOUS mode 
    44.             strncpy(ethreq.ifr_name, "eth0", IFNAMSIZ);
    45.             if(ioctl(sock, SIOCGIFFLAGS, &ethreq) != -1) {
    46.                   ethreq.ifr_flags &= ~IFF_PROMISC;
    47.                   ioctl(sock, SIOCSIFFLAGS, &ethreq);
    48.             }
    49.             close(sock);
    50.             exit(0);
    51.       }

    54.       int main(int argc, char ** argv) {
    55.             int n;
    56.             char buf[2048];
    57.             unsigned char *ethhead;
    58.             unsigned char *iphead;
    59.             struct ifreq ethreq;
    60.             struct sigaction sighandle;

    63.       #if 0
    64.             $tcpdump ip -s 2048 -d host 192.168.1.2
    65.             (000) ldh      [12]
    66.             (001) jeq      #0x800           jt 2 jf 7
    67.             (002) ld       [26]
    68.             (003) jeq      #0xc0a80102      jt 6 jf 4
    69.             (004) ld       [30]
    70.             (005) jeq      #0xc0a80102      jt 6 jf 7
    71.             (006) ret      #2048
    72.             (007) ret      #0
    73.       #endif

    76.             struct sock_filter bpf_code[] = {
    77.                   { 0x28, 0, 0, 0x0000000c },
    78.                   { 0x15, 0, 5, 0x00000800 },
    79.                   { 0x20, 0, 0, 0x0000001a },
    80.                   { 0x15, 2, 0, 0xc0a80102 },
    81.                   { 0x20, 0, 0, 0x0000001e },
    82.                   { 0x15, 0, 1, 0xc0a80102 },
    83.                   { 0x6, 0, 0, 0x00000800 },
    84.                   { 0x6, 0, 0, 0x00000000 }
    85.             };

    88.             struct sock_fprog filter;
    89.             filter.len = sizeof(bpf_code)/sizeof(bpf_code[0]);
    90.             filter.filter = bpf_code;

    93.             sighandle.sa_flags = 0;
    94.             sighandle.sa_handler = sig_handler;
    95.             sigemptyset(&sighandle.sa_mask);
    96.             //sigaddset(&sighandle.sa_mask, SIGTERM);
    97.             //sigaddset(&sighandle.sa_mask, SIGINT);
    98.             //sigaddset(&sighandle.sa_mask, SIGQUIT);
    100.             sigaction(SIGTERM, &sighandle, NULL);
    101.             sigaction(SIGINT, &sighandle, NULL);
    102.             sigaction(SIGQUIT, &sighandle, NULL);

    105.             // AF_PACKET allows application to read pecket from and write packet to network device
    106.             // SOCK_DGRAM the packet exclude ethernet header
    107.             // SOCK_RAW raw data from the device including ethernet header
    108.             // ETH_P_IP all IP packets 
    109.             if((sock = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IP))) == -1) {
    110.                   perror("socket");
    111.                   exit(1);
    112.             }

    115.             // set NIC to promiscous mode, so we can recieve all packets of the network
    116.             strncpy(ethreq.ifr_name, "eth0", IFNAMSIZ);
    117.             if(ioctl(sock, SIOCGIFFLAGS, &ethreq) == -1) {
    118.                   perror("ioctl");
    119.                   close(sock);
    120.                   exit(1);
    121.             }

    124.             ethreq.ifr_flags |= IFF_PROMISC;
    125.             if(ioctl(sock, SIOCSIFFLAGS, &ethreq) == -1) {
    126.                   perror("ioctl");
    127.                   close(sock);
    128.                   exit(1);
    129.             }

    132.             // attach the bpf filter
    133.             if(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter)) == -1) {
    134.                   perror("setsockopt");
    135.                   close(sock);
    136.                   exit(1);
    137.             }

    140.             while(1) {
    141.                   n = recvfrom(sock, buf, sizeof(buf), 0, NULL, NULL);
    142.                   if(n < (ETH_HDR_LEN+IP_HDR_LEN+UDP_HDR_LEN)) {
    143.                         printf("invalid packet/n");
    144.                         continue;
    145.                   }

    148.                   printf("%d bytes recieved/n", n);

    151.                   ethhead = buf;
    152.                   printf("Ethernet: MAC[%02X:%02X:%02X:%02X:%02X:%02X]", ethhead[0], ethhead[1], ethhead[2],
    153.                         ethhead[3], ethhead[4], ethhead[5]);
    154.                   printf("->[%02X:%02X:%02X:%02X:%02X:%02X]", ethhead[6], ethhead[7], ethhead[8],
    155.                         ethhead[9], ethhead[10], ethhead[11]);
    156.                   printf(" type[%04x]/n", (ntohs(ethhead[12]|ethhead[13]<<8)));

    159.                   iphead = ethhead + ETH_HDR_LEN;
    160.                   // header length as 32-bit
    161.                   printf("IP: Version: %d HeaderLen: %d[%d]", (*iphead>>4), (*iphead & 0x0f), (*iphead & 0x0f)*4);
    162.                   printf(" TotalLen %d", (iphead[2]<<8|iphead[3]));
    163.                   printf(" IP [%d.%d.%d.%d]", iphead[12], iphead[13], iphead[14], iphead[15]);
    164.                   printf("->[%d.%d.%d.%d]", iphead[16], iphead[17], iphead[18], iphead[19]);
    165.                   printf(" %d", iphead[9]);

    168.                   if(iphead[9] == IPPROTO_TCP)
    169.                         printf("[TCP]");
    170.                   else if(iphead[9] == IPPROTO_UDP)
    171.                         printf("[UDP]");
    172.                   else if(iphead[9] == IPPROTO_ICMP)
    173.                         printf("[ICMP]");
    174.                   else if(iphead[9] == IPPROTO_IGMP)
    175.                         printf("[IGMP]");
    176.                   else if(iphead[9] == IPPROTO_IGMP)
    177.                         printf("[IGMP]");
    178.                   else
    179.                         printf("[OTHERS]");

    182.                   printf(" PORT [%d]->[%d]/n", (iphead[20]<<8|iphead[21]), (iphead[22]<<8|iphead[23]));
    183.             }
    185.             close(sock);
    186.             exit(0);
    187.       }
    参考资料:
    [1] Linux下Sniffer程序的实现

    [2] 使用socket BPF

    转自：http://blog.csdn.net/wangxg_7520/article/details/2795229
  • 相关阅读:
    nohub
    swoole聊天室
    swoole httpserver学习
    swore tcp服务学习
    ps查看命令
    nginx和php-fpm调用方式
    Unix/Linux环境C编程入门教程(1) Solaris 11 64bit环境搭建
    Unix/Linux环境C编程入门教程(1) Solaris 11 64bit环境搭建
    C语言入门（4）——常量、变量与赋值
    C语言入门（3）——对Hello World程序的解释
  • 原文地址：https://www.cnblogs.com/alan666/p/8311902.html
Copyright © 2020-2023  润新知