感谢支持
我们一直在努力
当前位置：服务器评测 > 教程资讯 > Linux运维 > 正文

Netfilter的expect连接的原理和利用

2012-06-13 分类：Linux运维 阅读(187) 评论(0)

ip_conntrack有一个特性，那就是可以跟踪expect连接，所谓的expect连接，理解起来很简单，那就是“在一个连接中生成的另一个连接”，那么如何来识别一个连接要生成另一个连接呢？以FTP为例，FTP服务器会将文件传输所用的地址和端口信息作为数据载荷传输到对端的，Linux网关捕获这个数据包，将其解开然后根据FTP的协议规范获取地址和端口信息，随后就生成了一个expect连接。也就说，expect连接的参数是从数据载荷中得到的。


既然可以从数据载荷中得到一个“期望的连接”，那么随后的该期望的连接真正到来的时候一般是被允许通过的，这在防火墙上就是所谓的动态规则，在这里，一个约定就是防火墙本身对应用层协议是完全信任的，比方说FTP载荷中附带了生成expect连接的地址和端口信息，防火墙认为此信息是可信的，真的就是服务器或者客户端自己设置上去的。然而现实并不完美，这些信息可能是被攻击者硬添加进去的，如此一来，就有了绕过防火墙的可能，实现方式多种多样，最常见的就是包重放，攻击者截获一个包，然后在其载荷中按照一定的协议规范添加地址和端口信息，然后将此包重放在网络，当其经过防火墙的时候，防火墙就会生成一条动态的针对expect连接的允许规则，这样攻击者便可以绕过防火墙去访问本不该被访问的地址和端口了。


原理很简单，作为一个例子，我编写了一个内核模块，注册了一个捕获expect连接的helper(具体ip_conntrack的helper机制本文不再赘述，本质上就是一堆和既有显式ip_conntrack相关联的链表)，模块代码如下：


  1. #include <linux/module.h>  
  2. #include <linux/netfilter.h>  
  3. #include <linux/ip.h>  
  4. #include <net/tcp.h>  
  5.   
  6. #include <net/netfilter/nf_conntrack.h>  
  7. #include <net/netfilter/nf_conntrack_expect.h>  
  8. #include <net/netfilter/nf_conntrack_helper.h>  
  9.   
  10. MODULE_LICENSE(“GPL”);  
  11. MODULE_AUTHOR(“Marywangran <marywangran@126.com>”);  
  12. MODULE_DESCRIPTION(“expect helper test”);  
  13.   
  14. struct aa_proto {  
  15.     int type;  
  16.     int port;  
  17.     union nf_inet_addr addr;  
  18. };  
  19.   
  20. static int aa_help(struct sk_buff *skb,  
  21.         unsigned int protoff,  
  22.         struct nf_conn *ct,  
  23.         enum ip_conntrack_info ctinfo)  
  24. {  
  25.     unsigned int dataoff, datalen;  
  26.     const struct tcphdr *th;  
  27.     struct tcphdr _tcph;  
  28.     int ret;  
  29.     char *dt_ptr;  
  30.     struct nf_conntrack_expect *exp;  
  31.     int dir = CTINFO2DIR(ctinfo);  
  32.     struct aa_proto prot = {0};  
  33.     uint16_t port = ntohs((uint16_t)prot.port);  
  34.     char aa_buffer[512];  
  35.   
  36.     if (ctinfo != IP_CT_ESTABLISHED  
  37.         && ctinfo != IP_CT_ESTABLISHED+IP_CT_IS_REPLY) {  
  38.         return NF_ACCEPT;  
  39.     }  
  40.     //开始解析数据包的内容  
  41.     th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);  
  42.     dataoff = protoff + th->doff * 4;  
  43.     datalen = skb->len – dataoff;  
  44.     dt_ptr = skb_header_pointer(skb, dataoff, datalen, aa_buffer);  
  45.     //将协议头复制下来  
  46.     memcpy(&prot, dt_ptr, sizeof(struct aa_proto));  
  47.     if (prot.type != 12) {  //如果不是预定义的12类型，www.linuxidc.com说明不需要expect连接  
  48.         ret = NF_ACCEPT;  
  49.         goto out;  
  50.     }  
  51.   
  52.     exp = nf_ct_expect_alloc(ct);  
  53.     port = ntohs((uint16_t)prot.port);  
  54.     nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, AF_INET,  
  55.               &ct->tuplehash[dir].tuple.src.u3, &prot.addr,  
  56.               IPPROTO_TCP, NULL, &port);  
  57.     if (nf_ct_expect_related(exp) != 0)  
  58.         ret = NF_DROP;  
  59.     else  
  60.         ret = NF_ACCEPT;  
  61. out:  
  62.     return ret;  
  63. }  
  64. static const struct nf_conntrack_expect_policy aa_policy = {  
  65.     .max_expected    = 10,  
  66.     .timeout    = 50 * 60,  
  67. };  
  68.   
  69. static struct nf_conntrack_helper aa = {  
  70.     .name = “aa”,  
  71.     .me = THIS_MODULE,  
  72.     .tuple.src.l3num = AF_INET,  
  73.     //作用于TCP的12345端口  
  74.     .tuple.src.u.tcp.port = cpu_to_be16(12345),  
  75.     .tuple.dst.protonum = IPPROTO_TCP,  
  76.     .help = aa_help,  
  77.     .expect_policy = &aa_policy,  
  78. };  
  79.   
  80. static void nf_conntrack_aa_fini(void)  
  81. {  
  82.     nf_conntrack_helper_unregister(&aa);  
  83. }  
  84.   
  85. static int __init nf_conntrack_aa_init(void)  
  86. {  
  87.     int ret = nf_conntrack_helper_register(&aa);  
  88.     if (ret) {  
  89.         nf_conntrack_aa_fini();  
  90.     }  
  91.     return ret;  
  92. }  
  93.   
  94. module_init(nf_conntrack_aa_init);  
  95. module_exit(nf_conntrack_aa_fini);  
在上述实现中，我们自定义了一个简单的协议aa：


  1. struct aa_proto {  
  2.     int type;            //类型，如果是12则说明紧接着的端口，地址信息有效，需要初始化一个expect连接  
  3.     int port;            //若有效，表示expect连接的目的端口  
  4.     union nf_inet_addr addr;    //若有效，表示expect连接的目标地址  
  5. };  
该协议非常简单，那就是如果将第一个int型的字段设置成12，那么就说明要生成一个expect连接，具体的地址和端口信息由接下来两个字段来标示，如果不是12，那么接下来两个字段无意义。 这个协议的目的在于展示expect连接的生成原理，这显然不是本文的全部目的，然而明白这一点却是不可缺少的一步。既然有了内核模块，那么如何来使用它呢？这还得需要一个用户态的应用程序，这里就不展示这个socket程序的全部了，只是展示一下关键点：
1.首先定义aa协议：


  1. struct aa_proto {  
  2.         int type;  
  3.     int port;  
  4.         in_addr_t addr;  
  5. };  
2.定义一个socket写逻辑：


  1. while ((c = getchar())!= ‘q’) {  
  2.     if (c == ‘g’) {  
  3.         struct aa_proto ap = {0};  
  4.         ap.addr = inet_addr(“192.168.188.82”);  
  5.         ap.type = 12;  
  6.         ap.port = 80;  
  7.         send(cClient, &ap, sizeof(struct aa_proto), 0);      
  8.     } else {  
  9.         send(cClient, “11111111”, 8, 0);  
  10.     }      
  11. }  

如此一来，一旦敲入g字符，就会初始化一条expect连接，初始化一条这样的连接到第有什么用呢？这正是本文剩下的目的。我们先定义一个规则序列：


1.允许所有expect连接通过；
2.允许和一台单独的主机192.168.40.247通信
3.拒绝所有其它的通信


接下来我们把一个侦听12345端口的TCP服务器运行在192.168.40.247上，然后在本机上运行TCP客户端，随便输入几个不是q和g的字符，然后我们访问192.168.188.82的80端口，发现不通，这是合理的，毕竟我们拒绝了与该机器的通信，然后我们敲入g，再访问192.168.188.82的80端口，通了，这就是上述第一条规则“允许所有expect连接通过”起作用了。


这能说明什么呢？这说明，Netfilter可以建立一种所谓的“动态规则”，这种规则不是人工设置上去的，而是根据数据包的载荷内容自动生成的，正是所谓基于expect连接的规则。是的，这是一个概念，又能怎样？关键问题是，“我们对非人工干预的规则总是不信任的”，如果我们坐上了一架无人驾驶的飞机，心里面总是会扑通扑通的…具体来讲，我们知道数据包是可以被sniffer的，是可以被重放的，如果仔细研读一下关于FTP，SIP等协议的RFC的话，总是能发现一些可以产生expect连接的地方，那么如果防火墙上的第一条规则是“允许所有expect连接通过”，那么就有办法绕过防火墙访问不该访问的目标了，方法就是sniffer一个FTP/SIP/…包，然后根据RFC的标准按照自己的预设目标重新填充某些expect相关的字段，重新计算一下校验码之类的，然后将包重放到网络上，至此就完成了攻击。


至于如何利用expect连接绕过防火墙，我们的机制是有了，然而具体的操作需要自己的聪明才智了，除了阅读RFC理解协议细节之外，还需要一种采用怪诞方式处理问题的风格，很多时候这不是一种工作意义上的风格，更属于一种hack的风格…

赞(0) 打赏
转载请注明出处：服务器评测 » Netfilter的expect连接的原理和利用
分享到： 更多 (0)
标签：

相关推荐

分类

听说打赏我的人，都进福布斯排行榜啦！

支付宝扫一扫打赏

微信扫一扫打赏