Netfilter 内核数据包过滤框架

最新推荐文章于 2024-10-12 11:17:06 发布
最新推荐文章于 2024-10-12 11:17:06 发布
阅读量877 收藏 17
点赞数 1
分类专栏： 网络
原文链接：http://www.hyuuhit.com/2018/07/15/netfilter/
版权

作者：

原文：http://www.hyuuhit.com/2018/07/15/netfilter/

Netfilter 内核数据包过滤框架

Jul 15, 2018

文章目录

  1. 1. 协议族
  2. 2. hook点
  3. 3. 裁决值
  4. 4. 例子
  5. 5. 实现原理
    1. 5.1. 注册回调函数
    2. 5.2. 执行回调函数

Netfilter是linux内核中的数据包过滤框架，2.4版本及其后的内核包含该框架，该框架使数据包过滤、网络地址转换（NAT）和其他数据包修改功能成为可能。Netfilter框架由之前的ipfwadm和ipchains系统改进并重新设计而来，iptables工具与其紧密关联并依赖其在内核完成相应功能。

Netfilter框架由一组内核中的hook点组成，内核模块可以在网络栈的这些hook点上注册回调函数，当数据包穿过网络栈上相应的hook点时注册的回调函数将被调用，回调函数可以对参数中的数据包做需要的处理并裁决数据包后续的处理方式。

协议族

netfilter是一个通用的数据包过滤框架，支持多种协议族的数据包过滤。本文后续只关注IPV4协议。

ps：本文参考3.10.0-862.el7.x86_64版本内核代码。

本文参考的内核版本中对NFPROTO_INET看起来没有具体使用，未来版本可能会将对NFPROTO_INET的hook同时生效到IPV4与IPV6两个协议族上，也就是注册一个回调函数同时过滤两个协议族的数据包。从支持的协议族所对应的数字可以看到兼容了include/linux/socket.h中各个协议族的定义，对开发者更友好，比如NFPROTO_IPV4 == PF_INET、NFPROTO_IPV6 == PF_INET6，开发时混用也不会出错。

定义在include/uapi/linux/netfilter.h

1
2
3
4
5
6
7
8
9
10

enum {
    NFPROTO_UNSPEC =  0,
    NFPROTO_INET   =  1,
    NFPROTO_IPV4   =  2,
    NFPROTO_ARP    =  3,
    NFPROTO_BRIDGE =  7,
    NFPROTO_IPV6   = 10,
    NFPROTO_DECNET = 12,
    NFPROTO_NUMPROTO,
};

hook点

我没有关注其他协议族的情况，IPV4下共5个hook点，但是hook点的定义比较有趣。比如：

  • include/uapi/linux/netfilter_ipv4.h文件中定义有NF_IP_PRE_ROUTING
  • include/uapi/linux/netfilter.h文件中定义有NF_INET_PRE_ROUTING

其他几个hook点定义同样值相同。但是netfilter在内核IPV4与IPV6协议栈中调用回调函数时只使用了NF_INET_PRE_ROUTING这一组。不确定其他协议栈是否也是这5个hook点。

各个hook点调用时机如下：

  • NF_INET_PRE_ROUTING
    刚刚进入网络层的数据包通过此hook点，此时还没有判断式数据包的接收者是本地还是转发给其他host。
  • NF_INET_FORWARD
    通过pre_routing后，如果判断数据包应该转发给其他host，则会进一步通过forward点。
  • NF_INET_LOCAL_IN
    通过pre_routing点后，如果判断数据包应该由本地接收，则会进一步通过input点。
  • NF_INET_LOCAL_OUT
    本地向外发出的数据包会先经过output点。
  • NF_INET_POST_ROUTING
    本地向外发出的数据包经过output点后会经过post_routing点，转发的数据包经过forward点后也会经过post_routing点。

netfilter hooksnetfilter hooks

定义在include/uapi/linux/netfilter.h

1
2
3
4
5
6
7
8

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
};

裁决值

  • NF_DROP
    netfilter框架将丢掉该数据包并释放相关资源。
  • NF_ACCEPT
    回调函数放行了该数据包，将继续调用该hook点后续其他回调函数（如果有的话）或进入后续处理流程。
  • NF_STOLEN
    数据包由该回调函数负责后续处理（包括资源释放），netfilter及协议栈将不再对该数据包做任何动作。
  • NF_QUEUE
    数据包停止其他回调函数调用，由netfilter放入NFQUEUE队列中。参考NFQUEUE 用户态数据包处理。
  • NF_REPEAT
    数据包由netfilter再次调用刚刚返回NF_REPEAT值的回调函数，返回该值需要谨慎避免死循环。
  • NF_STOP
    与NF_ACCEPT类似，但不再调用该hook点后续的任何回调函数（如果有的话）直接进入后续处理流程。
  • NF_VERDICT_MASK
    裁决动作掩码。由于NF_DROP和NF_QUEUE在裁决动作之外可能需要额外的信息附带在返回值中，因此使用该掩码过滤掉其他信息只保留裁决动作。
  • NF_VERDICT_FLAG_QUEUE_BYPASS
    该flag位用于标记NFQUEUE入队列失败之后是否进行后续处理。如果没有该flag，入队列失败后将直接释放数据包资源。如果包含该flag，入队列失败后将等同于NF_ACCEPT做后续处理。
  • NF_VERDICT_QMASK
    该掩码记录了用于NFQUEUE队列号的bit位。

  • NF_VERDICT_QBITS
    回调函数裁决NF_QUEUE时，返回值右移此尾数以取到NFQUEUE队列号。

  • NF_QUEUE_NR
    一个辅助宏，输入NFQUEUE队列号，返回回调函数的合理返回值。

  • NF_DROP_ERR
    一个辅助宏，输入NF_DROP附带的错误值，返回回调函数的合理返回值。

定义在include/uapi/linux/netfilter.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/* Responses from hook functions. */
#define NF_DROP 0
#define NF_ACCEPT 1
#define NF_STOLEN 2
#define NF_QUEUE 3
#define NF_REPEAT 4
#define NF_STOP 5
#define NF_MAX_VERDICT NF_STOP

/* we overload the higher bits for encoding auxiliary data such as the queue
 * number or errno values. Not nice, but better than additional function
 * arguments. */
#define NF_VERDICT_MASK 0x000000ff

/* extra verdict flags have mask 0x0000ff00 */
#define NF_VERDICT_FLAG_QUEUE_BYPASS    0x00008000

/* queue number (NF_QUEUE) or errno (NF_DROP) */
#define NF_VERDICT_QMASK 0xffff0000
#define NF_VERDICT_QBITS 16

#define NF_QUEUE_NR(x) ((((x) << 16) & NF_VERDICT_QMASK) | NF_QUEUE)

#define NF_DROP_ERR(x) (((-x) << 16) | NF_DROP)

例子

netfilter只能在内核态注册回调函数，因此需要编译为内核模块，参考Linux kernel module 内核模块

这里贴一个例子，在IPV4协议栈的5个hook点都注册回调函数，udp端口包含10086的数据包在NF_INET_POST_ROUTING或NF_INET_LOCAL_IN阶段丢掉，udp端口包含10010的数据包在NF_INET_POST_ROUTING或NF_INET_LOCAL_IN阶段放入NFQUEUE队列10010中，其他数据包全部放行。这样也可以联动之前NFQUEUE的例子代码。

ps：注意这里要谨慎一些，因为内核IPV4的所有数据包都会经过该回调函数。

netfilter_example.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/netfilter_ipv4.h>
#include <linux/ip.h>
#include <linux/udp.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Hu Yu <hyuuhit@gmail.com>");
MODULE_DESCRIPTION("netfilter example");
MODULE_VERSION("0.1");

#define MY_QUEUE_NUM 10010

static char *hook_name(int hook) {
    switch (hook) {
        case NF_INET_PRE_ROUTING:
            return "pre_routing";
        case NF_INET_LOCAL_IN:
            return "local_in";
        case NF_INET_FORWARD:
            return "forward";
        case NF_INET_LOCAL_OUT:
            return "local_out";
        case NF_INET_POST_ROUTING:
            return "post_routing";
    }
    return NULL;
}

static unsigned int generic_hook(const struct nf_hook_ops *ops, struct sk_buff *skb, const struct net_device *in, const struct net_device *out, const struct nf_hook_state *state)
{
    struct iphdr    *iph;
    struct udphdr   *udph;
    struct udphdr   buf;

    iph         = ip_hdr(skb);

    if (iph->protocol != IPPROTO_UDP) {
        return NF_ACCEPT;
    }

    if (skb->len < iph->ihl * 4 + sizeof(*udph)) {
        return NF_ACCEPT;
    }

    if (skb_headlen(skb) < iph->ihl * 4 + sizeof(*udph)) {
        udph = (void *)iph + iph->ihl * 4;
    } else {
        skb_copy_bits(skb, iph->ihl * 4, &buf, sizeof(*udph));
        udph = &buf;
    }


    if (ntohs(udph->source) == 10086 || ntohs(udph->dest) == 10086) {
        if (ops->hooknum == NF_INET_POST_ROUTING || ops->hooknum == NF_INET_LOCAL_IN) {
            printk("%-15s udp drop   %pI4:%d -> %pI4:%d\n", hook_name(ops->hooknum), &iph->saddr, ntohs(udph->source), &iph->daddr, ntohs(udph->dest));
            return NF_DROP;
        } else {
            printk("%-15s udp accept %pI4:%d -> %pI4:%d\n", hook_name(ops->hooknum), &iph->saddr, ntohs(udph->source), &iph->daddr, ntohs(udph->dest));
            return NF_ACCEPT;
        }
    } else if (ntohs(udph->source) == 10010 || ntohs(udph->dest) == 10010) {
        if (ops->hooknum == NF_INET_POST_ROUTING || ops->hooknum == NF_INET_LOCAL_IN) {
            printk("%-15s udp queue  %pI4:%d -> %pI4:%d\n", hook_name(ops->hooknum), &iph->saddr, ntohs(udph->source), &iph->daddr, ntohs(udph->dest));
            return NF_QUEUE_NR(MY_QUEUE_NUM);
        } else {
            printk("%-15s udp accept %pI4:%d -> %pI4:%d\n", hook_name(ops->hooknum), &iph->saddr, ntohs(udph->source), &iph->daddr, ntohs(udph->dest));
            return NF_ACCEPT;
        }
    }
    return NF_ACCEPT;
}

static struct nf_hook_ops my_hooks[] = {
    {
        .hook   = generic_hook,
        .owner  = THIS_MODULE,
        .pf     = NFPROTO_IPV4,
        .hooknum    = NF_INET_PRE_ROUTING,
        .priority   = NF_IP_PRI_LAST,
    },
    {
        .hook   = generic_hook,
        .owner  = THIS_MODULE,
        .pf     = NFPROTO_IPV4,
        .hooknum    = NF_INET_LOCAL_IN,
        .priority   = NF_IP_PRI_LAST,
    },
    {
        .hook   = generic_hook,
        .owner  = THIS_MODULE,
        .pf     = NFPROTO_IPV4,
        .hooknum    = NF_INET_FORWARD,
        .priority   = NF_IP_PRI_LAST,
    },
    {
        .hook   = generic_hook,
        .owner  = THIS_MODULE,
        .pf     = NFPROTO_IPV4,
        .hooknum    = NF_INET_LOCAL_OUT,
        .priority   = NF_IP_PRI_LAST,
    },
    {
        .hook   = generic_hook,
        .owner  = THIS_MODULE,
        .pf     = NFPROTO_IPV4,
        .hooknum    = NF_INET_POST_ROUTING,
        .priority   = NF_IP_PRI_LAST,
    },
};

static int __init my_init(void)
{
    printk("my init.\n");
    return nf_register_hooks(my_hooks, ARRAY_SIZE(my_hooks));
}

static void __exit my_exit(void)
{
    printk("my exit.\n");
    nf_unregister_hooks(my_hooks, ARRAY_SIZE(my_hooks));
}

module_init(my_init);
module_exit(my_exit);

Makefile

1
2
3
4
5
6
7
8
9
10
11
12
13

obj-m := netfilter_example.o

PWD:=$(shell pwd)
KVER:=$(shell uname -r)
KDIR:=/lib/modules/$(KVER)/build

EXTRA_CFLAGS += -Wall -g

all:
    $(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
    $(MAKE) -C $(KDIR) M=$(PWD) clean

使用nc测试后的dmesg输出

[  614.926634] my init.
[  620.194403] local_out       udp accept 10.95.29.17:47690 -> 10.95.29.15:10086
[  620.194408] post_routing    udp drop   10.95.29.17:47690 -> 10.95.29.15:10086
[  623.164656] local_out       udp accept 10.95.29.17:44909 -> 10.95.29.15:10010
[  623.164662] post_routing    udp queue  10.95.29.17:44909 -> 10.95.29.15:10010
[  632.284199] pre_routing     udp accept 10.95.29.15:39701 -> 10.95.29.17:10086
[  632.284220] local_in        udp drop   10.95.29.15:39701 -> 10.95.29.17:10086
[  650.240826] pre_routing     udp accept 10.95.29.15:40502 -> 10.95.29.17:10010
[  650.240853] local_in        udp queue  10.95.29.15:40502 -> 10.95.29.17:10010
[  667.918573] my exit.

实现原理

注册回调函数

注册回调函数需要nf_hook_ops结构体，里面定义了注册的回调函数、协议族、hook点和优先级（升序排列执行）。

nf_hook_ops结构体定义在include/linux/netfilter.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

struct nf_hook_ops {
    struct list_head list;

    /* User fills in from here down. */
    nf_hookfn   *hook;
    struct module   *owner;
    void        *priv;
    u_int8_t    pf;
    unsigned int    hooknum;
    /* Hooks are ordered in ascending priority. */
    int     priority;

    /* Reserved for use in the future RHEL versions. Set to zero. */
    unsigned long   __rht_reserved1;
    unsigned long   __rht_reserved2;
    unsigned long   __rht_reserved3;
    unsigned long   __rht_reserved4;
    unsigned long   __rht_reserved5;
};

nf_hooks定义在net/netfilter/core.c

1

struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS] __read_mostly;

所有的回调函数都注册在二维数组全局变量nf_hooks中。list_head是linux内核中常用的双向链表结构，这里不关注。数组的第一个维度是注册回调函数的协议族，第二个维度是注册回调函数的hook点，也就是每一个协议族的每一个hook点都是一个双向链表连接的一组回调函数。NF_MAX_HOOKS值为8，不确定什么协议族有8个hook点。

nf_register_hook根据协议族和hook点确定nf_hooks中的链表，遍历链表根据nf_hook_ops中的优先级插入到链表的合适位置。nf_register_hooks只是nf_register_hook的循环包装，

注销回调函数时只是将该nf_hook_ops结构从链表中移出。

执行回调函数

以IPV4协议族收包为例，在确定网络层协议为IPV4协议后，内核进入ip_rcv函数。经过一系列检查后，最后运行到NF_HOOK，选择NFPROTO_IPV4协议族、NF_INET_PRE_ROUTINGhook点，同时设定协议栈下一步处理函数ip_rcv_finish（这个函数将在该hook点回调函数处理完毕并允许下一步逻辑执行时被调用，参考前文裁决值部分。

由NF_HOOK开始的netfilter框架执行代码贴在这里，可以看到代码简短逻辑清晰，但能够支持内核模块（比如ip_tables模块）通过注册各种回调函数完成复杂功能。netfilter作为内核数据包过滤框架，很好的体现了“提供机制，而不是策略”的设计思想。

ip_rcv定义在net/ipv4/ip_input.c

1
2
3
4
5
6
7
8
9
10
11
12
13

/*
 *  Main IP Receive routine.
 */
int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
{
    /*
     * ....................
     */

    return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, NULL, skb,
            dev, NULL,
            ip_rcv_finish);
}

include/linux/netfilter.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/**
 *  nf_hook_thresh - call a netfilter hook
 *
 *  Returns 1 if the hook has allowed the packet to pass.  The function
 *  okfn must be invoked by the caller in this case.  Any other return
 *  value indicates the packet has been consumed by the hook.
 */
static inline int nf_hook_thresh(u_int8_t pf, unsigned int hook,
        struct sock *sk,
        struct sk_buff *skb,
        struct net_device *indev,
        struct net_device *outdev,
        int (*okfn)(struct sock *, struct sk_buff *),
        int thresh)
{
    if (nf_hooks_active(pf, hook)) {
        struct nf_hook_state state;

        nf_hook_state_init(&state, hook, thresh, pf,
                indev, outdev, sk, okfn);
        return nf_hook_slow(skb, &state);
    }
    return 1;
}

static inline int
NF_HOOK_THRESH(uint8_t pf, unsigned int hook, struct sock *sk,
        struct sk_buff *skb, struct net_device *in,
        struct net_device *out,
        int (*okfn)(struct sock *, struct sk_buff *), int thresh)
{
    int ret = nf_hook_thresh(pf, hook, sk, skb, in, out, okfn, thresh);
    if (ret == 1)
        ret = okfn(sk, skb);
    return ret;
}

static inline int
NF_HOOK(uint8_t pf, unsigned int hook, struct sock *sk, struct sk_buff *skb,
        struct net_device *in, struct net_device *out,
        int (*okfn)(struct sock *, struct sk_buff *))
{
    return NF_HOOK_THRESH(pf, hook, sk, skb, in, out, okfn, INT_MIN);
}

net/netfilter/core.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

unsigned int nf_iterate(struct list_head *head,
        struct sk_buff *skb,
        struct nf_hook_state *state,
        struct nf_hook_ops **elemp)
{
    unsigned int verdict;

    /*
     * The caller must not block between calls to this
     * function because of risk of continuing from deleted element.
     */
    list_for_each_entry_continue_rcu((*elemp), head, list) {
        if (state->thresh > (*elemp)->priority)
            continue;

        /* Optimization: we don't need to hold module
           reference here, since function can't sleep. --RR */
repeat:
        verdict = (*elemp)->hook(*elemp, skb, state->in, state->out,
                state);
        if (verdict != NF_ACCEPT) {
#ifdef CONFIG_NETFILTER_DEBUG
            if (unlikely((verdict & NF_VERDICT_MASK)
                        > NF_MAX_VERDICT)) {
                NFDEBUG("Evil return from %p(%u).\n",
                        (*elemp)->hook, state->hook);
                continue;
            }
#endif
            if (verdict != NF_REPEAT)
                return verdict;
            goto repeat;
        }
    }
    return NF_ACCEPT;
}

/* Returns 1 if okfn() needs to be executed by the caller,
 * -EPERM for NF_DROP, 0 otherwise. */
int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state)
{
    struct nf_hook_ops *elem;
    unsigned int verdict;
    int ret = 0;

    /* We may already have this, but read-locks nest anyway */
    rcu_read_lock();

    elem = list_entry_rcu(&nf_hooks[state->pf][state->hook],
            struct nf_hook_ops, list);
next_hook:
    verdict = nf_iterate(&nf_hooks[state->pf][state->hook], skb, state,
            &elem);
    if (verdict == NF_ACCEPT || verdict == NF_STOP) {
        ret = 1;
    } else if ((verdict & NF_VERDICT_MASK) == NF_DROP) {
        kfree_skb(skb);
        ret = NF_DROP_GETERR(verdict);
        if (ret == 0)
            ret = -EPERM;
    } else if ((verdict & NF_VERDICT_MASK) == NF_QUEUE) {
        int err = nf_queue(skb, elem, state,
                verdict >> NF_VERDICT_QBITS);
        if (err < 0) {
            if (err == -ECANCELED)
                goto next_hook;
            if (err == -ESRCH &&
                    (verdict & NF_VERDICT_FLAG_QUEUE_BYPASS))
                goto next_hook;
            kfree_skb(skb);
        }
    }
    rcu_read_unlock();
    return ret;
}

linux

Linux kernel 链路层帧接收NFQUEUE 用户态数据包处理

maimang09
关注
专栏目录
Netfilter 基本的数据报过滤技术
fjachao的专栏
07-18 1764
继续关注了一些关于NetFilter的东西，在逆水行舟的blog上看到深入Linux网络核心堆栈 ，觉得下面这些东西很有用，就摘录了下来，如果有版权问题，烦请告知。1 - 深入hook函数    现在是到了看看什么数据被传递到hook函数中以及这些数据如何被用于做过滤选择的时候了。那么，让我们更深入的看看nf_hookfn函数的原型吧。这个函数原型在linux/netfilter.h中给出，如下：
【Linux 驱动】Netfilter/iptables (五) 数据包过滤
wenqian 'blog
12-22 7677
通过前面的学习，我们窥探了整个Netfilter框架，下面我们就通过一些编程实例来进一步学习。一. 基于网络设备接口进行数据包过滤 根据hook函数接收的参数中的 struct net_device 结构，net_device 结构体用于描述网络接口设备，其中name这个成员表示对应设备的名字，我们可以通过比对来判断数据包的源接口或目的接口。/*安装一个丢弃所有进入我们指定接口的数据包的 netf
iptables 和 netfilter 详解
最新发布
qq_49554011的博客
10-12 1380
iptables和netfilteriptables是Linux 上最常用的防火墙工具，iptables 与协议栈内有包过滤功能的 hook 交互来完成工作。这些内核 hook 构成了 netfilter 框架每个进入网络系统的包（接收或发送）在经过协议栈时都会触发这些 hook，程序可以通过注册 hook 函数的方式在一些关键路径上处理网络流量。iptables 相关的内核模块在这些 hook 点注册了处理函数，因此可以通过配置 iptables 规则来使得网络流量符合防火墙规则。
Netfilter的使用和实现
weixin_30901729的博客
04-02 163
本文主要内容：Netfilter的原理和实现浅析，以及示例模块。 内核版本：2.6.37 Author：zhangskd @ csdn blog 概述 Netfilter为多种网络协议（IPv4、IPv6、ARP等）各提供了一套钩子函数。 在IPv4中定义了5个钩子函数，这些钩子函数在数据包流经协议栈的5个关键点被调用。 这就像有5个钓鱼台，在每个钓鱼台放了一个鱼钩...
linux netfilter 过滤数据包,Linux网络防火墙Netfilter的数据包传输过滤原理
weixin_36271649的博客
05-15 216
Linux网络防火墙Netfilter的数据包传输过滤原理保密及网络安全2010年第23卷第5期ElectronicSci &Tech /May 15,2010Linux网络防火墙Netfilter的数据包传输过滤原理朱 艳(西安市儿童医院医保合疗办,陕西西安 710003)摘 要 给出了Linux网络防火墙Netfilter在IPV4网络环境下,Netfilter框架挂接点...
Netfilter框架下的数据包过滤与入侵检测：Linux防火墙实现
本文主要探讨了Netfilter框架在数据包过滤防火墙设计与实现中的关键作用。Netfilter是Linux内核中用于网络数据包处理的核心组件，它提供了一种灵活且高效的方式来管理网络流量。论文的作者陈昱志，作为一名硕士研究...
Linux内核下数据包处理与用户空间通信：基于Netfilter的包过滤防火墙设计
本篇文章主要探讨了如何在Linux环境下设计和实现一个基于数据包过滤的防火墙，特别关注了在用户空间与内核空间之间的数据交互。文章作者陈昱志，硕士研究生专业为软件工程，由指导教师孟宪福指导，研究了网络安全...
Linux Netfilter/iptables：内核防火墙与数据包过滤实战
Netfilter/iptables是Linux 2.6内核中一个至关重要的组件，它提供了一个通用的功能框架，用于对网络数据包进行高级的管理和控制。该系统的核心在于其规则表（iptables）和一系列相关的链（chain），它们协同工作以...
netfilter数据包过滤
specialsun的专栏
01-11 1518
    iptables可以很方便的构建系统防火墙，那它是如何实现的呢？Linux内核添加了netfilter机制，在IP协议栈上传递过程中，选择了5个检查点。利用5个检测点，查阅用户注册的回调处理函数，根据用户自定义回调函数监视进出的网络数据包。        有了上面的知识，可以实现自己的iptables。   一.编码     该示例简单拦截所有到达本机的http请求。 ...
基于Netfilter内核态网络流量分析研究.pdf
09-06
【标题】:基于Netfilter内核态网络流量分析研究 【描述】:本文探讨了在Linux操作系统中，利用Netfilter框架进行内核态网络流量分析的技术。通过内核级的流量采集和分析，实现了对局域网内所有数据包的监控，并对TCP...
Linux网络防火墙Netfilter的数据包传输过滤原理.pdf
09-06
Linux网络防火墙Netfilter的数据包传输过滤原理.pdf
防火墙软件Netfilter之包过滤技术(转)
congjukun0600的博客
08-10 420
防火墙软件Netfilter之包过滤技术(转)[@more@]如果您不知道什么是IP地址、网络地址、网络掩码、路由或者DNS，那么，请先阅读相关的网络基础书籍。1．什么是包过滤（Packet Filter）？包过滤技术就是利用一...
信息安全实验二：iptables设置代理和netfilter实现包过滤
qq_24293765的博客
03-21 1514
信息安全实验二：iptables设置代理和netfilter实现包过滤 通过wireshark分析http报文结构 HTTP报文结构 - 简书 iptables设置代理 任务：需要同一网络下的三台主机，通过设置iptables实现一个代理服务器，用户主机可以通过代理主机访问网页服务器上的网页 原理：实现代理，即需要用代理服务器将用户主机与内部服务器隔离起来，当用户向内部服务器申请资源时，请求报文的目的ip是代理服务器的ip，到达代理服务器后，在路由选择之前进行目标地址转换，将目的地址转换为内部服务器的地址。
netfilter/iptables (二) Netfilter hook 数据结构
Lawrence_121
10-07 455
一、Netfilter简介        Netfilter是Linux 2.4.x引入的一个子系统，它作为一个通用的、抽象的框架，提供一整套的hook函数的管理机制，使得诸如数据包过滤、网络地址转换(NAT)和基于协议类型的连接跟踪成为了可能。Netfilter在内核中位置如下图所示：               这幅图，很直观的反应了用户空间的iptables和内核空间的基于Netfi...
Linux协议栈-netfilter(2)-conntrack
热门推荐
落尘纷扰的专栏
04-04 1万+
连接跟踪（conntrack）用来跟踪和记录一个连接的状态，它为经过协议栈的数据包记录状态，这为防火墙检测连接状态提供了参考，同时在数据包需要做NAT时也为转换工作提供便利。本文基于Linux内核2.6.31实现的conntrack进行源码分析。1. conntrack模块初始化1.1 conntrack模块入口conntrack模块的初始化主要就是为必要的全局数据结构进行初始化，代码流程如下：上...
Netfilter框架
stonesharp的专栏
04-28 611
1. Netfilter/IPTables简介     Netfilter/IPTables是继2.0.x的ipfwadm、2.2.x的ipchains之后，新一代的 Linux防火墙机制。Netfilter采用模块化设计，具有良好的可扩充性。其重要工具模块IPTables连接到 NetFilter的架构中，并允许使用者对数据报进行过滤、地址转换、处理等操作.Netfilter提供了一个框架
利用Linux Netfilter框架实现Linux内核模块阻断HTTP数据包
qq_41727987的博客
05-08 907
主要参考内容： netfilter数据包过滤【https://tcspecial.iteye.com/blog/2174784】（很旧版netfilter下阻断http包） Linux内核编程 -- 从HelloWord到基于NetFilter的Linux驱动Demo【https://blog.csdn.net/xushuzhan/article/details/78843218】（很详细...
IP数据包过滤，过滤端口、黑名单、网段等(修改后的全部源码)
01-05
/** * 规则函数： addRule(char *driver_name,USHORT type,USHORT protocol,char *sourceIp,char *sourceMask,USHORT sourcePort, char *destinationIp, char *destinationMask, USHORT destinationPort,BOOLEAN isDrop)； * 规则说明： * type：参数 * LOCAL_PORT_FILTER类型： 端口过滤。 * BLANK_IP_FILTER类型： IP黑名单过滤。 * NET_FILTER类型：子网过滤。 * protocol参数：协议号 * 协议可以指定协议类型，TCP=6,UDP=17,ICMP=1。如果指定=0，表示对所有协议作用。 * sourceIp、sourceMask参数:源IP地址和掩码 * sourcePort参数：源端口号。等于0表示不指定端口。 * destinationIp、destinationMask参数：目的地址、目的掩码。 * destinationPort参数：目的端口。等于0表示不指定端口。 * isDrop参数：是否丢弃这个数据分组。TRUE:丢弃；FALSE：放过。 */
基于netfilter实现对http报文过滤，并并窃取http报文的用户名和密码
m0_63334846的博客
04-28 1893
攻击主机 192.168.163.132 Ubuntu20.04（5.13.0-39-generic） 受害主机 192.168.163.135 Ubuntu16.04（4.15.0-112-generic） Netfilter是从Linux 2.4开始引入内核的一个子系统，架构就是在整个网络流程的若干位置放置了一些检测点（HOOK），而在每个检测点上登记了一些处理函数进行处理（如包过滤，NAT等，以及可以是 用户自定义的功能）。 NF_INET_PRE_ROUT
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值