✍️ 필사 모드: eBPF 완전 가이드 2025: 커널 프로그래밍, Observability, 네트워킹, 보안의 혁명

┌─────────────────────────────────────────────┐
│  사용자 공간 (User Space)                    │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ bpftool  │  │ bpftrace │  │ Cilium   │  │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  │
│       │             │             │         │
│       └─────────────┼─────────────┘         │
│                     │ bpf() syscall          │
└─────────────────────┼───────────────────────┘
                      ▼
┌─────────────────────────────────────────────┐
│  커널 공간 (Kernel Space)                    │
│  ┌─────────────────────────────────────┐   │
│  │  BPF Verifier (안전성 검증)         │   │
│  └──────────────┬──────────────────────┘   │
│                 ▼                            │
│  ┌─────────────────────────────────────┐   │
│  │  JIT Compiler (네이티브 코드 변환)   │   │
│  └──────────────┬──────────────────────┘   │
│                 ▼                            │
│  ┌─────────────────────────────────────┐   │
│  │  Hooks: kprobe, tracepoint, XDP,    │   │
│  │  perf_event, socket, cgroup, LSM    │   │
│  └─────────────────────────────────────┘   │
└─────────────────────────────────────────────┘

// BPF_MAP_TYPE_HASH 예시: 시스템 콜 호출 횟수 카운팅
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, __u32);  // PID
    __type(value, __u64); // count
    __uint(max_entries, 10240);
} syscall_count SEC(".maps");

# BCC 예시: openat 시스템 콜 추적
from bcc import BPF

prog = """
int hello(void *ctx) {
    bpf_trace_printk("openat called!\\n");
    return 0;
}
"""

b = BPF(text=prog)
b.attach_kprobe(event="do_sys_openat2", fn_name="hello")
b.trace_print()

# 프로세스별 시스템 콜 호출 횟수
bpftrace -e 'tracepoint:syscalls:sys_enter_* { @[comm] = count(); }'

# 1초 이상 걸리는 read() 시스템 콜 추적
bpftrace -e '
kprobe:vfs_read { @start[tid] = nsecs; }
kretprobe:vfs_read /@start[tid]/ {
    $duration = nsecs - @start[tid];
    if ($duration > 1000000000) {
        printf("%s pid %d took %d ms\n", comm, pid, $duration / 1000000);
    }
    delete(@start[tid]);
}'

# CPU 사용량이 가장 높은 함수 (on-CPU 프로파일링)
bpftrace -e 'profile:hz:99 { @[ustack] = count(); }'

// libbpf 예시: openat() 추적
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

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

SEC("tracepoint/syscalls/sys_enter_openat")
int handle_openat(struct trace_event_raw_sys_enter *ctx) {
    char comm[16];
    bpf_get_current_comm(&comm, sizeof(comm));
    bpf_printk("openat by %s\n", comm);
    return 0;
}

# Cilium L7 Network Policy 예시
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: allow-api-only
spec:
  endpointSelector:
    matchLabels:
      app: backend
  ingress:
  - fromEndpoints:
    - matchLabels:
        app: frontend
    toPorts:
    - ports:
      - port: '8080'
      rules:
        http:
        - method: 'GET'
          path: '/api/v1/.*'

// XDP 예시: 특정 IP 차단
SEC("xdp")
int xdp_drop_blocked_ip(struct xdp_md *ctx) {
    void *data_end = (void *)(long)ctx->data_end;
    void *data = (void *)(long)ctx->data;
    struct ethhdr *eth = data;

    if ((void *)eth + sizeof(*eth) > data_end)
        return XDP_PASS;

    if (eth->h_proto != htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = (void *)eth + sizeof(*eth);
    if ((void *)ip + sizeof(*ip) > data_end)
        return XDP_PASS;

    // 특정 IP 차단 (예: 1.2.3.4)
    if (ip->saddr == htonl(0x01020304))
        return XDP_DROP;

    return XDP_PASS;
}

# Falco rule: 컨테이너에서 셸 실행 탐지
- rule: Terminal shell in container
  desc: A shell was used as the entrypoint/exec point into a container
  condition: >
    spawned_process and container
    and shell_procs and proc.tty != 0
  output: >
    Shell spawned in container (user=%user.name container=%container.name
    shell=%proc.name pid=%proc.pid)
  priority: WARNING

# 1. 어떤 프로세스가 디스크 I/O를 일으키는가?
sudo bpftrace -e '
tracepoint:block:block_rq_issue {
    @[comm] = count();
}
interval:s:5 {
    print(@);
    clear(@);
}'

# 2. I/O 지연시간 분포 (히스토그램)
sudo bpftrace -e '
kprobe:blk_account_io_start { @start[arg0] = nsecs; }
kprobe:blk_account_io_done /@start[arg0]/ {
    @ms = hist((nsecs - @start[arg0]) / 1000000);
    delete(@start[arg0]);
}'

sudo bpftrace -e '
tracepoint:syscalls:sys_enter_openat {
    printf("%s opened: %s\n", comm, str(args->filename));
}'

sudo bpftrace -e '
kprobe:tcp_close {
    $sk = (struct sock *)arg0;
    $state = $sk->__sk_common.skc_state;
    if ($state != 7) { // TCP_CLOSE
        printf("PID %d (%s) closed TCP connection in state %d\n",
               pid, comm, $state);
    }
}'

// 커널 5.10에서:
struct task_struct {
    int pid;
    char comm[16];
    // ...
};

// 커널 5.15에서 새 필드 추가:
struct task_struct {
    int pid;
    int tgid;  // 새로 추가
    char comm[16];
};

// CO-RE 매크로 사용
#include <bpf/bpf_core_read.h>

SEC("kprobe/do_unlinkat")
int handle_unlinkat(struct pt_regs *ctx) {
    struct task_struct *task = (struct task_struct *)bpf_get_current_task();
    
    // BPF_CORE_READ: BTF 기반 안전한 필드 읽기
    pid_t pid = BPF_CORE_READ(task, pid);
    
    bpf_printk("unlink by pid %d\n", pid);
    return 0;
}