Seccomp

#include <linux/seccomp.h>
#include <sys/prctl.h>

// 方式一：使用 prctl()
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);

// 方式二：使用 seccomp() 系统调用
#include <linux/seccomp.h>
#include <unistd.h>
#include <sys/syscall.h>

syscall(SYS_seccomp, SECCOMP_SET_MODE_STRICT, 0, NULL);

#include <stdio.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>

int main() {
    // 进入严格模式
    prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);

    // 允许：read/write/exit/sigreturn
    write(1, "Hello, Seccomp Strict!\n", 23);

    // 不允许：open() 会导致 SIGKILL
    open("/etc/passwd", O_RDONLY);  // 程序在此处被内核杀死

    return 0;
}

prctl(PR_SET_NO_NEW_PRIVS, 1);

struct seccomp_data {
    int   nr;                     /* 系统调用号 */
    __u32 arch;                   /* AUDIT_ARCH_* 值（如 AUDIT_ARCH_X86_64） */
    __u64 instruction_pointer;    /* CPU 指令指针（系统调用指令的地址） */
    __u64 args[6];                /* 最多 6 个系统调用参数 */
};

struct sock_filter {    /* 过滤器指令 */
    __u16 code;         /* 实际的操作码 */
    __u8  jt;           /* 条件为 true 时的跳转偏移 */
    __u8  jf;           /* 条件为 false 时的跳转偏移 */
    __u32 k;            /* 通用多用途字段 */
};

struct sock_fprog {
    unsigned short len;         /* 指令数量 */
    struct sock_filter *filter; /* 指向 BPF 指令数组的指针 */
};

# 查看内核支持的 Action 列表（按优先级降序）
cat /proc/sys/kernel/seccomp/actions_avail
# 输出：kill_process kill_thread trap errno user_notif trace log allow

# 配置哪些 Action 应记录日志
echo "kill_process kill_thread trap errno log" > /proc/sys/kernel/seccomp/actions_logged

# 查看进程的 seccomp 模式
cat /proc/$(pidof nginx)/status | grep Seccomp
# 输出：Seccomp:	2
# 0 = 禁用, 1 = 严格模式, 2 = 过滤模式

// 过滤器 A：禁止 mount
seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog_a);

// 过滤器 B：额外禁止 ptrace
// 结果：mount 和 ptrace 都被禁止
seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog_b);

// 通知消息
struct seccomp_notif {
    __u64 id;              /* 唯一标识符 */
    __u32 pid;             /* 触发系统调用的进程 PID */
    __u32 flags;           /* SECCOMP_NOTIF_FLAG_* */
    struct seccomp_data data; /* 系统调用数据 */
};

// 响应消息
struct seccomp_notif_resp {
    __u64 id;              /* 与通知中的 id 匹配 */
    __s64 val;             /* 返回值 */
    __s32 error;           /* errno 值（0 = 成功） */
    __u32 flags;           /* 响应标志 */
};

// 1. 安装过滤器时获取通知 fd
struct sock_fprog prog = { ... };
int notify_fd = seccomp(
    SECCOMP_SET_MODE_FILTER,
    SECCOMP_FILTER_FLAG_NEW_LISTENER,
    &prog
);

// 2. 循环接收通知
struct seccomp_notif req;
while (1) {
    memset(&req, 0, sizeof(req));
    ioctl(notify_fd, SECCOMP_IOCTL_NOTIF_RECV, &req);

    // 3. 根据 req.data 做出决策
    // 例如：检查 mount 的目标路径是否在白名单中
    struct seccomp_notif_resp resp = {
        .id = req.id,
        .val = 0,     // 返回值
        .error = 0,   // 0 = 成功, 非 0 = errno
        .flags = 0,
    };

    // 4. 发送响应
    ioctl(notify_fd, SECCOMP_IOCTL_NOTIF_SEND, &resp);
}

// 原子性地添加 fd 并发送响应
struct seccomp_notif_addfd addfd = {
    .id = req.id,
    .flags = SECCOMP_ADDFD_FLAG_SEND,    // 原子操作
    .srcfd = fd_to_inject,                // 要注入的 fd
    .newfd = 0,                           // 目标进程中的新 fd 号
};
ioctl(notify_fd, SECCOMP_IOCTL_NOTIF_ADDFD, &addfd);

#include <linux/seccomp.h>
#include <unistd.h>
#include <sys/syscall.h>

int syscall(SYS_seccomp,
    unsigned int operation,   /* 操作类型 */
    unsigned int flags,       /* 操作标志 */
    void *args);              /* 参数指针 */

#include <sys/prctl.h>
#include <linux/seccomp.h>

// 进入严格模式
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);

// 安装过滤器（无法使用 flags）
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

// 获取当前 seccomp 模式
int mode = prctl(PR_GET_SECCOMP);

# Ubuntu/Debian
sudo apt install libseccomp-dev libseccomp2

# CentOS/RHEL
sudo yum install libseccomp-devel

# 编译时链接
gcc -o myapp myapp.c -lseccomp

#include <seccomp.h>

// 创建过滤器上下文
scmp_filter_ctx seccomp_init(uint32_t def_action);

// 添加规则
int seccomp_rule_add(
    scmp_filter_ctx ctx,
    uint32_t action,      // 匹配时的动作
    int syscall,          // 系统调用号
    unsigned int arg_cnt, // 参数比较器数量
    ...                   // 比较器列表（成对出现：arg_index, cmp_op, value）
);

// 加载过滤器到内核
int seccomp_load(scmp_filter_ctx ctx);

// 释放上下文
void seccomp_release(scmp_filter_ctx ctx);

// 获取系统调用号
int seccomp_syscall_resolve_name(const char *name);

// 获取架构
uint32_t seccomp_arch_native(void);

// 导出为 BPF 程序（用于保存或传输）
int seccomp_export_bpf(scmp_filter_ctx ctx, int fd);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <sys/syscall.h>
#include <errno.h>

/* BPF 指令宏 */
#define BPF_LABEL(label)       JUMP_JT, JUMP_JF, label, label
#define JUMP_JT                0x00
#define JUMP_JF                0x00

/* 检查架构是否为 x86_64 */
#define ARCH_NR                AUDIT_ARCH_X86_64
#define syscall_nr             (offsetof(struct seccomp_data, args[0]))
#define arch_nr                (offsetof(struct seccomp_data, arch))

#define VALIDATE_ARCHITECTURE \
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, arch_nr), \
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ARCH_NR, 1, 0), \
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL_PROCESS)

#define EXAMINE_SYSCALL \
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, syscall_nr)

#define ALLOW_SYSCALL(name) \
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_##name, 0, 1), \
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW)

#define KILL_PROCESS \
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL_PROCESS)

int main(int argc, char *argv[]) {
    struct sock_filter filter[] = {
        /* 1. 验证架构 */
        VALIDATE_ARCHITECTURE,

        /* 2. 加载系统调用号 */
        EXAMINE_SYSCALL,

        /* 3. 白名单：允许的系统调用 */
        ALLOW_SYSCALL(read),
        ALLOW_SYSCALL(write),
        ALLOW_SYSCALL(exit_group),

        /* 4. 默认拒绝所有其他系统调用 */
        KILL_PROCESS,
    };

    struct sock_fprog prog = {
        .len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),
        .filter = filter,
    };

    /* 先设置 no_new_privs */
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
        perror("prctl(PR_SET_NO_NEW_PRIVS)");
        exit(EXIT_FAILURE);
    }

    /* 安装 seccomp 过滤器 */
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {
        perror("prctl(PR_SET_SECCOMP)");
        exit(EXIT_FAILURE);
    }

    /* 过滤器安装后：以下只有 read/write/exit_group 可用 */
    write(1, "Hello from seccomp sandbox!\n", 28);

    /* 尝试调用 open() —— 会被杀死 */
    // open("/etc/passwd", O_RDONLY);  /* 取消注释将导致 SIGSYS */

    return 0;
}

gcc -o seccomp_raw seccomp_raw.c
./seccomp_raw
# 输出：Hello from seccomp sandbox!
# 如果取消注释 open() 行，程序将被内核杀死

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <seccomp.h>

int main(int argc, char *argv[]) {
    int rc;

    /* 初始化过滤器：默认杀死进程 */
    scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL);
    if (ctx == NULL) {
        perror("seccomp_init");
        exit(EXIT_FAILURE);
    }

    /* 添加白名单：允许的系统调用 */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fstat), 0);    /* write 内部需要 */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mmap), 0);     /* 内存映射 */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);      /* 堆管理 */

    /* 加载过滤器到内核 */
    rc = seccomp_load(ctx);
    if (rc < 0) {
        fprintf(stderr, "seccomp_load failed: %d\n", rc);
        seccomp_release(ctx);
        exit(EXIT_FAILURE);
    }

    /* 过滤器已生效 */
    write(STDOUT_FILENO, "Sandboxed with libseccomp!\n", 27);

    seccomp_release(ctx);
    return 0;
}

gcc -o seccomp_lib seccomp_lib.c -lseccomp
./seccomp_lib
# 输出：Sandboxed with libseccomp!

#include <seccomp.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL);
    if (!ctx) { perror("init"); exit(1); }

    /* 允许 write() 到 stdout (fd=1) */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 1,
                     SCMP_A0(SCMP_CMP_EQ, 1));  /* arg[0] = fd = 1 */

    /* 允许 exit_group */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);

    /* 基础内存和 I/O 调用 */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mmap), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fstat), 0);
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);

    seccomp_load(ctx);

    /* 只允许写入 stdout */
    write(1, "This goes to stdout\n", 20);
    write(2, "This goes to stderr\n", 20);  /* 被杀死！*/

    seccomp_release(ctx);
    return 0;
}

# Docker 源码中的默认配置
# https://github.com/moby/moby/blob/master/profiles/seccomp/default.json

{
  "defaultAction": "SCMP_ACT_ALLOW",
  "syscalls": [
    { "names": ["ptrace", "kexec_load", "reboot"], "action": "SCMP_ACT_ERRNO" },
    { "names": ["mount"], "action": "SCMP_ACT_ERRNO" }
  ]
}

{
  "defaultAction": "SCMP_ACT_ERRNO",
  "architectures": ["SCMP_ARCH_X86_64"],
  "syscalls": [
    {
      "names": [
        "accept", "bind", "brk", "close", "connect",
        "execve", "exit_group", "fcntl", "fstat",
        "futex", "getdents64", "ioctl", "listen",
        "lseek", "mmap", "mprotect", "munmap",
        "openat", "poll", "read", "rt_sigaction",
        "socket", "stat", "write"
      ],
      "action": "SCMP_ACT_ALLOW"
    }
  ]
}

# 使用自定义 seccomp 配置运行容器
docker run --rm -it \
  --security-opt seccomp=custom-seccomp.json \
  nginx

# 完全禁用 seccomp（仅调试用）
docker run --rm -it \
  --security-opt seccomp=unconfined \
  alpine sh

# 查看 seccomp 拦截日志
dmesg | grep -i seccomp

# 使用 strace 发现被拦截的系统调用
strace -c -f docker run --rm nginx 2>&1 | grep -i "operation not permitted"

# 查看 JIT 是否启用
cat /proc/sys/net/core/bpf_jit_enable
# 0 = 禁用, 1 = 启用

# 启用 JIT（需要 root）
echo 1 > /proc/sys/net/core/bpf_jit_enable

seccomp(SECCOMP_SET_MODE_FILTER, SECCOMP_FILTER_FLAG_TSYNC, &prog);
// 如果任何线程无法同步（例如已经处于严格模式），调用返回失败

# 跟踪所有系统调用
strace -c ./myapp

# 仅跟踪特定调用
strace -e trace=openat,read,write,mmap ./myapp

# 输出到文件分析
strace -o trace.log -f ./myapp

# 提取唯一的系统调用名称
strace -c ./myapp 2>&1 | tail -n +4 | awk '{print $NF}' | sort -u

{
  "defaultAction": "SCMP_ACT_ALLOW",
  "syscalls": [
    {
      "names": ["ptrace", "mount", "kexec_load"],
      "action": "SCMP_ACT_LOG"
    }
  ]
}

# 内核日志
dmesg | grep -i seccomp

# systemd 日志
journalctl -k | grep -i seccomp

# 实时监控
dmesg -w | grep seccomp