Linux Netfilter框架实现及函数调用处理过程

已于 2024-01-26 15:22:36 修改
阅读量1.4k 收藏 35
点赞数 41
文章标签： linux 网络 运维
于 2024-01-26 15:03:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrtyxr/article/details/135047645
版权

背景

        本身从事网络安全工作，具体为防火墙产品的开发，对Linux 内核而言，Linux 防火墙功能由Netfilter框架实现，因此有了对Linux内核Netfilter实现逻辑的学习研究的兴趣，也想借此平台和大家一起交流学习。

概念

        Netfilter 是 Linux 内核中用于进行网络包过滤和操作的框架，在报文接收的处理的路径上，针对不同的协议，在不同的Hook位置调用相应的Hook函数(钩子函数)，实现对报文的处理，协议类型标注了钩子函数在处理网络包时所关注的协议，目前Netfilter根据不同的协议，对报文处理的支持分为以下几类：

        1）NFPROTO_BRIDGE，用于桥接设备相关的协议类型标识，桥接设备用于连接一个或多个网段的设备，工作在数据链路层，通过MAC地址转发或过滤数据包。

        2）NFPROTO_ARP，Netfilter中用于注册于ARP协议相关的钩子函数，用于在ARP报文处理过程中执行特定的操作。

        3）NFPROTO_IPV4，ipv4相关报文处理

        4）NFPROTO_IPV6， ipv6相关报文处理

        与之相对应，存在ebtables、arptables、iptables、ip6tables用于配置相应的规则，从而实现对具体特定特征报文执行特定的动作处理，关于xxtables的内容另外讨论。

Netfilter处理

        从Linux 内核实现上看，Netfilter处理分为以下几部分：

        1）nf_hook_ops注册

        2）NF_HOOK 钩子函数处理调用

        3）钩子函数处理后的后续处理

nf_hook_ops的注册

        钩子函数的注册通常随着模块的加载，在模块初始化过程中通过直接或间接调用nf_register_net_hooks或nf_register_net_hook（二者的区别在于注册一组还是一个钩子函数）注册（不绝对，有的可能在函数处理逻辑过程中注册），以连接模块的钩子函数注册为例，具体调用过程如下：

        这里从nf_register_net_hooks的上层调用函数nf_ct_netns_do_get入手，具体实现如下：

static int nf_ct_netns_do_get(struct net *net, u8 nfproto)
{
	struct nf_conntrack_net *cnet = nf_ct_pernet(net);
	bool fixup_needed = false, retry = true;
	int err = 0;
retry:
	mutex_lock(&nf_ct_proto_mutex);

	/* 如前所说Netfilter支持不同协议，这里依据NF协议，选择分支处理 */
	switch (nfproto) {
	case NFPROTO_IPV4:
		cnet->users4++;
		if (cnet->users4 > 1)
			goto out_unlock;
		err = nf_defrag_ipv4_enable(net);
		if (err) {
			cnet->users4 = 0;
			goto out_unlock;
		}

		/* 注册ipv4 连接相关处理钩子函数 */
		err = nf_register_net_hooks(net, ipv4_conntrack_ops,
					    ARRAY_SIZE(ipv4_conntrack_ops));
		if (err)
			cnet->users4 = 0;
		else
			fixup_needed = true;
		break;
#if IS_ENABLED(CONFIG_IPV6)
	case NFPROTO_IPV6:
		cnet->users6++;
		if (cnet->users6 > 1)
			goto out_unlock;
		err = nf_defrag_ipv6_enable(net);
		if (err < 0) {
			cnet->users6 = 0;
			goto out_unlock;
		}

		/* 注册ipv6 连接相关处理钩子函数 */
		err = nf_register_net_hooks(net, ipv6_conntrack_ops,
					    ARRAY_SIZE(ipv6_conntrack_ops));
		if (err)
			cnet->users6 = 0;
		else
			fixup_needed = true;
		break;
#endif
	case NFPROTO_BRIDGE:
		if (!nf_ct_bridge_info) {
			if (!retry) {
				err = -EPROTO;
				goto out_unlock;
			}
			mutex_unlock(&nf_ct_proto_mutex);
			request_module("nf_conntrack_bridge");
			retry = false;
			goto retry;
		}
		if (!try_module_get(nf_ct_bridge_info->me)) {
			err = -EPROTO;
			goto out_unlock;
		}
		cnet->users_bridge++;
		if (cnet->users_bridge > 1)
			goto out_unlock;

		/* 注册网桥报文连接相关处理钩子函数(针对三层转发报文) */
		err = nf_register_net_hooks(net, nf_ct_bridge_info->ops,
					    nf_ct_bridge_info->ops_size);
		if (err)
			cnet->users_bridge = 0;
		else
			fixup_needed = true;
		break;
	default:
		err = -EPROTO;
		break;
	}
 out_unlock:
	mutex_unlock(&nf_ct_proto_mutex);

	if (fixup_needed) {
		struct nf_ct_iter_data iter_data = {
			.net	= net,
			.data	= (void *)(unsigned long)nfproto,
		};
		nf_ct_iterate_cleanup_net(nf_ct_tcp_fixup, &iter_data);
	}

	return err;
}

        从nf_ct_netns_do_get函数的实现看，连接针对不同的协议报文注册了不同的钩子函数，以ipv4协议报文为例，对应ipv4_conntrack_ops；具体定义如下：

static const struct nf_hook_ops ipv4_conntrack_ops[] = {
	{
		.hook		= ipv4_conntrack_in,/* 钩子函数*/
		.pf		= NFPROTO_IPV4, /* 面向的协议 */
		.hooknum	= NF_INET_PRE_ROUTING, /*hook点，对应报文收发过程中位置 */
		.priority	= NF_IP_PRI_CONNTRACK, /* 确定hook函数的调用顺序*/
	},
	{
		.hook		= ipv4_conntrack_local,
		.pf		= NFPROTO_IPV4,
		.hooknum	= NF_INET_LOCAL_OUT,
		.priority	= NF_IP_PRI_CONNTRACK,
	},
	{
		.hook		= nf_confirm,
		.pf		= NFPROTO_IPV4,
		.hooknum	= NF_INET_POST_ROUTING,
		.priority	= NF_IP_PRI_CONNTRACK_CONFIRM,
	},
	{
		.hook		= nf_confirm,
		.pf		= NFPROTO_IPV4,
		.hooknum	= NF_INET_LOCAL_IN,
		.priority	= NF_IP_PRI_CONNTRACK_CONFIRM,
	},
};

       这里不围绕连接展开，只是通过此示例了解nf_hook_ops结构体变量中各字段的含义，nf_hook_ops结构体定义如下：

struct nf_hook_ops {
	nf_hookfn		*hook; /* hook函数指针 */
	struct net_device	*dev;
	void			*priv; /* 私有数据 */
	u8			pf;
    /* hook操作类型，指示hook适用的场景，目前已知有三种：0： NF_HOOK_OP_UNDEFINED 
                1：NF_HOOK_OP_NF_TABLES 2：NF_HOOK_OP_BPF */
	enum nf_hook_ops_type	hook_ops_type:8;
    /* hook点对应报文不同处理位置，分为PRE_ROUTING、LOCAL_IN、FORWARD、
                        LOCAL_OUT、POST_ROUTING */
	unsigned int		hooknum; 
	/* Hooks are ordered in ascending priority. */
	int			priority; 
    /* 优先级，一种协议的一个hook点因不同的模块可能会注册多个hook函数，
        优先级决定了这些函数的调用顺序，nf_hook_ops在链表中以优先级升序（数值大小）排列，
        但需要说明的是优先级数值大的，优先级反而低，即数值越小越早被调用 */
};

        nf_hook_ops的注册的实质就是将依据nf_hook_ops对应的协议，hook点的位置，按照优先级的大小放到指定nf_hook_entry数组中组织起来，方便后续报文处理过程中依据协议、位置、以优先级决定的顺序调用hook函数处理，具体流程如下：

        1）nf_register_net_hooks 函数注册nf_hook_ops组

                2）调用nf_register_net_hook逐个注册nf_hook_ops

                        3)__nf_register_net_hook函数处理

                                a)pp = nf_hook_entry_head(net, pf, reg->hooknum, reg->dev); 依据网络命名空间、协议、hook点，找到该协议、该位置nf_hook_entries数组起始地址，网络命名空间实现资源隔离。

                                b)nf_hook_entries_grow依据优先级以升序的方式将nf_hook_ops转换成nf_hook_entry条目信息放入nf_hook_entries内部nf_hook_entry数组对应位置。

NF_HOOK处理

        NF_HOOK处理即在报文处理路径上的特定位置调用已注册的相应的钩子函数，并根据钩子函数处理后的判定结果决定是否对报文执行后续处理，具体实现如下及流程如下：

static inline int
NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk, struct sk_buff *skb,
	struct net_device *in, struct net_device *out,
	int (*okfn)(struct net *, struct sock *, struct sk_buff *))
{
	/* nf_hook_ops 钩子函数处理*/
	int ret = nf_hook(pf, hook, net, sk, skb, in, out, okfn);
    /* 1即 NF_ACCEPT*/
	if (ret == 1)
		/* 钩子函数处理后的后续处理 */
		ret = okfn(net, sk, skb);
	return ret;
}

       1）调用nf_hook函数，进一步调用对应特定协议、特定位置的钩子函数。

static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
			  struct sock *sk, struct sk_buff *skb,
			  struct net_device *indev, struct net_device *outdev,
			  int (*okfn)(struct net *, struct sock *, struct sk_buff *))
{
	struct nf_hook_entries *hook_head = NULL;
	int ret = 1;

#ifdef CONFIG_JUMP_LABEL
	if (__builtin_constant_p(pf) &&
	    __builtin_constant_p(hook) &&
	    !static_key_false(&nf_hooks_needed[pf][hook]))
		return 1;
#endif

	rcu_read_lock();
	/*根据特定协议，hook点获取netfilter命名空间特定协议特定位置nf_hook_entries头指针 */
	switch (pf) {
	case NFPROTO_IPV4:
		hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]);
		break;
	case NFPROTO_IPV6:
		hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]);
		break;
	case NFPROTO_ARP:
#ifdef CONFIG_NETFILTER_FAMILY_ARP
		if (WARN_ON_ONCE(hook >= ARRAY_SIZE(net->nf.hooks_arp)))
			break;
		hook_head = rcu_dereference(net->nf.hooks_arp[hook]);
#endif
		break;
	case NFPROTO_BRIDGE:
#ifdef CONFIG_NETFILTER_FAMILY_BRIDGE
		hook_head = rcu_dereference(net->nf.hooks_bridge[hook]);
#endif
		break;
	default:
		WARN_ON_ONCE(1);
		break;
	}

	if (hook_head) {
		struct nf_hook_state state;

		/* 依据参数信息,初始化nf_hook_state已供后续钩子处理函数使用，
			nf_hook_ops中的hook字段为nf_hookfn函数指针，具体定义为:
			typedef unsigned int nf_hookfn(void *priv, struct sk_buff *skb,
			       const struct nf_hook_state *state); 需要nf_hook_state类型参数 */
		nf_hook_state_init(&state, hook, pf, indev, outdev,
				   sk, net, okfn);

		/* 根据hook_head,  nf_hook_state, 逐个调用钩子函数 */
		ret = nf_hook_slow(skb, &state, hook_head, 0);
	}
	rcu_read_unlock();

	return ret;
}

        通过上述实现可知，钩子函数调用，最终通过nf_hook_slow函数实现。

int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state,
		 const struct nf_hook_entries *e, unsigned int s)
{
	unsigned int verdict;
	int ret;

	/*逐个遍历，由于nf_hook_ops是依据优先级数值大小升序排列，所以数值小的在前也更早处理，
		这就对应了优先级数值大，优先级低的结论*/
	for (; s < e->num_hook_entries; s++) {
		verdict = nf_hook_entry_hookfn(&e->hooks[s], skb, state);
		switch (verdict & NF_VERDICT_MASK) {
		case NF_ACCEPT:
			break;
		case NF_DROP:
			kfree_skb_reason(skb,
					 SKB_DROP_REASON_NETFILTER_DROP);
			ret = NF_DROP_GETERR(verdict);
			if (ret == 0)
				ret = -EPERM;
			return ret;
		case NF_QUEUE:
			ret = nf_queue(skb, state, s, verdict);
			if (ret == 1)
				continue;
			return ret;
		default:
			/* Implicit handling for NF_STOLEN, as well as any other
			 * non conventional verdicts.
			 */
			return 0;
		}
	}

	return 1;
}

HOOK点处理位置

          Netfilter框架针对每种协议报文，提供多个HOOK点处理位置以及相应的后续处理，以IPv4报文处理为例，报文处理流程及路径如图所示：

       NF_HOOK处理调用具体位置及实现如下。

PRE_ROUTING

int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt,
	   struct net_device *orig_dev)
{
	......
    /* DNAT处理在此调用 */
	return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, net, NULL,
             skb, dev, NULL, ip_rcv_finish);
}

LOCAL_IN

int ip_local_deliver(struct sk_buff *skb)
{
	......

	return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN,
		       net, NULL, skb, skb->dev, NULL, ip_local_deliver_finish);
}
EXPORT_SYMBOL(ip_local_deliver);

FORWARD

int ip_forward(struct sk_buff *skb)
{
	......
	/* 转发报文netfilter处理，匹配过滤 */
	return NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
		       net, NULL, skb, skb->dev, rt->dst.dev, ip_forward_finish);

sr_failed:
	/*
	 *	Strict routing permits no gatewaying
	 */
	 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_SR_FAILED, 0);
	 goto drop;

too_many_hops:
	/* Tell the sender its packet died... */
	__IP_INC_STATS(net, IPSTATS_MIB_INHDRERRORS);
	icmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0);
	SKB_DR_SET(reason, IP_INHDR);
drop:
	kfree_skb_reason(skb, reason);
	return NET_RX_DROP;
}

LOCAL_OUT

/* 该HOOK点可能依据外发的具体协议报文可能在多个点调用*/
err = NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_OUT,
		      net, sk, skb, NULL, rt->dst.dev, dst_output);

POST_ROUTING 

int ip_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	struct net_device *dev = skb_dst(skb)->dev, *indev = skb->dev;/* 报文入接口*/

	......
	/* POSTROUTING 可作SNAT处理 */
	return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING,
			    net, sk, skb, indev, dev, ip_finish_output,
			    !(IPCB(skb)->flags & IPSKB_REROUTED));
}

进化中的码农
关注
Linux 操作系统原理 — netfilter/iptables 流量处理框架
烟云的计算
05-25 2263
即：内网 IP 地址向外访问 Internet 时，发起访问的内网 IP 地址转换为指定的对外 IP 地址（可指定具体的服务以及相应的端口或端口范围），这使内网的多部主机可以通过同一个有效的公网 IP 地址访问外部网络。IP 网络有公网与私网的区分，企业内网使用私网 IP，Internet 使用公网 IP。DNAT（Destination Network Transform，目的地址转换）与 SNAT 相对，当外部网络访问内部网络时，进来的 IP 数据包会被改变 dstIP 地址。
Linux网络层收发包流程及Netfilter框架浅析
j简说Linux的博客
11-19 813
在 TCP/IP 协议框架体系的五层网络模型中，每一层负责处理的数据包协议或类型均存在差异，物理层主要负责在物理载体上的数据包传输，如 WiFi，以太网，光纤，电话线等；数据链路层主要负责链路层协议解析（主要为以太网帧，其他类型此处暂不考虑），网络层主要负责 IP 协议（包括 IPv4 和 IPv6）解析，传输层负责传输层协议解析（主要为 TCP，UDP 等），而传输层以上我们均归类为应用层，主要包括各类应用层协议，如我们常用的 HTTP，FTP，SMTP，DNS，DHCP 等。
netfilter hook 注册，调用示例
08-17
Linux4.x内核编程实战——netfilter hook 注册，调用示例.nf_hook_ops,nf_register_net_hook, nf_unregister_net_hook 使用
netfilter
weixin_38184628的博客
02-19 1054
iptables，ip 说明这个工具工作在 ip 层，tables 说明这个工具的工作方式，通过多个表来工作。iptables 基于 netfilter 来实现，常常被用来做防火墙，通过 iptables 可以对报文进行过滤，修改或者 NAT。iptables 包括的概念比较多，功能很丰富，当然也很复杂，本文中只对一些基本的概念和操作做梳理。
【Android】(六) Netfilter
最新发布
CHENDONGHAO1105的博客
09-14 1392
struct net 有一个 struct netns_nf 成员，里面有个 nf_hook_entries 列表，每个 nf_hook_entries 就对应了每个钩子点所对应的钩子函数列表。nf_hook_entries 内的 hooks 就是钩子点所有的过滤函数，具体的钩子函数就是 nf_hook_entry 内的 nf_hookfn 函数。遍历 nf_hook_entries 中的 hook 函数，依次执行，根据返回值判断，是 NF_ACCEPT，还是 NF_DROP，还是NF_QUEUE。
netfilter框架概述
rondyning的博客
05-25 2844
1 Netfilter 1.1 netfilter概述 Netfilter是linux 2.4.x引入的一个子系统，它是一个通用的、抽象的框架。其不依赖于具体的协议，而是为每种网络协议定义一套HOOK函数。这些HOOK函数在数据报经过协议栈的几个关键点被调用。 内核的任何模块可以对每种协议的一个或多个HOOK进行注册，实现挂接。这样当某个数据报被传递给Netfilter框架时，内核能检测到是否有任何模块对该协议和HOOK函数进行了注册。若注册了，则调用该模块的注册时使用的回调函数，这样这些模块就有机会检查、
netfilter框架
隔壁-老阳
01-18 2062
netfilter框架Linux内核包含了一个强大的网络子系统，名为netfilter，它可以为iptables内核防火墙模块提供有状态或无状态的包过滤服务，如NAT、IP伪装等，也可以因高级路由或连接状态管理的需要而修改IP头信息。netfilter位于Linux网络层和防火墙内核模块之间，如图9-1所示。 （点击查看大图）图9-1  netfilter在内核中的位置虽然防火墙模块构建在Linux内核，并且要对流经IP层的数据包进行处理，但它并没有改变IP协议栈的代码，而是通过netfilter模块将防火
linux netfilter
weixin_30902251的博客
10-12 101
netfilter 是一种内核中用于扩展各种网络服务的结构化底层框架。netfilter的设计思想是生成一个模块结构使之能够比较容易的扩展。新的特性加入到内核中并不需要从新启动内核。这样，可以通过简单的构造一个内核模块来实现网络新特性的扩展。给底层的网络特性扩展带来了极大的便利，使更多从事网络底层研发的开发人员能够集中精力实现新的网络特性。netfilter有4大特性：1. 每一个协议定义"hoo...
Netfilter分析
bingyang_xue的专栏
10-26 628
一、概述1. Netfilter/IPTables框架简介          Netfilter/IPTables是继2.0.x的IPfwadm、2.2.x的IPchains之后，新一代的Linux防火墙机制。Netfilter采用模块化设计，具有良好的可扩充性。其重要工具模块IPTables连接到Netfilter的架构中，并允许使用者对数据报进行过滤、地址转换、处理等操作。   
Linux 内核开发 - NetFilter
阿呆的隐秘角落
09-12 2357
Linux 内核开发 - NetFilter
Netfilter框架-完全解析.doc
02-25
总的来说，Netfilter框架是Linux内核网络安全和流量控制的核心部分，它通过钩子函数和连接跟踪机制实现了灵活且强大的数据包处理能力。通过iptables等工具，用户可以方便地定义和管理网络策略，实现安全的网络环境。...
Linux Netfilter编程源码
12-16
实现linux下防火墙的应用，可以添加相应规则对网络数据包进行相应过滤。
Netfilter机制的框架分析
12-16
很好的Netfilter分析，适合初学者...
linux netfilter 框架分析
12-05
Netfilter框架的引入极大地提升了Linux内核在网络层面的安全性和灵活性，它通过精巧的设计实现了高效的数据包处理机制，同时也为开发者提供了丰富的扩展能力。无论是对于网络安全专家还是网络编程爱好者，理解...
Netfilter框架详解：钩子函数与hook点在Linux内核中的应用
在Linux 2.6内核的Netfilter框架中，钩子函数是关键组件，它们在数据包经过网络协议栈的关键点时被调用。这些函数通常按照优先级顺序执行，对数据包进行处理或决策。钩子函数有五个可能的返回值： 1. **NF_ACCEPT**...
Netfilter---框架的设计
chengfangang的专栏
04-09 1350
http://blog.chinaunix.net/uid-20786208-id-3429074.html 1. Netfilter/IPTables简介     Netfilter/IPTables是继2.0.x的ipfwadm、2.2.x的ipchains之后，新一代的 Linux防火墙机制。Netfilter采用模块化设计，具有良好的可扩充性。其重要工具模块IPTables连接
Linux 内核源码分析---netfilter 框架
学习记录
08-21 1192
学习记录
linux-内核：netfilter框架
赵凯月的博客
06-23 1857
Netfilter/IPTables 是 Linux2.4.x 之后新一代的 Linux 防火墙机制，是linux内核的一个子系统。Netfilter 采用模块化设计，具有良好的可扩充性。其重要工具模块 IPTables 从用户态的 iptables 连接 到内核态的 Netfilter 的架构中 ， Netfilter 与 IP 协议栈是无缝契合的， 并允许使用者对数据报进行过滤、地址转换、处理等操作。主要源代码文件。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值