Linux内核--基于Netfilter的内核级包过滤防火墙实现

测试内核版本：Linux Kernel 2.6.35----Linux Kernel 3.2.1

原创作品，转载请标明http://blog.csdn.net/yming0221/article/details/7572382

更多请查看专栏http://blog.csdn.net/column/details/linux-kernel-net.html

作者：闫明

知识基础：本防火墙的开发基于对Linux内核网络栈有个良好的概念，本人对网络栈的分析是基于早期版本（Linux 1.2.13），在明确了网络栈架构的前提下，上升一步分析高级版本内核中的Netfilter防火墙实现原理，然后进行模块或内核编程，开发一款基于包过滤的个人防火墙。

包过滤防火墙：包过滤防火墙是用一个软件查看所流经的数据包的包头（header），由此决定整个包的命运。它可能会决定丢弃（DROP）这个包，可能会接受（ACCEPT）这个包（让这个包通过），也可能执行其它更复杂的动作。工作于网络层，能对IP数据报进行首部检查。例如：IP源地址，目的地址，源端口和目的端口等。

本防火墙的包过滤功能如下：　　

* 拒绝来自某主机或某网段的所有连接。
　　* 允许来自某主机或某网段的所有连接。
　　* 拒绝来自某主机或某网段的指定端口的连接。
　　* 允许来自某主机或某网段的指定端口的连接。
　　* 拒绝发去某主机或某网段的所有连接。
　　* 允许发去某主机或某网段的所有连接。
　　* 拒绝发去某主机或某网段的指定端口的连接。
　　* 允许发去某主机或某网段的指定端口的连接。

Netfilter框架是Linux内核分析和过滤特定协议数据包处理框架，为其他模块动态参与网络层数据包处理提供了方便的途径。

该防火墙的总体结构如下：

本防火墙的简单功能就是检查数据包是否符合过滤的条件，如果不符合就舍弃（Drop），否则就接受（Accept），这里定义八个链表头结点

1. struct ip_node  ip_allowed_in_node_head;/*允许的远程主机或网络IP地址头节点*/
2. struct ip_node  ip_denied_in_node_head;/*拒绝的远程主机或网络IP地址头节点*/
3. struct ip_node  ip_allowed_out_node_head;/*允许的本地主机或网络IP地址头节点*/
4. struct ip_node  ip_denied_out_node_head;/*拒绝的本地主机或网络IP地址头节点*/
5. struct port_node port_allowed_in_node_head;/*允许的远程主机或网络传输层端口号头节点*/
6. struct port_node port_denied_in_node_head;/*拒绝的远程主机或网络传输层端口号头节点*/
7. struct port_node port_allowed_out_node_head;/*允许的本地主机或网络传输层端口号头节点*/
8. struct port_node port_denied_out_node_head;/*拒绝的本地主机或网络传输层端口号头节点*/

用于保存配置文件中的地址或端口信息。

定义两个钩子函数hook_func_in和hook_func_out，分别将其挂载到INET协议族的入口NF_INET_LOCAL_IN和出口NF_INET_LOCAL_OUT：

1. static struct nf_hook_ops my_netfilter[] =
2. {
3. {
4. .hook       =hook_func_in,
5. .owner      =THIS_MODULE,
6. .pf     =PF_INET,
7. .hooknum    =NF_INET_LOCAL_IN,
8. .priority   =100
9. },
10. {
11. .hook       =hook_func_out,
12. .owner      =THIS_MODULE,
13. .pf     =PF_INET,
14. .hooknum    =NF_INET_LOCAL_OUT,
15. .priority   =100
16. }
17. };

说明一下自己定义的一些宏和引用的头文件：

1. #ifndef MODULE
2. #define MODULE
3. #endif
4. #ifndef __KERNEL__
5. #define __KERNEL__
6. #endif
7. //#define NET_DOWN
8. #define MY_FIREWALL_DEBUG
9. #include <asm/system.h>
10. #include <linux/module.h>
11. #include <linux/types.h>
12. #include <linux/kernel.h>
13. #include <linux/string.h>
14. #include <linux/net.h>
15. #include <linux/socket.h>
16. #include <linux/sockios.h>
17. #include <linux/in.h>
18. #include <linux/inet.h>
19. #include <net/ip.h>
20. #include <net/protocol.h>
21. #include <linux/skbuff.h>
22. #include <net/sock.h>
23. #include <net/icmp.h>
24. #include <net/raw.h>
25. #include <net/checksum.h>
26. #include <linux/netfilter_ipv4.h>
27. #include <linux/tcp.h>
28. #include <linux/udp.h>
29. #include <linux/igmp.h>
30. #include <linux/fs.h>
31. #include <linux/mm.h>
32. #include <asm/uaccess.h>
33. #define YES 1
34. #define NO 0
35. #define IP_MAX_LEN 20
36. #define PORT_MAX_LEN 20
37. #define ALLOWED_IP_IN 0
38. #define DENIED_IP_IN 1
39. #define ALLOWED_IP_OUT 2
40. #define DENIED_IP_OUT 3
41. #define ALLOWED_PORT_IN 0
42. #define DENIED_PORT_IN 1
43. #define ALLOWED_PORT_OUT 2
44. #define DENIED_PORT_OUT 3
45. #define ALLOWED_IN_IP_CONF_FILE_DIR "/etc/my_firewall/ip_allowed_in"
46. #define DENIED_IN_IP_CONF_FILE_DIR "/etc/my_firewall/ip_denied_in"
47. #define ALLOWED_IN_PORT_CONF_FILE_DIR "/etc/my_firewall/port_allowed_in"
48. #define DENIED_IN_PORT_CONF_FILE_DIR "/etc/my_firewall/port_denied_in"
49. #define ALLOWED_OUT_IP_CONF_FILE_DIR "/etc/my_firewall/ip_allowed_out"
50. #define DENIED_OUT_IP_CONF_FILE_DIR "/etc/my_firewall/ip_denied_out"
51. #define ALLOWED_OUT_PORT_CONF_FILE_DIR "/etc/my_firewall/port_allowed_out"
52. #define DENIED_OUT_PORT_CONF_FILE_DIR "/etc/my_firewall/port_denied_out"
53. //DEFINE FOR WORK_MODE
54. /*不工作状态，默认*/
55. #define MODE_FREE 0
56. /*允许来自某主机或某网段的所有连接*/
57. #define MODE_IP_ONLY_ALLOWED_IN 1
58. /*拒绝来自某主机或某网段的所有连接*/
59. #define MODE_IP_ONLY_DENIED_IN 2
60. /*允许来自某主机或某网段指定端口的连接*/
61. #define MODE_IP_PORT_ALLOWED_IN 3
62. /*拒绝来自某主机或某网段的指定端口的连接*/
63. #define MODE_IP_PORT_DENIED_IN 4
64. /*允许本地主机或本地网络与其他主机或网络的所有连接*/
65. #define MODE_IP_ONLY_ALLOWED_OUT 5
66. /*拒绝本地主机或本地网络与其他主机或网络的所有连接*/
67. #define MODE_IP_ONLY_DENIED_OUT 6
68. /*允许本地主机或网络与其他主机或其他网络的指定端口的连接*/
69. #define MODE_IP_PORT_ALLOWED_OUT 7
70. /*拒绝本地主机或网络与其他主机或其他网络的指定端口的连接*/
71. #define MODE_IP_PORT_DENIED_OUT 8

下面是防火墙模块的初始化函数：

1. int init_firewall()
2. {
3. (&ip_allowed_in_node_head)->next = NULL;
4. (&ip_denied_in_node_head)->next = NULL;
5. (&port_allowed_in_node_head)->next = NULL;
6. (&port_denied_in_node_head)->next = NULL;
7. (&ip_allowed_out_node_head)->next = NULL;
8. (&ip_denied_out_node_head)->next = NULL;
9. (&port_allowed_out_node_head)->next = NULL;
10. (&port_denied_out_node_head)->next = NULL;
11. switch(work_mode)
12. {
13. case MODE_IP_ONLY_ALLOWED_IN:
14. open_ip_cfg_file(ALLOWED_IN_IP_CONF_FILE_DIR,ALLOWED_IP_IN);
15. break;
16. case MODE_IP_ONLY_DENIED_IN:
17. open_ip_cfg_file(DENIED_IN_IP_CONF_FILE_DIR,DENIED_IP_IN);
18. break;
19. case MODE_IP_PORT_ALLOWED_IN:
20. open_port_cfg_file(ALLOWED_IN_PORT_CONF_FILE_DIR,ALLOWED_PORT_IN);
21. open_ip_cfg_file(ALLOWED_IN_IP_CONF_FILE_DIR,ALLOWED_IP_IN);
22. break;
23. case MODE_IP_PORT_DENIED_IN:
24. open_port_cfg_file(DENIED_IN_PORT_CONF_FILE_DIR,DENIED_PORT_IN);
25. open_ip_cfg_file(ALLOWED_IN_IP_CONF_FILE_DIR,ALLOWED_IP_IN);
26. break;
27. case MODE_IP_ONLY_ALLOWED_OUT:
28. open_ip_cfg_file(ALLOWED_OUT_IP_CONF_FILE_DIR,ALLOWED_IP_OUT);
29. break;
30. case MODE_IP_ONLY_DENIED_OUT:
31. open_ip_cfg_file(DENIED_OUT_IP_CONF_FILE_DIR,DENIED_IP_OUT);
32. break;
33. case MODE_IP_PORT_ALLOWED_OUT:
34. open_port_cfg_file(ALLOWED_OUT_PORT_CONF_FILE_DIR,ALLOWED_PORT_OUT);
35. open_ip_cfg_file(ALLOWED_OUT_IP_CONF_FILE_DIR,ALLOWED_IP_OUT);
36. break;
37. case MODE_IP_PORT_DENIED_OUT:
38. open_port_cfg_file(DENIED_OUT_PORT_CONF_FILE_DIR,DENIED_PORT_OUT);
39. open_ip_cfg_file(ALLOWED_OUT_IP_CONF_FILE_DIR,ALLOWED_IP_OUT);
40. break;
41. default:break;
42. }
43. //open_port_cfg_file(DENIED_PORT_CONF_FILE,DENIED_PORT);
44. nf_register_hook(&my_netfilter[0]);
45. nf_register_hook(&my_netfilter[1]);
46. printk("INIT my firewall OK!\n");
47. return 0;
48. }

先从文件读取配置文件，加载到内核，然后注册钩子操作结构my_netfilter[0],my_netfilter[1]

下图是Netfilter的IPV4下的结构

上述的两个函数挂载位置NF_INET_LOCAL_IN和NF_INET_LOCAL_OUT，分别处理从本机发出和到达本机的数据包。

下面就是挂载到这两个挂载点的钩子函数，用于数据包的检查

1. static unsigned int hook_func_in(unsigned int hook,
2. struct sk_buff *skb,
3. const struct net_device *in,
4. const struct net_device *out,
5. int (*okfn)(struct sk_buff *))
6. {
7. #ifdef NET_DOWN
8. return NF_DROP;
9. #else
10. struct iphdr *iph = ip_hdr(skb);
11. __be32 saddr = ntohl(iph->saddr);
12. __be16 sport = 0,dport = 0;
13. if(trans_port(iph,skb,&sport,&dport) == NO && \
14. work_mode == MODE_IP_PORT_ALLOWED_IN || \
15. work_mode == MODE_IP_PORT_DENIED_IN)
16. return NF_ACCEPT;
17. #ifdef MY_FIREWALL_DEBUG
18. __be32 daddr = ntohl(iph->daddr);
19. printk("saddr= %u : %u  daddr= %u : %d\n",saddr,sport,daddr,dport);
20. #endif
21. switch(work_mode)
22. {
23. case MODE_FREE:
24. return NF_ACCEPT;
25. case MODE_IP_ONLY_ALLOWED_IN:
26. if(ip_in_cfg_file(saddr,&ip_allowed_in_node_head))
27. return NF_ACCEPT;
28. else return NF_DROP;
29. break;
30. case MODE_IP_ONLY_DENIED_IN:
31. if(ip_in_cfg_file(saddr,&ip_denied_in_node_head))
32. return NF_DROP;
33. else return NF_ACCEPT;
34. break;
35. case MODE_IP_PORT_ALLOWED_IN:
36. if(ip_in_cfg_file(saddr,&ip_allowed_in_node_head) && \
37. port_in_cfg_file(sport,&port_allowed_in_node_head))
38. return NF_ACCEPT;
39. else return NF_DROP;
40. break;
41. case MODE_IP_PORT_DENIED_IN:
42. if(ip_in_cfg_file(saddr,&ip_allowed_in_node_head) && \
43. !port_in_cfg_file(sport,&port_denied_in_node_head))
44. return NF_ACCEPT;
45. else return NF_DROP;
46. break;
47. default:
48. return NF_DROP;
49. break;
50. }
51. #endif
52. }
53. static unsigned int hook_func_out(unsigned int hook,
54. struct sk_buff *skb,
55. const struct net_device *in,
56. const struct net_device *out,
57. int (*okfn)(struct sk_buff *))
58. {
59. #ifdef NET_DOWN
60. return NF_DROP;
61. #else
62. struct iphdr *iph = ip_hdr(skb);
63. __be32 daddr = ntohl(iph->daddr);
64. __be16 sport = 0,dport = 0;
65. if(trans_port(iph,skb,&sport,&dport) == NO && \
66. work_mode == MODE_IP_PORT_ALLOWED_OUT && \
67. work_mode == MODE_IP_PORT_DENIED_OUT)
68. return NF_ACCEPT;
69. #ifdef MY_FIREWALL_DEBUG
70. __be32 saddr = ntohl(iph->saddr);
71. printk("saddr= %u : %u  daddr= %u : %d\n",saddr,sport,daddr,dport);
72. #endif
73. switch(work_mode)
74. {
75. case MODE_FREE:
76. return NF_ACCEPT;
77. case MODE_IP_ONLY_ALLOWED_OUT:
78. if(ip_in_cfg_file(daddr,&ip_allowed_out_node_head))
79. return NF_ACCEPT;
80. else return NF_DROP;
81. break;
82. case MODE_IP_ONLY_DENIED_OUT:
83. if(ip_in_cfg_file(daddr,&ip_denied_out_node_head))
84. return NF_DROP;
85. else return NF_ACCEPT;
86. break;
87. case MODE_IP_PORT_ALLOWED_OUT:
88. if(ip_in_cfg_file(daddr,&ip_allowed_out_node_head) && \
89. port_in_cfg_file(dport,&port_allowed_out_node_head))
90. return NF_ACCEPT;
91. else return NF_DROP;
92. break;
93. case MODE_IP_PORT_DENIED_OUT:
94. if(ip_in_cfg_file(daddr,&ip_allowed_out_node_head) && \
95. !port_in_cfg_file(dport,&port_denied_out_node_head))
96. return NF_ACCEPT;
97. else return NF_DROP;
98. break;
99. default:
100. return NF_DROP;
101. break;
102. }
103. #endif
104. }

下面是打开文件并读取信息的函数，这里以打开IP地址的配置文件为例

1. static int open_ip_cfg_file(char * file_dir,int flag)
2. {
3. struct file * filp = NULL;
4. char str[IP_MAX_LEN];
5. int i = 0;
6. if((filp = filp_open(file_dir,O_RDONLY,0)) < 0)
7. return NO;
8. mm_segment_t fs;
9. fs = get_fs();
10. set_fs(KERNEL_DS);
11. struct ip_node * work = NULL;
12. while((filp->f_op->read(filp,&str[i],1,&filp->f_pos)) == 1)
13. {
14. if(str[i] == '\n')//next line
15. {
16. str[i] = '\0';//the end of a string
17. i = 0;
18. #ifdef MY_FIREWALL_DEBUG
19. printk("%s\n",str);
20. #endif
21. work = (struct ip_node *)kmalloc(sizeof(ip_allowed_in_node_head),GFP_ATOMIC);
22. if( ip_to_unsigned(str,&(work->ip_start),&(work->ip_end)) == 0 )
23. return NO;
24. switch(flag)
25. {
26. case ALLOWED_IP_IN:
27. work->next = (&ip_allowed_in_node_head)->next;
28. (&ip_allowed_in_node_head)->next = work;//head insert
29. break;
30. case DENIED_IP_IN:
31. work->next = (&ip_denied_in_node_head)->next;
32. (&ip_denied_in_node_head)->next = work;//head insert
33. break;
34. case ALLOWED_IP_OUT:
35. work->next = (&ip_allowed_out_node_head)->next;
36. (&ip_allowed_out_node_head)->next = work;//head insert
37. break;
38. case DENIED_IP_OUT:
39. work->next = (&ip_denied_out_node_head)->next;
40. (&ip_denied_out_node_head)->next = work;//head insert
41. break;
42. default:break;
43. }
44. filp->f_op->read(filp,&str[0],1,&filp->f_pos);//eat the '\r'
45. }
46. if(i > IP_MAX_LEN) return NO;
47. i++;
48. }
49. return YES;
50. }

这里配置文件中不仅支持具体的IP地址，还支持IP地址网段，例如

192.168.1.1

192.168.1.*

192.168.*.*

192.*.*.*

下面是处理函数

1. /************************************************
2. str:The IP Address like 192.168.1.1
3. start:The pointer to the start IP
4. end:The pointer to the end IP
5. ***********************************************/
6. static int ip_to_unsigned(const char * str,unsigned int * start,unsigned int * end)
7. {
8. char cache[4][4];
9. /*split the IP address*/
10. int i;
11. int k = 0;
12. int j = 0;
13. for(i = 0;str[i] != '\0';i++)
14. {
15. cache[j][k] = str[i];
16. if(str[i] == '.')
17. {
18. cache[j][k] = '\0';
19. k = 0;
20. j++;
21. }
22. else k++;
23. if(j > 3) return NO;
24. }
25. cache[3][k] = '\0';
26. short int a[4];
27. for(i = 0;i < 4;i++)
28. {
29. if(cache[i][0] != '*')
30. {
31. a[i] = (short)simple_strtol(cache[i],NULL,0);
32. if(a[i] < 0 || a[i] > 255) return NO;
33. }
34. else
35. {
36. break;
37. }
38. }
39. switch(i)
40. {
41. case 4:/*Specific IP Address eg.  192.168.1.1   */
42. *start = *end = (a[0]<<24) + (a[1]<<16) + (a[2]<<8 )+a[3];
43. break;
44. case 3:/*  eg. 192.168.1.*   */
45. *start = (a[0]<<24) + (a[1]<<16) + (a[2]<<8);
46. *end = *start + (1<<8) - 1;
47. break;
48. case 2:/*  eg. 192.168.*.*   */
49. *start = (a[0]<<24) + (a[1]<<16);
50. *end = *start + (1<<16) - 1;
51. break;
52. case 1:/*  eg. 192.*.*.*    */
53. *start = (a[0]<<24);
54. *end = *start + (1<<24) - 1;
55. break;
56. default:
57. *start = 0;
58. *end = (1<<32) - 1;
59. break;
60. }
61. return  YES;
62. }

模块的移除函数

1. void remove_firewall()
2. {
3. free_ip_list(&ip_allowed_in_node_head);
4. free_ip_list(&ip_denied_in_node_head);
5. free_ip_list(&ip_allowed_out_node_head);
6. free_ip_list(&ip_denied_out_node_head);
7. free_port_list(&port_allowed_in_node_head);
8. free_port_list(&port_denied_in_node_head);
9. free_port_list(&port_allowed_out_node_head);
10. free_port_list(&port_denied_out_node_head);
11. nf_unregister_hook(&my_netfilter[0]);
12. nf_unregister_hook(&my_netfilter[1]);
13. printk("CLEAN up my firewall OK!\n");
14. }

1. MODULE_LICENSE("Dual BSD/GPL");
2. MODULE_AUTHOR("yming0221@gmail.com");

该防火墙支持命令参数设置，根据参数设置防火墙的工作模式，只需定义和声明

1. static int work_mode = 0;//default mode
2. module_param(work_mode,int,S_IRUGO);

目前测试，防火墙正常工作。

可以看到数据包能到达网络层，但由于防火墙启用的相应检查规则，浏览器等应用层软件无法联网，数据包被丢弃。