Netfilter 与struct nf_hook_ops 相关

Nerazzur

于 2025-04-27 22:30:40 发布

阅读量960

点赞数 10

CC 4.0 BY-SA版权

分类专栏： Linux应用编程/网络编程文章标签： linux Netfilter NF_HOOK iptables

本文链接：https://blog.csdn.net/frank_jb/article/details/147569654

Linux应用编程/网络编程专栏收录该内容

13 篇文章

订阅专栏

nf_hook_ops数据结构

struct nf_hook_ops
{
        struct list_head list;                      　　　　//链表成员
        /* User fills in from here down. */
        nf_hookfn *hook;                         　　　　　　//钩子函数指针
        struct module *owner;
        int pf;                                            //协议簇，对于ipv4而言，是PF_INET
        int hooknum;                                  　　　//hook类型
        /* Hooks are ordered in ascending priority. */
        int priority;                                      //优先级
};

成员list用于链入全局勾子数组nf_hooks中，它一定在第一位，保证&nf_hook_ops->list的值与&nf_hook_ops相同，稍后在使用时会用到这一技巧；

成员hook即用户定义的勾子函数；
owner表示注册这个勾子函数的模块，因为netfilter是内核空间的，所以一般为模块来完成勾子函数注册；
pf与hooknum一起索引到特定协议特定编号的勾子函数队列，用于索引nf_hooks；
priority决定在同一队列(pf与hooknum相同)的顺序，priority越小则排列越靠前。

struct nf_hook_ops只是存储勾子的数据结构，而真正存储这些勾子供协议栈调用的是nf_hooks，从定义可以看出，它其实就是二维数组的链表。
struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS];

一、nf_hook_ops中使用常量定义

1、协议/地址簇相关（#include <linux/socket.h>）

/* Supported address families. */
#define AF_UNSPEC       0
#define AF_UNIX         1       /* Unix domain sockets          */
#define AF_LOCAL        1       /* POSIX name for AF_UNIX       */
#define AF_INET         2       /* Internet IP Protocol         */
#define AF_AX25         3       /* Amateur Radio AX.25          */
#define AF_IPX          4       /* Novell IPX                   */
#define AF_APPLETALK    5       /* AppleTalk DDP                */
#define AF_NETROM       6       /* Amateur Radio NET/ROM        */
#define AF_BRIDGE       7       /* Multiprotocol bridge         */
#define AF_ATMPVC       8       /* ATM PVCs                     */
#define AF_X25          9       /* Reserved for X.25 project    */
#define AF_INET6        10      /* IP version 6                 */
#define AF_ROSE         11      /* Amateur Radio X.25 PLP       */
#define AF_DECnet       12      /* Reserved for DECnet project  */
#define AF_NETBEUI      13      /* Reserved for 802.2LLC project*/
#define AF_SECURITY     14      /* Security callback pseudo AF */
#define AF_KEY          15      /* PF_KEY key management API */
#define AF_NETLINK      16
#define AF_ROUTE        AF_NETLINK /* Alias to emulate 4.4BSD */
#define AF_PACKET       17      /* Packet family                */
#define AF_ASH          18      /* Ash                          */
#define AF_ECONET       19      /* Acorn Econet                 */
#define AF_ATMSVC       20      /* ATM SVCs                     */
#define AF_RDS          21      /* RDS sockets                  */
#define AF_SNA          22      /* Linux SNA Project (nutters!) */
#define AF_IRDA         23      /* IRDA sockets                 */
#define AF_PPPOX        24      /* PPPoX sockets                */
#define AF_WANPIPE      25      /* Wanpipe API Sockets */
#define AF_LLC          26      /* Linux LLC                    */
#define AF_IB           27      /* Native InfiniBand address    */
#define AF_MPLS         28      /* MPLS */
#define AF_CAN          29      /* Controller Area Network      */
#define AF_TIPC         30      /* TIPC sockets                 */
#define AF_BLUETOOTH    31      /* Bluetooth sockets            */
#define AF_IUCV         32      /* IUCV sockets                 */
#define AF_RXRPC        33      /* RxRPC sockets                */
#define AF_ISDN         34      /* mISDN sockets                */
#define AF_PHONET       35      /* Phonet sockets               */
#define AF_IEEE802154   36      /* IEEE802154 sockets           */
#define AF_CAIF         37      /* CAIF sockets                 */
#define AF_ALG          38      /* Algorithm sockets            */
#define AF_NFC          39      /* NFC sockets                  */
#define AF_VSOCK        40      /* vSockets                     */
#define AF_MAX          41      /* For now.. */

/* Protocol families, same as address families. */
#define PF_UNSPEC       AF_UNSPEC
#define PF_UNIX         AF_UNIX
#define PF_LOCAL        AF_LOCAL
#define PF_INET         AF_INET
#define PF_AX25         AF_AX25
#define PF_IPX          AF_IPX
#define PF_APPLETALK    AF_APPLETALK
#define PF_NETROM       AF_NETROM
#define PF_BRIDGE       AF_BRIDGE
#define PF_ATMPVC       AF_ATMPVC
#define PF_X25          AF_X25
#define PF_INET6        AF_INET6
#define PF_ROSE         AF_ROSE
#define PF_DECnet       AF_DECnet
#define PF_NETBEUI      AF_NETBEUI
#define PF_SECURITY     AF_SECURITY
#define PF_KEY          AF_KEY
#define PF_NETLINK      AF_NETLINK
#define PF_ROUTE        AF_ROUTE
#define PF_PACKET       AF_PACKET
#define PF_ASH          AF_ASH
#define PF_ECONET       AF_ECONET
#define PF_ATMSVC       AF_ATMSVC
#define PF_RDS          AF_RDS
#define PF_SNA          AF_SNA
#define PF_IRDA         AF_IRDA
#define PF_PPPOX        AF_PPPOX
#define PF_WANPIPE      AF_WANPIPE
#define PF_LLC          AF_LLC
#define PF_IB           AF_IB
#define PF_MPLS         AF_MPLS
#define PF_CAN          AF_CAN
#define PF_TIPC         AF_TIPC
#define PF_BLUETOOTH    AF_BLUETOOTH
#define PF_IUCV         AF_IUCV
#define PF_RXRPC        AF_RXRPC
#define PF_ISDN         AF_ISDN
#define PF_PHONET       AF_PHONET
#define PF_IEEE802154   AF_IEEE802154
#define PF_CAIF         AF_CAIF
#define PF_ALG          AF_ALG
#define PF_NFC          AF_NFC
#define PF_VSOCK        AF_VSOCK
#define PF_MAX          AF_MAX

2、hook返回值

LINUX_VERSION_CODE >= KERNEL_VERSION(4,1,0)

typedef unsigned int nf_hookfn(void *priv,
                               struct sk_buff *skb,
                               const struct nf_hook_state *state);


struct nf_hook_state {
        unsigned int hook;
        int thresh;
        u_int8_t pf;
        struct net_device *in;
        struct net_device *out;
        struct sock *sk;
        struct net *net;
        struct list_head *hook_list;
        int (*okfn)(struct net *, struct sock *, struct sk_buff *);
};

static inline void nf_hook_state_init(struct nf_hook_state *p,
                                      struct list_head *hook_list,
                                      unsigned int hook,
                                      int thresh, u_int8_t pf,
                                      struct net_device *indev,
                                      struct net_device *outdev,
                                      struct sock *sk,
                                      struct net *net,
                                      int (*okfn)(struct net *, struct sock *, struct sk_buff *))
{
        p->hook = hook;
        p->thresh = thresh;
        p->pf = pf;
        p->in = indev;
        p->out = outdev;
        p->sk = sk;
        p->net = net;
        p->hook_list = hook_list;
        p->okfn = okfn;
}

//hook函数由 指定,其函数声明如下: nf_hookfn *hook

// include/linux/netfilter.h

typedef unsigned int nf_hookfn(unsigned int hooknum,
                               struct sk_buff *skb,
                               const struct net_device *in,
                               const struct net_device *out,
                               int (*okfn)(struct sk_buff *));

/* Responses from hook functions. */

#define NF_DROP 0       ----丢弃，释放sk_buff结构

#define NF_ACCEPT 1     ----继续正常传输数据报(按照5个钩子点正常传输)

#define NF_STOLEN 2    ----模块接管该数据报，告诉Netfilter“忘掉”该数据报。该回调函数将从此开始对数据包的处理，并且Netfilter应当放弃对该数据包做任何的处理。但是，这并不意味着该数据包的资源已经被释放。这个数据包以及它独自的sk_buff数据结构仍然有效，只是回调函数从Netfilter获取了该数据包的所有权。

#define NF_QUEUE 3       ----对该数据报进行排队(通常用于将数据报给用户空间的进程进行处理)

#define NF_REPEAT 4      ----再次调用该回调函数，应当谨慎使用这个值，以免造成死循环

#define NF_STOP 5      ----终止hook链处理，不会释放sk_buff数据

 
3、 hook点及优先级相关

enum nf_ip_hook_priorities {
        NF_IP_PRI_FIRST = INT_MIN,
        NF_IP_PRI_CONNTRACK_DEFRAG = -400,
        NF_IP_PRI_RAW = -300,
        NF_IP_PRI_SELINUX_FIRST = -225,
        NF_IP_PRI_CONNTRACK = -200,
        NF_IP_PRI_MANGLE = -150,
        NF_IP_PRI_NAT_DST = -100,
        NF_IP_PRI_FILTER = 0,
        NF_IP_PRI_SECURITY = 50,
        NF_IP_PRI_NAT_SRC = 100,
        NF_IP_PRI_SELINUX_LAST = 225,
        NF_IP_PRI_CONNTRACK_CONFIRM = INT_MAX,
        NF_IP_PRI_LAST = INT_MAX,
};

4、NFPROTO_NUMPROTO表示勾子关联的协议

enum nf_ip_hook_priorities {
        NF_IP_PRI_FIRST = INT_MIN,
        NF_IP_PRI_CONNTRACK_DEFRAG = -400,
        NF_IP_PRI_RAW = -300,
        NF_IP_PRI_SELINUX_FIRST = -225,
        NF_IP_PRI_CONNTRACK = -200,
        NF_IP_PRI_MANGLE = -150,
        NF_IP_PRI_NAT_DST = -100,
        NF_IP_PRI_FILTER = 0,
        NF_IP_PRI_SECURITY = 50,
        NF_IP_PRI_NAT_SRC = 100,
        NF_IP_PRI_SELINUX_LAST = 225,
        NF_IP_PRI_CONNTRACK_CONFIRM = INT_MAX,
        NF_IP_PRI_LAST = INT_MAX,
};

5、NF_MAX_HOOKS表示勾子应用的位置，可选值在每个协议模块内部定义，这些值代表了勾子函数在协议流程中应用的位置

///< 以下宏定义为userspace中使用的 (include/uapi/linux/netfilter_ipv4.h)
/* IP Hooks */
/* After promisc drops, checksum checks. */
#define NF_IP_PRE_ROUTING    0
/* If the packet is destined for this box */
#define NF_IP_LOCCAL_IN    1
/* If the packet is destined for another interface */
#define NF_IP_FORWARD    2
/* Packets coming from a local process */
#define NF_IP_LOCCAL_OUT    3
/* Packets about to hit the wire */
#define NF_IP_POST_ROUTING    4
#define NF_IP_NUMHOOKS    5


///< 对于内核空间使用的Hook点的定义,使用如下的定义(include/uapi/linux/netfilter.h)
enum nf_inet_hooks {
    NF_INET_PRE_ROUTING,
    NF_INET_LOCAL_IN,
    NF_INET_FORWARD,
    NF_INET_LOCAL_OUT,
    NF_INET_POST_ROUTING,
    NF_INET_NUMHOOKS
};

/*
    BR、IP 与 INET 是一致的
    NF_XXX_PRE_ROUTING,
    NF_XXX_LOCAL_IN,
    NF_XXX_FORWARD,
    NF_XXX_LOCAL_OUT,
    NF_XXX_POST_ROUTING,
    NF_XXX_NUMHOOKS
*/

6、触发钩子函数

钩子函数已经被保存到不同的链上，什么时候才会触发调用这些钩子函数来处理数据包？
要触发调用某个挂载点上（链）的所有钩子函数，需要使用 NF_HOOK 宏来实现，其定义如下：

1 // 文件：include/linux/netfilter.h
2 
3 #define   NF_HOOK(pf, hook, skb, indev, outdev, okfn)  (list_empty(&nf_hooks[(pf)][(hook)]) ? (okfn)(skb) : nf_hook_slow((pf), (hook), (skb), (indev), (outdev), (okfn)))

NF_HOOK 宏的各个参数的作用：

pf：协议类型，就是 nf_hooks 数组的第一个维度，如 IPv4 协议就是 PF_INET。
hook：要调用哪一条链（挂载点）上的钩子函数，如 NF_IP_PRE_ROUTING。
indev：接收数据包的设备对象。
outdev：发送数据包的设备对象。
okfn：当链上的所有钩子函数都处理完成，将会调用此函数继续对数据包进行处理。

而 NF_HOOK 宏的实现也比较简单，

首先判断一下钩子函数链表是否为空，如果是空的话，就直接调用 okfn 函数来处理数据包，

否则就调用 nf_hook_slow 函数来处理数据包。我们来看看 nf_hook_slow 函数的实现：

// 文件：net/core/netfilter.c

int nf_hook_slow(int pf, unsigned int hook, struct sk_buff *skb,
                 struct net_device *indev, struct net_device *outdev,
                 int (*okfn)(struct sk_buff *))
{
    struct list_head *elem;
    unsigned int verdict;
    int ret = 0;

    elem = &nf_hooks[pf][hook]; // 获取要调用的钩子函数链表

    // 遍历钩子函数链表，并且调用钩子函数对数据包进行处理
    verdict = nf_iterate(&nf_hooks[pf][hook], &skb, hook, indev, outdev, &elem, okfn);
    ...
    // 如果处理结果为 NF_ACCEPT, 表示数据包通过所有钩子函数的处理, 那么就调用 okfn 函数继续处理数据包
    // 如果处理结果为 NF_DROP, 表示数据包被拒绝, 应该丢弃此数据包
    switch (verdict) {
    case NF_ACCEPT:
        ret = okfn(skb);
        break;
    case NF_DROP:
        kfree_skb(skb);
        ret = -EPERM;
        break;
    }

    return ret;
}

nf_hook_slow 函数的实现也比较简单，过程如下：

首先调用 nf_iterate 函数来遍历钩子函数链表，并调用链表上的钩子函数来处理数据包。
如果处理结果为 NF_ACCEPT，表示数据包通过所有钩子函数的处理, 那么就调用 okfn 函数继续处理数据包。
如果处理结果为 NF_DROP，表示数据包没有通过钩子函数的处理，应该丢弃此数据包。

既然 Netfilter 是通过调用 NF_HOOK 宏来调用钩子函数链表上的钩子函数，那么内核在什么地方调用这个宏呢？

比如数据包进入 IPv4 协议层的处理函数 ip_rcv 函数中就调用了 NF_HOOK 宏来处理数据包，

代码如下：

1 // 文件：net/ipv4/ip_input.c
2 
3 int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
4 {
5     ...
6     return NF_HOOK(PF_INET, NF_IP_PRE_ROUTING, skb, dev, NULL, ip_rcv_finish);
7 }

如上代码所示，在 ip_rcv 函数中调用了 NF_HOOK 宏来处理输入的数据包，

其调用的钩子函数链（挂载点）为 NF_IP_PRE_ROUTING。而 okfn 设置为 ip_rcv_finish，

也就是说，当 NF_IP_PRE_ROUTING 链上的所有钩子函数都成功对数据包进行处理后，

将会调用 ip_rcv_finish 函数来继续对数据包进行处理。

7、NetFilter注册

　　int nf_register_hook(struct nf_hook_ops *reg);

　　int nf_register_hooks(struct nf_hook_ops *reg,unsigned int n);

注销：

　　void nf_unregister_hook(struct nf_hook_ops *reg)；

　　void nf_unregister_hooks(struct nf_hook_ops *reg,unsigned int n)

二、Netfilter 之五个钩子点

1、挂载点解析：

PRE_ROUTING：路由前。数据包进入IP层后，但还没有对数据包进行路由判定前。
LOCAL_IN：进入本地。对数据包进行路由判定后，如果数据包是发送给本地的，在上送数据包给上层协议前。
FORWARD：转发。对数据包进行路由判定后，如果数据包不是发送给本地的，在转发数据包出去前。
LOCAL_OUT：本地输出。对于输出的数据包，在没有对数据包进行路由判定前。
POST_ROUTING：路由后。对于输出的数据包，在对数据包进行路由判定后。

路由判定：

从上图可以看出，路由判定是数据流向的关键点。

第一个路由判定通过查找输入数据包 IP头部 的目的 IP地址 是否为本机的 IP地址，如果是本机的 IP地址，说明数据是发送给本机的。否则说明数据包是发送给其他主机，经过本机只是进行中转。
第二个路由判定根据输出数据包 IP头部 的目的 IP地址 从路由表中查找对应的路由信息，然后根据路由信息获取下一跳主机（或网关）的 IP地址，然后进行数据传输。

数据包流向从图中可以看到，三个方向的数据包需要经过的钩子节点不完全相同：

发往本地：NF_INET_PRE_ROUTING-->NF_INET_LOCAL_IN
转发：NF_INET_PRE_ROUTING-->NF_INET_FORWARD-->NF_INET_POST_ROUTING
本地发出：NF_INET_LOCAL_OUT-->NF_INET_POST_ROUTING

挂载链表：

通过向这些 挂载点 注册钩子函数，就能够对处于不同阶段的数据包进行过滤或者修改操作。

由于钩子函数能够注册多个，所以内核使用链表来保存这些钩子函数。

当数据包进入本地（LOCAL_IN 挂载点）时，就会相继调用ipt_hook 和 fw_confirm 钩子函数来处理数据包。

另外，钩子函数还有优先级，优先级越小越先执行。

正因为挂载点是通过链表来存储钩子函数，所以挂载点又被称为 链，挂载点对应的链名称如下所示：

LOCAL_IN 挂载点：又称为 INPUT链。
LOCAL_OUT 挂载点：又称为 OUTPUT链。
FORWARD 挂载点：又称为 PORWARD链。
PRE_ROUTING 挂载点：又称为 PREROUTING链。
POST_ROUTING 挂载点：又称为 POSTOUTING链。

2、代码分析

NF_INET_PRE_ROUTING

当二层收包结束后，会根据注册的协议和回调函数分发数据包，其中ipv4的数据包会分发到ip_rcv函数进行三层协议栈处理，该函数对数据包的合法性进行检查，并且设置一些必要字段之后，经过PRE_ROUTING钩子点；

 1 int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
 2 {
 3         /* IP数据报的合法性检查和一些必要字段设置，此处省略 */
 4 
 5     /* 经过PRE_ROUTING钩子点 */
 6     return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
 7                net, NULL, skb, dev, NULL,
 8                ip_rcv_finish);
 9 
10 }

NF_INET_LOCAL_IN

上面的ip_rcv函数在经过了PRE_ROUTING钩子点之后，会调用ip_rcv_finish函数，该函数的主要功能是查路由，决定数据包是输入到本地还是转发，并调用dst_input函数；当数据包输入本地时，dst_input函数实际调用了ip_local_deliver函数，函数首先对分片进行检查，如果是分片则需要进行重组，然后经过NF_INET_LOCAL_IN钩子点，之后调用ip_local_deliver_finish继续进行输入本地的其他工作；

 1 int ip_local_deliver(struct sk_buff *skb)
 2 {
 3     struct net *net = dev_net(skb->dev);
 4 
 5     /* 分片重组 */
 6     if (ip_is_fragment(ip_hdr(skb))) {
 7         if (ip_defrag(net, skb, IP_DEFRAG_LOCAL_DELIVER))
 8             return 0;
 9     }
10 
11     /* 经过LOCAL_IN钩子点 */
12     return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN,
13                net, NULL, skb, skb->dev, NULL,
14                ip_local_deliver_finish);
15 }

NF_INET_FORWARD

上面的ip_rcv函数在经过了PRE_ROUTING钩子点之后，会调用ip_rcv_finish函数，该函数的主要功能是查路由，决定数据包是输入到本地还是转发，并调用dst_input函数；当数据包输入本地时，dst_input函数实际调用了ip_forward函数，函数数据包进行合法性检查，然后经过NF_INET_FORWARD钩子点，之后调用ip_forward_finish继续进行转发的其他工作，ip_forward_finish在输出数据包的时候，实际上又调用dst_output，实际上就是ip_output函数；

 1 static int ip_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
 2 {
 3         /* 合法性检查等，此处省略 */
 4 
 5         /* 经过FORWARD钩子点 */
 6     return NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
 7                net, NULL, skb, skb->dev, rt->dst.dev,
 8                ip_forward_finish);
 9 
10 }

NF_INET_LOCAL_OUT

从本机发出的数据包，在查询路由成功之后，会调用__ip_local_out函数，函数首先进行必要字段设置和校验和计算，然后经过NF_INET_LOCAL_OUT钩子点，之后会调用dst_output继续完成数据包输出的其他工作，ipv4的路由输出函数实际上就是ip_output函数；

int __ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb)
{
    struct iphdr *iph = ip_hdr(skb);

    /* 设置总长度 */
    iph->tot_len = htons(skb->len);
    /* 计算校验和 */
    ip_send_check(iph);

    /* if egress device is enslaved to an L3 master device pass the
     * skb to its handler for processing
     */
    skb = l3mdev_ip_out(sk, skb);
    if (unlikely(!skb))
        return 0;

    /* 设置ip协议 */
    skb->protocol = htons(ETH_P_IP);

    /* 经过NF的LOCAL_OUT钩子点 */
    return nf_hook(NFPROTO_IPV4, NF_INET_LOCAL_OUT,
               net, sk, skb, NULL, skb_dst(skb)->dev,
               dst_output);
}

NF_INET_POST_ROUTING

转发的数据包或者是本地输出的数据包，最后都会经过ip_output进行输出，函数设置设备和协议之后，经过NF_INET_POST_ROUTING钩子点，之后调用ip_finish_output进行后续输出操作，其中包括了分片等；

int ip_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
    struct net_device *dev = skb_dst(skb)->dev;

    IP_UPD_PO_STATS(net, IPSTATS_MIB_OUT, skb->len);

    /* 设置输出设备和协议 */
    skb->dev = dev;
    skb->protocol = htons(ETH_P_IP);

    /* 经过NF的POST_ROUTING钩子点 */
    return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING,
                net, sk, skb, NULL, dev,
                ip_finish_output,
                !(IPCB(skb)->flags & IPSKB_REROUTED));
}

最后还是以bridge来说明下hooks参数的意义：

上面已经讲过，它决定了在协议流程的何处调用勾子函数；

因为使用NetFilter的目的是在内核态处理报文，而哪些地方可以处理报文只能是内核已经定义好的。

一般来说，内核会在报文发送和接收的关键位置添加勾子函数处理，查找代码中NF_HOOK即可知。

下面以bridge，为例，来看下在哪些地方用到了，以及这些值的含义：

接收：