Linux内核系列:eBPF的透明眼睛

struct__sk_buff {

__u32 len; /* 数据包总长度 */

__u32 pkt_type; /* 包类型（单播/广播/多播） */

__u32 protocol; /* 协议类型（ETH_P_IP等） */

__u32 ifindex; /* 网络接口索引 */

__u32 cb[5]; /* 控制块（可自定义使用） */

// ... 更多字段

};

#include<linux/bpf.h>

#include<linux/if_ether.h>

#include<linux/ip.h>

#include<linux/tcp.h>

SEC("xdp")

intobserve_packets(struct xdp_md *ctx) {

// 1. 获取数据包边界

void *data = (void *)(long)ctx->data;

void *data_end = (void *)(long)ctx->data_end;

// 2. 解析以太网头

struct ethhdr *eth = data;

if ((void *)(eth + 1) > data_end) /* 边界检查 */

return XDP_PASS;

// 3. 只处理IPv4

if (eth->h_proto != bpf_htons(ETH_P_IP))

return XDP_PASS;

// 4. 解析IP头

struct iphdr *ip = (void *)(eth + 1);

if ((void *)(ip + 1) > data_end)

return XDP_PASS;

// 5. 记录源IP和目标IP

__u32 src_ip = ip->saddr;

__u32 dst_ip = ip->daddr;

// 6. 解析TCP头

if (ip->protocol == IPPROTO_TCP) {

struct tcphdr *tcp = (void *)ip + (ip->ihl * 4);

if ((void *)(tcp + 1) > data_end)

return XDP_PASS;

__u16 src_port = bpf_ntohs(tcp->source);

__u16 dst_port = bpf_ntohs(tcp->dest);

}

return XDP_PASS; /* 放行数据包 */

}

⚠️ 关键点：每次解析都必须做边界检查（(void *)(ptr + 1) > data_end），这是 eBPF verifier 的强制要求，也是安全的保障。

// 定义事件结构（内核与用户态共用）

structpacket_event {

__u32 src_ip;

__u32 dst_ip;

__u16 src_port;

__u16 dst_port;

__u8 protocol; /* 6=TCP, 17=UDP */

__u32 pkt_len;

};

// 定义 Perf Event Map

struct {

__uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);

__uint(key_size, sizeof(int));

__uint(value_size, sizeof(int));

} events SEC(".maps");

// 发送事件到用户态（无锁，高性能）

bpf_perf_event_output(ctx, &events,

BPF_F_CURRENT_CPU,

&evt, sizeof(evt));

✅ 零拷贝：不匹配的包完全不复制，极大节省性能

✅ 内核过滤：过滤逻辑在内核执行，用户态只收到目标数据包

✅ 不影响流量：原始数据包继续正常传输

#include<linux/bpf.h>

#include<linux/if_ether.h>

#include<linux/ip.h>

#include<linux/tcp.h>

#include<bpf/bpf_helpers.h>

#include<bpf/bpf_endian.h>

// 统计Map：目标端口 → 连接次数

struct {

__uint(type, BPF_MAP_TYPE_HASH);

__uint(max_entries, 64);

__type(key, __u16); /* 目标端口 */

__type(value, __u64); /* 包计数 */

} port_stats SEC(".maps");

// 事件Map：用于向用户态实时推送

structtcp_event {

__u32 src_ip;

__u32 dst_ip;

__u16 src_port;

__u16 dst_port;

__u8 tcp_flags;

};

struct {

__uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);

__uint(key_size, sizeof(int));

__uint(value_size, sizeof(int));

} tcp_events SEC(".maps");

SEC("xdp")

inttcp_monitor(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;

// 解析IP头

struct iphdr *ip = (void *)(eth + 1);

if ((void *)(ip + 1) > data_end) return XDP_PASS;

if (ip->protocol != IPPROTO_TCP) return XDP_PASS;

// 解析TCP头

struct tcphdr *tcp = (void *)ip + ip->ihl * 4;

if ((void *)(tcp + 1) > data_end) return XDP_PASS;

__u16 dst_port = bpf_ntohs(tcp->dest);

// 更新端口统计

__u64 *cnt = bpf_map_lookup_elem(&port_stats, &dst_port);

if (cnt) {

__sync_fetch_and_add(cnt, 1); /* 原子递增 */

}

// 发送TCP事件到用户态

struct tcp_event evt = {

.src_ip = ip->saddr,

.dst_ip = ip->daddr,

.src_port = bpf_ntohs(tcp->source),

.dst_port = dst_port,

.tcp_flags = (((__u8 *)tcp)[13]), /* TCP flags字节 */

};

bpf_perf_event_output(ctx, &tcp_events,

BPF_F_CURRENT_CPU,

&evt, sizeof(evt));

return XDP_PASS;

}

char _license[] SEC("license") = "GPL";

#include<stdio.h>

#include<arpa/inet.h>

#include<bpf/libbpf.h>

#include"tcp_monitor.skel.h"

// Perf事件回调：打印TCP连接信息

staticvoidhandle_event(void *ctx, int cpu,

void *data, __u32 size) {

struct tcp_event *evt = data;

char src[INET_ADDRSTRLEN], dst[INET_ADDRSTRLEN];

inet_ntop(AF_INET, &evt->src_ip, src, sizeof(src));

inet_ntop(AF_INET, &evt->dst_ip, dst, sizeof(dst));

printf("[TCP] %s:%d → %s:%d flags=0x%02x\n",

src, evt->src_port,

dst, evt->dst_port,

evt->tcp_flags);

}

intmain() {

// 1. 打开并加载eBPF程序（libbpf骨架API）

struct tcp_monitor_bpf *skel = tcp_monitor_bpf__open_and_load();

// 3. 初始化Perf Buffer

struct perf_buffer *pb = perf_buffer__new(

bpf_map__fd(skel->maps.tcp_events),

8, /* 每CPU 8页缓冲 */

handle_event, NULL, NULL, NULL

);

printf("开始监控TCP流量（Ctrl+C退出）...\n");

// 4. 事件循环：持续读取数据

while (1) {

perf_buffer__poll(pb, 100); /* 100ms超时 */

}

perf_buffer__free(pb);

tcp_monitor_bpf__destroy(skel);

return0;

}

# 编译eBPF内核程序

clang -O2 -target bpf \

-I/usr/include/bpf \

-c tcp_monitor.bpf.c \

-o tcp_monitor.bpf.o

# 生成libbpf骨架头文件

bpftool gen skeleton tcp_monitor.bpf.o > tcp_monitor.skel.h

# 编译用户态程序

gcc -O2 tcp_monitor.c -o tcp_monitor -lbpf

# 挂载XDP程序并运行

ip link set dev eth0 xdp obj tcp_monitor.bpf.o sec xdp

sudo ./tcp_monitor

开始监控TCP流量（Ctrl+C退出）...

[TCP] 192.168.1.100:54321 → 10.0.0.1:80 flags=0x02 (SYN)

[TCP] 10.0.0.1:80 → 192.168.1.100:54321 flags=0x12 (SYN+ACK)

[TCP] 192.168.1.100:54321 → 10.0.0.1:443 flags=0x02 (SYN)

[TCP] 192.168.1.100:55000 → 10.0.0.1:22 flags=0x02 (SYN → SSH连接)

bpftool map dump name port_stats

key: 00 50 value: 00 00 00 00 00 00 01 5e # 端口80, 350个包

key: 01 bb value: 00 00 00 00 00 00 02 3a # 端口443, 570个包

key: 00 16 value: 00 00 00 00 00 00 00 03 # 端口22, 3个包

🔹 XDP层的观察：在数据包刚刚离开网卡驱动、还没进入内核网络栈时就完成记录——就像在快递进入分拣中心前就扫描了包裹外皮

🔹 零侵入：被监控的应用程序、网络协议、数据包本身，完全感知不到这双眼睛的存在

🔹 全局视野：不论是容器内的流量、加密前的明文、还是系统调用层的数据，eBPF都能看到——这是传统工具无法企及的视角

1. 内核网络栈有三个主要eBPF挂载点：XDP（最早）、TC（流量控制层）、Socket Filter（套接字层）

2. 数据包解析必须做边界检查，这是eBPF verifier的安全保障，不能省略

3. Perf Event Array是从内核向用户态高效传递网络事件的核心机制

4. tcpdump的底层原理就是Socket Filter——eBPF让这个机制变得更强大、更灵活

5. 实战中，组合 XDP + Map + Perf Event 可以构建实时网络流量监控器