Linux 内核 Netfilter 与 Conntrack 深度剖析：从 NAT 包过滤到连接跟踪

> Netfilter 是 Linux 内核中最强大且最复杂的网络子系统之一。它为 iptables、nftables 等用户态工具提供了底层框架，而 Conntrack（连接跟踪子系统）则在此基础上实现了 NAT、状态检测等高级功能。本文将从内核源码级别深入剖析 Netfilter 的 Hook 机制、Conntrack 状态机、NAT 转换逻辑以及生产级性能调优策略。

一、Netfilter 框架架构总览

Netfilter 是嵌入在内核网络协议栈中的一套 Hook（钩子）机制，它允许内核模块在数据包处理的特定阶段注册回调函数，实现对数据包的拦截、修改、丢弃或放行。

Netfilter 在内核网络栈中定义了五个关键 Hook 点，构成了数据包生命周期中的五个拦截位置：

┌─────────────────────────────────────────────────────────────────────────┐
│                         Netfilter Hook 全景图                           │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   数据包接收 (ingress)                                                   │
│        │                                                                │
│        ▼                                                                │
│   ┌─────────────────┐                                                   │
│   │ NF_IP_PRE_ROUTING │ ◄── 数据包到达后首个 Hook（路由决策之前）          │
│   └────────┬────────┘                                                   │
│            │                                                            │
│            ▼                                                            │
│   ┌───────────────┐                                                     │
│   │   路由决策      │◄──── 判断数据包是发往本机还是转发                       │
│   └───────┬───────┘                                                     │
│            │                                                            │
│      ┌─────┴──────┐                                                     │
│      │            │                                                      │
│      ▼            ▼                                                      │
│  发往本机      转发数据包                                                   │
│      │            │                                                      │
│      ▼            ▼                                                      │
│ ┌──────────┐ ┌─────────────────┐                                        │
│ │NF_IP_LOCAL│ │ NF_IP_FORWARD   │ ◄── 转发的数据包                         │
│ │_IN       │ └────────┬────────┘                                        │
│ └────┬─────┘         │                                                  │
│      │               ▼                                                   │
│      │     ┌───────────────────┐                                         │
│      │     │ NF_IP_POST_ROUTING│ ◄── 路由决策后（发出前最后机会）             │
│      │     └────────┬──────────┘                                         │
│      │              │                                                    │
│      ▼              ▼                                                    │
│   本机进程     数据包发送 (egress)                                         │
│                                                                         │
│   ┌──────────────────┐                                                  │
│   │ NF_IP_LOCAL_OUT   │ ◄── 本机进程发出的数据包                           │
│   └────────┬─────────┘                                                  │
│            │                                                            │
│            ▼                                                            │
│   接入 POST_ROUTING → 发送                                               │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

五个 Hook 点在内核源码中的定义（include/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
};

数据包的完整处理流程：当数据包进入协议栈时，netfilter 会在遍历路由表之前先调用 NF_IP_PRE_ROUTING Hook，然后进行路由决策——如果目标地址是本机，走进 NF_IP_LOCAL_IN；如果是转发目标，走 NF_IP_FORWARD，最后都经过 NF_IP_POST_ROUTING 离开。而本机进程发出的包，先经过 NF_IP_LOCAL_OUT，再进入 NF_IP_POST_ROUTING。

二、核心数据结构与 Hook 注册机制

Netfilter 的核心数据结构包括 struct nf_hook_ops（Hook 操作描述符）、struct nf_hook_entries（Hook 链表头）和协议族特定的 Hook 管理结构。

struct nf_hook_ops {
/ 用户填充字段 /
nf_hookfn       *hook;       // Hook 回调函数
struct net_device *dev;      // 关联网络设备
void            *priv;       // 私有数据
u8              pf;          // 协议族 (NFPROTO_IPV4/IPV6)
unsigned int    hooknum;     // Hook 点编号
int             priority;    // 优先级（nf_ip_hook_priorities 中定义）

/ 内核填充字段 /
struct list_head list;
struct rcu_head rcu;
};

Hook 优先级与遍历顺序

IPv4 协议族的 Hook 优先级（net/netfilter/core.c）：

static const struct nf_hook_priorities ipv4_priorities[] = {
[NF_IP_PRI_FIRST]       = INT_MIN,      // 最先执行
[NF_IP_PRI_RAW]         = -300,         // raw 表
[NF_IP_PRI_SELINUX_FIRST]= -225,        // SELinux
[NF_IP_PRI_CONNTRACK_DEFRAG] = -200,   // Conntrack 分片重组
[NF_IP_PRI_RAW_FIRST]   = -150,         // mangle 前置
[NF_IP_PRI_NAT_DST]     = -100,         // DNAT（目标地址转换）
[NF_IP_PRI_FILTER]      = 0,            // filter 表
[NF_IP_PRI_SECURITY     = 50,           // 安全表
[NF_IP_PRI_NAT_SRC]     = 100,          // SNAT（源地址转换）
[NF_IP_PRI_SELINUX_LAST] = 225,         // SELinux
[NF_IP_PRI_CONNTRACK_HELPER] = 300,    // Conntrack helper
[NF_IP_PRI_LAST]        = INT_MAX       // 最后执行
};

优先级决定了 Hook 链的执行顺序。低优先级值（负数）的 Hook 先执行，这正是为什么 DNAT 在 filter 表之前（目标地址先转换），而 SNAT 在 filter 表之后（源地址后转换）。

Hook 注册 API

内核模块通过 nf_register_net_hook() 注册 Hook：

int nf_register_net_hook(struct net net, const struct nf_hook_ops ops);
void nf_unregister_net_hook(struct net net, const struct nf_hook_ops ops);

Hook 回调函数返回值：

#define NF_DROP     0   // 丢弃数据包
#define NF_ACCEPT   1   // 接受数据包（继续处理）
#define NF_STOLEN   2   // 接管数据包（由 Hook 处理，停止传递）
#define NF_QUEUE    3   // 排队到用户态
#define NF_REPEAT   4   // 重新调用 Hook

多表（Table）与多链（Chain）的组织

nftables（替代 iptables 的现代框架）在该基础上引入更灵活的链组织方式。在 net/netfilter/nf_tables_core.c 中，nft 的规则链（chain）最终也注册到 Netfilter 的 Hook 点：

static const struct nf_chain_type nft_chain_filter = {
.name       = "filter",
.type       = NFT_CHAIN_T_DEFAULT,
.family     = NFPROTO_IPV4,
.hookfn     = nft_do_chain,
};

nftables 的 "table → chain → rule" 三层结构中，chain 的类型分为 filter、nat 和 route，每种类型对应特定的 Hook 点和方向。

三、Conntrack 连接跟踪核心实现

Conntrack（net/netfilter/nf_conntrack_core.c）是连接跟踪子系统，它记录所有经过主机的网络连接的状态，是 NAT 和有状态防火墙的基础。

3.1 连接标识与哈希表

每个连接用一个五元组唯一标识：(源IP, 目的IP, L4协议, L4源端口, L4目的端口)。

struct nf_conn {
struct nf_conntrack ct_general;        // GC 引用计数
spinlock_t lock;

/ Hashes 链表头 /
struct hlist_node hash_conntrack;      // 正向（orig）哈希表节点
struct hlist_node hash_reply;          // 反向（reply）哈希表节点

struct nf_conntrack_tuple reply;       // 反向元组
struct nf_conntrack_tuple orig;        // 正向元组

struct nf_conntrack_zone zone;         // 防火墙区域
struct nf_conn __rcu *master_conn;     // master 连接（helper 使用）

unsigned long status;                  // 连接状态位掩码
u16 cpu;                               // CPU 编号（percpu 计数器）
};

struct nf_conntrack_tuple {
struct nf_conntrack_man src;    // 源地址/端口
struct {
union nf_inet_addr u3;      // 目的 IP
union {
__be16 all;             // 目的端口
struct { __be16 port; } tcp;
struct { __be16 port; } udp;
struct { __be8_t type, code; } icmp;
struct { __be16 key; } gre;
} u;
__u8 protonum;              // L4 协议号
__u8 dir;                   // IP_CT_DIR_ORIGINAL/REPLY
} dst;
};

整个连接跟踪系统维护两个哈希表：

• orig 哈希表：以正向五元组为 Key（原始方向）
• reply 哈希表：以反向五元组为 Key（回复方向）

这种双向哈希设计使得不管数据包来自哪个方向，都能在平均 O(1) 时间内定位到同一个连接记录。

3.2 连接状态机（TCP）

enum ip_conntrack_info {
IP_CT_NEW,              // 新连接（不属于任何已有连接）
IP_CT_ESTABLISHED,      // 已建立连接
IP_CT_RELATED,          // 辅助连接（如 FTP 数据通道）
IP_CT_INVALID,          // 无效连接
};

TCP 连接完整的状态转换：

Client                          Server
│                               │
│──── SYN ──► (NEW)             │
│                               │
│◄── SYN+ACK                    │
│                               │
│──── ACK ──► (ESTABLISHED)      │
│                               │
│◄═══ ESTABLISHED ═══►          │
│                               │
│──── FIN ──► (CLOSING)         │
│                               │
│◄── FIN+ACK                    │
│                               │
│──── ACK ──► (TIME_WAIT)        │
│                               │
└──[timeout]──► GC

对应的关键超时时间（net/netfilter/nf_conntrack_proto_tcp.c）：

static unsigned int tcp_timeouts[TCP_CONNTRACK_MAX] = {
[TCP_CONNTRACK_SYN_SENT]     = 120*HZ,     // SYN_SENT: 120s
[TCP_CONNTRACK_SYN_RECV]     = 60*HZ,      // SYN_RECV: 60s
[TCP_CONNTRACK_ESTABLISHED]  = 432000*HZ,  // ESTABLISHED: 5天
[TCP_CONNTRACK_FIN_WAIT]     = 120*HZ,     // FIN_WAIT: 2分钟
[TCP_CONNTRACK_CLOSE_WAIT]    = 60*HZ,      // CLOSE_WAIT: 1分钟
[TCP_CONNTRACK_LAST_ACK]      = 30*HZ,      // LAST_ACK: 30秒
[TCP_CONNTRACK_TIME_WAIT]     = 120*HZ,     // TIME_WAIT: 2分钟
[TCP_CONNTRACK_CLOSE]         = 10*HZ,      // CLOSE: 10秒
};

UDP 虽然无连接，但 Conntrack 同样为其维护状态：

static unsigned int udp_timeouts[UDP_CT_MAX] = {
[UDP_CT_UNREPLIED] = 30*HZ,     // 单向探测，30s 超时
[UDP_CT_REPLIED]   = 180*HZ,    // 双向通信后，3 分钟超时
};

3.3 Conntrack 信息头解析

每个数据包到达时，nf_conntrack_in() 执行连接跟踪的初始化流程：

unsigned int nf_conntrack_in(struct sk_buff skb, struct nf_hook_state state)
{
// 1. 从 skb 已有的 connection cache 中查找（若已有）
ct = resolve_normal_ct(tuple, zone, skb);

// 2. 哈希查找（双向）
h = __nf_conntrack_find_get(net, zone, tuple);

// 3. 未找到且允许创建 → 新建连接
if (!h) {
ct = init_conntrack(net, tmpl, tuple, skb, zone);
}

// 4. 获取 conntrack 附加信息（如 helper）
ret = nf_conntrack_handle(skb, ctinfo);

// 5. 设置 skb->_nfct 指针
nf_ct_set(skb, ct, ctinfo);

return ret;
}

连接跟踪信息通过 skb->_nfct 指针（标记位 enum ip_conntrack_info）传递给后续 Hook。这意味着状态匹配的 -m state --state ESTABLISHED,RELATED 规则实际上读取的是 skb->_nfct 中的标记，而无需再次哈希查找。

四、NAT 核心实现

NAT（Network Address Translation）是建立在 Conntrack 之上的功能，它通过修改数据包的五元组实现地址转换。

4.1 NAT 的两种形态

类型	Hook 点	转换对象	iptables 表
DNAT	PREROUTING / OUTPUT	目标地址/端口	nat 表
SNAT	POST_ROUTING	源地址/端口	nat 表

DNAT 必须在路由决策前执行（PREROUTING），这样路由表才能根据转换后的目标地址正确选择网络接口。SNAT 在路由决策后执行（POST_ROUTING），因为修改源地址前需要先确认数据包从哪个接口发出（确定可使用的源地址池）。

4.2 NAT 内核实现

net/netfilter/nf_nat_core.c 中的核心函数：

unsigned int nf_nat_inet_fn(void priv, struct sk_buff skb,
const struct nf_hook_state *state)
{
enum ip_conntrack_info ctinfo;
struct nf_conn *ct = nf_ct_get(skb, &ctinfo);

// 仅对已跟踪的连接执行 NAT
if (ct && !nf_ct_is_untracked(ct)) {
// 判断执行 DNAT 还是 SNAT
if (nf_ct_tuple_equal(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
&ct->tuplehash[IP_CT_DIR_REPLY].tuple)) {
return NF_ACCEPT;  // 元组相同 → 无需 NAT
}

// 根据 direction 选择 orig 或 reply 方向的 tuple
// orig: 原始方向（与数据包同向）
// reply: 反向（NAT 转换后方向）
if (ctinfo == IP_CT_IS_REPLY)
// 回复数据包 → 回复方向 orig tuple 执行反向 NAT
ret = ct_to_objreply(skb, ct);
else
// 原始数据包 → orig tuple 执行正向 NAT
ret = ct_to_obj(skb, ct);
}
}

修改数据包后必须重新计算校验和（IPv4 Header Checksum + L4 Checksum），现代网卡可以通过 CHECKSUM_PARTIAL 将校验和卸载（Offload）到硬件。

4.2 SNAT/MASQUERADE 与 DNAT/REDIRECT

iptables 用户态工具中的核心 NAT target：

-t nat -A POSTROUTING -j SNAT --to-source <IP>
↓ [内核]
nf_nat_setup_info() → 将 orig_tuple.dst 修改为 --to-source 指定的地址

-t nat -A POSTROUTING -j MASQUERADE
↓ [内核]
动态从网络设备获取可用地址（适用于 DHCP/动态 IP 环境）

MASQUERADE 与 SNAT 的关键区别在于：SNAT 需要静态指定源地址，而 MASQUERADE 在每次数据包处理时动态从选定网络设备的 IP 地址中选取，因此 MASQUERADE 在动态 IP 环境（拨号/家用宽带）中更灵活，但性能略逊（需动态查找）。

-t nat -A PREROUTING -j DNAT --to-destination <IP>:<PORT>
↓ [内核]
将 reply_tuple.src 修改为 --to-destination 指定的目标（反向映射）

一个典型的端口转发场景：

# 将到达主机的 8080 端口转发到内网 192.168.1.100:80
iptables -t nat -A PREROUTING -p tcp --dport 8080 -j DNAT --to-destination 192.168.1.100:80

同时需要 SNAT/MASQUERADE 使回程数据包经过主机
iptables -t nat -A POSTROUTING -d 192.168.1.100/32 -p tcp --dport 80 -j MASQUERADE

4.3 NAT 与 Conntrack 的交互

NAT 完全依赖 Conntrack 的状态机。一个连接首个数据包经过 NEW 状态时，NAT 信息被写入 struct nf_conn 的 nat_cache 字段。同一连接后续数据包只需根据已存储的 NAT 映射表项进行转换，因此第一个数据包（NEW）承担 NAT 映射创建开销，后续数据包只需应用已有映射。

struct nf_conn_nat {
struct hlist_node bysource;
struct nf_conn *ct;
union nf_conntrack_man saved;  // 转换前的原始地址（用于反向 NAT）
};

4.4 NAT 性能优化建议

连接跟踪哈希表调优：

# 查看当前哈希表大小（存储桶数量）
cat /proc/sys/net/netfilter/nf_conntrack_buckets

查看最大连接数
cat /proc/sys/net/netfilter/nf_conntrack_max

建议值：max / 8 = bucket 数（负载因子 0.125）
echo 524288 > /proc/sys/net/netfilter/nf_conntrack_max
echo 32768 > /proc/sys/net/netfilter/nf_conntrack_buckets

超时参数调优：

# 查看默认 TCP 超时
cat /proc/sys/net/netfilter/nf_conntrack_tcp_timeout_established
默认：432000（5天）→ 建议生产环境调低至 86400（1天）

查看 UDP 超时
cat /proc/sys/net/netfilter/nf_conntrack_udp_timeout
默认：30秒

cat /proc/sys/net/netfilter/nf_conntrack_udp_timeout_stream
默认：180秒（已建立双向 UDP 流）

连接跟踪表满时的行为：

当 Conntrack 表满时，新连接的数据包将被 DROP。默认行为是"新连接丢弃直到有空间"，可通过内核参数 nf_conntrack_tcp_loose 在 TCP 控制报文上宽松处理。

# 查看当前丢包计数
cat /proc/net/stat/nf_conntrack

查看等待处理的连接队列
cat /proc/sys/net/netfilter/nf_conntrack_max_retrans

五、Conntrack Helper：应用层网关

某些协议的控制报文和数据报文使用不同的端口（如 FTP 被动模式），Conntrack 无法直接跟踪。Helper 模块通过解析应用层协议内容，在 New 连接创建时生成 Related 连接。

Helper 注册与执行

struct nf_conntrack_helper {
struct hlist_node hnode;
char name[NF_CT_HELPER_NAME_LEN];   // 协议名称（如 "ftp"）
struct nf_conntrack_expect *expect; // 预期连接
struct module *me;
};

FTP 示例：

当 FTP 客户端发送 PASV 命令时，Conntrack 的 FTP Helper 解析服务器返回的端口，创建一个 "expectation"（预期连接），预期在 nf_conntrack_expect 结构中：

struct nf_conntrack_expect {
struct nf_conntrack_tuple expected;      // 预期连接五元组
struct nf_conntrack_tuple mask;          // 匹配掩码

struct hlist_node lnode;                 // 全局 expectation 链表
struct hlist_node hnode;                 // 所属 ct 链表

void (done)(struct nf_conntrack_expect exp);
struct rcu_head rcu;
};

当实际数据包到达并匹配到 expectation 时，Conntrack 将该连接标记为 RELATED 而非 NEW，使其不必经过完整的规则匹配链路。iptables 中的 -m state --state RELATED,ESTABLISHED 正是利用了这些标记实现高效的返回流量规则。

常见的 Helper 模块：

Helper	协议	作用
nf_conntrack_ftp	FTP	解析 PASV/PORT 命令发现数据端口
nf_conntrack_tftp	TFTP	解析 RRQ/WRQ 发现数据端口
nf_conntrack_sip	SIP	解析 SDP 中的 RTP 端口
nf_conntrack_pptp	PPTP	解析 GRE 隧道连接
nf_conntrack_h323	H.323	解析 H.245 通道
nf_conntrack_sane	SANE	扫描仪协议
nf_conntrack_proto_gre	GRE	解析 GRE keepalive

> ⚠️ 安全考虑：Helper 模块解析应用层协议时存在潜在的安全风险。在不需要相应协议的环境中应禁用对应 Helper。现代 nftables 通过 ct helper 语法实现按需绑定，比 iptables 的全局启用更安全。

六、nftables：下一代 Netfilter 框架

nftables 从 Linux 3.13 开始引入，逐步取代 iptables。它通过虚拟机和字节码执行规则，解决了 iptables 的协议族代码重复问题。

nftables 架构优势

传统 iptables：
iptables userspace
↓ netlink
xtables kernel (IPv4)
+ xtables kernel (IPv6)  [代码高度重复]

nftables：
nft userspace
↓ netlink
nf_tables core (统一引擎)
↓
nf_tables_ipv4 / nf_tables_ipv6 / nf_tables_bridge [瘦适配层]
↓
nf_register_net_hook()  [统一注册]

nftables 的内部虚拟机执行流程：

unsigned int nft_do_chain(struct nft_chain *chain,
struct sk_buff *skb,
const struct nf_hook_state *state)
{
const struct nft_rule_dp *rule;

for (rule = chain->rules; rule; rule = nft_rule_next(rule)) {
const struct nft_expr *expr;

nft_rule_for_each_expr(expr, rule) {
// 执行每条规则中的表达式
expr->ops->eval(expr, &regs, priv);

// 根据返回值决定下一步
switch (regs.verdict.code) {
case NFT_CONTINUE:
continue;
case NFT_JUMP:
// 跳转到指定 chain
goto do_next_chain;
case NFT_GOTO:
goto do_target_chain;
case NF_ACCEPT:
case NF_DROP:
return regs.verdict.code;
}
}
}
}

nftables 性能对比

维度	iptables	nftables
规则更新	全量替换（整个表原子替换）	增量更新（单条规则增删）
表达式复用	无	集合/字典/Maps
协议代码	IPv4/IPv6/ARP/Bridge 各自独立	统一引擎
集合匹配	O(线性) 链式	O(1) 哈希或 O(log n) 区间树
BinHM	无	内核字节码 JIT

nftables 规则示例

table inet filter {
chain input {
type filter hook input priority filter; policy drop;

# 允许已建立和 RELATED 连接（Conntrack 标记）
ct state established,related accept

# 丢弃无效数据包
ct state invalid drop

# 允许loopback
iif "lo" accept

# 允许ICMP
ip protocol icmp icmp type { echo-request } accept

# 允许SSH（限速）
tcp dport 22 ct state new \
limit rate 5/minute accept
}

chain forward {
type filter hook forward priority filter; policy accept;
}
}

NAT 在 nftables 中的声明：

table ip nat {
chain prerouting {
type nat hook prerouting priority dstnat;
tcp dport 8080 dnat to 192.168.1.100:80
}

chain postrouting {
type nat hook postrouting priority srcnat;
oif "eth0" masquerade
}
}

七、Conntrack 性能调优实战

7.1 生产环境关键参数

# /etc/sysctl.conf

连接跟踪最大条目数（每条目约 300 字节内存）
net.netfilter.nf_conntrack_max = 2097152

TCP 已建立连接超时（5天太长，建议调低至 1天）
net.netfilter.nf_conntrack_tcp_timeout_established = 86400

TCP TIME_WAIT 超时（默认 120s，高并发场景可降至 60s）
net.netfilter.nf_conntrack_tcp_timeout_time_wait = 60

UDP 超时（高频 UDP 应用如 DNS 可适当降低）
net.netfilter.nf_conntrack_udp_timeout = 30
net.netfilter.nf_conntrack_udp_timeout_stream = 180

临时连接数组大小
net.netfilter.nf_conntrack_expect_max = 4096

nf_log（调试时开启，生产推荐关闭）
net.netfilter.nf_log = 0

7.2 高并发 Conntrack 优化

当 Conntrack 表规模达到 100 万条时，以下几个技术至关重要：

1. Conntrack Zone 分片

通过 ct zone 将不同网络区域（如不同租户、不同业务）的连接隔离到独立区域，避免全局锁竞争：

iptables -A PREROUTING -i eth0 -j CT --zone 1
iptables -A PREROUTING -i eth1 -j CT --zone 2

2. NOTRACK 绕过跟踪

对于纯转发的高吞吐内网流量（如数据中心内部），不需要连接跟踪：

# 在 raw 表中标记不进行跟踪
iptables -t raw -A PRERELEASE -s 10.0.0.0/8 -d 10.0.0.0/8 -j NOTRACK
iptables -t raw -A OUTPUT -s 10.0.0.0/8 -d 10.0.0.0/8 -j NOTRACK

> ⚠️ NOTRACK 会完全跳过 Conntrack，因此该数据包无法被 NAT 识别、无法被状态防火墙阻止。仅在内网可信环境使用。

3. 连接跟踪流控（flow offload）

Linux 4.19+ 引入了 connection tracking flow offload，已被 Conntrack 标记的数据包可以跳过后续 Hook 检查，直接在网卡硬件层面转发：

# 查看 flowtable 状态
sysctl net.netfilter.nf_conntrack_offload_max

启用 flow offload
nft add rule inet filter forward ct status dn,sn flow add @flowtable0

4. eBPF/eXDP BPF 绕过

在极端场景（如 100Gbps+ 吞吐量），可以先通过 eBPF 在 XDP 层面实现无连接跟踪的快速路径，仅将首批数据包送入 Conntrack。

八、调试与观测

8.1 conntrack 工具

# 查看所有连接
conntrack -L

查看特定协议连接
conntrack -L -p tcp

查看所有条数统计
conntrack -C

删除特定连接（防火墙迁移或故障排查）
conntrack -D -s 192.168.1.100

实时监控连接跟踪事件
conntrack -E

删除所有连接（谨慎使用！）
conntrack -F

8.2 /proc 接口

# 连接跟踪表使用状态
cat /proc/sys/net/netfilter/nf_conntrack_count        # 当前条目数
cat /proc/sys/net/netfilter/nf_conntrack_max          # 最大条目数
cat /proc/net/nf_conntrack                            # 完整连接跟踪表
cat /proc/net/stat/nf_conntrack                       # 统计信息

/proc/net/stat/nf_conntrack 关键字段

entries  searched  found  new  invalid  delete drop early_drop
1234     5678901  567000 45000 1234     34000   56    3

• searched：哈希查找总次数
• new：因表满未能创建连接的次数
• invalid：状态无效的数据包数
• drop：连接跟踪表满丢弃计数
• early_drop：因早期连接关闭失败而丢弃

当 drop 或 early_drop > 0 时，说明 Conntrack 已成为瓶颈，需要调大 nf_conntrack_max 或优化超时参数加速条目回收。

8.3 nft monitor

# 实时监听 nftables 规则变更
nft monitor

监听 netfilter 事件
nft monitor trace

总结

Netfilter/Conntrack 是 Linux 防火墙、NAT 网关、负载均衡器的核心基础设施。理解其 Hook 优先级机制、Conntrack 哈希表与状态机、NAT 双向映射的对称性以及超时参数对生产系统性能的影响，是系统网络工程师必备的技能。

nftables 正在取代 iptables 成为新的默认框架，其字节码虚拟机、可组合表达式和增量更新为复杂策略场景提供了更高的灵活性和性能。随着 eBPF/XDP 等新兴技术的发展，内核网络数据面的可编程性正在进入一个崭新的阶段。

关键要点回顾：

1. 五个 Hook 点（PRE_ROUTING / LOCAL_IN / FORWARD / LOCAL_OUT / POST_ROUTING）构成包处理完整流水线

2. Hook 优先级系统确保 DNAT(−100) 在 filter(0) 之前、SNAT(100) 在 filter 之后执行

3. Conntrack 的双向哈希设计保证双向数据包在 O(1) 时间内定位到同一连接

4. NAT 完全依赖 Conntrack 状态机，首个数据包（NEW 状态）创建映射，后续应用已有映射

5. Helper 模块通过解析应用层协议发现辅助连接（如 FTP 数据通道）

6. 生产环境应调低 TCP established 超时（5天→1天）、按负载调整 bucket 数、对可信内网启用 NOTRACK

7. flow offload 和 XDP 技术可将已被 Conntrack 识别的直通流量快速路径卸载到硬件或提前执行