教你修改以及重构skb -基于2.6.18

最新推荐文章于 2023-08-05 13:05:45 发布
最新推荐文章于 2023-08-05 13:05:45 发布
阅读量1.6k 收藏 4
点赞数 1
文章标签： struct module null hook tcp 2010
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/high7344/article/details/6180242
版权

测试环境：
   CentOS5.3 2.6.18
工具:
   sendip和wireshark
   sendip可以发送各种数据包,确实方便.wireshark图形化的显示对于分析整个数据包还是相当不错的...
   
一：内核 态基于Netfilter构造数据包
主要有两种方式：
1. alloc_skb申请一个skb结构体，然后根据实际的应用填充不同的成员，或者基于当前数据包的skb，
   调用skb_copy() pskb_copy() skb_copy_expand()等新申请一个nskb，并且拷贝skb的内容。
2. 直接在先前接收到的数据包skb上作修改，主要有源IP、目IP，如果是TCP/UDP协议的话，还有源端口目的端口号。
  就是根据你自己的需求去调整数据包的相关成员即可。然后重新计算各个部分的校验和。

   不管你第一种方式还是第二种方式,你需要知道你也必须知道的就是对于l2 l3 l4层的数据你都必须去构造,我之前就是
由于没有构造L2而郁闷了一天...
   让我们先从一个小程序 开始,把5个hook都挂上mac这个函数,主要就是看看l2，对于l3 l4以及应用层我以前的几个帖子里面
已经有很多了,这里就不说了

  1.    printk("------begin %s--------/n", hooks[hooknum]);
  2.    print_ipproto(iph->protocol);
  3.    printk("len is %d, data len is %d/n", nskb->len, nskb->data_len);
  4.    if(nskb->mac_len > 0)
  5.            {
  6.             eth = (struct ethhdr*)(nskb->mac.raw);
  7.             print_mac(eth);       
  8.                    }   
  9.    printk("------end  %s--------/n", hooks[hooknum]);
复制代码

 

  1. #include <linux /module.h>
  2. #include <linux/kernel .h>
  3. #include <linux/init.h>
  4. #include <linux/netfilter .h>
  5. #include <linux/skbuff.h>
  6. #include <linux/ip.h>
  7. #include <linux/netdevice.h>
  8. #include <linux/if_ether.h>
  9. #include <linux/if_packet.h>
  10. #include <net/tcp .h>
  11. #include <net/udp.h>
  12. #include <net/icmp.h>
  13. #include <linux/netfilter_ipv4.h>
  15. #define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
  16. #define MAC_ARG(x) ((u8*)(x))[0],((u8*)(x))[1],((u8*)(x))[2],((u8*)(x))[3],((u8*)(x))[4],((u8*)(x))[5]
  18. MODULE_LICENSE("GPL");
  19. MODULE_AUTHOR("kenthy@163.com");
  21. const char* hooks[] ={ "NF_IP_PRE_ROUTING",
  22.                              "NF_IP_LOCAL_IN",
  23.                              "NF_IP_FORWARD",
  24.                              "NF_IP_LOCAL_OUT",
  25.                              "NF_IP_POST_ROUTING"};
  27. void print_ipproto(int proto)
  28. {
  29. switch(proto)
  30. {
  31.         case IPPROTO_ICMP:
  32.                 printk("%s/n", "IPPROTO_ICMP");
  33.           break;
  34.         case IPPROTO_TCP:
  35.                 printk("%s/n", "IPPROTO_TCP");
  36.           break;
  37.         case IPPROTO_UDP:
  38.                 printk("%s/n", "IPPROTO_UDP");
  39.           break;
  40.         default:
  41.                 printk("%s/n", "other IPPROTO");
  42.         }
  43. }
  45. void print_mac(struct ethhdr* eth)
  46. {
  47. if(eth==NULL)
  48.         return;
  49.        
  50. if(eth->h_source!=NULL)
  51.         printk("SOURCE:" MAC_FMT "/n", MAC_ARG(eth->h_source));
  53. if(eth->h_dest!=NULL)
  54.              printk("DEST:" MAC_FMT "/n", MAC_ARG(eth->h_dest));
  55. }
  57. unsigned int
  58. mac(unsigned int hooknum,
  59.                  struct sk_buff** skb,
  60.                  const struct net_device *in,
  61.                  const struct net_device *out,
  62.                  int (*okfn)(struct sk_buff*))
  63. {
  64.    struct sk_buff* nskb;
  65.    struct iphdr *iph = NULL;
  66.    struct ethhdr* eth;
  67.   
  68.   nskb = *skb;
  69.   if(nskb==NULL)
  70.   {
  71.     printk("%s/n", "*skb is NULL");
  72.     return NF_ACCEPT;
  73.    }
  74.   
  75.   iph = ip_hdr(nskb);
  76.   if(iph == NULL)
  77.   {
  78.     printk("%s/n", "*iph is NULL");
  79.     return NF_ACCEPT;
  80.    }
  82.       
  83.    printk("------begin %s--------/n", hooks[hooknum]);
  84.    print_ipproto(iph->protocol);
  85.    printk("len is %d, data len is %d/n", nskb->len, nskb->data_len);
  86.    if(nskb->mac_len > 0)
  87.            {
  88.             eth = (struct ethhdr*)(nskb->mac.raw);
  89.             print_mac(eth);       
  90.                    }
  91.    else
  92.     printk("%s", "mac is NULL");               
  93.    
  94.    
  95.    printk("------end  %s--------/n", hooks[hooknum]);
  96.   
  97.     return NF_ACCEPT;
  98. }
  100.                             
  101. static struct nf_hook_ops mac_ops[] = {
  102.         {
  103.                 .hook                = mac,
  104.                 .owner                = THIS_MODULE,
  105.                 .pf                = PF_INET,
  106.                 .hooknum        = NF_IP_PRE_ROUTING,
  107.                 .priority = NF_IP_PRI_FIRST,
  108.         },
  109.         {
  110.                 .hook                = mac,
  111.                 .owner                = THIS_MODULE,
  112.                 .pf                = PF_INET,
  113.                 .hooknum        = NF_IP_LOCAL_IN,
  114.                 .priority = NF_IP_PRI_FIRST,
  115.         },
  116.         {
  117.                 .hook                = mac,
  118.                 .owner                = THIS_MODULE,
  119.                 .pf                = PF_INET,
  120.                 .hooknum        = NF_IP_FORWARD,
  121.                 .priority = NF_IP_PRI_FIRST,
  122.         },
  123.         {
  124.                 .hook                = mac,
  125.                 .owner                = THIS_MODULE,
  126.                 .pf                = PF_INET,
  127.                 .hooknum        = NF_IP_LOCAL_OUT,
  128.                 .priority = NF_IP_PRI_FIRST,
  129.         },
  130.         {
  131.                 .hook                = mac,
  132.                 .owner                = THIS_MODULE,
  133.                 .pf                = PF_INET,
  134.                 .hooknum        = NF_IP_PRE_ROUTING,
  135.                 .priority = NF_IP_POST_ROUTING,
  136.         },
  137. };
  139. static int __init init(void)
  140. {
  141.     int ret;
  142.     ret = nf_register_hooks(mac_ops, ARRAY_SIZE(mac_ops));
  143.     if (ret < 0) {
  144.         printk("http detect:can't register mac_ops detect hook!/n");
  145.         return ret;
  146.     }
  147.     printk("insmod mac_ops detect module/n");
  148.     return 0;
  149. }
  151. static void __exit fini(void)
  152. {
  153.     nf_unregister_hooks(mac_ops, ARRAY_SIZE(mac_ops));
  154.     printk("remove mac_ops detect module./n");
  155. }
  157. module_init(init);
  158. module_exit(fini);
复制代码


  insmod mac.ko加载mac模块 后,随便发个ping包
  Jan 10 09:44:13 nfs-client kernel: ------begin NF_IP_LOCAL_OUT--------
Jan 10 09:44:13 nfs-client kernel: IPPROTO_ICMP
Jan 10 09:44:13 nfs-client kernel: len is 84, data len is 0
Jan 10 09:44:13 nfs-client kernel: mac is NULL------end  NF_IP_LOCAL_OUT--------
Jan 10 09:44:13 nfs-client kernel: ------begin NF_IP_PRE_ROUTING--------
Jan 10 09:44:13 nfs-client kernel: IPPROTO_ICMP
Jan 10 09:44:13 nfs-client kernel: len is 84, data len is 0
Jan 10 09:44:13 nfs-client kernel: SOURCE:00:50:56:fa:70:2a
Jan 10 09:44:13 nfs-client kernel: DEST:00:0c:29:4f:de:ac
Jan 10 09:44:13 nfs-client kernel: ------end  NF_IP_PRE_ROUTING--------
Jan 10 09:44:13 nfs-client kernel: ------begin NF_IP_LOCAL_IN--------
Jan 10 09:44:13 nfs-client kernel: IPPROTO_ICMP
Jan 10 09:44:13 nfs-client kernel: len is 84, data len is 0
Jan 10 09:44:13 nfs-client kernel: SOURCE:00:50:56:fa:70:2a
Jan 10 09:44:13 nfs-client kernel: DEST:00:0c:29:4f:de:ac
Jan 10 09:44:13 nfs-client kernel: ------end  NF_IP_LOCAL_IN--------
   可以看到对于挂载在out上的数据包mac已经被剥掉

当接收一个包时，处理n层协议头的函数从n-1层收到一个缓冲区，它的skb->data指向n层协议的头。处理n层协议的函数把本层的指针(例 如，L3对应的是skb->nh指针)初始化为skb->data，因为这个指针的值会在处理下一层协议时改变(skb->data将 被初始化成缓冲区里的其他地址)。在处理n层协议的函数结束时，在把包传递给n+1层的处理函数前，它会把skb->data指针指向n层协议头的 末尾，这正好是n+1层协议的协议头。

发送包的过程与此相反，但是由于要为每一层添加新的协议头，这个过程要比接收包的过程复杂。

sk_buff_003.jpg



      好的,到现在你已经知道要重新搞一个数据包需要自己来DIY l2 l3 l4当然还有l7如果你想....   
    来先看看skb的几个重要指针吧
unsigned char *head
unsigned char *end
unsigned char *data
unsigned char *tail
它们表示缓冲区和数据部分的边界。在每一层申请缓冲区时，它会分配比协议头或协议数据大的空间。head和end指向缓冲区的头部和尾部，而data和 tail指向实际数据的头部和尾部。每一层会在head和data之间填充协议头，或者在tail和end之间添加新的协议数据
   sk_buff_002.jpg



那么具体操作这些指针呢？
(a)skb_put, (b)skb_push, (c)skb_pull, and (d)skb_reserve
sk_buff_004.jpg



  再加上dev_queue_xmit这个函数,你已经可以完成整件事了,对你现在有点蒙感觉无从下手,我也是!!! 我是历经几十次的死机才成功的,写这个文章也是希望后来人少走点弯路...

  那就从修改开始吧....

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/init.h>
  5. #include <linux/netfilter.h>
  6. #include <linux/skbuff.h>
  7. #include <linux/ip.h>
  8. #include <linux/netdevice.h>
  9. #include <linux/if_ether.h>
  10. #include <linux/if_packet.h>
  11. #include <linux/inet.h>
  12. #include <net/tcp.h>
  13. #include <net/udp.h>
  14. #include <net/icmp.h>
  15. #include <linux/netfilter_ipv4.h>
  18. MODULE_LICENSE("GPL");
  19. MODULE_AUTHOR("kenthy@163.com");
  21. #define    ETH    "eth0"
  22. unsigned char   SMAC[ETH_ALEN] = {0x00,0x0C,0x29,0x4F,0xDE,0xAC};
  23. unsigned char   DMAC[ETH_ALEN] = {0x00,0x50,0x56,0xFA,0x70,0x2A};
  25. static struct nf_hook_ops modify_ops;
  27. static unsigned int modify(unsigned int hooknum, struct sk_buff ** skb,
  28.                                   const struct net_device * in, const struct net_device * out,
  29.                                   int (*okfn)(struct sk_buff *))
  30. {
  31.     struct sk_buff* nskb;
  32.     struct iphdr* nip_hdr;
  33.     unsigned int   nip_hdr_off;
  34.     struct tcphdr* ntcp_hdr;
  35.     unsigned int ntcp_hdr_off;
  36.     struct ethhdr* neth_hdr;
  37.     int ret = 0;
  38.    
  39.    nskb = skb_copy(*skb, GFP_ATOMIC);
  40.    if(nskb == NULL)
  41.      {
  42.              printk("%s/n", "skb_copy return NULL");
  43.              return NF_ACCEPT;
  44.      }
  46.   if( nskb->nh.iph->protocol != IPPROTO_TCP)
  47.     {
  48.             kfree_skb(nskb);
  49.       return NF_ACCEPT;
  50.      }
  52.     nip_hdr = nskb->nh.iph;
  53.     nip_hdr_off = nip_hdr->ihl << 2;
  54.    
  55.     ntcp_hdr = (struct tcphdr *)((void *)nip_hdr + nip_hdr_off);
  56.     ntcp_hdr_off = ntcp_hdr->doff << 2;
  57.     if(!ntcp_hdr->syn)
  58.             {
  59.                     kfree_skb(nskb);
  60.                     return NF_ACCEPT;
  61.             }
  62.    
  63.     //evil!
  64.     nip_hdr->daddr = in_aton("192.168.1.101");
  66.     nip_hdr->check = 0;
  67.     nip_hdr->check = ip_fast_csum((unsigned char *)nip_hdr, nip_hdr->ihl);
  68.         
  69.     nskb->csum = 0;
  70.     nskb->csum = csum_partial((unsigned char *)(ntcp_hdr + ntcp_hdr_off),
  71.                                       ntohs(nip_hdr->tot_len) - nip_hdr_off - ntcp_hdr_off, 0);
  73.     ntcp_hdr->check = 0;
  74.     ntcp_hdr->check = csum_tcpu dp_magic(nip_hdr->saddr, nip_hdr->daddr,
  75.                                         ntohs(nip_hdr->tot_len) - nip_hdr_off, nip_hdr->protocol,
  76.                                         csum_partial((unsigned char *)ntcp_hdr, ntcp_hdr_off, nskb->csum));
  79.     nskb->ip_summed = CHECKSUM_NONE;
  80.     nskb->pkt_type  = PACKET_OTHERHOST;
  81.    
  82.     nskb->dev = dev_get_by_name(ETH);
  83.     if(nskb->dev==NULL)
  84.     {
  85.             printk("%s/n", "dev_get_by_name return NULL");
  86.             kfree_skb(nskb);
  87.             return NF_ACCEPT;
  88.             }
  89.            
  90.     nskb->mac.raw = skb_push (nskb, ETH_HLEN);
  91.      { //eth headeri
  92.       neth_hdr = (struct ethhdr *)nskb->mac.raw;
  93.       memcpy (neth_hdr->h_dest, DMAC, ETH_ALEN);
  94.       memcpy (neth_hdr->h_source, SMAC, ETH_ALEN);
  95.       neth_hdr->h_proto = __constant_htons (ETH_P_IP);
  96.     }
  97.    
  99.     dev_hold(nskb->dev);
  100.     printk("%s/n", "dev_hold ok");
  101.    
  102.     ret = dev_queue_xmit(nskb);
  103.     printk("ret:%d/n", ret);
  104.     return NF_STOLEN;
  105. }
  108. static int __init init(void)
  109. {
  110.   int  ret = 0;
  111.   modify_ops.hook = modify;
  112.   modify_ops.hooknum = NF_IP_LOCAL_OUT;
  113.   modify_ops.pf = PF_INET;
  114.   modify_ops.priority = NF_IP_PRI_FIRST;
  116.   ret = nf_register_hook(&modify_ops);
  117.   if (ret < 0)
  118.    {
  119.      printk("%s/n", "can't modify skb hook!");
  120.      return ret;
  121.    }
  123.     printk("%s/n", "insmod modify skb module");
  124.     return 0;
  125. }
  127. static void __exit fini(void)
  128. {
  129.     nf_unregister_hook(&modify_ops);
  130.     printk("%s/n", "remove modify skb module.");
  131. }
  133. module_init(init);
  134. module_exit(fini);
复制代码



测试结果:

sendip -p ipv4 -is 192.168.238.180 -p tcp -ts 598982 -td 80 192.168.1.1
//                                  sip                                 sport       dport  dip
sendip比较好用吧,你可以指定syn ack之类的呢
skb_modify.JPG


上面的三个数据包是没有加载skb_modify模块的...上面的具体函数你们可以sourceinsight跟踪看看,我也不可能一一讲解

因为我们是挂在NF_IP_LOCAL_OUT上所以我们需要重新搞mac header

那么DIY SKB呢？

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/init.h>
  4. #include <linux/netfilter.h>
  5. #include <linux/skbuff.h>
  6. #include <linux/ip.h>
  7. #include <linux/inet.h>
  8. #include <linux/netdevice.h>
  9. #include <linux/if_ether.h>
  10. #include <linux/if_packet.h>
  11. #include <net/tcp.h>
  12. #include <net/udp.h>
  13. #include <net/route.h>
  14. #include <net/icmp.h>
  15. #include <linux/netfilter_ipv4.h>
  17. MODULE_LICENSE("GPL");
  18. MODULE_AUTHOR("kenthy@163.com");
  20. #define    ETH     "eth0"
  21. #define    SIP     "192.168.238.180"
  22. #define    DIP     "192.168.1.101"
  23. #define    SPORT   39804
  24. #define    DPORT   80
  26. unsigned char   SMAC[ETH_ALEN] = {0x00,0x0C,0x29,0x4F,0xDE,0xAC};
  27. unsigned char   DMAC[ETH_ALEN] = {0x00,0x50,0x56,0xFA,0x70,0x2A};
  29. int cp_dev_xmit_tcp (char * eth, u_char * smac, u_char * dmac,
  30.              u_char * pkt, int pkt_len,
  31.              u_long sip, u_long dip,
  32.              u_short sport, u_short dport, u_long seq, u_long ack_seq, u_char psh, u_char fin)
  33. {
  34.   struct sk_buff * skb = NULL;
  35.   struct net_device * dev = NULL;
  36.   struct ethhdr * ethdr = NULL;
  37.   struct iphdr * iph = NULL;
  38.   struct tcphdr * tcph = NULL;
  39.   u_char * pdata = NULL;
  40.   int nret = 1;
  42.   if (NULL == smac || NULL == dmac) goto out;
  44.   dev = dev_get_by_name(eth);
  45.   if (NULL == dev)
  46.    goto out;
  48.   skb = alloc_skb (pkt_len + sizeof (struct iphdr) + sizeof (struct tcphdr) + LL_RESERVED_SPACE (dev), GFP_ATOMIC);
  49.   
  50.   if (NULL == skb)
  51.     goto out;
  52.   
  53.   skb_reserve (skb, LL_RESERVED_SPACE (dev));
  55.   skb->dev = dev;
  56.   skb->pkt_type = PACKET_OTHERHOST;
  57.   skb->protocol = __constant_htons(ETH_P_IP);
  58.   skb->ip_summed = CHECKSUM_NONE;
  59.   skb->priority = 0;
  60.   
  61.   skb->nh.iph = (struct iphdr*)skb_put(skb, sizeof (struct iphdr));
  62.   skb->h.th = (struct tcphdr*)skb_put(skb, sizeof (struct tcphdr));
  64.   pdata = skb_put (skb, pkt_len);
  65.   {
  66.     if (NULL != pkt)
  67.      memcpy (pdata, pkt, pkt_len);
  68.   }
  69.   
  71.   {
  72.     tcph = (struct tcphdr *) skb->h.th;
  73.     memset (tcph, 0, sizeof (struct tcphdr));
  74.     tcph->source = sport;
  75.     tcph->dest = dport;
  76.     tcph->seq = seq;
  77.     tcph->ack_seq = ack_seq;
  78.     tcph->doff = 5;
  79.     tcph->psh = psh;
  80.     tcph->fin = fin;
  81.     tcph->syn = 1;
  82.     tcph->ack = 0;
  83.     tcph->window = __constant_htons (5840);
  84.     skb->csum = 0;
  85.     tcph->check = 0;
  86.   }
  87.   
  88.   {
  89.     iph = (struct iphdr*) skb->nh.iph;
  90.     iph->version = 4;
  91.     iph->ihl = sizeof(struct iphdr)>>2;
  92.     iph->frag_off = 0;
  93.     iph->protocol = IPPROTO_TCP;
  94.     iph->tos = 0;
  95.     iph->daddr = dip;
  96.     iph->saddr = sip;
  97.     iph->ttl = 0x40;
  98.     iph->tot_len = __constant_htons(skb->len);
  99.     iph->check = 0;
  100.   }
  101.   
  102.   skb->csum = skb_checksum (skb, iph->ihl*4, skb->len - iph->ihl * 4, 0);
  103.   tcph->check = csum_tcpudp_magic (sip, dip, skb->len - iph->ihl * 4, IPPROTO_TCP, skb->csum);
  105.   
  106.   skb->mac.raw = skb_push (skb, 14);
  107.   {
  108.     ethdr = (struct ethhdr *)skb->mac.raw;
  109.     memcpy (ethdr->h_dest, dmac, ETH_ALEN);
  110.     memcpy (ethdr->h_source, smac, ETH_ALEN);
  111.     ethdr->h_proto = __constant_htons (ETH_P_IP);
  112.   }
  115.   if (0 > dev_queue_xmit(skb)) goto out;
  116.   
  117.   nret = 0;
  118. out:
  119.   if (0 != nret && NULL != skb) {dev_put (dev); kfree_skb (skb);}
  120.   
  121.   return (nret);
  122. }
  124. static int __init init(void)
  125. {
  126.   printk("%s/n","insmod skb_diy module/n");
  127.    
  128.    cp_dev_xmit_tcp (ETH, SMAC, DMAC,NULL, 0,
  129.                     in_aton(SIP),in_aton(DIP),
  130.                     htons(SPORT),htons(DPORT),
  131.                     0, 0, 0, 0);
  132.     return 0;
  133. }
  135. static void __exit fini(void)
  136. {
  137.     printk("%s/n","remove skb_diy module./n");
  138. }
  140. module_init(init);
  141. module_exit(fini);
复制代码



测试结果:
skb_diy.JPG




我这里并没有填充上层的东西 但是已经提供接口
pdata = skb_put (skb, pkt_len);
  {
    if (NULL != pkt)
     memcpy (pdata, pkt, pkt_len);
  }

你可以自己先截获一个上层的包再填充进去...  关于上层的东西我开源应用层DPI--l7detect初步成果 已经很清楚了,都已经DPI了


就这么多吧,天冷在寝室又没有暖气和空调,考个研还不让我们进实验室^_^,经过这两天的奋战终于搞定修改skb DIY SKB再加上以前基于netfilter的深度数据包检测.... 至此我可以很自信的说对于netfilter不算静态也算熟练了...

由于本人也是菜鸟,纰漏和不对之处还望指正...   写这些东西纯属爱好,由于内核网络 代码这块变化看对于测试环境不一样的机子,概不保证正确性...但是思路肯定还是这样的,主要就是几个API的变化而已


参考:
  http://blog.chinaunix .net/u/33048/showart_2043789.html
  http://hi.baidu.com/zshidong/blo ... 5f1d00213f2eb0.html

[ 本帖最后由 ubuntu er 于 2010-1-10 14:42 编辑 ]

本主题由 send_linux 于 2010-06-19 14:53 鉴定为 原创
high7344
关注
教你修改以及重构skb
weijinqian0的博客
06-05 4913
测试环境：    CentOS5.3 2.6.18 工具:    sendip和wireshark    sendip可以发送各种数据包,确实方便.wireshark图形化的显示对于分析整个数据包还是相当不错的... 一：内核态基于Netfilter构造数据包 主要有两种方式： 1. alloc_skb申请一个skb结构体，然后根据实际的应用填充不同的成员，或者基
修改以及重构SKB
星愿心愿的专栏
06-05 924
修改以及重构SKB 测试环境：   Fedora13工具:   sendip和wireshark   sendip可以发送各种数据包,确实方便.wireshark图形化的显示对于分析整个数据包还是相当不错的...   一：内核态基于Netfilter构造数据包主要有两种方式：1. alloc_skb申请一个skb结构体，然后根据实际的应用填充不同的成员，或者基于
在2.6.30上修改以及重构skb
high7344的专栏
02-12 1405
<br />上次看了ubuntuer兄写的教你修改以及重构skb ，受益匪浅，真是经典之作。<br /> 但ubuntuer兄的代码是基于2.6.18的，比较旧。今天经过摸索，我终于让其可以在2.6.30上运行了，代码如下：<br /> skb_DIY.c<br /><br /> #include <linux/module.h><br /> #include <linux/kernel.h><br /> #include <linux/init.h><br /> #include <linu
linux内核中如何修改skb报文
小小程序员的博客
07-17 3288
前言 在内核开发中，我们很多时候需要修改linux网络数据包的内容。那么怎样修改skb报文才正确？这个问题在网上的资料讲解的不是很全，下面是我这几天梳理的步骤 skb修改数据包流程 -内核代码中有许多用于计算校验和的API，一下是linux网络技术内幕相关API的截图 修改数据包的流程分析和相关api的介绍 在内核中构造数据包的时候，我们需要关注三个校验和：分别是sk_buf中的csum，ip_summed，ip头部中的check和udp或者tcp头部中的check 用于计算校验和的API：L3
内核扩展数据包的方法之-----skb_copy_expand
草木相隔的博客
06-15 5114
skb_copy_expand是用来拷贝并且扩展原来skb的一个函数。 方法的作用很简单，那么接下来，我们一起看看skb_copy_expand方法的实现方式以及用法。skb_copy_expand原函数 /** * skb_copy_expand - 复制并扩展sk_buff * @skb：要复制的缓冲区 * @newheadroom：头上有新的空闲字节 * @newtailro
skb-java-commons:普通班
05-19
下载并解压后，你可以查看源代码以获取更详细的实现细节，包括类的结构、方法的功能以及可能的示例代码，从而更好地理解和使用这些功能。 总的来说，`skb-java-commons`是一个为Java开发设计的实用工具集，它通过...
skb-java-composite:复合模式实现的基类，以及特殊对象（如 Null、Error、Success）
07-21
"skb-java-composite"项目正是基于Java实现的复合模式的一个实例，其中包含了一些基本类和特殊对象，如Null、Error和Success，这些对象在处理复合结构时有着特殊的意义。 首先，让我们深入理解复合模式。复合模式的...
Ind-SKB-1 - MetaTrader 4脚本.zip
09-11
"Ind-SKB-1.mq4"正是这个指标的源代码文件，用户可以通过查看和编辑此文件来理解其工作原理，甚至根据需要进行个性化修改。 在MT4中，自定义指标通常基于历史数据计算，然后在图表上显示结果，帮助交易者识别模式或...
i - SKB-F - MetaTrader 4脚本.zip
09-10
《MetaTrader 4脚本——i-SKB-F深入解析》 MetaTrader 4（MT4）是一款由MetaQuotes Software Corp开发的广泛应用于外汇、差价合约等金融交易市场的交易平台。其强大的图表分析功能、自定义指标及自动化交易策略...
SKB-1 - MetaTrader 5脚本.zip
09-11
《MetaTrader 5中的SKB-1脚本详解——基于分形的通道与云图实现》 MetaTrader 5（MT5）是一款广泛应用于外汇、股票、期货等金融市场交易的平台，以其强大的图表分析功能和丰富的编程语言MQL5著称。在MT5中，用户...
linux网络校验和计算API
九天小哥的专栏
12-18 1802
文章目录校验和算法IP首部校验和计算APIip_compute_csum()ip_fast_csum()ip_send_check()ip_decrease_ttl()通用校验和计算APIskb_checksum()csum_fold()csum_partial系列csum_block_add/sub()csum_add/sub()skb_checksum_help()csum_tcpudp_magic() 校验和算法 发送方先把校验和字段置为0，然后对参与校验的数据每16bit进行二进制反码求和，然后将结
使用dev_queue_xmit发送定制报文
ldong2007的专栏
05-18 5490
使用dev_queue_xmit发送定制报文 本文档的Copyleft归necofang所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，严禁用于任何商业用途。msn : necofang@hotmail.com来源： necofang.cublog.cn    本文通过实例讲述如何使用dev_queue_xmit来直接发送udp和t
iptable 内核流程
n1wer的专栏
12-01 285
记录一下iptables指令在内核的流程，分为配置和匹配
简单HOOK流程
sinat_40572875的博客
11-15 1196
windows操作系统是以事件驱动，进程从消息队列获取到消息，做出不同的反应，如果我们在进程获取消息之前捕捉到了消息，对消息加以处理，在决定给不给进程发这个消息，就达到了对消息的掌控权，消息HOOK机制就是在系统消息队列和进程消息队列中而建立的一种机制。IAT注入的原理在于我们在进程中注入一个Dll时候，并使用它的函数，实际上实在使用数据目录表中导入的最后一项FirstThun,它表示我们加载函数的地址，如果修改了它，那么我们在调用函数的时候，就会调用我们自己的写函数地址。这样就达到了修改函数作用。
linux内核协议栈skb被释放,linux协议栈skb操作函数
weixin_31893893的博客
05-01 1006
字缓冲区函数函数名功能函数形成参数描述skb_queue_empty检查队列是否为空int skb_queue_empty (struct sk_buff_head * list)list为队列头如果队列为空返回真，否则返回假skb_get引用缓冲区struct sk_buff * skb_get (struct sk_buff * skb)skb为要引用的缓冲区对套接字缓冲区再引用一次，返回指向...
sk_buff操作函数学习
最新发布
to_be_better_wen的博客
08-05 1507
linux 内核socket buffer的操作函数
重构skb包中的检验和的计算
high7344的专栏
03-15 3238
作者：　和linux 相关 <br />简介：这是重构skb包中的检验和的计算的详细页面，介绍了和linux,有关的知识、技巧、经验，和一些linux源码等。   在之前看过那篇对于sk_buff结构介绍的文章后，对skb包中各字段有了比较深的认识吧，这两天又看了如何构造skb包的两个帖子，也在虚拟机上实现了一把，但在这里不讨论实现的具体流程，只说一下在自己构造skb包时各个检验和字段的计算。   其中主要涉及三个函数：skb_checksum(const struct sk_buff *skb,
skb管理函数之alloc_skb、dev_alloc_skb、kfree_skb、dev_kfree_skb、consume_skb
weixin_30539625的博客
09-16 1765
alloc_skb--分配skb dev_alloc_skb--分配skb，通常被设备驱动用在中断上下文中，它是alloc_skb的封装函数，因为在中断处理函数中被调用，因此要求原子操作(GFP_ATOMIC) kfree_skb--减少skb引用，为0则释放，用于出错丢包时释放skb使用； dev_kfree_skb==consume_skb--减少skb引用，为0则释放，成功状态下...
解释一下这段代码的作用if ( skb_tailroom(h_skb) > ( n_skb->len + 4 ) ) { ieee8023_header_to_rfc1042_txsc(n_skb, add_pad); memcpy(skb_put(h_skb, n_skb->len), n_skb->data, n_skb->len); rtw_skb_free(n_skb); return _SUCCESS;
06-14
这段代码的作用如下： 首先判断条件 `skb_tailroom(h_skb) > ( n_skb->len + 4 )` 是否成立，如果成立则执行花括号内的代码。其中，`skb_tailroom(h_skb)` 表示 `h_skb` 指向的数据包中尚未使用的空间大小，`n_skb->len` 表示 `n_skb` 指向的数据包的长度，4 表示 IEEE802.2 协议头的长度。因此，这个条件的意思是判断是否还有足够的空间在 `h_skb` 数据包中，以便能够将 `n_skb` 数据包添加到其中。 如果条件成立，就先将 `n_skb` 数据包转换为 RFC 1042 格式的数据包，并将转换后的数据包存储到 `add_pad` 缓冲区中。这个转换的过程涉及到数据包头的修改，具体实现可以参考 `ieee8023_header_to_rfc1042_txsc` 函数的实现。 接着，将 `n_skb` 数据包的数据区域拷贝到 `h_skb` 数据包中，以便将 `n_skb` 数据包合并到 `h_skb` 数据包中。这个操作使用了 `memcpy` 函数，将 `n_skb` 数据包的数据区域从 `n_skb->data` 地址开始的 `n_skb->len` 个字节拷贝到 `h_skb` 数据包的尾部，返回值是拷贝后 `h_skb` 数据包的尾部地址。 最后，释放 `n_skb` 数据包的内存空间，并返回 `_SUCCESS` 表示操作成功。这个操作使用了 `rtw_skb_free` 函数，释放 `n_skb` 指向的数据包的内存空间，以便不再使用这个数据包。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值