第11周：Netfilter 框架与 iptables 原理

字数统计: 2.9k字   |   阅读时长≈ 15分

第11周：Netfilter 框架与 iptables 原理

目标：理解 Netfilter 框架的五个钩子点，掌握 conntrack 机制，能编写内核模块在钩子点过滤数据包。

1. Netfilter 架构概览

1.1 五个钩子点

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
数据包流向：

                         ┌──────────────────────────────────────────────────┐
                         │                  LOCAL PROCESS                   │
                         └──────────────────────┬───────────────────────────┘
                                                │
                        ┌───────────────────────▼────────────────────────┐
                        │              LOCAL_IN                           │
                        │    (NF_INET_LOCAL_IN)                          │
                        │    目的 IP = 本机                               │
                        └───────────────────────┬────────────────────────┘
                                                │
  ┌──────────────┐   PREROUTING   ┌──────────────▼───────────┐
  │              │ ─────────────▶ │                          │
  │              │   NF_INET_    │         FORWARD          │
  │   网络接口    │   PRE_ROUTING │      (NF_INET_FORWARD)   │
  │              │               │      IP 转发              │
  │              │ ◀───────────── │                          │
  └──────────────┘  POSTROUTING └──────────────▲───────────┘
                                                │
                        ┌───────────────────────┼────────────────────────┐
                        │              LOCAL_OUT│                       │
                        │               NF_INET│_LOCAL_OUT              │
                        │              本机发出 │                       │
                        └───────────────────────┴────────────────────────┘
                                                │
                                                ▼
                                          POSTROUTING
                                        (NF_INET_POST_ROUTING)
                                              所有出站包
                                              做 NAT / 修改
                                              路由查找

Hook 点汇总：
┌──────────────┬──────────────────┬────────────────────────────────┐
│ 钩子点       │ 宏定义           │ 用途                            │
├──────────────┼──────────────────┼────────────────────────────────┤
│ PREROUTING   │ NF_INET_PRE_ROUTING │ 路由查找前，所有到达本机的包  │
│              │                    │ （DNAT、QoS、mangle）          │
├──────────────┼──────────────────┼────────────────────────────────┤
│ LOCAL_IN     │ NF_INET_LOCAL_IN   │ 路由确认是本机后，入栈前       │
│              │                    │ （filter、conntrack）          │
├──────────────┼──────────────────┼────────────────────────────────┤
│ FORWARD      │ NF_INET_FORWARD    │ 转发路径                       │
│              │                    │ （filter、conntrack）          │
├──────────────┼──────────────────┼────────────────────────────────┤
│ LOCAL_OUT    │ NF_INET_LOCAL_OUT  │ 本机发出的包，路由查找前       │
│              │                    │ （filter、NAT、mangle）        │
├──────────────┼──────────────────┼────────────────────────────────┤
│ POSTROUTING  │ NF_INET_POST_ROUTING │ 所有出站包最后执行            │
│              │                    │ （NAT、mangle）                │
└──────────────┴──────────────────┴────────────────────────────────┘

1.2 iptables 表与钩子点对应

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Table  ────── Hook 点 ───────────────── 用途
────────────────────────────────────────────────────
filter  ── PREROUTING / LOCAL_IN     包过滤（accept/drop/reject）
          ── FORWARD
          ── LOCAL_OUT

nat     ── PREROUTING                 DNAT（目的地址转换）
          ── POSTROUTING              SNAT/MASQUERADE（源地址转换）
          ── LOCAL_OUT

mangle  ── ALL 5 个钩子             修改包标记、TOS

raw     ── PREROUTING / LOCAL_OUT   关闭 conntrack
          （优先级最高）

security ─ PREROUTING / LOCAL_IN    SELinux 安全标签
          ── FORWARD
          ── LOCAL_OUT

优先级（优先级数字越小越先执行）：
raw > mangle > nat (PREROUTING) > filter (PREROUTING/LOCAL_IN)
    > mangle > filter (FORWARD) > nat (LOCAL_OUT) > mangle
    > filter (LOCAL_OUT) > mangle > nat (POSTROUTING)

2. iptables 常用命令

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
# === 基本操作 ===

# 查看所有规则
sudo iptables -t filter -L -v -n
sudo iptables -t nat -L -v -n
sudo iptables -L -v -n --line-numbers  # 显示行号

# 清空规则
sudo iptables -F           # 清空 filter 表
sudo iptables -t nat -F    # 清空 nat 表
sudo iptables -X           # 删除自定义链

# 默认策略
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT

# === 过滤规则 ===

# 允许已建立的连接
sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# 允许本地回环
sudo iptables -A INPUT -i lo -j ACCEPT

# 允许 SSH
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# 允许 HTTP/HTTPS
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 禁止特定 IP
sudo iptables -A INPUT -s 192.168.1.100 -j DROP

# 限制 ICMP（ping）
sudo iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

# 限制新连接速率（防扫描）
sudo iptables -A INPUT -p tcp --syn -m limit --limit 10/s -j ACCEPT

# === NAT ===

# 内网共享上网（SNAT/MASQUERADE）
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

# 端口转发
sudo iptables -t nat -A PREROUTING -p tcp --dport 8080 -j DNAT --to 192.168.1.10:80

# === 日志 ===

# 记录丢弃的包
sudo iptables -A INPUT -j LOG --log-prefix "IPTABLES DROP: "

# 使用 NFLOG 发送到用户态
sudo iptables -A INPUT -j NFLOG --nflog-group 1

# === 保存/恢复 ===

# 保存
sudo iptables-save > iptables.rules

# 恢复
sudo iptables-restore < iptables.rules

# === 统计 ===

# 各规则的计数器
sudo iptables -L -v -n

# 查看 conntrack 表
sudo conntrack -L
sudo conntrack -L -p tcp --dport 80
sudo conntrack -D  # 清空

3. Conntrack（连接跟踪）

3.1 工作原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
每个通过 Netfilter 的包会被 conntrack 记录：

初始状态（NEW）：
  ┌─────┐                      ┌─────┐
  │Client│ ─── SYN ──────────▶ │Server│
  └─────┘                      └─────┘
  conntrack 记录：192.168.1.2:12345 → 10.0.0.1:80 [SYN]

ESTABLISHED：
  conntrack 更新：192.168.1.2:12345 ↔ 10.0.0.1:80 [ESTABLISHED]

CLOSE：
  Client ── FIN ──▶ Server
  Server ── FIN ──▶ Client
  conntrack 状态变为：TIME_WAIT / CLOSE

3.2 Conntrack 状态机

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
               +------------+
               | NEW        | ← SYN 到达
               +-----+------+
                     |
                     v
               +------------+
               | ESTABLISHED| ← SYN+ACK 交换完成
               +-----+------+
                     |
        +------------+------------+
        |                         |
        v                         v
+--------------+          +--------------+
| FIN_WAIT     |          | TIME_WAIT    |
+-----+--------+          +--------------+
      |
      v
+--------------+
| CLOSE        |
+--------------+

3.3 Conntrack 参数调优

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 查看当前连接跟踪表大小
sudo sysctl net.netfilter.nf_conntrack_max
# 默认 65536

# 查看当前使用量
sudo sysctl net.netfilter.nf_conntrack_count

# 查看超时参数
sudo sysctl net.netfilter.nf_conntrack_tcp_timeout_established  # 432000 (5天)
sudo sysctl net.netfilter.nf_conntrack_tcp_timeout_time_wait    # 120
sudo sysctl net.netfilter.nf_conntrack_tcp_timeout_close_wait   # 60
sudo sysctl net.netfilter.nf_conntrack_tcp_timeout_fin_wait     # 120

# 调优
sudo sysctl -w net.netfilter.nf_conntrack_max=262144
sudo sysctl -w net.netfilter.nf_conntrack_tcp_timeout_established=600

# 查看 conntrack 表（已跟踪的连接）
sudo cat /proc/net/nf_conntrack
# 格式：tcp ESTABLISHED src=... dst=... sport=... dport=... ...

# 统计
sudo conntrack -L | wc -l
sudo conntrack -L -f tcp | head

3.4 Conntrack 限制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1. 表大小限制（nf_conntrack_max）
   - 默认 65536，高并发场景不够
   - 设太大会消耗内存（每条记录约 300 字节）
   - 262144 条 ≈ 75MB

2. 每个连接的哈希桶
   nf_conntrack_buckets (默认 65536)

3. 超时机制
   - ESTABLISHED 默认 5 天
   - TIME_WAIT 默认 120 秒
   - 可调但需平衡内存和准确性

4. NAT 场景
   - 每个 NAT 映射占用额外条目
   - NAT 表也有类似限制

4. 编写 Netfilter 内核模块

4.1 Netfilter Hook 注册

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
// netfilter_hook.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netfilter.h>
#include <linux/netfilter_ipv4.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/inet.h>

#define TARGET_PORT 80

// 统计计数器
static unsigned long packet_count = 0;
static unsigned long dropped_count = 0;

// Hook 函数
static unsigned int hook_func(void *priv,
                              struct sk_buff *skb,
                              const struct nf_hook_state *state) {
    struct iphdr *iph;
    struct tcphdr *tcph;
    struct udphdr *udph;
    __be32 daddr;

    // 统计所有包
    packet_count++;

    // 安全检查
    if (!skb)
        return NF_ACCEPT;

    // 获取 IP 头
    iph = ip_hdr(skb);
    if (!iph)
        return NF_ACCEPT;

    // 只处理 TCP 和 UDP
    if (iph->protocol != IPPROTO_TCP && iph->protocol != IPPROTO_UDP)
        return NF_ACCEPT;

    daddr = iph->daddr;

    // TCP 处理
    if (iph->protocol == IPPROTO_TCP) {
        // 获取 TCP 头（需要确保数据足够）
        if (skb_linearize(skb) != 0)
            return NF_ACCEPT;

        tcph = (struct tcphdr *)((__u32 *)iph + iph->ihl);
        if (!tcph)
            return NF_ACCEPT;

        // 打印包信息
        printk(KERN_INFO "NFT: TCP %pI4:%u -> %pI4:%u (len=%u)\n",
               &iph->saddr, ntohs(tcph->source),
               &iph->daddr, ntohs(tcph->dest),
               ntohs(iph->tot_len));

        // 在 LOCAL_IN 钩子点拦截 80 端口
        if (state->hook == NF_INET_LOCAL_IN &&
            tcph->dest == htons(TARGET_PORT)) {
            dropped_count++;
            printk(KERN_INFO "NFT: DROPPED TCP packet to port %d "
                   "from %pI4\n", TARGET_PORT, &iph->saddr);
            return NF_DROP;
        }
    }
    // UDP 处理
    else if (iph->protocol == IPPROTO_UDP) {
        if (skb_linearize(skb) != 0)
            return NF_ACCEPT;

        udph = (struct udphdr *)((__u32 *)iph + iph->ihl);
        if (!udph)
            return NF_ACCEPT;

        printk(KERN_INFO "NFT: UDP %pI4:%u -> %pI4:%u (len=%u)\n",
               &iph->saddr, ntohs(udph->source),
               &iph->daddr, ntohs(udph->dest),
               ntohs(iph->tot_len));
    }

    return NF_ACCEPT;
}

// Hook 注册结构
static struct nf_hook_ops nfho = {
    .hook     = hook_func,            // 处理函数
    .pf       = NFPROTO_IPV4,         // 协议族：IPv4
    .hooknum  = NF_INET_LOCAL_IN,     // 钩子点：本地入站
    .priority = -300,     // 优先级：最早执行（= 旧版 NF_IP_PRI_FIRST）
};

static int __init nf_init(void) {
    int ret;

    // 注册 hook
    ret = nf_register_net_hook(&init_net, &nfho);
    if (ret) {
        printk(KERN_ERR "Failed to register netfilter hook: %d\n", ret);
        return ret;
    }

    printk(KERN_INFO "Netfilter module loaded\n");
    printk(KERN_INFO "Monitoring port %d at LOCAL_IN hook\n", TARGET_PORT);
    return 0;
}

static void __exit nf_exit(void) {
    nf_unregister_net_hook(&init_net, &nfho);
    printk(KERN_INFO "Netfilter module unloaded\n");
    printk(KERN_INFO "Total packets: %lu, Dropped: %lu\n",
           packet_count, dropped_count);
}

module_init(nf_init);
module_exit(nf_exit);
MODULE_LICENSE("GPL");
1
2
3
4
5
6
7
8
9
10
# Makefile
obj-m += netfilter_hook.o

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

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

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 编译
make

# 加载
sudo insmod netfilter_hook.ko

# 查看日志
sudo dmesg -w

# 产生流量（访问 80 端口）
curl http://localhost:80

# 查看统计
cat /proc/net/netfilter  # 系统级 conntrack 信息

# 卸载
sudo rmmod netfilter_hook
dmesg | tail
# Netfilter module unloaded
# Total packets: 42, Dropped: 3

4.2 使用多个钩子点

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
// 多钩子点注册
static struct nf_hook_ops hooks[3];

static int __init multi_hook_init(void) {
    // Hook 1: PREROUTING (最早执行)
    hooks[0].hook     = pre_routing_func;
    hooks[0].pf       = NFPROTO_IPV4;
    hooks[0].hooknum  = NF_INET_PRE_ROUTING;
    hooks[0].priority = -300;   // 越小越先执行
    nf_register_net_hook(&init_net, &hooks[0]);

    // Hook 2: LOCAL_IN
    hooks[1].hook     = local_in_func;
    hooks[1].pf       = NFPROTO_IPV4;
    hooks[1].hooknum  = NF_INET_LOCAL_IN;
    hooks[1].priority = 0;      // filter 表默认优先级
    nf_register_net_hook(&init_net, &hooks[1]);

    // Hook 3: POSTROUTING (最后执行)
    hooks[2].hook     = post_routing_func;
    hooks[2].pf       = NFPROTO_IPV4;
    hooks[2].hooknum  = NF_INET_POST_ROUTING;
    hooks[2].priority = INT_MAX; // 最后执行（修改后）

    return 0;
}

4.3 优先级常量

1
2
3
4
5
6
7
8
9
10
11
// 优先级（值越小越先执行）
// 注意：NF_IP_PRI_* 系列宏在 Linux 5.x+ 已移除，直接使用数值
#define NF_PRI_RAW          (-300)  // raw 表
#define NF_PRI_SELINUX      (-225)  // SELinux
#define NF_PRI_CONNTRACK    (-200)  // conntrack
#define NF_PRI_MANGLE       (-150)  // mangle 表
#define NF_PRI_NAT_DST      (-100)  // nat 表 (PREROUTING)
#define NF_PRI_FILTER       (0)     // filter 表
#define NF_PRI_SECURITY     (50)    // security 表
#define NF_PRI_NAT_SRC      (100)   // nat 表 (POSTROUTING)
#define NF_PRI_LAST         (0x7FFFFFFF) // INT_MAX 等价

5. nf_tables（现代替代方案）

5.1 nftables 基础

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
# nftables 是 iptables 的现代替代（使用通用 netlink 接口）
# 基于表和链（tables + chains）组织

# === 基本操作 ===

# 创建表
sudo nft add table inet filter
sudo nft add table ip nat

# 创建链
sudo nft add chain inet filter input {
    type filter hook input priority 0; policy accept;
}
sudo nft add chain inet filter forward {
    type filter hook forward priority 0; policy accept;
}
sudo nft add chain inet filter output {
    type filter hook output priority 0; policy accept;
}

# 添加规则
sudo nft add rule inet filter input tcp dport 22 accept
sudo nft add rule inet filter input tcp dport 80 accept
sudo nft add rule inet filter input ip saddr 192.168.1.100 drop

# 查看
sudo nft list ruleset
sudo nft list table inet filter

# 删除规则
sudo nft delete rule inet filter input handle 5

# 清空
sudo nft flush ruleset

5.2 nftables vs iptables

特性 iptables nftables
内核接口 每个表独立 netlink 通用 netlink
规则存储 内核每个表分开 统一的规则集
性能 O(n) 匹配 O(log n) 匹配
集合 有限支持 原生支持集合
动态更新 需替换整个表 增量更新
脚本 每行一个规则 结构化

6. 内核模块动态规则管理

6.1 /proc 接口动态控制

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
// dynamic_nf.c — 带 /proc 控制接口的 netfilter 模块
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netfilter.h>
#include <linux/netfilter_ipv4.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/slab.h>

#define MAX_BLACKLIST 1024

// 黑名单（使用红黑树存储）
struct blacklist_entry {
    __be32 ip;
    struct rb_node node;
};

static struct rb_root blacklist = RB_ROOT;
static DEFINE_SPINLOCK(bl_lock);

// 查找 IP
static bool ip_in_blacklist(__be32 ip) {
    struct rb_node *node = blacklist.rb_node;
    while (node) {
        struct blacklist_entry *entry = rb_entry(node, struct blacklist_entry, node);
        if (ip < entry->ip)
            node = node->rb_left;
        else if (ip > entry->ip)
            node = node->rb_right;
        else
            return true;
    }
    return false;
}

// 添加 IP
static int blacklist_add(__be32 ip) {
    struct rb_node **link = &blacklist.rb_node;
    struct rb_node *parent = NULL;
    struct blacklist_entry *entry;

    spin_lock(&bl_lock);

    // 查找是否已存在
    while (*link) {
        parent = *link;
        entry = rb_entry(parent, struct blacklist_entry, node);
        if (ip < entry->ip)
            link = &(*link)->rb_left;
        else if (ip > entry->ip)
            link = &(*link)->rb_right;
        else {
            spin_unlock(&bl_lock);
            return -EEXIST;
        }
    }

    entry = kmalloc(sizeof(*entry), GFP_KERNEL);
    if (!entry) {
        spin_unlock(&bl_lock);
        return -ENOMEM;
    }
    entry->ip = ip;
    rb_link_node(&entry->node, parent, link);
    rb_insert_color(&entry->node, &blacklist);

    spin_unlock(&bl_lock);
    printk(KERN_INFO "Blacklist added: %pI4\n", &ip);
    return 0;
}

// 移除 IP
static int blacklist_remove(__be32 ip) {
    struct rb_node *node = blacklist.rb_node;

    spin_lock(&bl_lock);
    while (node) {
        struct blacklist_entry *entry = rb_entry(node, struct blacklist_entry, node);
        if (ip < entry->ip)
            node = node->rb_left;
        else if (ip > entry->ip)
            node = node->rb_right;
        else {
            rb_erase(node, &blacklist);
            kfree(entry);
            spin_unlock(&bl_lock);
            printk(KERN_INFO "Blacklist removed: %pI4\n", &ip);
            return 0;
        }
    }
    spin_unlock(&bl_lock);
    return -ENOENT;
}

// Netfilter Hook
static unsigned int blacklist_hook(void *priv,
                                   struct sk_buff *skb,
                                   const struct nf_hook_state *state) {
    struct iphdr *iph;

    if (!skb) return NF_ACCEPT;
    iph = ip_hdr(skb);
    if (!iph) return NF_ACCEPT;

    // 检查目的 IP 和源 IP
    if (ip_in_blacklist(iph->saddr) || ip_in_blacklist(iph->daddr)) {
        printk(KERN_INFO "BLOCKED: %pI4 -> %pI4\n",
               &iph->saddr, &iph->daddr);
        return NF_DROP;
    }

    return NF_ACCEPT;
}

static struct nf_hook_ops nfho = {
    .hook     = blacklist_hook,
    .pf       = NFPROTO_IPV4,
    .hooknum  = NF_INET_PRE_ROUTING,
    .priority = -300,   // 最早执行
};

// /proc 接口
static int proc_show(struct seq_file *m, void *v) {
    struct blacklist_entry *entry;
    struct rb_node *node;

    seq_printf(m, "Blacklist:\n");
    seq_printf(m, "%-15s\n", "IP Address");

    // 只读遍历：用 rb_first/rb_next 安全（不改动树）
    for (node = rb_first(&blacklist); node; node = rb_next(node)) {
        entry = rb_entry(node, struct blacklist_entry, node);
        seq_printf(m, "%-15pI4\n", &entry->ip);
    }
    return 0;
}

static ssize_t proc_write(struct file *file, const char __user *buf,
                          size_t count, loff_t *ppos) {
    char kbuf[32];
    __be32 ip;
    char op;

    if (count >= sizeof(kbuf)) return -EINVAL;
    if (copy_from_user(kbuf, buf, count)) return -EFAULT;
    kbuf[count] = '\0';

    if (sscanf(kbuf, "%c %u", &op, &ip) != 2) return -EINVAL;

    if (op == 'a')  // add
        return blacklist_add(ip) == 0 ? count : -EFAULT;
    if (op == 'r')  // remove
        return blacklist_remove(ip) == 0 ? count : -EFAULT;

    return -EINVAL;
}

static int proc_open(struct inode *inode, struct file *file) {
    return single_open(file, proc_show, NULL);
}

static const struct proc_ops proc_fops = {
    .proc_read  = seq_read,
    .proc_write = proc_write,
    .proc_open  = proc_open,
    .proc_lseek = seq_lseek,
    .proc_release = single_release,
};

static int __init bl_init(void) {
    struct proc_dir_entry *entry;

    nf_register_net_hook(&init_net, &nfho);

    entry = proc_create("firewall_blacklist", 0666, NULL, &proc_fops);
    if (!entry) {
        nf_unregister_net_hook(&init_net, &nfho);
        return -ENOMEM;
    }

    printk(KERN_INFO "Firewall blacklist module loaded\n");
    printk(KERN_INFO "Usage: echo 'a <IP>' > /proc/firewall_blacklist\n");
    printk(KERN_INFO "       echo 'r <IP>' > /proc/firewall_blacklist\n");
    printk(KERN_INFO "       cat /proc/firewall_blacklist\n");
    return 0;
}

static void __exit bl_exit(void) {
    struct rb_node *node = rb_first(&blacklist);
    struct blacklist_entry *entry;

    // 清理
    while (node) {
        entry = rb_entry(node, struct blacklist_entry, node);
        node = rb_next(node);
        kfree(entry);
    }

    nf_unregister_net_hook(&init_net, &nfho);
    remove_proc_entry("firewall_blacklist", NULL);
    printk(KERN_INFO "Firewall blacklist module unloaded\n");
}

module_init(bl_init);
module_exit(bl_exit);
MODULE_LICENSE("GPL");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 测试
sudo insmod dynamic_nf.ko

# 添加黑名单
echo "a 3232235777" | sudo tee /proc/firewall_blacklist  # 192.168.1.1

# 查看黑名单
cat /proc/firewall_blacklist

# 测试 — 黑名单 IP 的包被拦截
curl --connect-timeout 3 http://192.168.1.1:80

# 查看内核日志
sudo dmesg | tail
# BLOCKED: 192.168.1.1 -> ...

# 移除黑名单
echo "r 3232235777" | sudo tee /proc/firewall_blacklist

# 卸载
sudo rmmod dynamic_nf
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870