标签：

1.NAT的原理

NAT会修改数据包的ip层的源或者目的ip地址。在实际应用中，NAT 主要用于实现私有网络访问公共网络的功能。

1.1 SNAT

源目的地址转换，即对ip数据包的源ip地址进行转换操作，典型的应用即是网关，网关的lan侧会下挂至少两台设备，而这两台设备的ip地址都是lan侧地址，而lan侧设备又要访问公网，这就需要SNAT大展身手了，通过将lan侧发送的ip数据包的源ip地址转换成公网地址即可以访问公网了。

1.2 DNAT

目的地址转换主要是将ip数据包的目的ip地址进行修改。典型的应用就是lan侧的设备需要作为服务器使用，比如网关的lan侧有一个设备用作ftp服务器，而作为服务器就需要一个公网地址。而对于服务器来说，只有客户端先向服务器发送请求后，服务器才会应答，这样的话，客户端发送的请求会首先到达网关，而此时的目的地址为公网地址，这就需要网关将目的ip地址修改成lan侧ftp的lan侧ip地址后才能发送给lan侧ftp服务器，这就需要使用DNAT操作，即DNAT的工作场景

本节我们分析nat表的创建及其hook函数分析，同样的 需要实例化xt_table与ipt_replace这两个结构体。创建filter表时同样需要这样做。

2.NAT模块的初始化

对于NAT模块的初始化，可以分为如下几个方面：

a）NAT表的初始化

b）NAT模块的SNAT与DNAT的target的注册

c）NAT的hook回调函数的初始化

d）四层协议中NAT模块相关的协议变量初始化

下面我们就从这几个方面进行分析

2. 1nat表的注册

首先是nat表的初始化，nat表的初始化与filter表的初始化大致相同，都是

下面是nat表实例化的这两个结构体

[cpp] view plain copy

 

 print?

1. #define NAT_VALID_HOOKS ((1<<NF_IP_PRE_ROUTING) | (1<<NF_IP_POST_ROUTING) | (1<<NF_IP_LOCAL_OUT))  
2.    
3. static struct  
4. {  
5. struct ipt_replace repl;  
6. struct ipt_standard entries[3];  
7. struct ipt_error term;  
8. } nat_initial_table __initdata = {  
9. .repl = {  
10. .name = "nat",  
11. .valid_hooks = NAT_VALID_HOOKS,  
12. .num_entries = 4,  
13. .size = sizeof(struct ipt_standard) * 3 + sizeof(struct ipt_error),  
14. .hook_entry = {  
15. [NF_IP_PRE_ROUTING] = 0,  
16. [NF_IP_POST_ROUTING] = sizeof(struct ipt_standard),  
17. [NF_IP_LOCAL_OUT] = sizeof(struct ipt_standard) * 2 },  
18. .underflow = {  
19. [NF_IP_PRE_ROUTING] = 0,  
20. [NF_IP_POST_ROUTING] = sizeof(struct ipt_standard),  
21. [NF_IP_LOCAL_OUT] = sizeof(struct ipt_standard) * 2 },  
22. },  
23. .entries = {  
24. /* PRE_ROUTING */  
25. {  
26. .entry = {  
27. .target_offset = sizeof(struct ipt_entry),  
28. .next_offset = sizeof(struct ipt_standard),  
29. },  
30. .target = {  
31. .target = {  
32. .u = {  
33. .target_size = IPT_ALIGN(sizeof(struct ipt_standard_target)),  
34. },  
35. },  
36. .verdict = -NF_ACCEPT - 1,  
37. },  
38. },  
39. /* POST_ROUTING */  
40. {  
41. .entry = {  
42. .target_offset = sizeof(struct ipt_entry),  
43. .next_offset = sizeof(struct ipt_standard),  
44. },  
45. .target = {  
46. .target = {  
47. .u = {  
48. .target_size = IPT_ALIGN(sizeof(struct ipt_standard_target)),  
49. },  
50. },  
51. .verdict = -NF_ACCEPT - 1,  
52. },  
53. },  
54. /* LOCAL_OUT */  
55. {  
56. .entry = {  
57. .target_offset = sizeof(struct ipt_entry),  
58. .next_offset = sizeof(struct ipt_standard),  
59. },  
60. .target = {  
61. .target = {  
62. .u = {  
63. .target_size = IPT_ALIGN(sizeof(struct ipt_standard_target)),  
64. },  
65. },  
66. .verdict = -NF_ACCEPT - 1,  
67. },  
68. },  
69. },  
70. /* ERROR */  
71. .term = {  
72. .entry = {  
73. .target_offset = sizeof(struct ipt_entry),  
74. .next_offset = sizeof(struct ipt_error),  
75. },  
76. .target = {  
77. .target = {  
78. .u = {  
79. .user = {  
80. .target_size = IPT_ALIGN(sizeof(struct ipt_error_target)),  
81. .name = IPT_ERROR_TARGET,  
82. },  
83. },  
84. },  
85. .errorname = "ERROR",  
86. },  
87. }  
88. };  
89.    
90. static struct xt_table nat_table = {  
91. .name = "nat",  
92. .valid_hooks = NAT_VALID_HOOKS,  
93. .lock = RW_LOCK_UNLOCKED,  
94. .me = THIS_MODULE,  
95. .af = AF_INET,  
96. };  
97.    

对于这两个结构体，我们已经非常熟悉了，即创建了一个名字为nat的xt_table表，且只在NF_IP_PRE_ROUTING、NF_IP_POST_ROUTING、NF_IP_LOCAL_OUT这3个hook点进行nat操作。且为该表创建了NF_IP_PRE_ROUTING、NF_IP_POST_ROUTING、NF_IP_LOCAL_OUT等3个链，且为每一条链创建了一条target为accept的默认规则。

然后通过调用ipt_register_table即实现了nat表的初始化。

2.2 NAT模块的target注册

对于NAT模块来说，最主要的就是实现地址转换，而iptables中是通过-j实现地址转换的，这就说明NAT模块的注册的target模块一定很重要，那我们现在就分析一下这两个模块

2.2.1 SNAT target的注册

SNAT target的定义如下：

其中target的名称为SNAT，target函数ipt_snat_target，通过这个函数我们能够实现对连接跟踪项的SNAT操作。

[cpp] view plain copy

 

 print?

1. static struct xt_target ipt_snat_reg = {  
2. .name = "SNAT",  
3. .target = ipt_snat_target,  
4. .targetsize = sizeof(struct nf_nat_multi_range_compat),  
5. .table = "nat",  
6. .hooks = 1 << NF_IP_POST_ROUTING,  
7. .checkentry = ipt_snat_checkentry,  
8. .family = AF_INET,  
9. };  

通过模块名称，我们可以知道怎样通过iptables添加SNAT，如下：

iptables -t nat -A POSTROUTING -s 192.168.1.123 -j SNAT --to-source 25.29.1.23

而ipt_snat_target是实现SNAT的重要函数，我们看下这个函数的定义：

功能:实现SNAT功能

1.调用nf_ct_get，获取传入数据包关联的nf_conn变量

2.此处进行SNAT只是设置连接跟踪项中的reply方向的nf_conntrack_tuple变量，

     因此，

   对于主连接，仅设置连接跟踪项的状态为NEW的SNAT操作，因为对于状态不为NEW的连接跟踪项，其reply方向的nf_conntrack_tuple结构的变量的目的地址和 端口号已经修改过了，不需要再次修改了；

   对于期望连接来说，当期望连接刚建立时，其状态仅为IP_CT_RELATED或者IP_CT_RELATED+IP_CT_IS_REPLY，所以

   也只对这两种情况的期望连接，进行SNAT操作。

3.调用nf_nat_setup_info，根据targinfo中的地址范围与端口值修改连接跟踪项的reply方向的nf_conntrack_tuple变量中的值。

执行这个target只是修改了数据包对应的连接跟踪项的reply方向的tuple变量，并没有修改数据包的ip地址，

而修改数据包的ip地址是nat模块的hook函数中执行的(在执行了target操作后才会执行)。

(疑问:为什么是期望连接时，状态为IP_CT_RELATED或者IP_CT_RELATED+IP_CT_IS_REPLY都认为是起始状态呢?

 状态为IP_CT_RELATED时，认为是新创建的连接跟踪项，我是能理解的，但是IP_CT_RELATED+IP_CT_IS_REPLY也

 做为新创建的连接跟踪项的依据，我没有搞懂? 而且我感觉不会出现状态为IP_CT_RELATED+IP_CT_IS_REPLY的

 连接跟踪项

 )

[cpp] view plain copy

 

 print?

1. static unsigned int ipt_snat_target(struct sk_buff **pskb,  
2.     const struct net_device *in,  
3.     const struct net_device *out,  
4.     unsigned int hooknum,  
5.     const struct xt_target *target,  
6.     const void *targinfo)  
7. {  
8. struct nf_conn *ct;  
9. enum ip_conntrack_info ctinfo;  
10. const struct nf_nat_multi_range_compat *mr = targinfo;  
11.    
12. NF_CT_ASSERT(hooknum == NF_IP_POST_ROUTING);  
13.    
14. ct = nf_ct_get(*pskb, &ctinfo);  
15.    
16. /* Connection must be valid and new. */  
17. NF_CT_ASSERT(ct && (ctinfo == IP_CT_NEW || ctinfo == IP_CT_RELATED ||  
18.     ctinfo == IP_CT_RELATED + IP_CT_IS_REPLY));  
19. NF_CT_ASSERT(out);  
20.    
21. return nf_nat_setup_info(ct, &mr->range[0], hooknum);  
22. }  

这个函数主要是通过调用nf_nat_setup_info实现SNAT操作，而对于该函数的分析，我准备放到下一节里分析。

最后通过调用函数xt_register_target，将该target添加到xt[AF_INET].target链表中

2.2.2 DNAT target的注册

[cpp] view plain copy

 

 print?

1. static struct xt_target ipt_dnat_reg = {  
2. .name = "DNAT",  
3. .target = ipt_dnat_target,  
4. .targetsize = sizeof(struct nf_nat_multi_range_compat),  
5. .table = "nat",  
6. .hooks = (1 << NF_IP_PRE_ROUTING) | (1 << NF_IP_LOCAL_OUT),  
7. .checkentry = ipt_dnat_checkentry,  
8. .family = AF_INET,  
9. };  

该target的名称为DNAT，要使用该target，则在iptables命令中需要增加-j DNAT，下面是一个DNAT的命令：

iptables -t nat -A PREROUTING -i wan0 -j DNAT --to-destination 192.168.1.183

该target的处理函数为ipt_dnat_target，该函数的定义如下，与SNAT的处理函数的定义类似，最终都是通过调用函数nf_nat_setup_info实现DNAT转换。

[cpp] view plain copy

 

 print?

1. static unsigned int ipt_dnat_target(struct sk_buff **pskb,  
2.     const struct net_device *in,  
3.     const struct net_device *out,  
4.     unsigned int hooknum,  
5.     const struct xt_target *target,  
6.     const void *targinfo)  
7. {  
8. struct nf_conn *ct;  
9. enum ip_conntrack_info ctinfo;  
10. const struct nf_nat_multi_range_compat *mr = targinfo;  
11.    
12. NF_CT_ASSERT(hooknum == NF_IP_PRE_ROUTING ||  
13.      hooknum == NF_IP_LOCAL_OUT);  
14.    
15. ct = nf_ct_get(*pskb, &ctinfo);  
16.    
17. /* Connection must be valid and new. */  
18. NF_CT_ASSERT(ct && (ctinfo == IP_CT_NEW || ctinfo == IP_CT_RELATED));  
19.    
20. if (hooknum == NF_IP_LOCAL_OUT &&  
21.     mr->range[0].flags & IP_NAT_RANGE_MAP_IPS)  
22. warn_if_extra_mangle((*pskb)->nh.iph->daddr,  
23.      mr->range[0].min_ip);  
24.    
25. return nf_nat_setup_info(ct, &mr->range[0], hooknum);  
26. }  

在初始化函数里通过调用函数xt_register_target，将该target添加到xt[AF_INET].target链表中

2.3 NAT模块的hook函数的注册

Nat表主要对NF_IP_PRE_ROUTING、NF_IP_POST_ROUTING、NF_IP_LOCAL_OUT、NF_IP_LOCAL_IN这4条hook点感兴趣， 那nat的hook函数同样也是注册在这4个hook点上的。下面分析下nat表的hook函数注册情况。

通过ip_nat_in_ops的定义，我发现其在NF_IP_LOCAL_IN这个hook点上也定义了nf_hook_ops，但是我们在nat表的valid_hooks中并没有发现NF_IP_LOCAL_IN呢。

我们知道nat表上是没有NF_IP_LOCAL_IN链的，即在NF_IP_LOCAL_IN点根本不存在任何规则，那即使在NF_IP_LOCAL_IN hook点注册了hook函数，也不会匹配任何规则，那除非其hook函数并不是遍历nat表，而是进行其他的操作。

/* We must be after connection tracking and before packet filtering. */

/*注册在NF_IP_PRE_ROUTING链上，实现DNAT转换的功能(或者对于SNAT时，对reply的数据包实现De-SNAT功能)*/

[cpp] view plain copy

 

 print?

1. static struct nf_hook_ops nf_nat_ops[] = {  
2. /*注册在NF_IP_PRE_ROUTING链上，实现DNAT转换的功能(或者对于SNAT时，对reply的 
3. 数据包实现De-SNAT功能)*/  
4. {  
5. .hook = nf_nat_in,  
6. .owner = THIS_MODULE,  
7. .pf = PF_INET,  
8. .hooknum = NF_IP_PRE_ROUTING,  
9. .priority = NF_IP_PRI_NAT_DST,  
10. },  
11. /* After packet filtering, change source */  
12. /*注册在NF_IP_POST_ROUTING实现SNAT转换的功能(或者对于开启DNAT时，在此处 
13. 会对数据包实现De-DNAT功能)*/  
14. {  
15. .hook = nf_nat_out,  
16. .owner = THIS_MODULE,  
17. .pf = PF_INET,  
18. .hooknum = NF_IP_POST_ROUTING,  
19. .priority = NF_IP_PRI_NAT_SRC,  
20. },  
21. /* After conntrack, adjust sequence number */  
22. {  
23. .hook = nf_nat_adjust,  
24. .owner = THIS_MODULE,  
25. .pf = PF_INET,  
26. .hooknum = NF_IP_POST_ROUTING,  
27. .priority = NF_IP_PRI_NAT_SEQ_ADJUST,  
28. },  
29. /* Before packet filtering, change destination */  
30. /* 
31. 注册在NF_IP_LOCAL_OUT链，实现DNAT转换功能 
32. */  
33. {  
34. .hook = nf_nat_local_fn,  
35. .owner = THIS_MODULE,  
36. .pf = PF_INET,  
37. .hooknum = NF_IP_LOCAL_OUT,  
38. .priority = NF_IP_PRI_NAT_DST,  
39. },  
40. /* After packet filtering, change source */  
41. /* 
42. 注册在NF_IP_LOCAL_IN链上，实现SNAT转换功能 
43. */  
44. {  
45. .hook = nf_nat_fn,  
46. .owner = THIS_MODULE,  
47. .pf = PF_INET,  
48. .hooknum = NF_IP_LOCAL_IN,  
49. .priority = NF_IP_PRI_NAT_SRC,  
50. },  
51. /* After conntrack, adjust sequence number */  
52. {  
53. .hook = nf_nat_adjust,  
54. .owner = THIS_MODULE,  
55. .pf = PF_INET,  
56. .hooknum = NF_IP_LOCAL_IN,  
57. .priority = NF_IP_PRI_NAT_SEQ_ADJUST,  
58. },  
59. };  

接着通过调用nf_register_hooks，即完成nat模块的hook点的注册。

2.4 NAT模块四层协议相关的结构注册

在NAT模块里，四层协议相关的函数与变量，抽象出了结构体nf_nat_protocol，该结构体的定义如下，主要包括四层协议号、转换数据包四层协议相关的关键字的函数、根据输入tuple通过修改四层协议相关的关键字返回一个唯一的未被使用的tuple变量的函数等。

[cpp] view plain copy

 

 print?

1. struct nf_nat_protocol  
2. {  
3. /* Protocol name */  
4. const char *name;  
5.    
6. /* Protocol number. */  
7. /*四层协议号*/  
8. unsigned int protonum;  
9. /*是否为模块*/  
10. struct module *me;  
11.    
12. /* Translate a packet to the target according to manip type. 
13.    Return true if succeeded. */  
14. /*对数据包进行四层协议相关的关键字的NAT转换*/     
15. int (*manip_pkt)(struct sk_buff **pskb,  
16.  unsigned int iphdroff,  
17.  const struct nf_conntrack_tuple *tuple,  
18.  enum nf_nat_manip_type maniptype);  
19.    
20. /* Is the manipable part of the tuple between min and max incl? */  
21. /* 
22. 判断一个连接跟踪的四层协议相关的关键字的值是否在合理的范围内 
23. */  
24. int (*in_range)(const struct nf_conntrack_tuple *tuple,  
25. enum nf_nat_manip_type maniptype,  
26. const union nf_conntrack_man_proto *min,  
27. const union nf_conntrack_man_proto *max);  
28.    
29. /* Alter the per-proto part of the tuple (depending on 
30.    maniptype), to give a unique tuple in the given range if 
31.    possible; return false if not.  Per-protocol part of tuple 
32.    is initialized to the incoming packet. */  
33.  /* 
34. 根据传递的tuple变量与range值，通过随机获取四层协议相关的关键字 
35. 找到一个唯一的未被其他连接跟踪项使用的tuple变量。 
36. */    
37. int (*unique_tuple)(struct nf_conntrack_tuple *tuple,  
38.     const struct nf_nat_range *range,  
39.     enum nf_nat_manip_type maniptype,  
40.     const struct nf_conn *ct);  
41. /*netlink相关*/  
42. int (*range_to_nfattr)(struct sk_buff *skb,  
43.        const struct nf_nat_range *range);  
44.    
45. int (*nfattr_to_range)(struct nfattr *tb[],  
46.        struct nf_nat_range *range);  
47. };  

因为不同的协议，其 nf_nat_protocol变量可能不一样，因此对不同的协议需要定义一个nf_nat_protocol变量。NAT模块用nf_nat_protos[MAX_IP_NAT_PROTO]数组存储不同协议的nf_nat_protocol变量，可以通过函数nf_nat_protocol_register将一个新的nf_nat_protocol变量添加到nf_nat_protos[]数组中。Tcp、udp、icmp的nf_nat_protocol变量的定义以及注册函数如下：

[cpp] view plain copy

 

 print?

1. struct nf_nat_protocol nf_nat_protocol_tcp = {  
2. .name = "TCP",  
3. .protonum = IPPROTO_TCP,  
4. .me = THIS_MODULE,  
5. .manip_pkt = tcp_manip_pkt,  
6. .in_range = tcp_in_range,  
7. .unique_tuple = tcp_unique_tuple,  
8. #if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)  
9. .range_to_nfattr = nf_nat_port_range_to_nfattr,  
10. .nfattr_to_range = nf_nat_port_nfattr_to_range,  
11. #endif  
12. };  
13.    
14. rcu_assign_pointer(nf_nat_protos[IPPROTO_TCP], &nf_nat_protocol_tcp);  
15. rcu_assign_pointer(nf_nat_protos[IPPROTO_UDP], &nf_nat_protocol_udp);  
16. rcu_assign_pointer(nf_nat_protos[IPPROTO_ICMP], &nf_nat_protocol_icmp);  
17.    
18.    

以上就是四个方面的初始化，下面讲一下这个四个方面分别在哪些初始化函数里被调用。

A）nf_nat_init

该函数主要是进行nat相关的nf_nat_protocol变量的初始化，不同四层协议相关的nf_nat_protocol变量的实现可能不一样，nf_nat_protocol变量主要是实现四层协议相关的NAT转换等操作，即上述2.4是在这个函数里初始化的

B）nf_nat_standalone_init

该函数实现如下三个功能：

1.调用函数nf_conntrack_register_cache创建nat模块相关的nf_conn_help 的slab缓存

2.调用nf_nat_rule_init进行nat表与nat转换相关的target的初始化

3.调用nf_register_hooks进行NAT模块相关的hook函数的注册。

即2.3 是在该函数里初始化的，而2.1与2.2则是通过调用nf_nat_rule_init初始化的

C）nf_nat_rule_init

该函数主要实现如下几个功能：

1.注册nat表

2.调用xt_register_target注册SNAT的target，根据该target变量里的target函数，能够 实现SNAT

3.调用xt_register_target注册DNAT的target，根据该target变量里的target函数，能够 实现DNAT功能

即2.1 2.2是在这个函数里进行初始化的。

以上就是本节的主要内容，本节主要是介绍了NAT模块的初始化，下一节就开始分析NAT模块相关的hook函数，以及NAT转换的实现等功能。

Linux netfilter 学习笔记 之十一 ip层netfilter的NAT模块初始化以及NAT原理

标签：

原文地址：http://www.cnblogs.com/foonsun/p/5737945.html