測試核心版本：Linux Kernel 2.6.35----Linux Kernel 3.2.1

作者：閆明

知識基礎：本防火牆的開發基於對Linux核心網路棧有個良好的概念，本人對網路棧的分析是基於早期版本（Linux 1.2.13），在明確了網路棧架構的前提下，上升一步分析高階版本核心中的Netfilter防火牆實現原理，然後進行模組或核心程式設計，開發一款基於包過濾的個人防火牆。

包過濾防火牆：包過濾防火牆是用一個軟體檢視所流經的資料包的包頭（header），由此決定整個包的命運。它可能會決定丟棄（DROP）這個包，可能會接受（ACCEPT）這個包（讓這個包通過），也可能執行其它更復雜的動作。工作於網路層，能對IP資料報進行首部檢查。例如：IP源地址，目的地址，源埠和目的埠等。

本防火牆的包過濾功能如下：　　

* 拒絕來自某主機或某網段的所有連線。
　　* 允許來自某主機或某網段的所有連線。
　　* 拒絕來自某主機或某網段的指定埠的連線。
　　* 允許來自某主機或某網段的指定埠的連線。
　　* 拒絕發去某主機或某網段的所有連線。
　　* 允許發去某主機或某網段的所有連線。
　　* 拒絕發去某主機或某網段的指定埠的連線。
　　* 允許發去某主機或某網段的指定埠的連線。

Netfilter框架是Linux核心分析和過濾特定協議資料包處理框架，為其他模組動態參與網路層資料包處理提供了方便的途徑。

該防火牆的總體結構如下：

本防火牆的簡單功能就是檢查資料包是否符合過濾的條件，如果不符合就捨棄（Drop）

struct ip_node  ip_allowed_in_node_head;/*允許的遠端主機或網路IP地址頭節點*/
struct ip_node  ip_denied_in_node_head;/*拒絕的遠端主機或網路IP地址頭節點*/
struct ip_node  ip_allowed_out_node_head;/*允許的本地主機或網路IP地址頭節點*/
struct ip_node  ip_denied_out_node_head;/*拒絕的本地主機或網路IP地址頭節點*/

struct port_node port_allowed_in_node_head;/*允許的遠端主機或網路傳輸層埠號頭節點*/
struct port_node port_denied_in_node_head;/*拒絕的遠端主機或網路傳輸層埠號頭節點*/
struct port_node port_allowed_out_node_head;/*允許的本地主機或網路傳輸層埠號頭節點*/
struct port_node port_denied_out_node_head;/*拒絕的本地主機或網路傳輸層埠號頭節點*/
 

用於儲存配置檔案中的地址或埠資訊。

定義兩個鉤子函式hook_func_in和hook_func_out，分別將其掛載到INET協議族的入口NF_INET_LOCAL_IN和出口NF_INET_LOCAL_OUT：

static struct nf_hook_ops my_netfilter[] =
{
	{
		.hook		=hook_func_in,
		.owner		=THIS_MODULE,
		.pf		=PF_INET,
		.hooknum	=NF_INET_LOCAL_IN,
		.priority	=100
	},
	{
		.hook		=hook_func_out,
		.owner		=THIS_MODULE,
		.pf		=PF_INET,
		.hooknum	=NF_INET_LOCAL_OUT,
		.priority	=100
	}
};

說明一下自己定義的一些巨集和引用的標頭檔案：

#ifndef MODULE
#define MODULE
#endif

#ifndef __KERNEL__
#define __KERNEL__
#endif
//#define NET_DOWN
#define MY_FIREWALL_DEBUG

#include <asm/system.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>

#include <linux/net.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/in.h>
#include <linux/inet.h>


#include <net/ip.h>
#include <net/protocol.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <net/icmp.h>
#include <net/raw.h>
#include <net/checksum.h>
#include <linux/netfilter_ipv4.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/igmp.h>

#include <linux/fs.h>
#include <linux/mm.h>
#include <asm/uaccess.h>

#define YES 1
#define NO 0

#define IP_MAX_LEN 20
#define PORT_MAX_LEN 20

#define ALLOWED_IP_IN 0
#define DENIED_IP_IN 1
#define ALLOWED_IP_OUT 2
#define DENIED_IP_OUT 3

#define ALLOWED_PORT_IN 0
#define DENIED_PORT_IN 1
#define ALLOWED_PORT_OUT 2
#define DENIED_PORT_OUT 3

#define ALLOWED_IN_IP_CONF_FILE_DIR "/etc/my_firewall/ip_allowed_in"
#define DENIED_IN_IP_CONF_FILE_DIR "/etc/my_firewall/ip_denied_in"
#define ALLOWED_IN_PORT_CONF_FILE_DIR "/etc/my_firewall/port_allowed_in"
#define DENIED_IN_PORT_CONF_FILE_DIR "/etc/my_firewall/port_denied_in"

#define ALLOWED_OUT_IP_CONF_FILE_DIR "/etc/my_firewall/ip_allowed_out"
#define DENIED_OUT_IP_CONF_FILE_DIR "/etc/my_firewall/ip_denied_out"
#define ALLOWED_OUT_PORT_CONF_FILE_DIR "/etc/my_firewall/port_allowed_out"
#define DENIED_OUT_PORT_CONF_FILE_DIR "/etc/my_firewall/port_denied_out"

//DEFINE FOR WORK_MODE

/*不工作狀態，預設*/
#define MODE_FREE 0
/*允許來自某主機或某網段的所有連線*/
#define MODE_IP_ONLY_ALLOWED_IN 1

/*拒絕來自某主機或某網段的所有連線*/
#define MODE_IP_ONLY_DENIED_IN 2

/*允許來自某主機或某網段指定埠的連線*/
#define MODE_IP_PORT_ALLOWED_IN 3

/*拒絕來自某主機或某網段的指定埠的連線*/
#define MODE_IP_PORT_DENIED_IN 4

/*允許本地主機或本地網路與其他主機或網路的所有連線*/
#define MODE_IP_ONLY_ALLOWED_OUT 5

/*拒絕本地主機或本地網路與其他主機或網路的所有連線*/
#define MODE_IP_ONLY_DENIED_OUT 6

/*允許本地主機或網路與其他主機或其他網路的指定埠的連線*/
#define MODE_IP_PORT_ALLOWED_OUT 7

/*拒絕本地主機或網路與其他主機或其他網路的指定埠的連線*/
#define MODE_IP_PORT_DENIED_OUT 8

下面是防火牆模組的初始化函式：

int init_firewall()
{
	(&ip_allowed_in_node_head)->next = NULL;
	(&ip_denied_in_node_head)->next = NULL;
	(&port_allowed_in_node_head)->next = NULL;
	(&port_denied_in_node_head)->next = NULL;

	(&ip_allowed_out_node_head)->next = NULL;
	(&ip_denied_out_node_head)->next = NULL;
	(&port_allowed_out_node_head)->next = NULL;
	(&port_denied_out_node_head)->next = NULL;

	switch(work_mode)
	{
		case MODE_IP_ONLY_ALLOWED_IN:
			open_ip_cfg_file(ALLOWED_IN_IP_CONF_FILE_DIR,ALLOWED_IP_IN);
			break;
		case MODE_IP_ONLY_DENIED_IN:
			open_ip_cfg_file(DENIED_IN_IP_CONF_FILE_DIR,DENIED_IP_IN);
			break;
		case MODE_IP_PORT_ALLOWED_IN:
			open_port_cfg_file(ALLOWED_IN_PORT_CONF_FILE_DIR,ALLOWED_PORT_IN);
			open_ip_cfg_file(ALLOWED_IN_IP_CONF_FILE_DIR,ALLOWED_IP_IN);
			break;
		case MODE_IP_PORT_DENIED_IN:
			open_port_cfg_file(DENIED_IN_PORT_CONF_FILE_DIR,DENIED_PORT_IN);
			open_ip_cfg_file(ALLOWED_IN_IP_CONF_FILE_DIR,ALLOWED_IP_IN);
			break;
		case MODE_IP_ONLY_ALLOWED_OUT:
			open_ip_cfg_file(ALLOWED_OUT_IP_CONF_FILE_DIR,ALLOWED_IP_OUT);
			break;
		case MODE_IP_ONLY_DENIED_OUT:
			open_ip_cfg_file(DENIED_OUT_IP_CONF_FILE_DIR,DENIED_IP_OUT);
			break;
		case MODE_IP_PORT_ALLOWED_OUT:
			open_port_cfg_file(ALLOWED_OUT_PORT_CONF_FILE_DIR,ALLOWED_PORT_OUT);
			open_ip_cfg_file(ALLOWED_OUT_IP_CONF_FILE_DIR,ALLOWED_IP_OUT);
			break;
		case MODE_IP_PORT_DENIED_OUT:
			open_port_cfg_file(DENIED_OUT_PORT_CONF_FILE_DIR,DENIED_PORT_OUT);
			open_ip_cfg_file(ALLOWED_OUT_IP_CONF_FILE_DIR,ALLOWED_IP_OUT);
			break;
		default:break;
	}
	
	
	
	//open_port_cfg_file(DENIED_PORT_CONF_FILE,DENIED_PORT);
	nf_register_hook(&my_netfilter[0]);
	nf_register_hook(&my_netfilter[1]);
	printk("INIT my firewall OK!\n");
	return 0;
}

下圖是Netfilter的IPV4下的結構

上述的兩個函式掛載位置NF_INET_LOCAL_IN和NF_INET_LOCAL_OUT，分別處理從本機發出和到達本機的資料包。

下面就是掛載到這兩個掛載點的鉤子函式，用於資料包的檢查

static unsigned int hook_func_in(unsigned int hook,
				struct sk_buff *skb,
				const struct net_device *in,
				const struct net_device *out,
				int (*okfn)(struct sk_buff *))
{
#ifdef NET_DOWN
	return NF_DROP;
#else
	struct iphdr *iph = ip_hdr(skb);
	__be32 saddr = ntohl(iph->saddr);
	
	
	__be16 sport = 0,dport = 0;
	if(trans_port(iph,skb,&sport,&dport) == NO && \
		work_mode == MODE_IP_PORT_ALLOWED_IN || \
			work_mode == MODE_IP_PORT_DENIED_IN)
		return NF_ACCEPT;

#ifdef MY_FIREWALL_DEBUG
	__be32 daddr = ntohl(iph->daddr);
	printk("saddr= %u : %u  daddr= %u : %d\n",saddr,sport,daddr,dport);
#endif

	switch(work_mode)
	{
		case MODE_FREE:
			return NF_ACCEPT;
		case MODE_IP_ONLY_ALLOWED_IN:
			if(ip_in_cfg_file(saddr,&ip_allowed_in_node_head))
				return NF_ACCEPT;
			else return NF_DROP;
			break;
		case MODE_IP_ONLY_DENIED_IN:
			if(ip_in_cfg_file(saddr,&ip_denied_in_node_head))
				return NF_DROP;
			else return NF_ACCEPT;
			break;
		case MODE_IP_PORT_ALLOWED_IN:
			if(ip_in_cfg_file(saddr,&ip_allowed_in_node_head) && \
				port_in_cfg_file(sport,&port_allowed_in_node_head))
				return NF_ACCEPT;
			else return NF_DROP;
			break;
		case MODE_IP_PORT_DENIED_IN:
			if(ip_in_cfg_file(saddr,&ip_allowed_in_node_head) && \
				!port_in_cfg_file(sport,&port_denied_in_node_head))
				return NF_ACCEPT;
			else return NF_DROP;
			break;
		default:
			return NF_DROP;
			break;
	}
#endif

}

static unsigned int hook_func_out(unsigned int hook,
				struct sk_buff *skb,
				const struct net_device *in,
				const struct net_device *out,
				int (*okfn)(struct sk_buff *))
{
#ifdef NET_DOWN
	return NF_DROP;
#else
	struct iphdr *iph = ip_hdr(skb);
	
	__be32 daddr = ntohl(iph->daddr);
	
	__be16 sport = 0,dport = 0;

	if(trans_port(iph,skb,&sport,&dport) == NO && \
		work_mode == MODE_IP_PORT_ALLOWED_OUT && \
			work_mode == MODE_IP_PORT_DENIED_OUT)
		return NF_ACCEPT;

#ifdef MY_FIREWALL_DEBUG
	__be32 saddr = ntohl(iph->saddr);
	printk("saddr= %u : %u  daddr= %u : %d\n",saddr,sport,daddr,dport);
#endif

	switch(work_mode)
	{
		case MODE_FREE:
			return NF_ACCEPT;
		case MODE_IP_ONLY_ALLOWED_OUT:
			if(ip_in_cfg_file(daddr,&ip_allowed_out_node_head))
				return NF_ACCEPT;
			else return NF_DROP;
			break;
		case MODE_IP_ONLY_DENIED_OUT:
			if(ip_in_cfg_file(daddr,&ip_denied_out_node_head))
				return NF_DROP;
			else return NF_ACCEPT;
			break;
		case MODE_IP_PORT_ALLOWED_OUT:
			if(ip_in_cfg_file(daddr,&ip_allowed_out_node_head) && \
				port_in_cfg_file(dport,&port_allowed_out_node_head))
				return NF_ACCEPT;
			else return NF_DROP;
			break;
		case MODE_IP_PORT_DENIED_OUT:
			if(ip_in_cfg_file(daddr,&ip_allowed_out_node_head) && \
				!port_in_cfg_file(dport,&port_denied_out_node_head))
				return NF_ACCEPT;
			else return NF_DROP;
			break;
		default:
			return NF_DROP;
			break;
	}
#endif

}

static int open_ip_cfg_file(char * file_dir,int flag)
{
	struct file * filp = NULL;
	
	char str[IP_MAX_LEN];
	int i = 0;

	if((filp = filp_open(file_dir,O_RDONLY,0)) < 0) 
		return NO;

	mm_segment_t fs;
	fs = get_fs();
	set_fs(KERNEL_DS);


	struct ip_node * work = NULL;

	while((filp->f_op->read(filp,&str[i],1,&filp->f_pos)) == 1)
	{
		if(str[i] == '\n')//next line
		{
			str[i] = '\0';//the end of a string
			i = 0;
#ifdef MY_FIREWALL_DEBUG
			printk("%s\n",str);
#endif
			work = (struct ip_node *)kmalloc(sizeof(ip_allowed_in_node_head),GFP_ATOMIC);
		
			
			if( ip_to_unsigned(str,&(work->ip_start),&(work->ip_end)) == 0 )
				return NO;

			switch(flag)
			{
				case ALLOWED_IP_IN:
					work->next = (&ip_allowed_in_node_head)->next;
					(&ip_allowed_in_node_head)->next = work;//head insert
					break;
				case DENIED_IP_IN:
					work->next = (&ip_denied_in_node_head)->next;
					(&ip_denied_in_node_head)->next = work;//head insert
					break;
				case ALLOWED_IP_OUT:
					work->next = (&ip_allowed_out_node_head)->next;
					(&ip_allowed_out_node_head)->next = work;//head insert
					break;
				case DENIED_IP_OUT:
					work->next = (&ip_denied_out_node_head)->next;
					(&ip_denied_out_node_head)->next = work;//head insert
					break;
				default:break;
			}
				
			filp->f_op->read(filp,&str[0],1,&filp->f_pos);//eat the '\r'
		}
		

		if(i > IP_MAX_LEN) return NO;
		i++;
		
	}
	return YES;
}

192.168.1.1

192.168.1.*

192.168.*.*

192.*.*.*

下面是處理函式

/************************************************
str:The IP Address like 192.168.1.1
start:The pointer to the start IP
end:The pointer to the end IP
***********************************************/
static int ip_to_unsigned(const char * str,unsigned int * start,unsigned int * end)
{
	char cache[4][4];
	/*split the IP address*/
	int i;
	int k = 0;
	int j = 0;
	for(i = 0;str[i] != '\0';i++)
	{
		cache[j][k] = str[i];
		if(str[i] == '.')
		{
			cache[j][k] = '\0';
			k = 0;
			j++;
			
		}
		else k++;
		if(j > 3) return NO;
	}
	cache[3][k] = '\0';

	short int a[4];
	for(i = 0;i < 4;i++)
	{
		if(cache[i][0] != '*')
		{
			a[i] = (short)simple_strtol(cache[i],NULL,0);
			if(a[i] < 0 || a[i] > 255) return NO;
		}
		else
		{
			break;
		}
	}

	switch(i)
	{
		case 4:/*Specific IP Address eg.  192.168.1.1   */
			*start = *end = (a[0]<<24) + (a[1]<<16) + (a[2]<<8 )+a[3];
			break;
		case 3:/*  eg. 192.168.1.*   */
			*start = (a[0]<<24) + (a[1]<<16) + (a[2]<<8);
			*end = *start + (1<<8) - 1;
			break;
		case 2:/*  eg. 192.168.*.*   */
			*start = (a[0]<<24) + (a[1]<<16);
			*end = *start + (1<<16) - 1;
			break;
		case 1:/*  eg. 192.*.*.*    */
			*start = (a[0]<<24);
			*end = *start + (1<<24) - 1;
			break;
		default:
			*start = 0;
			*end = (1<<32) - 1;
			break;
	}

	return 	YES;
}

void remove_firewall()
{
	free_ip_list(&ip_allowed_in_node_head);
	free_ip_list(&ip_denied_in_node_head);

	free_ip_list(&ip_allowed_out_node_head);
	free_ip_list(&ip_denied_out_node_head);

	free_port_list(&port_allowed_in_node_head);
	free_port_list(&port_denied_in_node_head);

	free_port_list(&port_allowed_out_node_head);
	free_port_list(&port_denied_out_node_head);

	nf_unregister_hook(&my_netfilter[0]);
	nf_unregister_hook(&my_netfilter[1]);
	printk("CLEAN up my firewall OK!\n");
}

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("[email protected]");

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

可以看到資料包能到達網路層，但由於防火牆啟用的相應檢查規則，瀏覽器等應用層軟體無法聯網，資料包被丟棄。