✍️ 필사 모드: eBPF Deep Dive — 리눅스 커널을 프로그래머블하게 만든 VM, Verifier, XDP, CO-RE 완전 정복 (2025)

필터식: "tcp and port 80"
         ↓
      BPF 바이트코드 (32-bit ISA, 2개 레지스터)
         ↓
      커널 안에서 실행 → 매치되는 패킷만 유저로

struct bpf_insn {
    __u8    code;       // 8 bits: opcode
    __u8    dst_reg:4;  // 4 bits: destination register
    __u8    src_reg:4;  // 4 bits: source register
    __s16   off;        // 16 bits: signed offset
    __s32   imm;        // 32 bits: signed immediate
};

R0  : 리턴값 (함수 호출 결과)
R1-R5: 함수 인자 (C 스타일 ABI)
R6-R9: 호출 보존 레지스터
R10 : 프레임 포인터 (read-only, 스택 접근용)

// C 코드
int add(int a, int b) { return a + b; }

; 0000000000000000 <add>:
;    0:  bf 10 00 00 00 00 00 00   r0 = r1       ; R0 = a
;    1:  0f 20 00 00 00 00 00 00   r0 += r2      ; R0 += b
;    2:  95 00 00 00 00 00 00 00   exit          ; return R0

eBPF Bytecode        JIT (x86_64)
----------------     -----------------
r0 = r1              mov rax, rdi
r0 += r2             add rax, rsi
exit                 ret

sysctl net.core.bpf_jit_enable  # 1 = enabled

// Linux 5.3+: OK
for (int i = 0; i < 64; i++) {
    // ...
}

// 항상 OK: unroll pragma
#pragma unroll
for (int i = 0; i < 4; i++) { ... }

// NG: verifier가 상한을 알 수 없음
for (int i = 0; i < x; i++) { ... }  // x가 unknown

int x = get_pid();   // x: [0, 4194304] (pid 범위)
if (x > 100) {
    // 이 분기에서 x: [101, 4194304]
    use(x);
}

PTR_TO_CTX     : 프로그램 컨텍스트 (struct __sk_buff, struct xdp_md 등)
PTR_TO_PACKET  : 네트워크 패킷 (data)
PTR_TO_PACKET_END : 패킷 끝
PTR_TO_MAP_KEY : 맵 키
PTR_TO_MAP_VALUE : 맵 값
PTR_TO_STACK   : 스택 메모리
PTR_TO_SOCKET  : 소켓 구조체
SCALAR_VALUE   : 포인터가 아닌 스칼라

SEC("xdp")
int drop_port_80(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    // NG: verifier는 (eth + sizeof(*eth)) <= data_end 를 모름
    if (eth->h_proto == bpf_htons(ETH_P_IP)) { ... }
    return XDP_PASS;
}

if (data + sizeof(*eth) > data_end)  // 필수 bounds check
    return XDP_PASS;

if (eth->h_proto == bpf_htons(ETH_P_IP)) { ... }

0: R1=ctx(off=0,imm=0) R10=fp0
0: (b7) r0 = 0                          ; R0 = 0
1: R0=inv0 R1=ctx(off=0,imm=0) R10=fp0
1: (79) r2 = *(u64 *)(r1 +0)            ; r2 = ctx->data
2: R0=inv0 R1=ctx(off=0,imm=0) R2=pkt(off=0,r=0) R10=fp0
...
17: invalid access to packet, off=14 size=2, R1(id=0,off=14,r=0)
R1 offset is outside of the packet

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, u32);
    __type(value, u64);
    __uint(max_entries, 10240);
} pid_counts SEC(".maps");

u32 pid = bpf_get_current_pid_tgid() >> 32;
u64 *count = bpf_map_lookup_elem(&pid_counts, &pid);
if (!count) {
    u64 one = 1;
    bpf_map_update_elem(&pid_counts, &pid, &one, BPF_ANY);
} else {
    __sync_fetch_and_add(count, 1);  // atomic
}

u32 pid = 1234;
u64 count;
bpf_map_lookup_elem(map_fd, &pid, &count);
printf("PID %u: %llu\n", pid, count);

struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __type(key, u32);
    __type(value, u64);
    __uint(max_entries, 1);
} counter SEC(".maps");

SEC("kprobe/sys_openat")
int count_openat(struct pt_regs *ctx) {
    u32 key = 0;
    u64 *val = bpf_map_lookup_elem(&counter, &key);
    if (val) (*val)++;  // 락 없음, 자기 CPU 슬롯
    return 0;
}

int ncpus = libbpf_num_possible_cpus();
u64 vals[ncpus];
bpf_map_lookup_elem(fd, &key, vals);
u64 total = 0;
for (int i = 0; i < ncpus; i++) total += vals[i];

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);  // 256KB
} events SEC(".maps");

struct event {
    u32 pid;
    char comm[16];
};

SEC("tp/sched/sched_process_exec")
int handle_exec(void *ctx) {
    struct event *e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
    if (!e) return 0;
    e->pid = bpf_get_current_pid_tgid() >> 32;
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
    bpf_ringbuf_submit(e, 0);
    return 0;
}

struct ring_buffer *rb = ring_buffer__new(map_fd, handle_event, NULL, NULL);
while (!exiting) {
    ring_buffer__poll(rb, 100);  // 100ms timeout
}

SEC("kprobe/do_sys_openat2")
int kprobe_openat(struct pt_regs *ctx) {
    const char *filename = (const char *)PT_REGS_PARM2(ctx);
    char buf[256];
    bpf_probe_read_user_str(buf, sizeof(buf), filename);
    bpf_printk("open: %s\n", buf);
    return 0;
}

SEC("tracepoint/syscalls/sys_enter_openat")
int tp_openat(struct trace_event_raw_sys_enter *ctx) {
    bpf_printk("openat called\n");
    return 0;
}

SEC("fentry/tcp_v4_connect")
int BPF_PROG(connect_entry, struct sock *sk) {
    bpf_printk("connect: sk=%p\n", sk);
    return 0;
}

SEC("fexit/tcp_v4_connect")
int BPF_PROG(connect_exit, struct sock *sk, int ret) {
    bpf_printk("connect ret=%d\n", ret);
    return 0;
}

SEC("xdp")
int xdp_drop_tcp_80(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    if (data + sizeof(*eth) > data_end) return XDP_PASS;
    if (eth->h_proto != bpf_htons(ETH_P_IP)) return XDP_PASS;

    struct iphdr *ip = data + sizeof(*eth);
    if ((void *)(ip + 1) > data_end) return XDP_PASS;
    if (ip->protocol != IPPROTO_TCP) return XDP_PASS;

    struct tcphdr *tcp = (void *)ip + ip->ihl * 4;
    if ((void *)(tcp + 1) > data_end) return XDP_PASS;

    if (tcp->dest == bpf_htons(80))
        return XDP_DROP;  // 80 포트로 오는 TCP 드롭

    return XDP_PASS;
}

SEC("classifier")
int tc_prog(struct __sk_buff *skb) {
    // skb->data / skb->data_end 접근 가능
    return TC_ACT_OK;
}

SEC("cgroup_skb/egress")
int cgroup_egress(struct __sk_buff *skb) {
    // 이 cgroup에 속한 프로세스의 egress 트래픽 필터
    if (skb->remote_port == bpf_htons(22)) return 0;  // SSH 차단
    return 1;
}

SEC("lsm/file_open")
int BPF_PROG(block_secret_file, struct file *file) {
    // 특정 파일 접근 차단
    char name[256];
    bpf_probe_read_kernel_str(name, sizeof(name),
        file->f_path.dentry->d_iname);
    if (strcmp(name, "secret") == 0)
        return -EACCES;
    return 0;
}

SEC("sockops")
int bpf_sockmap(struct bpf_sock_ops *ops) {
    if (ops->op == BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB) {
        // 연결 수립됨, sockmap에 등록
        // ...
    }
    return 0;
}

// Linux 5.10
struct task_struct {
    ...
    pid_t pid;            // offset 1232
    ...
};

// Linux 6.5
struct task_struct {
    ...
    // 중간에 새 필드 추가됨
    pid_t pid;            // offset 1264
    ...
};

#include <vmlinux.h>  // 커널 타입 정의 (BTF에서 생성)
#include <bpf/bpf_core_read.h>

SEC("kprobe/tcp_sendmsg")
int trace_tcp_sendmsg(struct pt_regs *ctx) {
    struct sock *sk = (struct sock *)PT_REGS_PARM1(ctx);
    u16 sport;
    BPF_CORE_READ_INTO(&sport, sk, __sk_common.skc_num);
    bpf_printk("tcp_sendmsg sport=%d\n", sport);
    return 0;
}

bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h

if (bpf_core_field_exists(task->comm_size)) {
    // 새 커널: comm_size 필드 사용
} else {
    // 구 커널: 하드코딩된 16 사용
}

[컨테이너 이미지]
  ├─ kernel-headers-*
  ├─ gcc / clang
  ├─ LLVM IR
  ├─ bcc runtime
  ├─ 실제 프로그램
→ 수백 MB

[컨테이너 이미지]
  ├─ libbpf (shared library)
  ├─ foo.bpf.o (CO-RE 가능한 바이트코드)
  ├─ foo (유저 프로그램)
→ 수 MB

NIC → XDP (드라이버 RX 직후) → sk_buff 할당 → TC ingress → 라우팅 → TC egress → 드라이버 TX → NIC
       ↑                                                                                        ↑
       패킷이 sk_buff로 변환되기 전                                              커널 네트워크 스택 전부

SEC("xdp")
int ddos_filter(struct xdp_md *ctx) {
    // 1. IP 블랙리스트 확인 (LPM trie)
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    struct ethhdr *eth = data;
    if (data + sizeof(*eth) > data_end) return XDP_DROP;

    if (eth->h_proto != bpf_htons(ETH_P_IP)) return XDP_PASS;
    struct iphdr *ip = data + sizeof(*eth);
    if ((void *)(ip + 1) > data_end) return XDP_DROP;

    struct lpm_key key = { .prefixlen = 32, .addr = ip->saddr };
    if (bpf_map_lookup_elem(&blacklist, &key))
        return XDP_DROP;  // 블랙리스트 히트

    // 2. SYN flood rate limit
    if (ip->protocol == IPPROTO_TCP) {
        struct tcphdr *tcp = (void *)ip + ip->ihl * 4;
        if ((void *)(tcp + 1) > data_end) return XDP_DROP;
        if (tcp->syn && !tcp->ack) {
            u64 *count = bpf_map_lookup_elem(&syn_counts, &ip->saddr);
            if (count && *count > THRESHOLD)
                return XDP_DROP;
            // ... rate 증가 로직
        }
    }

    return XDP_PASS;
}

클라이언트 → [Katran 서버]
                ↓ XDP: consistent hash로 backend 선택
                ↓ IPIP 또는 GUE 인캡슐레이션
             [Backend 서버]

Pod → Cilium eBPF 프로그램 (veth 페어 TC hook)
       ├─ Service Resolution (kube-proxy 대체)
       ├─ Network Policy (Identity 기반)
       ├─ Load Balancing (Maglev hash)
       └─ Encryption (WireGuard/IPsec)
     → Egress → 원격 노드

apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: allow-frontend-to-backend
spec:
  endpointSelector:
    matchLabels:
      app: backend
  ingress:
  - fromEndpoints:
    - matchLabels:
        app: frontend
    toPorts:
    - ports:
      - port: "8080"
        protocol: TCP

Pod → connect(svc_ip) → iptables DNAT (수천 룰 스캔) → 실제 backend pod_ip

Pod → connect(svc_ip)
       ↓
     sockops BPF 프로그램 실행
       ↓
     "이 서비스 → 이 backend"로 DNAT (맵 조회 O(1))
       ↓
     connect는 처음부터 backend_ip로 진행 (iptables 건드리지 않음)

connect(svc_ip) → sockmap redirect → 직접 localhost 통신

# syscall 호출 횟수 (1초마다)
bpftrace -e 'tracepoint:syscalls:sys_enter_* { @[probe] = count(); }'

# TCP 연결 레이턴시 히스토그램
bpftrace -e '
kprobe:tcp_v4_connect { @start[tid] = nsecs; }
kretprobe:tcp_v4_connect /@start[tid]/ {
    @latency = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

# 어떤 프로세스가 파일 열고 있나
bpftrace -e '
tracepoint:syscalls:sys_enter_openat {
    printf("%s %s\n", comm, str(args->filename));
}'

from bcc import BPF

program = """
int count(void *ctx) {
    bpf_trace_printk("hello\\n");
    return 0;
}
"""

b = BPF(text=program)
b.attach_kprobe(event="do_sys_openat2", fn_name="count")
b.trace_print()

// trace.bpf.c
#include <vmlinux.h>
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);
} events SEC(".maps");

SEC("tp/syscalls/sys_enter_openat")
int handle_openat(void *ctx) {
    u32 *e = bpf_ringbuf_reserve(&events, sizeof(u32), 0);
    if (!e) return 0;
    *e = bpf_get_current_pid_tgid() >> 32;
    bpf_ringbuf_submit(e, 0);
    return 0;
}

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

clang -O2 -target bpf -g -c trace.bpf.c -o trace.bpf.o
bpftool gen skeleton trace.bpf.o > trace.skel.h

// trace.c
#include "trace.skel.h"

int main() {
    struct trace_bpf *skel = trace_bpf__open_and_load();
    trace_bpf__attach(skel);
    struct ring_buffer *rb = ring_buffer__new(
        bpf_map__fd(skel->maps.events), handle_event, NULL, NULL);
    while (!exiting) ring_buffer__poll(rb, 100);
    trace_bpf__destroy(skel);
}

- rule: Read sensitive file untrusted
  desc: Detect reading sensitive files
  condition: >
    sensitive_files and open_read
    and proc_name_exists
    and not proc.name in (trusted_procs)
  output: >
    Sensitive file opened (user=%user.name
    command=%proc.cmdline file=%fd.name)
  priority: WARNING

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

# 패킷 생성 (다른 머신)
pktgen ... -d target_ip -p 10000 -pps 10000000

# 수신 머신에서 eBPF 로드
ip link set dev eth0 xdp obj drop.o sec xdp

# 트래픽 관찰
ip -s link show eth0

bpftool prog load prog.o /sys/fs/bpf/prog \
    log_level 2 log_size 4194304 2>&1 | tee verifier.log

struct {
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
    __uint(max_entries, 4);
    __type(key, u32);
    __type(value, u32);
} prog_array SEC(".maps");

SEC("xdp")
int entry(struct xdp_md *ctx) {
    // 첫 번째 단계 처리
    bpf_tail_call(ctx, &prog_array, NEXT_PROG);
    return XDP_PASS;  // tail call 실패 시
}

static __noinline int helper(int x) {
    return x * 2;
}

SEC("xdp")
int prog(struct xdp_md *ctx) {
    return helper(42);
}

SEC("struct_ops/scx_example_enqueue")
void BPF_STRUCT_OPS(enqueue, struct task_struct *p, u64 enq_flags) {
    scx_bpf_dispatch(p, SCX_DSQ_GLOBAL, SCX_SLICE_DFL, enq_flags);
}

use aya_bpf::{macros::xdp, programs::XdpContext};

#[xdp]
pub fn my_xdp(ctx: XdpContext) -> u32 {
    match unsafe { try_my_xdp(ctx) } {
        Ok(ret) => ret,
        Err(_) => xdp_action::XDP_PASS,
    }
}

┌────────────────────────────────────────────────────┐
│              eBPF Cheat Sheet                       │
├────────────────────────────────────────────────────┤
│ VM:                                                 │
│  - 11 regs (R0=ret, R1-5=args, R10=stack)           │
│  - 64-bit RISC-like, JIT to native                  │
│  - 1M insn limit, bounded loops                     │
│                                                     │
│ Verifier:                                           │
│  - Symbolic execution                               │
│  - Proves termination + memory safety               │
│  - Pointer types: CTX, PKT, MAP_VALUE, STACK, ...   │
│  - Must NULL-check map lookups                      │
│  - Must bounds-check packet access                  │
│                                                     │
│ Maps:                                               │
│  - Hash, Array, LRU, LPM trie, Ring buffer          │
│  - Per-CPU variants for lock-free counters          │
│  - Helpers: lookup/update/delete                    │
│                                                     │
│ Program types (hooks):                              │
│  - kprobe/kretprobe : 동적, 함수 진입                │
│  - tracepoint       : 안정 ABI 이벤트                │
│  - fentry/fexit     : trampoline 기반, 빠름          │
│  - XDP              : 드라이버 바로 뒤, 초고속        │
│  - TC (classifier)  : qdisc 레벨                    │
│  - cgroup_skb       : 네임스페이스별                 │
│  - LSM              : 보안 훅                        │
│  - sockops          : 소켓 수립                      │
│                                                     │
│ CO-RE:                                              │
│  - BTF가 커널 타입 정보 저장                          │
│  - libbpf가 로드 시 오프셋 리라이트                    │
│  - 한 번 컴파일, 모든 커널                            │
│  - vmlinux.h 자동 생성                               │
│                                                     │
│ 프로덕션:                                             │
│  - Cilium: K8s CNI, kube-proxy 대체                 │
│  - Katran: Meta L4 LB                               │
│  - Pixie: 관측성, uprobe 기반                        │
│  - Falco: 런타임 보안                                │
│  - bpftrace: ad-hoc 추적                            │
│                                                     │
│ 도구:                                                 │
│  - bpftool: prog/map 관리                           │
│  - libbpf: 프로덕션 라이브러리                         │
│  - bcc: Python, LLVM 런타임                         │
│  - aya: Rust 프레임워크                              │
└────────────────────────────────────────────────────┘