kernel/bpf-developer-tutorial
1
0
Fork 0
mirror of https://github.com/eunomia-bpf/bpf-developer-tutorial.git synced 2026-02-11 14:16:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: Add cgroup eBPF policy guard with TCP, device, and sysctl controls

Browse Source 
- Implemented cgroup-based access control using eBPF with three main functionalities:
  1. Block TCP connections to specified ports.
  2. Deny access to specified devices.
  3. Control sysctl read/write operations.
- Added necessary Makefile and documentation for building and running the policy guard.
This commit is contained in:
github-actions[bot]
2026-01-31 05:37:35 +00:00
parent 42884e3cef
commit 6d3ba3ea34
8 changed files with 1561 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

606
src/cgroup/README.zh.md Normal file
View File

@@ -0,0 +1,606 @@
# eBPF 实例教程：基于 cgroup 的策略控制
你是否需要对容器或特定进程组实施网络访问控制，但又不想影响整个系统？或者你需要限制某些进程访问特定设备，同时允许其他进程正常使用？传统的 iptables 和设备权限是全局生效的，无法做到按进程组精细控制。
这就是 **cgroup eBPF** 解决的问题。通过将 eBPF 程序挂载到 cgroup（控制组），你可以实现按进程归属的策略控制，只有属于特定 cgroup 的进程才会受到影响。这使得容器隔离、多租户安全和沙箱环境成为可能。在本教程中，我们将构建一个完整的"策略守卫"程序，同时演示 TCP 连接过滤、设备访问控制和 sysctl 读取限制三种 cgroup eBPF 用法。
## cgroup eBPF 简介：按进程组做策略
cgroup eBPF 的核心思想很简单：把 eBPF 程序挂到 cgroup 上，这个 cgroup 里的所有进程都会受到这个程序的控制。与 XDP/tc 按网卡过滤流量不同，cgroup eBPF 按进程归属过滤，你把容器放进一个 cgroup，挂上策略程序，这个容器的网络访问、设备访问、sysctl 读写就都在你的控制之下了。其他 cgroup 里的进程完全不受影响。
这种模型非常适合容器和多租户场景。Kubernetes 的 NetworkPolicy 底层就用了 cgroup eBPF。你也可以用它来做设备隔离（比如限制哪些容器能访问 GPU）、安全沙箱（禁止读取敏感 sysctl）等。当 cgroup eBPF 程序拒绝一个操作时，用户态的系统调用会返回 `EPERM`（操作不允许）。
## cgroup eBPF 挂载点
### 1. `BPF_PROG_TYPE_CGROUP_SOCK_ADDR` - Socket 地址钩子
在 socket 地址相关的系统调用（bind/connect/sendmsg/recvmsg）上触发：
| 钩子 | Section 名称 | 描述 |
|------|--------------|------|
| IPv4 bind | `cgroup/bind4` | 过滤 bind() 调用 |
| IPv6 bind | `cgroup/bind6` | 过滤 bind() 调用 |
| IPv4 connect | `cgroup/connect4` | 过滤 connect() 调用 |
| IPv6 connect | `cgroup/connect6` | 过滤 connect() 调用 |
| UDP sendmsg | `cgroup/sendmsg4`, `cgroup/sendmsg6` | 过滤 UDP 发送 |
| UDP recvmsg | `cgroup/recvmsg4`, `cgroup/recvmsg6` | 过滤 UDP 接收 |
| Unix connect | `cgroup/connect_unix` | 过滤 Unix socket 连接 |
**上下文**：`struct bpf_sock_addr` - 包含 `user_ip4`、`user_port`（网络字节序）
**返回语义**：`return 1` = 允许，`return 0` = 拒绝（EPERM）
### 2. `BPF_PROG_TYPE_CGROUP_DEVICE` - 设备访问控制
| 钩子 | Section 名称 | 描述 |
|------|--------------|------|
| 设备访问 | `cgroup/dev` | 过滤设备 open/read/write/mknod |
**上下文**：`struct bpf_cgroup_dev_ctx` - 包含 `major`、`minor`、`access_type`
**返回语义**：`return 0` = 拒绝（EPERM），非零 = 允许
### 3. `BPF_PROG_TYPE_CGROUP_SYSCTL` - Sysctl 访问控制
| 钩子 | Section 名称 | 描述 |
|------|--------------|------|
| Sysctl 访问 | `cgroup/sysctl` | 过滤 /proc/sys 的读写 |
**上下文**：`struct bpf_sysctl` - 使用 `bpf_sysctl_get_name()` 获取 sysctl 名称
**返回语义**：`return 0` = 拒绝（EPERM），`return 1` = 允许
### 4. 其他 cgroup 钩子
- `cgroup_skb/ingress`、`cgroup_skb/egress` - 包级过滤
- `cgroup/getsockopt`、`cgroup/setsockopt` - Socket 选项过滤
- `cgroup/sock_create`、`cgroup/sock_release` - Socket 生命周期
- `sockops` - TCP 层优化（通过 `BPF_CGROUP_SOCK_OPS` 挂载）
## 本教程：cgroup 策略守卫
我们实现一个包含三个程序的 eBPF 对象：
1. **网络（TCP）**：阻断到指定目的端口的 `connect()`
2. **设备**：阻断对指定 `major:minor` 设备的访问
3. **Sysctl**：阻断读取指定的 sysctl（只读，测试更安全）
事件通过 ringbuf 发送到用户态以便观测。
## 实现
### 共享头文件：cgroup_guard.h
这个头文件定义了内核态和用户态共享的数据结构：
```c
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
#ifndef __CGROUP_GUARD_H
#define __CGROUP_GUARD_H
#ifndef TASK_COMM_LEN
#define TASK_COMM_LEN 16
#endif
#define SYSCTL_NAME_LEN 64
enum event_type {
EVENT_CONNECT4 = 1,
EVENT_DEVICE = 2,
EVENT_SYSCTL = 3,
};
struct event {
__u64 ts_ns;
__u32 pid;
__u32 type;
char comm[TASK_COMM_LEN];
union {
struct {
__u32 daddr; /* IPv4, network order */
__u16 dport; /* host order */
__u16 proto; /* e.g. 6 for TCP */
} connect4;
struct {
__u32 major;
__u32 minor;
__u32 access_type;
} device;
struct {
__u32 write;
char name[SYSCTL_NAME_LEN];
} sysctl;
};
};
#endif /* __CGROUP_GUARD_H */
```
`event` 结构使用 union 来存储不同类型事件的特定数据，这样可以节省空间并保持统一的事件格式。
### eBPF 程序：cgroup_guard.bpf.c
```c
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
/* cgroup_guard.bpf.c - cgroup eBPF policy guard
*
* This program demonstrates three types of cgroup eBPF hooks:
* 1. cgroup/connect4 - TCP connection filtering
* 2. cgroup/dev - Device access control
* 3. cgroup/sysctl - Sysctl read/write control
*/
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>
#include "cgroup_guard.h"
char LICENSE[] SEC("license") = "Dual BSD/GPL";
/* ===== Configurable options: set by userspace before load ===== */
#define IPPROTO_TCP 6
const volatile __u16 blocked_tcp_dport = 0; /* host order */
const volatile __u32 blocked_dev_major = 0;
const volatile __u32 blocked_dev_minor = 0;
const volatile char denied_sysctl_name[SYSCTL_NAME_LEN] = {}; /* NUL-terminated */
/* ===== ringbuf: send denied events to userspace ===== */
struct {
__uint(type, BPF_MAP_TYPE_RINGBUF);
__uint(max_entries, 1 << 24); /* 16MB */
} events SEC(".maps");
static __always_inline void fill_common(struct event *e, __u32 type)
{
e->ts_ns = bpf_ktime_get_ns();
e->type = type;
e->pid = (__u32)(bpf_get_current_pid_tgid() >> 32);
bpf_get_current_comm(&e->comm, sizeof(e->comm));
}
/* Compare two strings, return 1 if equal, 0 if not
* Note: b is volatile to handle const volatile rodata arrays correctly */
static __always_inline int str_eq(const char *a, const volatile char *b, int max_len)
{
#pragma unroll
for (int i = 0; i < SYSCTL_NAME_LEN; i++) {
char ca = a[i];
char cb = b[i];
if (ca != cb)
return 0;
if (ca == '\0')
return 1;
}
return 1;
}
/* ===== 1) Network: block TCP connect4 to specified port =====
* ctx: struct bpf_sock_addr
* user_ip4/user_port: network byte order (need conversion)
*
* Return semantics:
* - return 1: allow
* - return 0: deny (userspace gets EPERM)
*/
SEC("cgroup/connect4")
int cg_connect4(struct bpf_sock_addr *ctx)
{
if (blocked_tcp_dport == 0)
return 1;
if (ctx->protocol != IPPROTO_TCP)
return 1;
__u16 dport = bpf_ntohs((__u16)ctx->user_port);
if (dport != blocked_tcp_dport)
return 1;
struct event *e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
if (e) {
fill_common(e, EVENT_CONNECT4);
e->connect4.daddr = ctx->user_ip4; /* network order */
e->connect4.dport = dport; /* host order */
e->connect4.proto = ctx->protocol;
bpf_ringbuf_submit(e, 0);
}
return 0; /* deny -> userspace gets EPERM on connect */
}
/* ===== 2) Device: block access to specified major:minor =====
* ctx: struct bpf_cgroup_dev_ctx { access_type, major, minor }
*
* Return semantics:
* - return 0: deny (userspace gets EPERM)
* - return non-zero: allow
*/
SEC("cgroup/dev")
int cg_dev(struct bpf_cgroup_dev_ctx *ctx)
{
if (blocked_dev_major == 0 && blocked_dev_minor == 0)
return 1;
if (ctx->major != blocked_dev_major || ctx->minor != blocked_dev_minor)
return 1;
struct event *e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
if (e) {
fill_common(e, EVENT_DEVICE);
e->device.major = ctx->major;
e->device.minor = ctx->minor;
e->device.access_type = ctx->access_type;
bpf_ringbuf_submit(e, 0);
}
return 0; /* deny -> -EPERM */
}
/* ===== 3) Sysctl: block reading specified sysctl =====
* ctx: struct bpf_sysctl
* Use bpf_sysctl_get_name() to get name
*
* Return semantics:
* - return 0: reject
* - return 1: proceed
* If return 0, userspace read/write returns -1 with errno=EPERM
*/
SEC("cgroup/sysctl")
int cg_sysctl(struct bpf_sysctl *ctx)
{
char name[SYSCTL_NAME_LEN];
int ret = bpf_sysctl_get_name(ctx, name, sizeof(name), 0);
if (ret < 0)
return 1;
if (denied_sysctl_name[0] == '\0')
return 1;
/* Only deny reads, allow writes (safer for testing) */
if (ctx->write)
return 1;
if (!str_eq(name, denied_sysctl_name, SYSCTL_NAME_LEN))
return 1;
struct event *e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
if (e) {
fill_common(e, EVENT_SYSCTL);
e->sysctl.write = ctx->write;
#pragma unroll
for (int i = 0; i < SYSCTL_NAME_LEN; i++) {
e->sysctl.name[i] = name[i];
if (name[i] == '\0')
break;
}
bpf_ringbuf_submit(e, 0);
}
return 0; /* deny -> -EPERM */
}
```
#### 理解 BPF 代码
这个程序的整体逻辑很清晰：三个 cgroup 钩子分别处理网络连接、设备访问和 sysctl 读写。每个钩子的工作流程都是一样的，检查当前操作是否匹配配置的阻断规则，如果匹配就通过 ringbuf 上报事件并返回 0（拒绝），否则返回 1（放行）。
`cg_connect4` 函数使用 `SEC("cgroup/connect4")` 挂载，在进程发起 IPv4 连接时触发。这里有一个重要的细节：`ctx->user_port` 是网络字节序（大端），而我们配置的端口号是主机字节序，所以必须用 `bpf_ntohs()` 转换后再比较。如果目标端口匹配我们配置的 `blocked_tcp_dport`，程序返回 0，用户态的 `connect()` 调用就会失败并返回 `EPERM`。
`cg_dev` 函数处理设备访问。它的上下文 `struct bpf_cgroup_dev_ctx` 包含三个关键字段：`major` 和 `minor` 标识设备（比如 `/dev/null` 是 1:3），`access_type` 表示访问类型（读/写/mknod）。我们只需要比较 major:minor 是否匹配配置值就行了。
`cg_sysctl` 函数拦截 `/proc/sys/` 下的 sysctl 读写。这里用 `bpf_sysctl_get_name()` 获取 sysctl 名称，格式是 `kernel/hostname` 这样的路径形式（用斜杠分隔，不是点）。我们只阻断读操作，写操作放行，这样测试更安全，不会意外改变系统配置。
程序顶部的配置项使用 `const volatile` 声明。这是 CO-RE（Compile Once, Run Everywhere）的标准模式：BPF 程序编译时这些值是默认值（0 或空字符串），用户态在 `load()` 之前通过 `skel->rodata->` 设置实际值。这样一份编译好的 BPF 程序可以用不同的配置运行。
### 用户态加载器：cgroup_guard.c
```c
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
/* cgroup_guard.c - Userspace loader for cgroup eBPF policy guard */
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <bpf/libbpf.h>
#include "cgroup_guard.skel.h"
#include "cgroup_guard.h"
static volatile sig_atomic_t exiting = 0;
static void sig_handler(int sig)
{
(void)sig;
exiting = 1;
}
static int libbpf_print_fn(enum libbpf_print_level level,
const char *format, va_list args)
{
if (level == LIBBPF_DEBUG)
return 0;
return vfprintf(stderr, format, args);
}
static void usage(const char *prog)
{
fprintf(stderr,
"Usage: %s [OPTIONS]\n"
"\n"
"Options:\n"
" -c, --cgroup PATH cgroup v2 path (default: /sys/fs/cgroup/ebpf_demo)\n"
" -p, --block-port PORT block TCP connect() to this dst port (IPv4)\n"
" -d, --deny-device MAJ:MIN deny device access for (major:minor)\n"
" -s, --deny-sysctl NAME deny sysctl READ of this name\n"
" -h, --help show this help\n",
prog);
}
static int handle_event(void *ctx, void *data, size_t data_sz)
{
(void)ctx;
(void)data_sz;
const struct event *e = (const struct event *)data;
if (e->type == EVENT_CONNECT4) {
char ip[INET_ADDRSTRLEN] = {0};
struct in_addr addr = { .s_addr = e->connect4.daddr };
inet_ntop(AF_INET, &addr, ip, sizeof(ip));
printf("[DENY connect4] pid=%u comm=%s daddr=%s dport=%u proto=%u\n",
e->pid, e->comm, ip, e->connect4.dport, e->connect4.proto);
} else if (e->type == EVENT_DEVICE) {
printf("[DENY device] pid=%u comm=%s major=%u minor=%u access_type=0x%x\n",
e->pid, e->comm, e->device.major, e->device.minor, e->device.access_type);
} else if (e->type == EVENT_SYSCTL) {
printf("[DENY sysctl] pid=%u comm=%s write=%u name=%s\n",
e->pid, e->comm, e->sysctl.write, e->sysctl.name);
}
fflush(stdout);
return 0;
}
int main(int argc, char **argv)
{
const char *cgroup_path = "/sys/fs/cgroup/ebpf_demo";
int block_port = 0;
int dev_major = 0, dev_minor = 0;
const char *deny_sysctl = NULL;
/* Parse command line arguments */
static const struct option long_opts[] = {
{ "cgroup", required_argument, NULL, 'c' },
{ "block-port", required_argument, NULL, 'p' },
{ "deny-device", required_argument, NULL, 'd' },
{ "deny-sysctl", required_argument, NULL, 's' },
{ "help", no_argument, NULL, 'h' },
{}
};
int opt;
while ((opt = getopt_long(argc, argv, "c:p:d:s:h", long_opts, NULL)) != -1) {
switch (opt) {
case 'c': cgroup_path = optarg; break;
case 'p': block_port = atoi(optarg); break;
case 'd': /* parse major:minor */ break;
case 's': deny_sysctl = optarg; break;
default: usage(argv[0]); return 1;
}
}
libbpf_set_print(libbpf_print_fn);
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
/* Create cgroup directory if needed */
mkdir(cgroup_path, 0755);
int cg_fd = open(cgroup_path, O_RDONLY | O_DIRECTORY);
if (cg_fd < 0) {
fprintf(stderr, "open(%s) failed: %s\n", cgroup_path, strerror(errno));
return 1;
}
/* Open and configure BPF skeleton */
struct cgroup_guard_bpf *skel = cgroup_guard_bpf__open();
if (!skel) {
fprintf(stderr, "cgroup_guard_bpf__open() failed\n");
close(cg_fd);
return 1;
}
/* Write .rodata configuration (must be before load) */
if (block_port > 0 && block_port <= 65535)
skel->rodata->blocked_tcp_dport = (__u16)block_port;
if (dev_major > 0 || dev_minor > 0) {
skel->rodata->blocked_dev_major = (__u32)dev_major;
skel->rodata->blocked_dev_minor = (__u32)dev_minor;
}
if (deny_sysctl) {
snprintf((char *)skel->rodata->denied_sysctl_name,
SYSCTL_NAME_LEN, "%s", deny_sysctl);
}
/* Load BPF programs into kernel */
int err = cgroup_guard_bpf__load(skel);
if (err) {
fprintf(stderr, "cgroup_guard_bpf__load() failed: %d\n", err);
goto cleanup;
}
/* Attach programs to cgroup */
struct bpf_link *link_connect = bpf_program__attach_cgroup(skel->progs.cg_connect4, cg_fd);
struct bpf_link *link_dev = bpf_program__attach_cgroup(skel->progs.cg_dev, cg_fd);
struct bpf_link *link_sysctl = bpf_program__attach_cgroup(skel->progs.cg_sysctl, cg_fd);
/* Setup ring buffer for events */
struct ring_buffer *rb = ring_buffer__new(bpf_map__fd(skel->maps.events),
handle_event, NULL, NULL);
printf("Attached to cgroup: %s\n", cgroup_path);
printf("Config: block_port=%d, deny_device=%d:%d, deny_sysctl_read=%s\n",
block_port, dev_major, dev_minor, deny_sysctl ? deny_sysctl : "(none)");
/* Main event loop */
while (!exiting) {
err = ring_buffer__poll(rb, 200 /* ms */);
if (err == -EINTR)
break;
}
ring_buffer__free(rb);
cleanup:
bpf_link__destroy(link_sysctl);
bpf_link__destroy(link_dev);
bpf_link__destroy(link_connect);
cgroup_guard_bpf__destroy(skel);
close(cg_fd);
return err ? 1 : 0;
}
```
#### 理解用户态代码
用户态加载器的核心工作是把 BPF 程序挂载到指定的 cgroup 上，然后不断轮询 ringbuf 打印被拒绝的事件。
程序首先用 `getopt_long` 解析命令行参数，获取 cgroup 路径和三个策略配置。然后用 `open()` 以 `O_RDONLY | O_DIRECTORY` 打开 cgroup 目录，拿到一个文件描述符。这个 fd 就是后面 attach 的目标，cgroup eBPF 程序是挂到 cgroup 目录上的。
接下来是 skeleton 的标准流程：`open()` 打开 BPF 对象，设置 `.rodata` 配置项，然后 `load()` 加载到内核。注意配置必须在 load 之前设置，load 之后 `.rodata` 就是只读的了。
Attach 用的是 `bpf_program__attach_cgroup(prog, cg_fd)`，把每个 BPF 程序挂载到 cgroup。这里我们挂了三个程序：connect4、dev、sysctl。挂载成功后，这个 cgroup 里的所有进程的相关操作都会经过这些 BPF 程序。
最后是事件循环。`ring_buffer__poll()` 轮询 ringbuf，每当有事件到来就调用 `handle_event` 回调打印出来。这样你就能实时看到哪些操作被拒绝了。
## 编译
```bash
cd src/cgroup
make
```
## 运行
### 终端 A：启动加载器
```bash
# 阻断：TCP 端口 9090、/dev/null (1:3)、读取 kernel/hostname
sudo ./cgroup_guard \
--cgroup /sys/fs/cgroup/ebpf_demo \
--block-port 9090 \
--deny-device 1:3 \
--deny-sysctl kernel/hostname
```
你应该看到：
```
Attached to cgroup: /sys/fs/cgroup/ebpf_demo
Config: block_port=9090, deny_device=1:3, deny_sysctl_read=kernel/hostname
Press Ctrl-C to stop.
```
### 终端 B：启动测试服务器（在 cgroup 外）
```bash
# 启动两个 HTTP 服务器
python3 -m http.server 8080 --bind 127.0.0.1 &
python3 -m http.server 9090 --bind 127.0.0.1 &
```
### 终端 C：在 cgroup 内测试
```bash
sudo bash -c '
echo $$ > /sys/fs/cgroup/ebpf_demo/cgroup.procs
echo "== TCP 测试 =="
curl -s http://127.0.0.1:8080 >/dev/null && echo "8080 OK"
curl -s http://127.0.0.1:9090 >/dev/null && echo "9090 OK (意外)" || echo "9090 被阻断 (预期)"
echo
echo "== 设备测试 =="
cat /dev/null && echo "/dev/null OK (意外)" || echo "/dev/null 被阻断 (预期)"
echo
echo "== Sysctl 测试 =="
cat /proc/sys/kernel/hostname && echo "sysctl 读取 OK (意外)" || echo "sysctl 读取被阻断 (预期)"
'
```
预期输出：
- `8080 OK` - 端口 8080 允许访问
- `9090 被阻断 (预期)` - 端口 9090 被阻断
- `/dev/null 被阻断 (预期)` - 设备 1:3 被阻断
- `sysctl 读取被阻断 (预期)` - 读取 kernel/hostname 被阻断
### 终端 A 输出（事件）
```
[DENY connect4] pid=12345 comm=curl daddr=127.0.0.1 dport=9090 proto=6
[DENY device] pid=12346 comm=cat major=1 minor=3 access_type=0x...
[DENY sysctl] pid=12347 comm=cat write=0 name=kernel/hostname
```
## 一键测试
我们提供了一个测试脚本，可以自动完成编译、启动服务器、运行测试和清理：
```bash
sudo ./test.sh
```
## 使用 bpftool 验证
```bash
sudo bpftool cgroup tree /sys/fs/cgroup/ebpf_demo
```
## 何时使用 cgroup eBPF
选择合适的技术取决于你的控制粒度需求。
cgroup eBPF 的控制粒度是**进程组**，你把进程放进 cgroup，挂上 BPF 程序，策略就对这组进程生效。这非常适合容器场景：每个容器就是一个 cgroup，你可以给不同容器设置不同的网络策略、设备权限、sysctl 访问规则。进程离开 cgroup，策略自动失效，不需要手动清理。
XDP 和 tc 的控制粒度是**网卡**。它们处理经过某个网卡的所有流量，不区分来自哪个进程。如果你需要做高性能包处理、DDoS 防护、负载均衡，XDP/tc 是更好的选择。但如果你想"只允许容器 A 访问端口 80，容器 B 可以访问任意端口"，XDP/tc 就不太方便了。
seccomp-BPF 的控制粒度是**单个进程**。它过滤系统调用，比如禁止进程调用 `fork`、`exec`、`socket`。seccomp 更底层，适合做进程沙箱。但它不能控制网络目的地址、设备 major:minor 这些高层语义。
传统的 iptables/nftables 是**全局**生效的。你配置的规则对整个系统的所有进程都有效，无法区分"这条规则只对容器 A 生效"。
总结一下：如果你需要按容器/进程组做策略，同时控制网络、设备、sysctl，并且希望策略随进程生命周期自动管理，cgroup eBPF 就是正确的选择。
## 总结
cgroup eBPF 通过将策略与进程组绑定，解决了传统全局策略无法精细控制的问题。本教程演示了三种常用的 cgroup 钩子：
- **`cgroup/connect4`**：在 TCP 连接时过滤目标端口，阻断不允许的出站连接
- **`cgroup/dev`**：在设备访问时检查 major:minor，限制对特定设备的读写
- **`cgroup/sysctl`**：在 sysctl 读写时检查名称，防止敏感配置泄露或篡改
这种"策略守卫"模式可以扩展到生产用例：容器网络策略（类似 Kubernetes NetworkPolicy）、设备隔离（GPU/TPU 独占）、安全沙箱（限制系统信息访问）。通过 ringbuf 事件上报，你还可以实现策略审计和告警。
> 如果你想深入了解 eBPF，请查看我们的教程仓库 <https://github.com/eunomia-bpf/bpf-developer-tutorial> 或访问我们的网站 <https://eunomia.dev/tutorials/>。
## 参考资料
- **内核文档：** [libbpf 程序类型](https://docs.kernel.org/bpf/libbpf/program_types.html) - 所有 cgroup 相关 section 名称
- **eBPF 文档：** [CGROUP_SOCK_ADDR](https://docs.ebpf.io/linux/program-type/BPF_PROG_TYPE_CGROUP_SOCK_ADDR/) - socket 地址钩子详解
- **eBPF 文档：** [CGROUP_DEVICE](https://docs.ebpf.io/linux/program-type/BPF_PROG_TYPE_CGROUP_DEVICE/) - 设备访问控制详解
- **eBPF 文档：** [CGROUP_SYSCTL](https://docs.ebpf.io/linux/program-type/BPF_PROG_TYPE_CGROUP_SYSCTL/) - sysctl 访问控制详解
- **教程仓库：** <https://github.com/eunomia-bpf/bpf-developer-tutorial/tree/main/src/cgroup>
完整源代码可在教程仓库中获得。需要 Linux 内核 4.10+（cgroup v2）和 libbpf。