1
// 验证器中的寄存器状态（简化）
2
struct bpf_reg_state {
3
    enum bpf_reg_type type;  // NOT_INIT, SCALAR_VALUE, PTR_TO_CTX, ...
4
    s64 min_value, max_value;
5
    u64 umin_value, umax_value;
6
    struct bpf_map *map_ptr;
7
    // ... 更多字段
8
};

1
// 示例：路径敏感分析
2
SEC("xdp")
3
int example(struct xdp_md *ctx)
4
{
5
    void *data = (void *)(long)ctx->data;
6
    void *data_end = (void *)(long)ctx->data_end;
7

8
    // 路径 A：data + 14 <= data_end
9
    if (data + 14 <= data_end) {
10
        // 验证器知道：data_end - data >= 14
11
        // 可以安全访问前 14 字节
12
        struct ethhdr *eth = data;
13
        __u16 proto = eth->h_proto;  //  安全：验证器已证明
14
    }
15

16
    // 路径 B：data + 14 > data_end
17
    // 不能安全访问以太网头
18

19
    return XDP_PASS;
20
}

1
SEC("xdp")
2
int parse_packet(struct xdp_md *ctx)
3
{
4
    void *data = (void *)(long)ctx->data;
5
    void *data_end = (void *)(long)ctx->data_end;
6

7
    // 错误：没有边界检查
8
    // struct ethhdr *eth = data;
9
    // __u16 proto = eth->h_proto;  // 验证器拒绝！
10

11
    //  正确：先做边界检查
12
    struct ethhdr *eth = data;
13
    if ((void *)(eth + 1) > data_end)
14
        return XDP_PASS;
15

16
    // 验证器现在知道：data_end - data >= sizeof(*eth)
17
    __u16 proto = eth->h_proto;  // 安全！
18

19
    // 解析 IP 头
20
    struct iphdr *iph = (void *)(eth + 1);
21
    if ((void *)(iph + 1) > data_end)
22
        return XDP_PASS;
23

24
    // 验证器现在知道可以访问 IP 头
25
    __u8 protocol = iph->protocol;  // 安全！
26

27
    return XDP_PASS;
28
}

1
// 内核中的复杂度限制
2
#define BPF_COMPLEXITY_LIMIT_STATES 64   // 每条指令最大状态数
3
#define BPF_COMPLEXITY_LIMIT_STACK 512   // 栈大小限制
4
#define BPF_COMPLEXITY_LIMIT_JMP_SEQ 8   // 连续跳转限制

1
// 错误：无限循环
2
while (1) {  // 验证器拒绝：无法证明终止
3
    // ...
4
}
5

6
// 错误：动态循环上限
7
for (int i = 0; i < count; i++) {  // 验证器拒绝：count 未知
8
    // ...
9
}
10

11
//  正确：常量循环上限（5.3+ 支持 bounded loops）
12
for (int i = 0; i < 10; i++) {  // 验证器接受：上限已知
13
    // ...
14
}
15

16
//  正确：使用 #pragma unroll 展开循环
17
#pragma unroll
18
for (int i = 0; i < 4; i++) {
19
    // 编译器展开为 4 条独立指令
20
}

1
// 错误
2
SEC("kprobe/do_sys_open")
3
int bad_example(void *ctx)
4
{
5
    u32 key = 1;
6
    u64 *val = bpf_map_lookup_elem(&my_map, &key);
7
    *val += 1;  // 验证器拒绝：val 可能为 NULL
8
    return 0;
9
}
10

11
//  正确
12
SEC("kprobe/do_sys_open")
13
int good_example(void *ctx)
14
{
15
    u32 key = 1;
16
    u64 *val = bpf_map_lookup_elem(&my_map, &key);
17
    if (!val)           // NULL 检查
18
        return 0;
19
    *val += 1;          // 验证器知道 val 非 NULL
20
    return 0;
21
}

1
// 错误：边界检查模式不正确
2
if (data_end - data < 14)  // 验证器不识别这种模式
3
    return XDP_PASS;
4

5
//  正确：使用指针比较
6
if (data + 14 > data_end)  // 验证器识别的模式
7
    return XDP_PASS;

1
// 错误：读取未初始化的栈变量
2
SEC("kprobe/sys_open")
3
int bad_example(void *ctx)
4
{
5
    u32 key;  // 未初始化
6
    u64 *val = bpf_map_lookup_elem(&my_map, &key);  // 验证器拒绝
7
    return 0;
8
}
9

10
//  正确：初始化变量
11
SEC("kprobe/sys_open")
12
int good_example(void *ctx)
13
{
14
    u32 key = 0;  // 初始化
15
    u64 *val = bpf_map_lookup_elem(&my_map, &key);
16
    return 0;
17
}

1
# 查看详细的验证日志
2
sudo bpftool prog load hello.bpf.o /sys/fs/bpf/hello \
3
    type tracepoint name sys_enter_execve
4

5
# 如果验证失败，bpftool 会输出详细的验证日志
6
# 包括每条指令的寄存器状态
7

8
# 使用 libbpf 的调试模式
9
export LIBBPF_LOG_LEVEL=4
10
sudo ./hello
11

12
# 在代码中启用验证器日志
13
struct bpf_object_open_opts opts = {
14
    .kernel_log_level = 2,  // 1=stats, 2=verbose
15
};

1
// unverified.bpf.c — 故意触发验证器错误
2
#include <linux/bpf.h>
3
#include <bpf/bpf_helpers.h>
4

5
SEC("xdp")
6
int bad_program(struct xdp_md *ctx)
7
{
8
    // 错误 1：没有边界检查的数据包访问
9
    void *data = (void *)(long)ctx->data;
10
    struct ethhdr *eth = data;
11
    __u16 proto = eth->h_proto;  // 验证器拒绝！
12

13
    return XDP_PASS;
14
}
15

16
char LICENSE[] SEC("license") = "GPL";

1
# 编译并尝试加载
2
clang -O2 -target bpf -c unverified.bpf.c -o unverified.bpf.o
3
sudo bpftool prog load unverified.bpf.o /sys/fs/bpf/bad type xdp
4

5
# 预期输出：
6
# Error: invalid mem access 'scalar'

1
# 使用 libbpf 的详细日志模式
2
sudo bpftool prog load -v hello.bpf.o /sys/fs/bpf/hello type xdp
3

4
# 输出验证过程的详细信息：
5
# func#0 @0
6
# 0: R1=ctx(off=0,imm=0) R10=fp0
7
// 1: (bf) r6 = r1
8
//  R1=ctx(off=0,imm=0) R6=ctx(off=0,imm=0)
9
// 2: (61) r2 = *(u32 *)(r6 +0)
10
//  R2=scalar(umin=0,umax=4294967295)

1
// bounded_loop.bpf.c — 有界循环（5.3+ 通过验证）
2
SEC("xdp")
3
int bounded(struct xdp_md *ctx)
4
{
5
    int sum = 0;
6
    #pragma unroll
7
    for (int i = 0; i < 4; i++) {
8
        sum += i;
9
    }
10
    return sum ? XDP_PASS : XDP_DROP;
11
}
12

13
// unbounded_loop.bpf.c — 无界循环（验证器拒绝）
14
SEC("xdp")
15
int unbounded(struct xdp_md *ctx)
16
{
17
    int sum = 0;
18
    while (sum < 100) {  // 验证器无法证明终止
19
        sum += 1;
20
    }
21
    return XDP_PASS;
22
}