自己动手写网络抓包工具

刺骨的言语ヽ痛彻心扉 2021-11-01 09:04 471阅读 0赞

看了太多的“自己动手”，这次咱也“自己动手”一下，写个简单的网络抓包工具吧。要写出像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
2.  
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
2.  
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  
    
10.   
    
11. 
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.  \};
22.   
    
23. 
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>
21.   
    
22. 
23. 
24.  \#define ETH\_HDR\_LEN 14
25.  \#define IP\_HDR\_LEN 20
26.  \#define UDP\_HDR\_LEN 8
27.  \#define TCP\_HDR\_LEN 20
28.   
    
29. 
30. staticint sock;
31.   
    
32. 
33. void sig\_handler(int sig) 
34.  \{ 
35. struct ifreq ethreq;
36. if(sig == SIGTERM)
37.  printf("SIGTERM recieved, exiting.../n");
38. elseif(sig == SIGINT)
39.  printf("SIGINT recieved, exiting.../n");
40. elseif(sig == SIGQUIT)
41.  printf("SIGQUIT recieved, exiting.../n");
42. 
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.  \}
52.   
    
53. 
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;
61.   
    
62. 
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
74.   
    
75. 
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.  \};
86.   
    
87. 
88. struct sock\_fprog filter;
89.  filter.len = sizeof(bpf\_code)/sizeof(bpf\_code\[0\]);
90.  filter.filter = bpf\_code;
91.   
    
92. 
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);
99. 
100.  sigaction(SIGTERM, &sighandle, NULL);
101.  sigaction(SIGINT, &sighandle, NULL);
102.  sigaction(SIGQUIT, &sighandle, NULL);
103.   
    
104. 
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.  \}
113.   
    
114. 
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.  \}
122.   
    
123. 
124.  ethreq.ifr\_flags |= IFF\_PROMISC;
125. if(ioctl(sock, SIOCSIFFLAGS, &ethreq) == -1) \{ 
126.  perror("ioctl");
127.  close(sock);
128.  exit(1);
129.  \}
130.   
    
131. 
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.  \}
138.   
    
139. 
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.  \}
146.   
    
147. 
148.  printf("%d bytes recieved/n", n);
149.   
    
150. 
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)));
157.   
    
158. 
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\]);
166.   
    
167. 
168. if(iphead\[9\] == IPPROTO\_TCP)
169.  printf("\[TCP\]");
170. elseif(iphead\[9\] == IPPROTO\_UDP)
171.  printf("\[UDP\]");
172. elseif(iphead\[9\] == IPPROTO\_ICMP)
173.  printf("\[ICMP\]");
174. elseif(iphead\[9\] == IPPROTO\_IGMP)
175.  printf("\[IGMP\]");
176. elseif(iphead\[9\] == IPPROTO\_IGMP)
177.  printf("\[IGMP\]");
178. else
179.  printf("\[OTHERS\]");
180.   
    
181. 
182.  printf(" PORT \[%d\]->\[%d\]/n", (iphead\[20\]<<8|iphead\[21\]), (iphead\[22\]<<8|iphead\[23\]));
183.  \}
184. 
185.  close(sock);
186.  exit(0);
187.  \}

参考资料:  
\[1\]  [Linux下Sniffer程序的实现][Linux_Sniffer]

\[2\] [使用socket BPF][socket BPF]

转自：http://blog.csdn.net/wangxg\_7520/article/details/2795229

转载于:https://www.cnblogs.com/alan666/p/8311902.html

[Linux_Sniffer]: http://www.nsfocus.net/index.php?act=magazine&do=view&mid=1797
[socket BPF]: http://blog.donews.com/quickmouse/archive/2004/11/17/173266.aspx