您好:欢迎来到大同基础教育网!
 您的位置:首页 >> 专题报道 >> 网络安全教育

捕获TCP/IP协议栈数据包的原理

作者:徐毅森 来源: 发表日期:2021-05-13 

捕获TCP/IP协议栈数据包的原理

wireshark或tcpdump相信大家都用过,这些工具看起来都很酷,因为我们平时都是在界面看到应用层的数据,这些工具居然可以让我们看到tcp/ip协议栈每层的数据。

本文转载自微信公众号「编程杂技」,作者 theanarkh   。转载本文请联系编程杂技公众号。

wireshark或tcpdump相信大家都用过,这些工具看起来都很酷,因为我们平时都是在界面看到应用层的数据,这些工具居然可以让我们看到tcp/ip协议栈每层的数据。本文介绍一下查看tcp/ip协议栈数据的方法。并实现一个简陋的sniffer,通过nodejs暴露出来使用。我们先看实现。

  1. #include <stdio.h> 
  2. #include <errno.h>  
  3. #include <unistd.h> 
  4. #include <sys/socket.h> 
  5. #include <sys/types.h>   
  6. #include <linux/in.h> 
  7. #include <linux/if_ether.h> 
  8. #include <stdlib.h> 
  9. #include <node_api.h> 
  10. #define DATA_LEN 500 
  11.  
  12. static napi_value start(napi_env env, napi_callback_info info) { 
  13.   int sockfd; 
  14.   int bytes; 
  15.   char data[DATA_LEN]; 
  16.   unsigned char *ipHeader; 
  17.   unsigned char *macHeader; 
  18.   unsigned char *transportHeader; 
  19.   // 对ETH_P_IP协议的数据包感兴趣,PF_PACKET在早期内核是AF_INET 
  20.   sockfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP)); 
  21.   if (sockfd < 0) { 
  22.     printf("创建socket错误"); 
  23.     exit(1); 
  24.   } 
  25.  
  26.   while (1) { 
  27.     bytes = recvfrom(sockfd,data,DATA_LEN,0,NULL,NULL); 
  28.     printf("读到字节数:%d\n",bytes); 
  29.     macHeader = data; 
  30.     printf("MAC报文----------\n"); 
  31.     printf("源Mac地址: %02x:%02x:%02x:%02x:%02x:%02x\n"
  32.            macHeader[0],macHeader[1],macHeader[2], 
  33.            macHeader[3],macHeader[4],macHeader[5]); 
  34.     printf("目的Mac地址: %02x:%02x:%02x:%02x:%02x:%02x\n"
  35.            macHeader[6],macHeader[7],macHeader[8], 
  36.            macHeader[9],macHeader[10],macHeader[11]); 
  37.     printf("上层协议: %04x\n"
  38.            (macHeader[12] << 8) + macHeader[13]); 
  39.     // 跳过Mac头 
  40.     ipHeader = data + 6 + 6 + 2; 
  41.     printf("IP报文--------\n"); 
  42.     printf("ip协议版本:%d\n"
  43.              (ipHeader[0] & 0xF0) >> 4);  
  44.     int ipHeaderLen = (ipHeader[0] & 0x0F) << 2; 
  45.     printf("首部长度:%d\n"
  46.          ipHeaderLen); 
  47.     printf("区分服务:%d\n"
  48.          ipHeader[1]);      
  49.     printf("总长度:%d\n"
  50.          (ipHeader[2]<<8)+ipHeader[3]);  
  51.     printf("标识:%d\n"
  52.          (ipHeader[4]<<8)+ipHeader[5]); 
  53.     printf("标志:%d\n"
  54.          (ipHeader[6] & 0xE0) >> 5);      
  55.     printf("片偏移:%d\n"
  56.          (ipHeader[6] & 0x11) + ipHeader[7]);   
  57.     printf("TTL:%d\n"
  58.          ipHeader[8]); 
  59.     printf("上层协议:%d\n"
  60.          ipHeader[9]);      
  61.     printf("首部校验和:%x%x\n"
  62.          ipHeader[10]+ipHeader[11]);                           
  63.     printf("源ip:%d.%d.%d.%d\n"
  64.          ipHeader[12],ipHeader[13], 
  65.          ipHeader[14],ipHeader[15]); 
  66.     printf("目的ip:%d.%d.%d.%d\n"
  67.          ipHeader[16],ipHeader[17], 
  68.          ipHeader[18],ipHeader[19]); 
  69.  
  70.     transportHeader = ipHeader + ipHeaderLen; 
  71.     printf("传输层报文-----------\n"); 
  72.     printf("源端口:%d\n"
  73.          (transportHeader[0]<<8)+transportHeader[1]); 
  74.     printf("目的端口:%d\n"
  75.          (transportHeader[2]<<8)+transportHeader[3]); 
  76.     printf("序列号:%ud%ud%ud%ud\n"
  77.          transportHeader[4],transportHeader[5],transportHeader[6],transportHeader[7]); 
  78.     printf("确认号:%ud\n"
  79.          (transportHeader[8]<<24)+(transportHeader[9]<<16)+(transportHeader[10]<<8)+(transportHeader[11])); 
  80.     printf("传输层首部长度:%d\n"
  81.         ((transportHeader[12] & 0xF0) >> 4) * 4); 
  82.     printf("FIN:%d\n"
  83.         transportHeader[13] & 0x01); 
  84.     printf("SYN:%d\n"
  85.         (transportHeader[13] & 0x02) >> 1); 
  86.     printf("RST:%d\n"
  87.         (transportHeader[13] & 0x04) >> 2); 
  88.     printf("PSH:%d\n"
  89.         (transportHeader[13] & 0x08) >> 3); 
  90.     printf("ACK:%d\n"
  91.         (transportHeader[13] & 0x016) >> 4); 
  92.     printf("URG:%d\n"
  93.         (transportHeader[13] & 0x32) >> 5); 
  94.     printf("窗口大小:%d\n"
  95.         (transportHeader[14] << 8) + transportHeader[15]); 
  96.     }} 
  97.  
  98. napi_value Init(napi_env env, napi_value exports) { 
  99.   napi_value func; 
  100.   napi_create_function(env, 
  101.                     NULL
  102.                     NAPI_AUTO_LENGTH, 
  103.                     start, 
  104.                     NULL
  105.                     &func); 
  106.   napi_set_named_property(env, exports, "start", func); 
  107.   return exports; 
  108.  
  109. NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) 

我们看到实现并不复杂,首先创建一个socket,然后接收socket上面的数据进行分析就行。上面的代码可以捕获到所有发给本机的tcp/ip包,下面我们看看效果(有些字段还没有仔细处理)。

下面我们来看看底层的实现(2.6.13.1内核)。我们从socket函数的实现开始分析。

  1. asmlinkage long sys_socket(int family, int type, int protocol){ 
  2.   int retval; 
  3.   struct socket *sock; 
  4.   // 创建一个socket 
  5.   retval = sock_create(family, type, protocol, &sock); 
  6.   // 返回文件描述符给用户 
  7.   retval = sock_map_fd(sock); 

接着看sock_create。

  1. int sock_create(int family, int type, int protocol, struct socket **res){ 
  2.   return __sock_create(family, type, protocol, res, 0); 
  3.  
  4. static int __sock_create(int family, int type, int protocol, struct socket **res, int kern){ 
  5.   int err; 
  6.   struct socket *sock; 
  7.   // 分配一个socket 
  8.   if (!(sock = sock_alloc())) { 
  9.     // ... 
  10.   } 
  11.   // socket类型 
  12.   sock->type  = type; 
  13.   err = -EAFNOSUPPORT; 
  14.   // 根据协议簇拿到对应的函数集,然后调用create函数 
  15.   if ((err = net_families[family]->create(sock, protocol)) < 0) 
  16.     goto out_module_put; 

我们看到__sock_create的逻辑很简单,根据协议簇拿到对应的函数集,然后执行其create函数。我们看看PF_PACKET协议簇对应的函数集。PF_PACKET协议簇通过packet_init注册了对应的函数集。

  1. static int __init packet_init(void){ 
  2.   sock_register(&packet_family_ops); 
  3.  
  4. static struct net_proto_family packet_family_ops = { 
  5.   .family = PF_PACKET, 
  6.   .create = packet_create, 
  7.   .owner  = THIS_MODULE, 
  8. }; 

我们看到create函数的值是packet_create。

  1. static int packet_create(struct socket *sock, int protocol){ 
  2.   struct sock *sk; 
  3.   struct packet_sock *po; 
  4.   int err; 
  5.   // 分配一个packet_sock结构体 
  6.   sk = sk_alloc(PF_PACKET, GFP_KERNEL, &packet_proto, 1); 
  7.   // 赋值函数集 
  8.   sock->ops = &packet_ops; 
  9.   // 关联socket和sock 
  10.   sock_init_data(sock, sk); 
  11.   // 拿到一个packet_sock结构体,第一个字段是sock结构体(struct packet_sock *po) 
  12.   po = pkt_sk(sk); 
  13.   sk->sk_family = PF_PACKET; 
  14.   // 接收数据包的函数 
  15.   po->prot_hook.func = packet_rcv; 
  16.   po->prot_hook.af_packet_priv = sk; 
  17.  
  18.   if (protocol) { 
  19.     po->prot_hook.type = protocol; 
  20.     dev_add_pack(&po->prot_hook); 
  21.     sock_hold(sk); 
  22.     po->running = 1; 
  23.   } 

packet_create首先创建了一个packet_sock结构体并初始化,最后调用dev_add_pack。

  1. static struct list_head ptype_base[16];  
  2.  
  3. void dev_add_pack(struct packet_type *pt){ 
  4.   int hash; 
  5.  
  6.   spin_lock_bh(&ptype_lock); 
  7.   if (pt->type == htons(ETH_P_ALL)) { 
  8.     netdev_nit++; 
  9.     list_add_rcu(&pt->list, &ptype_all); 
  10.   } else { 
  11.     hash = ntohs(pt->type) & 15; 
  12.     list_add_rcu(&pt->list, &ptype_base[hash]); 
  13.   } 
  14.   spin_unlock_bh(&ptype_lock); 

我们看到dev_add_pack的逻辑是往ptype_base对应的队列加入一个节点。接着我们看看网卡收到数据包的时候是如何处理的。

  1. int netif_receive_skb(struct sk_buff *skb){ 
  2.   type = skb->protocol; 
  3.   list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) { 
  4.     if (ptype->type == type && 
  5.         (!ptype->dev || ptype->dev == skb->dev)) { 
  6.       if (pt_prev)  
  7.         ret = deliver_skb(skb, pt_prev); 
  8.       pt_prev = ptype; 
  9.     } 
  10.   } 
  11.   ret = pt_prev->func(skb, skb->dev, pt_prev); 

netif_receive_skb的逻辑中会根据收到mac包中上层协议字段找到对应的处理函数,比如本文的packet。最后执行func。从刚才的create函数我们看到func的值是packet_rcv。

  1. static int packet_rcv(struct sk_buff *skb, struct net_device *dev,  struct packet_type *pt) { 
  2.   __skb_queue_tail(&sk->sk_receive_queue, skb); 
  3.   sk->sk_data_ready(sk, skb->len); 

packet_rcv首先把收到的数据包插入socket的接收队列,然后调用sk_data_ready通知socket,对应函数是sock_def_readable。

  1. static void sock_def_readable(struct sock *sk, int len){ 
  2.   if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 
  3.     wake_up_interruptible(sk->sk_sleep); 

sock_def_readable会唤醒阻塞在该socket的进程。那么这个队列里有什么呢?我们回到文章开始的代码,我们创建socket后阻塞在recvfrom。recvfrom通过层层调用最后执行对应函数集的recvmsg。

  1. static int packet_recvmsg(struct kiocb *iocb, struct socket *sock, 
  2.         struct msghdr *msg, size_t len, int flags){ 
  3.  
  4.   struct sk_buff *skb; 
  5.   skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err); 

packet_recvmsg从socket的接收队列取出一个数据包,我们看看skb_recv_datagram。

  1. struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, 
  2.           int noblock, int *err){ 
  3.  
  4.   struct sk_buff *skb; 
  5.   long timeo; 
  6.   /* 
  7.     static inline long sock_rcvtimeo(const struct sock *sk, int noblock) 
  8.     { 
  9.       return noblock ? 0 : sk->sk_rcvtimeo; 
  10.     } 
  11.     获取没有数据包时等待的超时时间 
  12.   */ 
  13.   timeo = sock_rcvtimeo(sk, noblock); 
  14.  
  15.   do { 
  16.     skb = skb_dequeue(&sk->sk_receive_queue); 
  17.     // 有则返回 
  18.     if (skb) 
  19.       return skb; 
  20.  
  21.     // 没有 
  22.     error = -EAGAIN; 
  23.     // 不等待则直接返回 
  24.     if (!timeo) 
  25.       goto no_packet; 
  26.   // 否则等待一段时间 
  27.   } while (!wait_for_packet(sk, err, &timeo)); 

我们看到没有数据包的时候会等待一段时间,我们看看这个时间是多少。

  1. sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 
  2. #define MAX_SCHEDULE_TIMEOUT  LONG_MAX 

我们看到超时时间非常长,当然这个值我们可以通过setsockopt的SO_RCVTIMEO选项设置。接着我们看等待的逻辑wait_for_packet。

  1. #define DEFINE_WAIT(name)           \ 
  2.   wait_queue_t name = {           \ 
  3.     .private  = current,        \ 
  4.     .func   = autoremove_wake_function,   \ 
  5.     .task_list  = LIST_HEAD_INIT((name).task_list), \ 
  6.   } 
  7.  
  8. static int wait_for_packet(struct sock *sk, int *err, long *timeo_p){ 
  9.   DEFINE_WAIT(wait); 
  10.   prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 
  11.   int error = 0; 
  12.   *timeo_p = schedule_timeout(*timeo_p); 
  13. out
  14.   finish_wait(sk->sk_sleep, &wait); 
  15.   return error 

wait_for_packet首先把当前进程插入对应的等待队列并修改进程状态为非就绪(TASK_INTERRUPTIBLE)

  1. void fastcall prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state){ 
  2.   // 把当前进程插入等待队列 
  3.   if (list_empty(&wait->task_list)) 
  4.     __add_wait_queue_tail(q, wait); 
  5.   // 修改进程状态 
  6.   set_current_state(state); 

接着执行进程调度schedule_timeout。

  1. fastcall signed long __sched schedule_timeout(signed long timeout){ 
  2.   struct timer_list timer; 
  3.   unsigned long expire; 
  4.   // 超时时间 
  5.   expire = timeout + jiffies; 
  6.   // 开启定时器 
  7.   init_timer(&timer); 
  8.   timer.expires = expire; 
  9.   timer.data = (unsigned long) current
  10.   timer.function = process_timeout; 
  11.   // 启动定时器 
  12.   add_timer(&timer); 
  13.   // 进程调度 
  14.   schedule(); 
  15.   timeout = expire - jiffies; 
  16.  
  17.  out
  18.   return timeout < 0 ? 0 : timeout; 

以上就是实现捕获tcp/ip协议栈数据包的底层原理。代码仓库https://github.com/theanarkh/node-sniffer

上一篇新闻:

下一篇新闻:

    

举办单位:大同市电化教育馆  

地址:山西省大同市育才北路179号    邮箱:dtdjgwlb@163.com    联系方式:0352-2537438

技术支持:郑州威科姆科技股份有限公司

晋ICP备18001045号    晋公网安备 14020202000129号