eBPF 与 Netfilter 的安全能力对比：谁是更好的防火墙

/* 简化的 iptables 规则匹配逻辑 (net/ipv4/netfilter/ip_tables.c) */
static unsigned int
ipt_do_table(struct sk_buff *skb, const struct nf_hook_state *state,
             struct xt_table *table)
{
    const struct ipt_entry *e;
    e = get_entry(table_base, private->hook_entry[hook]);
    do {
        if (ip_packet_match(ip, e->ip) && xt_ematch_foreach(ematch, e)) {
            verdict = ipt_get_target(e)->u.kernel.target->target(skb, ...);
            if (verdict != XT_CONTINUE)
                break;
        }
        e = ipt_next_entry(e);  /* 逐条遍历，O(n) */
    } while (e != end);
    return verdict;
}

/* nft 虚拟机核心循环 (net/netfilter/nf_tables_core.c) */
unsigned int nft_do_chain(struct nft_pktinfo *pkt, void *priv)
{
    const struct nft_rule_dp *rule;
    const struct nft_expr *expr;

    nft_rule_for_each(rule, blob) {
        nft_rule_dp_for_each_expr(expr, last, rule) {
            /* 执行字节码指令 */
            expr->ops->eval(expr, &regs, pkt);
            if (regs.verdict.code != NFT_CONTINUE)
                break;
        }
    }
    return regs.verdict.code;
}

# 一个 Service 3 个 endpoint 的 iptables 规则（简化）
-A KUBE-SERVICES -d 10.96.0.10/32 -p tcp -m tcp --dport 53 \
    -j KUBE-SVC-ERIFXISQEP7F7OF0

-A KUBE-SVC-ERIFXISQEP7F7OF0 -m statistic --mode random --probability 0.333 \
    -j KUBE-SEP-ID1
-A KUBE-SVC-ERIFXISQEP7F7OF0 -m statistic --mode random --probability 0.500 \
    -j KUBE-SEP-ID2
-A KUBE-SVC-ERIFXISQEP7F7OF0 \
    -j KUBE-SEP-ID3

-A KUBE-SEP-ID1 -p tcp -j DNAT --to-destination 10.244.1.5:53
-A KUBE-SEP-ID2 -p tcp -j DNAT --to-destination 10.244.2.8:53
-A KUBE-SEP-ID3 -p tcp -j DNAT --to-destination 10.244.3.2:53

# 查看 iptables 规则总数
iptables-save | wc -l
iptables -t nat -L KUBE-SERVICES | wc -l

# kube-proxy 的更新流程（简化）
iptables-save -t nat > current_rules.txt
# ... 修改 current_rules.txt ...
iptables-restore -w 5 -T nat < new_rules.txt

# 常见的锁竞争日志
# kube-proxy: "Another app is currently holding the xtables lock.
#              Stopped waiting after 5s."

# 查看 xt_lock 竞争情况
bpftrace -e 'kprobe:xt_lock_table { @[comm] = count(); }'

# 查看 conntrack 表大小和当前使用量
sysctl net.netfilter.nf_conntrack_max
# 默认值：nf_conntrack_max = 262144 (256K)

cat /proc/net/nf_conntrack | wc -l
# 或
conntrack -C

# 监控 conntrack
conntrack -C && sysctl net.netfilter.nf_conntrack_max

# 缓解手段
sysctl -w net.netfilter.nf_conntrack_max=1048576
sysctl -w net.netfilter.nf_conntrack_tcp_timeout_time_wait=30
sysctl -w net.netfilter.nf_conntrack_tcp_timeout_established=86400

# nftables 原子替换示例
nft -f - <<'EOF'
flush ruleset
table inet filter {
    set allowed_ips {
        type ipv4_addr
        flags interval
        elements = { 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 }
    }

    chain input {
        type filter hook input priority 0; policy drop;
        ct state established,related accept
        ip saddr @allowed_ips accept
        tcp dport { 22, 80, 443 } accept
    }
}
EOF

/* nftables 原子替换的内核实现（简化） */
static int nf_tables_commit(struct net *net, struct sk_buff *skb)
{
    /* 通过 RCU 指针替换发布新规则集 */
    rcu_assign_pointer(chain->blob_gen_0, new_blob);
    synchronize_rcu();           /* 等待所有 CPU 完成当前读取 */
    nf_tables_commit_release(net); /* 释放旧规则集 */
    return 0;
}

# 创建哈希集合（O(1) 查找）
nft add set inet filter blacklist { type ipv4_addr\; }
nft add element inet filter blacklist { 192.168.1.100, 10.0.0.50 }

# 在规则中使用集合匹配
nft add rule inet filter input ip saddr @blacklist drop

# 创建带区间的集合（红黑树，O(log n) 查找）
nft add set inet filter allowed_ranges {
    type ipv4_addr\;
    flags interval\;
    elements = { 10.0.0.0/8, 172.16.0.0/12 }\;
}

# verdict map：根据目标端口选择动作
nft add map inet filter port_policy {
    type inet_service : verdict\;
    elements = {
        22 : accept,
        80 : accept,
        443 : accept,
        8080 : jump web_chain
    }\;
}

nft add rule inet filter input tcp dport vmap @port_policy

# 数据 map：根据源 IP 做 DNAT（类似 Service 负载均衡）
nft add map inet nat svc_backends {
    type ipv4_addr . inet_service : ipv4_addr . inet_service\;
    elements = {
        10.96.0.10 . 53 : 10.244.1.5 . 53,
        10.96.0.20 . 80 : 10.244.2.8 . 8080
    }\;
}

# 检查 kube-proxy 是否使用 nftables（1.31+）
kubectl get configmap kube-proxy -n kube-system -o yaml | grep mode
# mode: "nftables"  # alpha in v1.31

/* 定义一个哈希 map 用于防火墙策略 */
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, __u32);           /* 源 IP */
    __type(value, struct policy);  /* 策略：允许/拒绝/限速 */
    __uint(max_entries, 1000000);
} firewall_policy SEC(".maps");

/* 定义 LPM trie 用于 CIDR 匹配 */
struct {
    __uint(type, BPF_MAP_TYPE_LPM_TRIE);
    __type(key, struct lpm_key);   /* prefix_len + IP */
    __type(value, struct policy);
    __uint(max_entries, 100000);
    __uint(map_flags, BPF_F_NO_PREALLOC);
} cidr_policy SEC(".maps");

/* XDP 程序中的策略查找 */
SEC("xdp")
int xdp_firewall(struct xdp_md *ctx)
{
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *iph = (void *)(eth + 1);
    if ((void *)(iph + 1) > data_end)
        return XDP_PASS;

    /* O(1) 哈希查找 */
    __u32 src_ip = iph->saddr;
    struct policy *pol = bpf_map_lookup_elem(&firewall_policy, &src_ip);
    if (pol && pol->action == ACTION_DROP)
        return XDP_DROP;

    /* CIDR 匹配使用 LPM trie */
    struct lpm_key key = {
        .prefixlen = 32,
        .addr = src_ip,
    };
    pol = bpf_map_lookup_elem(&cidr_policy, &key);
    if (pol && pol->action == ACTION_DROP)
        return XDP_DROP;

    return XDP_PASS;
}

/* per-CPU map：每个 CPU 核心有独立的副本，无锁竞争 */
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_HASH);
    __type(key, struct flow_key);
    __type(value, struct flow_state);
    __uint(max_entries, 1000000);
} per_cpu_ct SEC(".maps");

/* 在 BPF 程序中更新统计，无需任何锁 */
SEC("tc")
int tc_firewall(struct __sk_buff *skb)
{
    __u32 idx = 0;
    struct flow_stats *stats = bpf_map_lookup_elem(&per_cpu_stats, &idx);
    if (stats) {
        stats->packets++;    /* 无锁更新，每个 CPU 独立计数 */
        stats->bytes += skb->len;
    }
    return TC_ACT_OK;
}

/* Cilium CT map 定义（简化，参考 bpf/lib/conntrack.h） */
struct ct_entry {
    __u64 rx_packets;
    __u64 rx_bytes;
    __u64 tx_packets;
    __u64 tx_bytes;
    __u32 lifetime;
    __u16 rx_closing:1, tx_closing:1, seen_non_syn:1, node_port:1, reserved:12;
    __u8  tx_flags_seen;
    __u8  rx_flags_seen;
};

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, struct ipv4_ct_tuple);
    __type(value, struct ct_entry);
    __uint(max_entries, CT_MAP_SIZE_TCP);  /* 默认 512K */
} CT_MAP_TCP4 SEC(".maps");

# 查看 Cilium CT map 的使用情况
cilium bpf ct list global | head -20

# 查看 CT map 大小配置
cilium status | grep -i conntrack

# 对比 nf_conntrack
conntrack -C
sysctl net.netfilter.nf_conntrack_max

/* XDP DDoS 防护：SYN flood 令牌桶限速 */
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_HASH);
    __type(key, __u32);              /* 源 IP */
    __type(value, struct rate_info);
    __uint(max_entries, 1000000);
} syn_rate SEC(".maps");

SEC("xdp")
int xdp_ddos(struct xdp_md *ctx)
{
    /* ... 解析包头，提取 src_ip, TCP flags ... */
    if (!(tcp->syn && !tcp->ack))
        return XDP_PASS;

    __u32 src_ip = iph->saddr;
    struct rate_info *ri = bpf_map_lookup_elem(&syn_rate, &src_ip);
    if (!ri) {
        struct rate_info new_ri = { .tokens = SYN_RATE_LIMIT - 1,
                                    .last_update = bpf_ktime_get_ns() };
        bpf_map_update_elem(&syn_rate, &src_ip, &new_ri, BPF_ANY);
        return XDP_PASS;
    }

    /* 令牌桶：补充令牌，检查余量 */
    __u64 now = bpf_ktime_get_ns();
    __u64 new_tokens = (now - ri->last_update) / TOKEN_INTERVAL;
    if (new_tokens > 0) {
        ri->tokens = min(ri->tokens + new_tokens, (__u64)SYN_RATE_LIMIT);
        ri->last_update = now;
    }
    if (ri->tokens > 0) { ri->tokens--; return XDP_PASS; }
    return XDP_DROP;
}

/* Cilium TC 策略执行（简化，参考 bpf/bpf_lxc.c） */
SEC("tc")
int handle_policy(struct __sk_buff *skb)
{
    __u32 src_identity = skb->cb[CB_SRC_IDENTITY];
    struct policy_key key = {
        .identity = src_identity, .dport = dst_port, .protocol = protocol,
    };
    struct policy_entry *pol = map_lookup_elem(&POLICY_MAP, &key);

    if (!pol)
        return default_deny ? TC_ACT_SHOT : TC_ACT_OK;
    if (pol->deny)
        return TC_ACT_SHOT;

    ct_create(skb, &ct_key, &ct_entry);
    return TC_ACT_OK;
}

# iptables: N 条规则线性匹配
for i in $(seq 1 $N); do
    iptables -A INPUT -s "10.$((i/65536%256)).$((i/256%256)).$((i%256))" -j DROP
done

# nftables: 一个包含 N 个元素的 set（O(1) 查找）
nft add set inet filter blacklist { type ipv4_addr\; }
# ... 批量添加 N 个元素 ...
nft add rule inet filter input ip saddr @blacklist drop

# eBPF: 一个包含 N 个条目的 BPF hash map
bpftool map update id $MAP_ID key hex ... value hex 01

# 使用 wrk2 测试 HTTP 短连接（每个请求一个新连接）
wrk2 -t 8 -c 100 -d 60s -R 200000 --latency http://target:80/

# 检查 Cilium 节点上残留的 iptables 规则
iptables-save | grep -v "^#" | grep -v "^:" | grep -v "^*" | grep -v "COMMIT" | wc -l

# 典型输出：仍有 20-50 条规则

# Cilium Helm values
kubeProxyReplacement: "true"
k8sServiceHost: "api-server.example.com"
k8sServicePort: "6443"

# 启用 eBPF host routing（绕过 iptables）
routingMode: "native"
bpf:
  masquerade: true    # eBPF SNAT 替代 iptables MASQUERADE
  hostRouting: true   # eBPF host routing 替代 iptables FORWARD

# 验证 kube-proxy replacement 是否生效
cilium status | grep KubeProxyReplacement
# KubeProxyReplacement: True [eth0 (Direct Routing)]

# 查看 eBPF Service map
cilium bpf lb list

# 查看 Cilium 的 BPF SNAT 配置
cilium bpf nat list

# 对比 iptables MASQUERADE（如果未完全替代）
iptables -t nat -L KUBE-POSTROUTING -n --line-numbers

# Istio sidecar 注入的 iptables 规则（在 Pod 网络命名空间内）
# istio-init 容器执行
iptables -t nat -A PREROUTING -p tcp -j ISTIO_INBOUND
iptables -t nat -A OUTPUT -p tcp -j ISTIO_OUTPUT
iptables -t nat -A ISTIO_INBOUND -p tcp --dport 15008 -j RETURN
iptables -t nat -A ISTIO_INBOUND -p tcp -j ISTIO_IN_REDIRECT
iptables -t nat -A ISTIO_IN_REDIRECT -p tcp -j REDIRECT --to-port 15006

# MetalLB speaker 的 iptables 规则
iptables -t nat -A KUBE-SERVICES -d 192.168.1.100/32 -j KUBE-MARK-MASQ

# Calico 的 iptables 规则（如果作为 CNI 共存）
iptables -t filter -L cali-INPUT -n --line-numbers

# 第一步：确认当前使用的后端
iptables -V
# iptables v1.8.9 (nf_tables)  ← 已经使用 nf_tables 后端
# iptables v1.8.7 (legacy)     ← 仍在使用 legacy 后端

# 第二步：使用 iptables-translate 转换现有规则
iptables-translate -A INPUT -s 10.0.0.0/8 -p tcp --dport 22 -j ACCEPT
# 输出: nft add rule ip filter INPUT ip saddr 10.0.0.0/8 tcp dport 22 counter accept

# 第三步：批量转换
iptables-save | iptables-restore-translate > nft-ruleset.nft

# 第四步：验证转换后的规则
nft -c -f nft-ruleset.nft  # -c 只检查不应用

# 第五步：应用
nft -f nft-ruleset.nft

# 第一步：确认内核版本（需要 5.10+，推荐 5.15+）
uname -r
cilium preflight install --chart-version 1.16.0

# 第二步：安装 Cilium（先保留 kube-proxy）
helm install cilium cilium/cilium --version 1.16.0 \
    --namespace kube-system \
    --set kubeProxyReplacement=false \
    --set routingMode=native

# 第三步：验证后启用 kube-proxy replacement
cilium status --wait && cilium connectivity test
helm upgrade cilium cilium/cilium --version 1.16.0 \
    --namespace kube-system \
    --set kubeProxyReplacement=true \
    --set k8sServiceHost="<api-server>" \
    --set k8sServicePort="6443"

# 第四步：删除 kube-proxy，清理残留规则
kubectl -n kube-system delete ds kube-proxy
kubectl -n kube-system delete cm kube-proxy
iptables-save | grep -i kube  # 确认无残留

# 连通性与性能验证
cilium connectivity test --all-flows
kubectl run test --image=busybox --rm -it -- wget -qO- http://kubernetes.default.svc/healthz
wrk2 -t 4 -c 50 -d 30s -R 10000 --latency http://target-svc/

# conntrack 监控
watch -n5 'cilium bpf ct list global | wc -l'

# 回滚 kube-proxy replacement
helm upgrade cilium cilium/cilium --set kubeProxyReplacement=false
kubectl apply -f kube-proxy-daemonset.yaml

# 最坏情况：完全移除 Cilium
helm uninstall cilium -n kube-system