Linux协议栈-netfilter(5)-iptables

最新推荐文章于 2023-01-15 14:05:52 发布
最新推荐文章于 2023-01-15 14:05:52 发布
阅读量307 收藏
点赞数
分类专栏： LINUX 源码 文章标签： LINUX netfilter

文章转载------------------------------点击打开链接

iptables是用户态的配置工具，用于实现网络层的防火墙，用户可以通过iptables命令设置一系列的过滤规则，来截获特定的数据包并进行过滤或其他处理。

iptables命令通过与内核中的netfilter交互来起作用。我们知道netfilter通过挂在每个hook点上的hook函数来过滤数据包，并且将过滤规则存放在几个表中供hook函数使用。相应的，iptables工具也定义了同样的几张规则表来对应netfilter中的表，以及定义了不同的链（chain）来对应netfilter中的hook点。这样，通过iptables命令生成的规则可以很容易的作用到内核中的netfilter模块，netfilter根据这些规则做真正的过滤工作。

netfilter模块中，不同的协议族定义了各自的一套hook点，例如，IPv4、IPv6、ARP、BRIDGE等协议族都分别定义了各自的netfilter处理流程以及各自的hook点，我们比较常见的就是IPv4协议定义的5个hook点（PRE_ROUTING，LOCAL_IN，LOCAL_OUT，FORWARD和POST_ROUTING）。同样的，为了和netfilter交互，在用户态分别有iptables、ip6tables、arptables、ebtables等命令来定义各协议族的过滤规则。

要使用iptables命令，则必须将netfilter模块编进内核。本文内容基于内核版本2.6.31。

1. 数据结构

netfilter中的每个表都定义成一个struct xt_table类型的结构体。例如下面定义的表：

   struct xt_table       *iptable_filter;

   struct xt_table      *iptable_mangle;

   struct xt_table      *iptable_raw;

   struct xt_table      *nat_table;

xt_table结构定义如下，表中的实际规则就放在其中的private成员中。

  1. struct xt_table
  2. {
  3. struct list_head list;
  4. /* 在哪些hook点上注册了hook函数，是一个位图 */
  5. unsigned int valid_hooks;
  6. /*表的实际数据 */
  7. struct xt_table_info *private;
  8. struct module *me;
  9. /* 所属协议族 */
  10. u_int8_t af;
  11. /*表名，供用户空间设置iptables规则，或者内核匹配iptables规则 */
  12. const char name[XT_TABLE_MAXNAMELEN];
  13. };

而private里的内容是：

  1. /* The table itself */
  2. struct xt_table_info
  3. {
  4. /* 表的大小 */
  5. unsigned int size;
  6. /* Number of entries，即规则的数量 */
  7. unsigned int number;
  8. /* Initial number of entries，一般为上一次修改规则时的number */
  9. unsigned int initial_entries;
  11. /* 在每个hook点作用的entry的偏移(注意是相对于最后一个参数entry的偏移，即第一个hook的第一个ipt_entry的hook_entry为0) */
  12. unsigned int hook_entry[NF_INET_NUMHOOKS];
  14. /* 规则表的最大下界 */
  15. unsigned int underflow[NF_INET_NUMHOOKS];
  17. /* 规则表入口，即真正的规则存储结构. 在遍历一个规则表时，以此作为表的起始(即第一个ipt_entry)。由定义可知这是一个数组，每个元素对应每个CPU上的规则 入口。 */
  18. void *entries[ 1];
  19. };

所以，通过private就可以定位到规则的实际内容了。

例如NAT表的定义如下，可知在定义时初始化好了下面4个成员。而在注册时会赋值list成员，在添加新规则时会给private赋值。
  1. static struct xt_table nat_table = {
  2. .name = "nat",
  3. .valid_hooks = ( 1 << NF_INET_PRE_ROUTING) | \
  4. ( 1 << NF_INET_POST_ROUTING) | \
  5. ( 1 << NF_INET_LOCAL_OUT),
  6. .me = THIS_MODULE,
  7. .af = AF_INET,
  8. };

一条iptables规则包括三个部分：ipt_entry、ipt_entry_matches、ipt_entry_target。

ipt_entry_matches由多个ipt_entry_match组成，ipt_entry结构主要保存标准匹配的内容，ipt_entry_match 结构主要保存扩展匹配的内容，ipt_entry_target结构主要保存规则的动作。

  1. struct ipt_entry
  2. {
  3. /* ipt_ip结构:将要进行匹配动作的IP数据报报头的描述 */
  4. struct ipt_ip ip;
  5. /* 经过这个规则后数据报的状态:未改变，已改变，不确定 */
  6. unsigned int nfcache;
  7. /* Size of ipt_entry + matches,target在matches的后面 */
  8. u_int16_t target_offset;
  9. /* Size of ipt_entry + matches + target,即下一个ipt_entry的开始 */
  10. u_int16_t next_offset;
  11. /* 指向数据报所经历的上一个规则地址。还可以作为hook mask表示规则作用于那个
  12. hook点上 */
  13. unsigned int comefrom;
  14. /* 匹配这个规则的数据报的计数以及字节计数 */
  15. struct xt_counters counters;
  16. /* 存放matches(一条规则可有0到多个match)和一个target */
  17. unsigned char elems[ 0];
  18. };

结构体中的elems成员用于定位规则的matches，target_offset用于定位规则的target，next_offset指向下一条规则入口即下一个ipt_entry。这样，只要定位到一个表中第一个规则的ipt_entry，就可以找到这个表中的所有规则了。

一个表中可以有多条规则，下图以IPV4上注册的表以及nat表的规则为例，说明了表中规则的存放形式，该图显示了IPv4协议有filter和nat等规则表，并显示了nat表的规则的存放位置。


NAT表允许在PRE_ROUTING、LOCAL_OUT、POST_ROUTING三个链上设置规则，所以，struct xt_table_info的hook_entry[]和underflow[]成员分别有三个数组元素，用来定位每个链（即hook点）上的第一条规则和最后一条规则。

每个链可以有多条规则，每条规则都是由entry+matches+target组成的，所以在遍历每个链上的规则时，就根据struct ipt_entry来定位每条规则的位置。

用iptables命令还可以创建自定义的子链，例如用户新建一个自定义链NEW_PRE_CHAIN：

iptables -N NEW_PRE_CHAIN

然后设置了两条规则添加到NEW_PRE_CHAIN链上。

接着在PREROUTING链（对应netfilter的hook点NF_INET_PRE_ROUTING）上追加一条跳转到NEW_PRE_CHAIN子链的规则，并将这条规则放到NAT表中，例如：

iptables -t nat -A PREROUTING -i eth1 -p tcp -s 192.168.2.0/24 -d 192.168.2.1 --dport 8080 -j NEW_PRE_CHAIN

上面这条规则的意思是在nat表中添加一条规则：从eth1进来的TCP包，在经过在PREROUTING链时进行判断，如果源IP是192.168.2.x网段，目的IP是192.168.2.1，目的端口为8080，则跳转到NEW_PRE_CHAIN链上继续匹配规则。

说是子链，实际上仍然和原有规则放在一起。例如上面在子链中新添加两条规则后，netfilter的NAT表的规则就变成了：


可以看到两条新的PRE_ROUTING规则被紧跟在原有规则后面存放，并且在内核中的NAT表中并没有关于子链NEW_PRE_CHAIN的信息，因为“子链”的概念是用户态的iptables命令才使用的，iptables做一些处理后将规则传到内核，而内核中netfilter的工作就不会那么复杂。

用户态的iptables命令传入的match和target在内核都要有对应的match和target。内核中所有的match和target都注册在全局数组xt中，该数组每个元素是一个struct xt_af结构，存储一类地址族的matches和targets，如NFPROTO_IPV4。

static struct xt_af *xt;

  1. struct xt_af {
  2. struct mutex mutex;
  3. struct list_head match; //该协议的match集合
  4. struct list_head target; //该协议的taget集合
  5. };

注册函数为xt_register_match(struct xt_match *match)和xt_register_target(struct xt_target *target)。

find_check_entry()函数中可以看到内核如何根据用户态传过来的规则中match和target的name来匹配内核支持的match和target。struct xt_match 和struct xt_target结构都有name成员，用户态传入的name必须是内核已注册的，才能找到对应项添加到一条规则中去。例如，iptables命令想要使用DNAT这个target，则内核中必须要定义了对应“DNAT”的target函数。

2. 用户态使用iptables添加一条规则的流程

用iptables -vxnL或iptables –t filter -vxnL命令可以看到filter表上的所有规则。用iptables –t nat -vxnL命令可以看到nat表中的所有规则。

iptables工具是用户空间和内核的netfilter模块通信的手段，因此iptables中也有“表”和“hook点”的概念，只是hook点被称为内建chain。

Iptables命令中的内建链与Netfilter中hook点的对应关系如下：

  1. static const char *hooknames[] = {
  2. [HOOK_PRE_ROUTING] = "PREROUTING",
  3. [HOOK_LOCAL_IN] = "INPUT",
  4. [HOOK_FORWARD] = "FORWARD",
  5. [HOOK_LOCAL_OUT] = "OUTPUT",
  6. [HOOK_POST_ROUTING] = "POSTROUTING",
  7. #ifdef HOOK_DROPPING
  8. [HOOK_DROPPING] = "DROPPING"
  9. #endif
  10. };

用户配置完iptables规则之后，传给内核的是一个ipt_replace结构，其中包含了内核所需要的所有内容：

  1. /* The argument to IPT_SO_SET_REPLACE. */
  2. struct ipt_replace
  3. {
  4. /* 表名 */
  5. char name[IPT_TABLE_MAXNAMELEN];
  7. /* hook mask */
  8. unsigned int valid_hooks;
  10. /* 新规则的entry数 */
  11. unsigned int num_entries;
  13. /* Total size of new entries */
  14. unsigned int size;
  16. /* Hook entry points. */
  17. unsigned int hook_entry[NF_INET_NUMHOOKS];
  19. /* Underflow points. */
  20. unsigned int underflow[NF_INET_NUMHOOKS];
  22. /* 旧规则的entry数 */
  23. unsigned int num_counters;
  25. /* The old entries' counters. */
  26. struct xt_counters __user *counters;
  28. /* 规则本身 */
  29. struct ipt_entry entries[0];
  30. };

该结构包含了表名，规则挂载的hook点，ipt entry的数目等信息，该结构的最后为实际的规则内容，基本包含了内核中struct xt_table和struct xt_table_info结构所需要的内容。传递的过程通过getsockopt()和setsockopt()系统调用来完成，这两个系统调用的函数原型为：

int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);

 int setsockopt(ints, int level, int optname, const void *optval, socklen_t optlen);

其中getsockopt的参数optname可取的值为IPT_SO_GET_INFO、IPT_SO_GET_ENTRIES、IPT_SO_GET_REVISION_MATCH和IPT_SO_GET_REVISION_TARGET。

setsockopt的参数optname可取的值为IPT_SO_SET_REPLACE和IPT_SO_SET_ADD_COUNTERS，所有修改规则的动作（添加、修改、删除等）都通过IPT_SO_SET_REPLACE完成，而IPT_SO_SET_ADD_COUNTERS更新表中每个ipt_entry的counters成员。

当然这些都是iptables工具做的事情，我们只要会使用iptables命令即可。而我们知道可以自定义链，这也是iptables工具所的要处理的事情，实际上内核是不知道有自定义链的。

在ip_tables_init函数中调用nf_register_sockopt(&ipt_sockopts)注册get和set方法，如下：

  1. ipt_sockopts-> set = do_ipt_set_ctl;
  2. ipt_sockopts->get = do_ipt_get_ctl;

用户改变iptables规则时，通过ipt_sockopts注册的这两个函数进行进一步工作，例如set方法就是将用户空间传过来的ipt_replace来替换旧的iptables规则。这个工作在do_replace()函数中完成。

do_replace()处理流程如下：


该函数流程比较清晰，最终结果是更新了内核中的某个xt_table表，如NAT表。图中未列出一系列的合法性检查，如size和valid_hook的检查，以及对entry/match/target的匹配和检查等。

3. netfilter进行规则匹配的流程

3.1 ipt_do_table()

前面一直讲到根据ipt_do_table()来匹配match并执行target，那我们就从ipt_do_table()开始分析。hook点上的hook函数就是通过这个ipt_do_table()来查找表中规则并将规则作用于数据包的。

  1. unsigned int
  2. ipt_do_table (struct sk_buff *skb,
  3. unsigned int hook,
  4. const struct net_device *in,
  5. const struct net_device *out,
  6. struct xt_table *table)
  7. {
  8. #define tb_comefrom ((struct ipt_entry *)table_base)->comefrom
  9. static const
  10. char nulldevname[IFNAMSIZ] __attribute__((aligned( sizeof( long))));
  11. const struct iphdr *ip;
  12. u_int16_t datalen;
  13. bool hotdrop = false;
  14. /* Initializing verdict to NF_DROP keeps gcc happy. */
  15. unsigned int verdict = NF_DROP;
  16. const char *indev, *outdev;
  17. void *table_base;
  18. struct ipt_entry *e, *back;
  19. struct xt_table_info *private;
  20. struct xt_match_param mtpar;
  21. struct xt_target_param tgpar;
  23. ip = ip_hdr(skb);
  25. /* 是否挂在正确的hook点 */
  26. IP_NF_ASSERT(table->valid_hooks & ( 1 << hook));
  27. xt_info_rdlock_bh();
  29. /* 获取规则内容 */
  30. private = table-> private;
  32. /* 获得表的规则总入口 */
  33. table_base = private->entries[smp_processor_id()];
  35. /* 获得表在该hook点定义的规则的入口 */
  36. e = get_entry(table_base, private->hook_entry[hook]);
  38. /* 如果没有match部分也没有target函数，直接根据verdict的值返回 */
  39. if (e->target_offset <= sizeof(struct ipt_entry) &&
  40. (e->ip.flags & IPT_F_NO_DEF_MATCH)) {
  41. struct ipt_entry_target *t = ipt_get_target(e);
  42. if (!t->u.kernel.target->target) {
  43. int v = ((struct ipt_standard_target *)t)->verdict;
  44. if ((v < 0) && (v != IPT_RETURN)) {
  45. ADD_COUNTER(e->counters, ntohs(ip->tot_len), 1);
  46. xt_info_rdunlock_bh();
  47. return ( unsigned)(-v) - 1; /****finish****/
  48. }
  49. }
  50. }
  52. /* Initialization */
  53. datalen = skb->len - ip->ihl * 4;
  54. indev = in ? in->name : nulldevname;
  55. outdev = out ? out->name : nulldevname;
  57. /* 初始化match的参数 */
  58. mtpar.fragoff = ntohs(ip->frag_off) & IP_OFFSET;
  59. mtpar.thoff = ip_hdrlen(skb);
  60. mtpar.hotdrop = &hotdrop;
  61. mtpar.in = tgpar.in = in;
  62. mtpar.out = tgpar.out = out;
  63. mtpar.family = tgpar.family = NFPROTO_IPV4;
  64. mtpar.hooknum = tgpar.hooknum = hook;
  66. /* For return from builtin chain */
  67. back = get_entry(table_base, private->underflow[hook]);
  69. do {
  70. struct ipt_entry_target *t;
  72. /* 匹配规则的entry部分和match部分 */
  73. IP_NF_ASSERT(e);
  74. IP_NF_ASSERT(back);
  75. /* skb相应字段是否和规则匹配，即匹配entry部分 */
  76. if (!ip_packet_match(ip, indev, outdev,
  77. &e->ip, mtpar.fragoff) ||
  78. /* 将skb放在e的所有match函数中依次进行match */
  79. IPT_MATCH_ITERATE(e, do_match, skb, &mtpar) != 0) {
  80. /* 如果entry或match匹配失败，就不再走下一个match，直接
  81. 跳到下一个entry，依次匹配matches。 */
  82. e = ipt_next_entry(e);
  83. continue;
  84. }
  86. /* 经过上面的匹配，e指向了匹配成功的ipt_entry */
  88. /* 增加统计计数(数据报的字节总数不包含链路层数据长度) */
  89. ADD_COUNTER(e->counters, ntohs(ip->tot_len), 1);
  91. /* 获得target部分 */
  92. t = ipt_get_target(e);
  93. IP_NF_ASSERT(t->u.kernel.target);
  95. /* 如果target函数为NULL，则根据verdict判断是否返回 */
  96. if (!t->u.kernel.target->target) {
  97. int v;
  99. v = ((struct ipt_standard_target *)t)->verdict;
  100. if (v < 0) {
  101. /* Pop from stack? */
  102. if (v != IPT_RETURN) {
  103. verdict = ( unsigned)(-v) - 1;
  104. break; /****finish****/
  105. }
  106. /* 如果返回的是IPT_RETURN，则要返回到父链 */
  107. e = back;
  108. back = get_entry(table_base, back->comefrom);
  109. continue;
  110. }
  111. /* 没有target且verdict>0时，verdict为自定义链起始位置的相对偏移量 */
  112. if (table_base + v != ipt_next_entry(e)
  113. && !(e->ip.flags & IPT_F_GOTO)) {
  114. /* Save old back ptr in next entry */
  115. struct ipt_entry *next = ipt_next_entry(e);
  116. next->comefrom = ( void *)back - table_base;
  117. /* set back pointer to next entry */
  118. back = next;
  119. }
  120. /* 跳到下一个entry */
  121. e = get_entry(table_base, v);
  122. continue;
  123. }
  125. /* Targets which reenter must return
  126. abs. verdicts */
  127. /* 初始化target的参数 */
  128. tgpar.target = t->u.kernel.target;
  129. tgpar.targinfo = t->data;
  131. /* 为skb执行target函数，返回处理结果verdict */
  132. verdict = t->u.kernel.target->target(skb, &tgpar);
  134. /* Target might have changed stuff. */
  135. ip = ip_hdr(skb);
  136. datalen = skb->len - ip->ihl * 4;
  138. /* 如果返回continue，接着走下一个entry。
  139. 返回其他的则处理结束，直接返回verdict */
  140. if (verdict == IPT_CONTINUE)
  141. e = ipt_next_entry(e);
  142. else
  143. /* 返回target函数本身的处理结果 */
  144. /* Verdict */
  145. break; /****finish****/
  146. } while (!hotdrop);
  147. xt_info_rdunlock_bh();
  149. if (hotdrop)
  150. return NF_DROP;
  151. else return verdict;
  153. #undef tb_comefrom
  154. }

注意，找到一个匹配成功的规则，执行target之后就不再遍历下一条规则了，无论target结果怎样。

代码中最主要的内容就是while循环中遍历表中规则，匹配entry和match并执行target。该函数的返回值为规则的处理结果，代码中有三处会停止遍历并返回结果，已用注释/****finish****/标出，返回值都是存放在一个名为verdict的变量中，这个值有多重含义：

1.   如果规则指定了target函数，例如配置iptables命令时指定-j SNAT，verdict就是target函数（如ipt_snat_target）的返回值，如NF_ACCEPT等。

2.   如果规则没有指定target函数，例如配置iptables命令时指定-j ACCEPT。这时如果verdict<0，并且verdict !=  IPT_RETURN，就把(unsigned)(-v) – 1作为返回值。

3.   如果规则没有指定target函数，且verdict<0，verdict ==  IPT_RETURN，则需要返回到父链继续匹配后续规则，例如上面设置的NEW_PRE_CHAIN子链规则匹配完成后需要跳回父链。

4.   如果规则没有指定target函数，且verdict>0，则verdict的值是子链相对于表规则入口的偏移，即后续应该跳到该子链去匹配规则，例如上面设置的NEW_PRE_CHAIN子链规则入口。

对于前两种取值，verdict是作为ipt_do_table()的返回值返回到调用者的，对于后两种取值，则需要继续while循环。

对于第二种取值，如果verdict<0，那需要通过计算来得出返回结果，例如，如果verdict = 0xfffffffe，则(unsigned)(-v) – 1就是1，即NF_ACCEPT，同样的，verdict = 0xffffffff即NF_DROP，等等。

IPT_CONTINUE 和IPT_RETURN定义如下：
  1. /* CONTINUE verdict for targets */
  2. #define XT_CONTINUE 0xFFFFFFFF
  3. /* For standard target */
  4. #define XT_RETURN (-NF_REPEAT - 1)

在一个链中还可以设置默认规则，即如果所有规则都不匹配，就走默认规则。默认规则一般设置为NF_ACCEPT或NF_DROP等。默认规则的target在iptables命令中被称为policy。

例如，我们在NAT表中设置PRE_ROUTING链上的policy是ACCEPT：

       iptables -t nat -P PREROUTING ACCEPT

那在这条链上的最后一条规则不是我们自己手动添加的，而是一条没有match和target的默认规则，verdict被设置为0xfffffffe。

  1. # iptables -t nat -L
  2. Chain PREROUTING (policy ACCEPT)
  3. ••••••

注意，只能设置内建链的policy，不能设置自定义链，因为policy是内核中要使用的，内核并不知道自定义链的存在。另外，NAT表的各链的policy都不能为DROP，因为NAT表本来就不是用来过滤的，想要DROP的规则可以放到filter表中。

3.2 以NAT举例规则匹配流程

我们以下面的规则为例来说明规则匹配过程：

iptables -t nat -I POSTROUTING 3 -o eth1 -j MASQUERADE

这条规则作用在POST_ROUTING链，从eth1发出的数据包，去执行MASQUERADE动作，规则放在NAT表中。所以在NAT的POST_ROUTING的hook函数中会去执行该规则，即nf_nat_out()。

先说一下struct ipt_entry结构中，有一个成员ip，它是一个struct ipt_ip类型的结构体，用来匹配一些基本信息，所以规则的匹配工作并不完全在match中进行，ipt_entry也负责匹配一些内容。

  1. struct ipt_ip {
  2. /* Source and destination IP addr */
  3. struct in_addr src, dst;
  4. /* Mask for src and dest IP addr */
  5. struct in_addr smsk, dmsk;
  6. char iniface[IFNAMSIZ], outiface[IFNAMSIZ];
  7. unsigned char iniface_mask[IFNAMSIZ], outiface_mask[IFNAMSIZ];
  9. /* Protocol, 0 = ANY */
  10. u_int16_t proto;
  12. /* Flags word */
  13. u_int8_t flags;
  14. /* Inverse flags */
  15. u_int8_t invflags;
  16. };

可以看到这个结构可以完成源IP和目的IP、入口和出口设备、协议类型等的匹配。负责匹配ipt_entry部分的函数为ip_packet_match()。

上面的nat规则只要出口是eth1即可，所以该规则并没有match部分。在ipt_do_table()函数中找到target为MASQUERADE，对应到内核的masquerade_tg()函数，该函数负责将skb对应的其关联的nf_conn结构实例进行NAT转换，在下次数据包经过该hook点时，masquerade_tg()会判断conntrack状态而直接返回，从而达到只有第一个包需要查找NAT表，后续skb可以根据conntrack来做NAT的效果。

3.3 SNAT和masquerade

这是两个iptables规则的target，实际上他俩没有区别，只是nat配置规则的两种写法而已。我们先来看一下规则的写法：

iptables -t nat-I POSTROUTING 1  -o $wan_if -jMASQUERADE

iptables -t nat-I POSTROUTING 2  -s $lan_ip/$lan_mask -d$lan_ip/$lan_mask -j SNAT --to-source $wan_ip

规则中的-j选项指定target，这两个target分别对应内核的下面两个函数：

masquerade_tg(structsk_buff *skb, const struct xt_target_param *par);

ipt_snat_target(structsk_buff *skb, const struct xt_target_param *par);

snat规则指定了应该将源ip变成什么地址，而masquerade需要在出口设备的IP列表中选择一个合适的作为转换IP。二者都会调用nf_nat_setup_info()对ct进行转换。

注意，一般情况下路由器只允许内网到外网的NAT，所以必须做完SNAT后，外网的数据包才可以通过转换后的conntrack条目到达内网，所以我们通常不会设置DNAT规则。

同样的，REDIRECT和DNAT这两个target的作用一样，都是修改数据包的目的地址。


linux内核协议栈 netfilter 之 ip 层的 hook 注册概述以及 hook 的调用场景
10-29 2494
1三层netfilterhook点的注册与注销 我们知道使用iptables，添加规则时需要指定表，在iptables中有filter、nat、mangle三张表，因为我们接下来几节分析的内容也是从这三个table表加上连接跟踪，此处我们也已这四个模块来将，而不是按HOOK点的分类来分析 1.1filter 表 hook 注册 struct nf_hook_ops ipt_ops Filter表主要在以下几个hook点上其作用： NF_IP_LOCAL_IN NF_IP_LOCAL_OUT ...
Linux防火墙-Netfilter和iptables
最新发布
flytalei的博客
07-11 864
防火墙（FireWall ) ：隔离功能，工作在网络或主机边缘，对进出网络或主机的数据包基于一定的规则检查，并在匹配某规则时由规则定义的行为进行处理的一组功能的组件，基本上的实现都是默认情况下关闭所有的通过型访问，只开放允许访问的策略,会将希望外网访问的主机放在DMZ(demilitarized zone)网络中.
Linux内核--基于Netfilter的内核级包过滤防火墙实现
星.云计算
05-16 981
测试内核版本：Linux Kernel 2.6.35----Linux Kernel 3.2.1 原创作品，转载请标明http://blog.youkuaiyun.com/yming0221/article/details/7572382 更多请查看专栏http://blog.youkuaiyun.com/column/details/linux-kernel-net.html 作者：闫明 知识基础：本防火墙的开发基于...
(一)洞悉linux下的Netfilter&iptables：什么是Netfilter？
01-23 986
本人研究linux的防火墙系统也有一段时间了，由于近来涉及到的工作比较纷杂，久而久之怕生熟了。趁有时间，好好把这方面的东西总结一番。一来是给自己做个沉淀，二来也欢迎这方面比较牛的前辈给小弟予以指点，共同学习，共同进步。     能在CU上混的人绝非等闲之辈。因此，小弟这里说明一下：本系列博文主要侧重于分析Netfilter的实现机制，原理和设计思想层面的东西，同时从用户态的iptables到内核
Linux 内核开发 - NetFilter
阿呆的隐秘角落
09-12 2742
Linux 内核开发 - NetFilter
Linux协议栈-netfilter(3)-NAT
落尘纷扰的专栏
04-04 3669
本文对netfilter中NAT部分的源码进行分析，读者需要先对NAT的基本概念有一个大致了解。1. NAT模块的初始化NAT模块的初始化过程主要是初始化一些全局变量以及注册NAT相关的hook函数。在下面nf_nat_init()函数和nf_nat_standalone_init()函数的流程图中用红色标记了要初始化的全局数据结构。nf_nat_init()函数：nf_nat_standalon...
Linux协议栈-netfilter(2)-conntrack
热门推荐
落尘纷扰的专栏
04-04 1万+
连接跟踪（conntrack）用来跟踪和记录一个连接的状态，它为经过协议栈的数据包记录状态，这为防火墙检测连接状态提供了参考，同时在数据包需要做NAT时也为转换工作提供便利。本文基于Linux内核2.6.31实现的conntrack进行源码分析。1. conntrack模块初始化1.1 conntrack模块入口conntrack模块的初始化主要就是为必要的全局数据结构进行初始化，代码流程如下：上...
Linux协议栈-netfilter(1)-框架
落尘纷扰的专栏
04-04 1万+
1. netfilter框架 Netfilter 是内核中进行数据包过滤，连接跟踪，地址转换等的主要实现框架。当我们希望过滤特定的数据包或者需要修改特定数据包的某些内容再发送出去，这些动作主要都在netfilter中完成。 iptables工具就是用户空间和内核的Netfilter模块通信的手段，iptables命令提供很多选项来实现过滤数据包的各种操作，后面会讲到iptables命令如何
iptables和netfilter的通信流程
脚踏实地，不断突破自我，每天有收获就OK
12-14 3058
iptables和netfilter通信采用的是setsockopt和getsockopt函数 一、用户态iptables代码 前面博客文章 https://blog.youkuaiyun.com/haolipengzhanshen/article/details/84888489 我们分析了iptables的主流程，相信大家会熟悉下面的代码 ret = do_command4(argc, argv,...
Linux netfilter 学习笔记 之四 ip层netfilter的table注册及规则的添加
lickylin的专栏
06-22 6237
既然我们都已经将xt_table、rule、match、target的结构体之间的联系都已经分析清楚了，那我们接下来分析表的注册、表中规则的添加、表中规则的删除、表中规则的替换也应该比较容易了。   在上节分析时，我们应该有注意到一个细节，即xt_table_info->entries[]是指向每一个CPU对应于该xt_table的所有规则的首地址，而一个表里面所有的规则是按照连续内存存取的。
Linux Netfilter实现机制和扩展技术
08-27 2064
Linux Netfilter实现机制和扩展技术内容：1． IP Packet Flowing2． Netfilter Frame3． Netfilter-iptables Extensions4． 案例：用Netfilter实现VPN
洞悉linux下的Netfilter&iptables：什么是Netfilter？
海边顽石的专栏
08-31 1万+
转自：http://blog.chinaunix.net/uid-23069658-id-3160506.html 很多人在接触iptables之后就会这么一种感觉：我通过iptables命令配下去的每一条规则，到底是如何生效的呢？内核又是怎么去执行这些规则匹配呢？如果iptables不能满足我当下的需求，那么我是否可以去对其进行扩展呢？这些问题，都是我在接下来的博文中一一和大家分享的话题。
iptables的自定义链--子链
weixin_33735077的博客
06-25 1038
我个人理解：子链的作用就是为了减少重复设置，有的时候可能对数据包进行一系列的处理，而且还被多种规则引用。这样就可以设置成子链，一起跳转过去处理。 -j subchain 子链用-N来创建。 iptables -N 规则  ...
Red hat Linux内置防火墙软件iptables---子链RH-Firewall-1-INPUT
anonymalias的专栏
01-07 9550
iptables是Linux内置的封装包过滤软件。它定义了进出Linux封包的过滤规则。Iptables由多个表格组成，每个表格由若干链组成，每个链由若干规则组成。 其中最常用也是最重要的是管理本机进出封包的filter（过滤器）表格，filter默认包含以下3个链：  INPUT链：定义了进入Linux主机的封包的过滤规则； OUTPUT链：定义了送出Linux主机的封包的过滤规则；FO
iptables详解
Windeal
04-09 2423
基本概念防火墙Net-wall　　Net-wall 即防火墙 　　简单地说，网络防火墙的作用就是对计算机流入或者流出的网络通信进行扫描处理。 　　防火墙提供了许多有用的功能，下面是一些例子：1. 过滤掉经过计算机的垃圾报文和攻击报文 2. 端口转发：外网PC通过端口转发可以访问内网PC 3. 限制特殊站点的访问 4. 限制特定流量的流出 ......防火墙的工作原理： 在内核表里生成一系列防火墙
iptables学习
Ghost_199503的博客
11-27 726
iptables学习
(十五)洞悉linux下的Netfilter&iptables：开发自己的hook函数【实战】
~~ LINUX ~~
04-16 573
向Netfilter中注册自己的hook函数 数据包在协议栈中传递时会经过不同的HOOK点，而每个HOOK点上又被Netfilter预先注册了一系列hook回调函数，当每个清纯的数据包到达这些点后会被这些可恶hook函数轮番调戏一番。有时候我们就在想，只让系统自带的这些恶棍来快活，我自己能不能也make一个hook出来和它们同流合污呢？答案是肯定的。 我们来回顾一...
【博客587】ipvs hook点在netfilter中的位置以及优先级
qq_43684922的博客
01-15 2377
根据定义，ipvs挂载在LOCAL_IN、FORWORD和LOCAL_OUT的hook点上了，根据优先级，我们得到以下结论：1、INPUT：ipvs的hook会在Filter TABLE 后执行，然后转到NAT TABLE2、OUTPUT：ipvs的hook会在NAT TABLE ，然后转到Filter TABLE3、FORWARD：ipvs的hookFilter TABLE后执行，然后结束整个FORWARD，包往POSTROUTING走。
ja-netfilter-all压缩包内容解析与应用指南
Linux网络子系统是基于协议栈的设计，负责处理数据包的接收、发送和路由。netfilter作为这个子系统的一个重要组成部分，它位于网络子系统中，与IP层等其他层次交互，可以对流经的数据包执行各种操作。 2. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值