[原创]Seccomp BPF与容器安全-二进制漏洞-看雪安全社区

[原创]Seccomp BPF与容器安全

发表于: 2022-6-30 10:40 25130

[原创]Seccomp BPF与容器安全

ZxyNull

2022-6-30 10:40

25130

本文详细介绍了关于seccomp的相关概念，包括seccomp的发展历史、Seccomp BPF的实现原理以及与seccomp相关的一些工具等。此外，通过实例验证了如何使用seccomp bpf 来保护Docker的安全。

seccomp（全称securecomputing mode）是linux kernel支持的一种安全机制。在Linux系统里，大量的系统调用（systemcall）直接暴露给用户态程序。但是，并不是所有的系统调用都被需要，而且不安全的代码滥用系统调用会对系统造成安全威胁。通过seccomp，我们限制程序使用某些系统调用，这样可以减少系统的暴露面，同时是程序进入一种“安全”的状态。

2005年，Linux 2.6.12中的引入了第一个版本的seccomp，通过向/proc/PID/seccomp接口中写入“1”来启用过滤器，最初只有一个模式：严格模式（strict mode），该模式下只允许被限制的进程使用4种系统调用：read(), write(), _exit(), 和 sigreturn() ，需要注意的是，open()系统调用也是被禁止的，这就意味着在进入严格模式之前必须先打开文件。一旦为程序施加了严格模式的seccomp，对于其他的所有系统调用的调用，都会触发SIGKILL并立即终止进程。

2007年，Linux 2.6.23 内核使用prctl（）操作代替了/proc/PID/seccomp接口来施加seccomp，通过Prctl (PR_SET_SECCOMP,arg)修改调用者的seccomp模式；prctl(PR_GET_SECCOMP)用来获取seccomp的状态，返回值为0时代表进程没有被施加seccomp，但是如果进程配置了seccomp，则会由于不能调用prctl(）导致进程中止，那就没有其他返回值了？？

2012年，Linux 3.5引入了”seccomp mode 2“，为seccomp带来了一种新的模式：过滤模式（ filter mode ），该模式使用 Berkeley 包过滤器 (BPF) 程序过滤任意系统调用及其参数,使用该模式，进程可以使用 prctl (PR_SET_SECCOMP, SECCOMP_MODE_FILTER, ...)来指定允许哪些系统调用。现在已经有许多应用使用 seccomp 过滤器来对系统调用进行控制，包括 Chrome/Chromium 浏览器、OpenSSH、vsftpd 和 Firefox OS 。

2013年，Linux 3.8版本，在/proc/PID/status中添加了一个Seccomp字段，可以通过读取该文件获取对应进程的 seccomp 模式的状态（0 表示禁用，1 表示严格，2 表示过滤）。

2014年，Linux 3.17 引入了seccomp()系统调用，seccomp()在prctl()的基础上提供了现有功能的超集，增加了将进程中的所有线程同步到同一组过滤器的能力，这有助于确保即使在施加seccomp过滤器之前创建的线程仍然有效。

seccomp 过滤模式允许开发人员编写 BPF 程序来确定是否允许给定的系统调用，基于系统调用号和参数（寄存器）值进行过滤。当使用seccomp()或prctl()对进程施加seccomp 时，需要提前将编写好的BPF程序安装到内核，之后每次系统调用都会经过该过滤器。而且此过程是不可逆的，因为安装过滤器实际上是声明任何后续执行的代码都不可信。

BPF在1992年的tcpdump程序中首次提出，tcpdump是一个网络数据包的监控工具，但是由于数据包的数量很大，而且将内核空间捕获到的数据包传输到用户空间会带来很多不必要的性能损耗，所以要对数据包进行过滤，只保留感兴趣的那一部分，而在内核中过滤感兴趣的数据包比在用户空间中进行过滤更有效。BPF 就是提供了一种进行内核过滤的方法，因此用户空间只需要处理经过内核过滤的后感兴趣的数据包。

BPF定义了一个可以在内核内实现的虚拟机(VM)。该虚拟机有以下特性：

BPF 程序在Linux内核中主要在filter.h和bpf_common.h中实现，主要的数据结构包括以下几个：

Linux v5.18.4/include/uapi/linux/filte.h -> sock_fprog

这个结构体记录了过滤规则个数与规则数组起始位置 , 而 filter 域指向了具体的规则，每一条规则的形式如下：

Linux v5.18.4/include/uapi/linux/filte.h -> sock_filter

该规则有四个参数，code：过滤指令；jt:条件真跳转；jf：条件假跳转；k：操作数

BPF的指令集比较简单，主要有以下几个指令：

如何编写BPF程序呢？BPF指令可以手工编写，但是，开发人员定义了符号常量和两个方便的宏BPF_STMT和BPF_JUMP可以用来方便的编写BPF规则。

Linux v5.18.4/include/uapi/linux/filte.h -> BPF_STMT&BPF_JUMP

BPF_STMT有两个参数，操作码(code)和值(k)，举个例子：

这里的操作码是由三个指令相或组成的，BPF_LD: 建一个 BPF 加载操作；BPF_W:操作数大小是一个字，BPF_ABS: 使用绝对偏移，即使用指令中的值作为数据区的偏移量,该值是体系结构字段与数据区域的偏移量。offsetof()生成数据区域中期望字段的偏移量。

该指令的功能是将体系架构数加载到累加器中。

BPF_JUMP

BPF_JUMP 中有四个参数：操作码、值(k)、为真跳转(jt)和为假跳转(jf)，举个例子：

BPF_JMP | BPF JEQ会创建一个相等跳转指令，它将指令中的值（即第二个参数AUDIT_ARCH_X86_64）与累加器中的值（BPF_K）进行比较。判断是否相等，也就是说，如果架构是 x86-64，则跳过下一条指令（jt=1，代表测试为真跳过一条指令），否则将执行下一条指令（jf=0，代表如果测试为假，则跳过0条指令，也就是继续执行下一条指令）。

上面这两条指令常用作系统架构的验证。

再举个实际例子，该示例用作过滤execve系统调用的过滤规则：

在bpf_common.h中给出了BPF_STMT和BPF_JUMP相关的操作码:

与seccomp相关的定义大多数在seccomp.h中定义。

一旦为程序配置了seccomp-BPF，每个系统调用都会经过seccomp过滤器，这在一定程度上会影响系统的性能。此外，Seccomp过滤器会向内核返回一个值，指示是否允许该系统调用，该返回值是一个 32 位的数值，其中最重要的 16 位（SECCOMP_RET_ACTION掩码）指定内核应该采取的操作，其他位（SECCOMP_RET_DATA 掩码）用于返回与操作关联的数据。

每一个seccomp-BPF程序都使用seccomp_data结构作为输入参数：

/include/uapi/linux/seccomp.h :

prctl 函数是为进程制定而设计的，该函数原型如下

其中明确指定哪种种操作在于option选项， option有很多，与seccomp有关的option主要有两个： PR_SET_NO_NEW_PRIVS()和PR_SET_SECCOMP()。

PR_SET_NO_NEW_PRIVS()：是在Linux 3.5 之后引入的特性，当一个进程或者子进程设置了PR_SET_NO_NEW_PRIVS 属性,则其不能访问一些无法共享的操作，如setuid、chroot等。配置seccomp-BPF的程序必须拥有Capabilities 中的CAP_SYS_ADMIN，或者程序已经定义了no_new_privs属性。若不这样做非 root 用户使用该程序时 seccomp保护将会失效，设置了 PR_SET_NO_NEW_PRIVS 位后能保证 seccomp 对所有用户都能起作用

如果将其第二个参数设置为1，则这个操作能保证seccomp对所有用户都能起作用，并且会使子进程即execve后的进程依然受到seccomp的限制。

PR_SET_SECCOMP()：为进程设置seccomp；通常的形式如下

SECCOMP_MODE_FILTER参数表示设置的seccomp的过滤模式，如果设置为SECCOMP_MODE_STRICT，则代表严格模式；若为过滤模式，则对应的系统调用限制通过&prog结构体定义（上面提到过的 struct sock_fprog）。

严格模式的简单示例

在严格模式下，进程可用的系统调用只有4个，因为open()也被禁用，所有在进入严格模式前，需要先打开文件，简单的示例如下：

seccomp_strict.c：

代码功能实现简单的文件复制，当seccomp施加严格模式的时候运行时，seccomp 会在执行open(argv[1], O_RDONLY)函数调用时终止应用程序。

过滤模式的简单示例

通过上面的介绍和程序流，如果我们想要为一个程序施加seccomp-BPF策略，那可以分为以下几个步骤，首先定义filter数组，之后定义prog参数，最后使用prctl施加策略。

示例一：禁止execve系统调用

seccomp_filter_execv.c:

示例二：

seccomp_filter.c:

在这种情况下，在这种情况下，seccomp-BPF 程序将允许使用 O_RDONLY 参数打开第一个调用 , 但是在使用 O_WRONLY | O_CREAT 参数调用 open 时终止程序。

项目地址：libseccomp：04bK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6K6k6h3y4U0L8$3#2H3i4K6u0r3L8r3W2T1M7$3g2U0j5$3!0E0M7l9`.`.

基于prctl()函数的机制不够灵活，libseccomp库可以提供一些函数实现prctl类似的效果，库中封装了一些函数，可以不用了解BPF规则而实现过滤。但是在c程序中使用它，需要装一些库文件：

使用示例：

simple_syscall_seccomp.c：

编译运行, 在执行 execve 时程序报错退出 :

解释一下上诉代码：

scmp_filter_ctx : 过滤器的结构体

seccomp_init : 初始化的过滤状态 ,函数原型：

可选的def_action有：

seccomp_rule_add ：添加一条规则，函数原型为：

其中arg_cnt参数表明是否需要对对应系统调用的参数做出限制以及指示做出限制的个数，如果仅仅需要允许或者禁止所有某个系统调用，arg_cnt直接传入0即可，如 seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0) 即禁用execve，不管其参数如何。如果arg_cnt的参数不为0，那 arg_cnt 表示后面限制的参数的个数，也就是只有调用 execve，且参数满足要求时，才会拦截 syscall 。如果想要更细粒度的过滤系统调用，把参数也考虑进去,就要设置arg_cnt不为零，然后在利用宏做一些过滤。

举个例子，拦截 write 函数参数大于 0x10 时的系统调用：

seccomp_write_limit.c：

编译执行

其中SCMP_A2代表为第二个参数指定比较结构，SCMP_CMP_GT代表大于(greater than)，详细内容如下。

libseccmop/include/seccomp.h.in：

除了seccomp_rule_add之外，还有其他添加规则的函数，如：seccomp_rule_add_array ()、 seccomp_rule_add_exact ()和seccomp_rule_add_exact_array ()，详细信息可查看参考链接。

seccomp_load：将当前的 seccomp 过滤器加载到内核中，函数原型：

seccomp_reset : 释放现有的过滤上下文重新初始化之前的状态，并且只能在成功调用seccomp_init () 之后才能使用。

seccomp-bpf.h是由开发人员编写的一个十分便捷的头文件用于开发seccomp-bpf 。该头文件已经定义好了很多常见的宏，如验证系统架构、允许系统调用等功能，十分便捷，如下所示。

应用示例：

seccomp_policy.c

执行结果

一款用于分析seccomp的开源工具，项目地址：d85K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6V1j5i4k6A6k6o6V1@1x3X3A6Q4x3V1k6K6k6h3y4U0L8$3#2H3i4K6u0V1N6r3!0G2L8s2x3`.

主要功能：

安装

使用

从输出中可知禁用了execve系统调用。

Seccomp技术被用在很多应用程序上以保护系统的安全性，Docker支持使用seccomp来限制容器的系统调用，不过需要启用内核中的CONFIG_SECCOMP。

当使用docker run 启动一个容器时，Docker会使用默认的seccomp配置文件来对容器施加限制策略，该默认文件是以json格式编写，在 300 多个系统调用中禁用了大约 44 个系统调用，可以在Moby项目中找到该源码。

Docker中默认的配置文件提供了最大限度的包容性，除了默认的选择之外，Docker允许我们自定义该配置文件来灵活的对容器的系统调用进行限制。

示例：以白名单的形式允许特定的系统调用

example.json

这样，在使用 docker run 运行容器时，就可以使用 --security-opt 选项指定该配置文件来对容器进行系统调用定制。

举例，禁止容器创建文件夹，就可以用黑名单的形式禁用mkdir系统调用

seccomp_mkdir.json:

使用该策略启动容器，并在容器中创建文件夹时，就会收到禁止信息，不允许创建文件夹。

当然也可以不适用任何seccomp策略启动容器，只需要在启动选项中加上--security-opt seccomp=unconfined即可。

zaz seccomp 是一个可以为容器自动生成json格式的seccomp文件的开源工具，项目地址：faaK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6H3K9X3u0Y4k6W2)9J5c8Y4A6S2P5W2!0q4x3#2)9^5x3q4)9^5x3R3`.`.

主要用法为

它能够为特定的可执行文件定制系统调用，以只允许特定的操作，禁止其他操作

举个例子：为alpine中的ping命令生成seccomp配置文件

如上所示，zaz检测到了33个系统调用，使用白名单的形式过滤系统调用。那它以白名单的形式生成的系统调用能否很好的过滤系统系统呢？是否能够满足运行ping命令，而不能运行除了它允许的系统调用之外的命令呢？做个测试，首先用下面Dockerfile构建一个简单的镜像。

Dockerfile

构建成功后，使用默认的seccomp策略启动容器，没有任何问题，可以运行。

接着我们使用上述zaz生成的策略试试，

容器并没有成功启动，在创建OCI的时候就报错了，报错原因是operation not permitted,这个报错上面似乎提到过，是想要使用的系统调用被禁用的缘故，可能zaz这种白名单的模式鲁棒性还是不够强，而且Docker更新那么多次，zaz缺乏维护导致捕获的系统调用不足，在容器启动过程中出现了问题。奇怪的是，当我在此运行同样的命令，却引发了panic报错：No error following JSON procError payload。

这种报错或许是不应该的，我尝试在网上寻找报错的相关信息，类似的情况很少，而且并不是每次运行都是出现这种panic，正常情况下应该是operation not permitted，这是由于我们的白名单没有完全包括必须的系统调用导致的。目前将此情况汇报给了Moby issue，或许能够得到一些解答。

类似panic信息：

ba0K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6T1N6h3N6*7K9h3I4D9j5g2)9J5k6i4u0W2k6r3S2S2N6q4)9J5k6h3y4G2L8g2)9J5c8Y4y4Z5L8%4N6Q4y4h3k6T1N6h3N6Q4x3X3g2U0k6$3W2Q4x3@1k6X3L8%4u0E0j5i4c8Q4x3@1c8E0N6h3I4@1K9i4m8D9k6g2)9J5y4X3q4E0M7q4)9K6b7X3W2V1i4K6y4p5x3e0M7I4y4o6p5^5x3H3`.`.

无论是哪种报错，看起来都是runc出了问题，尝试解决这个问题，我们就要知道Docker到底是如何在运行时加载seccomp？

当我们要创建一个容器的时候，容器守护进程 Dockerd会请求 containerd 来创建一个容器， containerd 收到请求后，也并不会直接去操作容器，而是创建一个叫做 containerd-shim 的进程，让这个进程去操作容器，之后containerd-shim会通过OCI去调用容器运行时runc来启动容器， runc 启动完容器后本身会直接退出，containerd-shim 则会成为容器进程的父进程, 负责收集容器进程的状态, 上报给 containerd, 并在容器中 pid 为 1 的进程退出后接管容器中的子进程进行清理, 确保不会出现僵尸进程。也就是说调用顺序为

启动一个容器ubuntu，并在容器中再运行一个bash

查看调用栈，containerd-shim（28051-28129）并没有被施加seccomp,而容器内的两个bash（1 -> 28075;9->28126）被施加了seccomp策略。

也就是说对容器施加seccomp 是在container-shim启动之后，在调用runc的时候出现了问题，是否我们的seccomp策略也要将runc所必须的系统调用考虑进去呢？Zaz是否考虑了容器启动时候的runc所必须的系统调用?

这就需要捕获容器在启动时，runc所必要的系统调用了。

为了获取容器运行时runc用了哪些系统调用，可以有很多方法，比如ftrace、strace、fanotify等，这里使用sysdig来监控容器的运行，sisdig时一款原生支持容器的系统可见性工具，项目地址：55dK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6V1M7X3q4A6L8%4y4Q4x3V1k6K6P5i4y4V1K9h3N6Q4c8e0y4Q4z5o6m8Q4z5o6u0Q4c8e0g2Q4z5o6g2Q4b7U0N6Q4c8e0c8Q4b7V1c8Q4z5e0y4Q4c8e0N6Q4z5f1q4Q4z5o6c8Q4c8e0g2Q4b7f1g2Q4z5o6W2Q4c8e0S2Q4b7e0y4Q4z5o6g2Q4c8e0g2Q4z5e0u0Q4z5p5y4Q4c8e0c8Q4b7V1c8Q4b7V1k6Q4c8e0N6Q4z5e0c8Q4b7e0S2Q4c8e0k6Q4z5e0k6Q4b7U0W2Q4c8e0k6Q4b7U0y4Q4z5e0g2Q4c8e0g2Q4z5p5k6Q4b7f1k6Q4c8e0c8Q4b7V1u0Q4b7e0g2Q4c8e0g2Q4z5p5k6Q4z5o6u0Q4c8e0S2Q4z5o6m8Q4z5o6y4s2K9i4c8t1N6h3u0Q4c8e0c8Q4b7U0S2Q4z5p5q4Q4c8e0N6Q4b7V1u0Q4z5e0W2Q4c8e0g2Q4z5o6N6Q4b7V1q4Q4c8e0N6Q4z5f1q4Q4z5o6c8Q4c8e0S2Q4b7f1k6Q4b7e0k6Q4c8e0N6Q4b7V1u0Q4z5o6k6Q4c8e0k6Q4z5e0g2Q4z5e0W2Q4c8e0N6Q4b7e0S2Q4z5p5u0Q4c8f1k6Q4b7V1y4Q4z5p5y4Q4c8e0S2Q4b7V1k6Q4z5e0W2Q4c8e0W2Q4z5o6N6Q4z5p5y4Q4c8e0g2Q4z5p5k6Q4b7f1q4Q4c8e0g2Q4z5o6q4Q4z5f1q4Q4c8e0N6Q4b7f1g2Q4z5o6m8Q4c8e0g2Q4z5p5c8Q4z5e0g2Q4c8e0c8Q4b7V1u0Q4z5p5u0Q4c8e0N6Q4b7V1u0Q4z5p5c8Q4c8e0y4Q4z5o6m8Q4z5o6t1`.

安装完成后，直接在命令行运行sysdig，不加任何参数， sysdig 会捕获所有的事件并将其写入标准输出：

默认情况下，sysdig 在一行中打印每个事件的信息，格式如下

%evt.num %evt.time %evt.cpu %proc.name (%thread.tid) %evt.dir %evt.type %evt.args

其中

启动一个终端A，输入以下命令进行监控，container.name指定捕获容器名为ping，proc.name指定进程名为runc的包，保存为runc.scap.

接着在另一个终端B启动该容器

执行完毕后，在终端A使用ctrl+c停止捕获，并筛选捕获的内容，只留系统调用，将结果保存到runc_syscall.txt中，这样我们就得到了启动容器时runc使用了哪些系统调用。

可以发现筛选出的系统调用数还是有很多的，其中包含很多重复的系统调用，这里可以简单的写一个脚本，进行过滤，通过过滤后，一共有72个系统调用。

将zaz生成的系统调用与我们捕获的系统调用合二为一，系统调用数到了85个。如下：

通过该文件再次运行容器，发现可以成功运行！

尝试运行其他命令，有些命令由于缺乏必须的系统调用，会出现Operation not permitted的报错。

本文记录了在学习seccomp过程中的相关内容，其中的一些观点难免会有一些问题，若有错误或者建议，烦请批评指正。

BPF操作码

1efK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4M7K6i4K6u0W2M7r3S2&6M7$3&6W2N6q4)9J5k6i4g2F1K9g2)9J5k6r3S2S2L8h3u0#2M7X3N6Q4x3X3g2V1k6g2)9J5c8Y4m8Z5P5i4y4F1k6i4c8Q4x3V1k6f1M7Y4f1$3y4q4)9J5k6q4g2F1K9i4S2Q4x3V1k6t1g2p5#2x3i4K6u0r3e0f1q4z5i4K6u0r3e0f1q4z5y4#2)9J5c8U0l9H3x3e0t1`.__.HTM

seccomp_rule_add

0f1K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6E0j5h3^5%4i4K6u0W2L8%4u0Y4i4K6u0r3L8r3W2F1N6i4S2Q4x3V1k6E0j5h3&6Q4x3X3c8H3j5h3N6W2M7#2)9J5c8X3#2S2L8U0y4Q4x3V1k6K6k6h3y4U0L8$3#2H3i4K6g2X3M7Y4g2D9k6g2)9#2k6X3q4V1k6q4)9J5k6e0y4Q4x3X3g2Z5N6r3#2D9

seccomp和seccomp bfp

e76K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6S2K9Y4S2U0K9r3q4H3L8h3q4F1i4K6u0W2k6$3W2@1K9s2g2T1i4K6u0W2K9h3!0Q4x3V1k6D9K9h3&6#2P5q4)9J5c8U0t1H3x3e0k6Q4x3V1j5H3z5q4)9J5c8U0x3I4i4K6u0r3M7$3g2U0j5$3!0E0M7q4)9J5k6r3q4F1k6q4)9J5k6s2y4W2j5$3y4G2L8i4m8Q4x3X3c8T1M7r3k6Q4x3X3g2Z5N6r3#2D9

seccomp 概述

2d3K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6D9N6$3&6Q4x3X3g2F1k6i4c8Q4x3V1k6m8M7Y4c8A6j5$3I4W2M7#2)9J5c8U0j5#2y4U0x3H3y4#2)9J5c8R3`.`.

seccomp沙箱机制 & 2019ByteCTF VIP

https://bbs.pediy.com/thread-258146.htm

prctl(2) — Linux manual page

30bK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6E0j5h3^5%4i4K6u0W2L8%4u0Y4i4K6u0r3L8r3W2F1N6i4S2Q4x3V1k6E0j5h3&6Q4x3X3c8H3j5h3N6W2M7#2)9J5c8X3#2S2L8U0u0Q4x3V1k6H3M7X3y4@1L8q4)9J5k6e0u0Q4x3X3g2Z5N6r3#2D9

seccomp-tools

5d4K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6V1j5i4k6A6k6o6V1@1x3X3A6Q4x3V1k6K6k6h3y4U0L8$3#2H3i4K6u0V1N6r3!0G2L8s2x3`.

libseccomp

beeK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6K6k6h3y4U0L8$3#2H3i4K6u0r3L8r3W2T1M7$3g2U0j5$3!0E0M7q4)9J5c8X3u0D9L8$3u0Q4x3V1j5K6k6U0m8W2y4o6N6X3k6e0t1%4x3e0N6T1y4K6y4U0j5$3g2X3y4U0S2U0j5e0p5^5k6U0W2X3y4K6t1&6y4$3g2W2y4K6y4W2j5X3t1J5i4K6u0r3K9h3&6U0L8s2g2V1k6g2)9J5c8Y4y4W2j5$3y4G2L8i4m8Q4x3X3g2Z5i4K6u0W2K9h3^5`.

docker seccomp

e0aK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6V1L8$3y4K6i4K6u0W2k6r3!0U0K9$3g2J5i4K6u0W2j5$3!0E0i4K6u0r3k6h3&6Y4K9h3&6W2i4K6u0r3M7$3g2U0N6i4u0A6N6s2W2Q4x3V1k6K6k6h3y4U0L8$3#2H3i4K6u0r3

Docker seccomp 与OCI

8a6K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6X3L8%4u0#2L8i4y4Q4x3X3g2E0L8$3u0&6M7s2u0G2K9X3g2U0N6q4)9J5k6h3!0J5k6#2)9J5c8Y4c8Q4x3V1k6V1L8$3y4C8k6i4u0Q4x3X3c8K6k6h3y4U0L8$3#2H3i4K6u0V1M7s2u0W2N6X3g2F1N6s2y4Q4x3X3c8K6P5i4y4@1k6h3#2Q4x3X3c8U0j5h3I4D9M7#2)9J5k6r3W2K6M7%4g2W2k6q4)9J5k6r3u0&6i4K6u0V1L8$3y4A6i4K6u0V1M7Y4g2F1N6r3W2E0k6g2)9J5c8U0t1&6y4#2)9J5c8U0V1`.

/* Valid values for seccomp.mode and prctl(PR_SET_SECCOMP, <mode>) */
#define SECCOMP_MODE_DISABLED    0 /* seccomp is not in use. */
#define SECCOMP_MODE_STRICT    1 /* uses hard-coded filter. */
#define SECCOMP_MODE_FILTER    2 /* uses user-supplied filter. */

/* Valid values for seccomp.mode and prctl(PR_SET_SECCOMP, <mode>) */

#define SECCOMP_MODE_DISABLED 0 /* seccomp is not in use. */

#define SECCOMP_MODE_STRICT 1 /* uses hard-coded filter. */

#define SECCOMP_MODE_FILTER 2 /* uses user-supplied filter. */

null@ubuntu:~/seccomp$ cat /proc/1/status | grep Seccomp

Seccomp: 0

null@ubuntu:~/seccomp$ cat /proc/1/status | grep Seccomp

Seccomp: 0

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

struct sock_fprog { /* Required for SO_ATTACH_FILTER. */

unsigned short len; /* BPF指令的数量 */

struct sock_filter __user *filter; /*指向BPF数组的指针 */

};

struct sock_filter {    /* Filter block */
    __u16    code;   /* Actual filter code */
    __u8    jt;    /* Jump true */
    __u8    jf;    /* Jump false */
    __u32    k;      /* Generic multiuse field */
};

struct sock_filter { /* Filter block */

__u16 code; /* Actual filter code */

__u8 jt; /* Jump true */

__u8 jf; /* Jump false */

__u32 k; /* Generic multiuse field */

};

/*
 * Macros for filter block array initializers.
 */
#ifndef BPF_STMT
#define BPF_STMT(code, k) { (unsigned short)(code), 0, 0, k }
#endif
#ifndef BPF_JUMP
#define BPF_JUMP(code, k, jt, jf) { (unsigned short)(code), jt, jf, k }
#endif

/*

* Macros for filter block array initializers.

*/

#ifndef BPF_STMT

#define BPF_STMT(code, k) { (unsigned short)(code), 0, 0, k }

#endif

#ifndef BPF_JUMP

#define BPF_JUMP(code, k, jt, jf) { (unsigned short)(code), jt, jf, k }

#endif

BPF_STMT(BPF_LD | BPF_W | BPF_ABS,(offsetof(struct seccomp_data, arch)))

BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K ,AUDIT_ARCH_X86_64 , 1, 0)

struct sock_filter filter[] = {
    BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0),           //将帧的偏移0处，取4个字节数据，也就是系统调用号的值载入累加器
    BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1),           //当A == 59时，顺序执行下一条规则，否则跳过下一条规则，这里的59就是x64的execve系统调用号
    BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL),   //返回KILL
    BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW),  //返回ALLOW
};

struct sock_filter filter[] = {

BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0), //将帧的偏移0处，取4个字节数据，也就是系统调用号的值载入累加器

BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1), //当A == 59时，顺序执行下一条规则，否则跳过下一条规则，这里的59就是x64的execve系统调用号

BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL), //返回KILL

BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW), //返回ALLOW

};

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#ifndef _UAPI__LINUX_BPF_COMMON_H__
#define _UAPI__LINUX_BPF_COMMON_H__
 
/* Instruction classes */                    
#define BPF_CLASS(code) ((code) & 0x07)    //指定操作的类别
#define        BPF_LD        0x00               //将值复制到累加器中
#define        BPF_LDX        0x01               //将值加载到索引寄存器中
#define        BPF_ST        0x02               //将累加器中的值存到暂存器
#define        BPF_STX        0x03               //将索引寄存器的值存储在暂存器中
#define        BPF_ALU        0x04               //用索引寄存器或常数作为操作数在累加器上执行算数或逻辑运算
#define        BPF_JMP        0x05               //跳转
#define        BPF_RET        0x06               //返回
#define        BPF_MISC        0x07           // 其他类别
 
/* ld/ldx fields */
#define BPF_SIZE(code)  ((code) & 0x18)
#define        BPF_W        0x00 /* 32-bit */       //字
#define        BPF_H        0x08 /* 16-bit */       //半字
#define        BPF_B        0x10 /*  8-bit */       //字节
/* eBPF        BPF_DW        0x18    64-bit */       //双字
#define BPF_MODE(code)  ((code) & 0xe0)
#define        BPF_IMM        0x00                  //常数  
#define        BPF_ABS        0x20                  //固定偏移量的数据包数据(绝对偏移)
#define        BPF_IND        0x40                  //可变偏移量的数据包数据(相对偏移)
#define        BPF_MEM        0x60                  //暂存器中的一个字
#define        BPF_LEN        0x80                  //数据包长度
#define        BPF_MSH        0xa0
 
/* alu/jmp fields */
#define BPF_OP(code)    ((code) & 0xf0)       //当操作码类型为ALU时，指定具体运算符    
#define        BPF_ADD        0x00         
#define        BPF_SUB        0x10
#define        BPF_MUL        0x20
#define        BPF_DIV        0x30
#define        BPF_OR        0x40
#define        BPF_AND        0x50
#define        BPF_LSH        0x60
#define        BPF_RSH        0x70
#define        BPF_NEG        0x80
#define        BPF_MOD        0x90
#define        BPF_XOR        0xa0
                                               //当操作码是jmp时指定跳转类型
#define        BPF_JA        0x00
#define        BPF_JEQ        0x10
#define        BPF_JGT        0x20
#define        BPF_JGE        0x30
#define        BPF_JSET        0x40
#define BPF_SRC(code)   ((code) & 0x08)
#define        BPF_K        0x00                    //常数
#define        BPF_X        0x08                    //索引寄存器
 
#ifndef BPF_MAXINSNS
#define BPF_MAXINSNS 4096
#endif
 
#endif /* _UAPI__LINUX_BPF_COMMON_H__ */

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */

#ifndef _UAPI__LINUX_BPF_COMMON_H__

#define _UAPI__LINUX_BPF_COMMON_H__

/* Instruction classes */

#define BPF_CLASS(code) ((code) & 0x07) //指定操作的类别

#define BPF_LD 0x00 //将值复制到累加器中

#define BPF_LDX 0x01 //将值加载到索引寄存器中

#define BPF_ST 0x02 //将累加器中的值存到暂存器

#define        BPF_STX        0x03               //将索引寄存器的值存储在暂存器中

#define        BPF_ALU        0x04               //用索引寄存器或常数作为操作数在累加器上执行算数或逻辑运算

#define BPF_JMP 0x05 //跳转

#define BPF_RET 0x06 //返回

#define BPF_MISC 0x07 // 其他类别

/* ld/ldx fields */

#define BPF_SIZE(code) ((code) & 0x18)

#define BPF_W 0x00 /* 32-bit */ //字

#define BPF_H 0x08 /* 16-bit */ //半字

#define BPF_B 0x10 /* 8-bit */ //字节

/* eBPF BPF_DW 0x18 64-bit */ //双字

#define BPF_MODE(code) ((code) & 0xe0)

#define BPF_IMM 0x00 //常数

#define        BPF_ABS        0x20                  //固定偏移量的数据包数据(绝对偏移)

#define        BPF_IND        0x40                  //可变偏移量的数据包数据(相对偏移)

#define BPF_MEM 0x60 //暂存器中的一个字

#define BPF_LEN 0x80 //数据包长度

#define BPF_MSH 0xa0

/* alu/jmp fields */

#define BPF_OP(code) ((code) & 0xf0) //当操作码类型为ALU时，指定具体运算符

#define BPF_ADD 0x00

#define BPF_SUB 0x10

#define BPF_MUL 0x20

#define BPF_DIV 0x30

#define BPF_OR 0x40

#define BPF_AND 0x50

#define BPF_LSH 0x60

#define BPF_RSH 0x70

#define BPF_NEG 0x80

#define BPF_MOD 0x90

#define BPF_XOR 0xa0

//当操作码是jmp时指定跳转类型

#define BPF_JA 0x00

#define BPF_JEQ 0x10

#define BPF_JGT 0x20

#define BPF_JGE 0x30

#define BPF_JSET 0x40

#define BPF_SRC(code) ((code) & 0x08)

#define BPF_K 0x00 //常数

#define BPF_X 0x08 //索引寄存器

#ifndef BPF_MAXINSNS

#define BPF_MAXINSNS 4096

#endif

#endif /* _UAPI__LINUX_BPF_COMMON_H__ */

/*
 * All BPF programs must return a 32-bit value.
 * The bottom 16-bits are for optional return data.
 * The upper 16-bits are ordered from least permissive values to most,
 * as a signed value (so 0x8000000 is negative).
 *
 * The ordering ensures that a min_t() over composed return values always
 * selects the least permissive choice.
 */
#define SECCOMP_RET_KILL_PROCESS 0x80000000U /* kill the process */
#define SECCOMP_RET_KILL_THREAD     0x00000000U /* kill the thread */
#define SECCOMP_RET_KILL     SECCOMP_RET_KILL_THREAD
#define SECCOMP_RET_TRAP     0x00030000U /* disallow and force a SIGSYS */
#define SECCOMP_RET_ERRNO     0x00050000U /* returns an errno */
#define SECCOMP_RET_USER_NOTIF     0x7fc00000U /* notifies userspace */
#define SECCOMP_RET_TRACE     0x7ff00000U /* pass to a tracer or disallow */
#define SECCOMP_RET_LOG         0x7ffc0000U /* allow after logging */
#define SECCOMP_RET_ALLOW     0x7fff0000U /* allow */
 
/* Masks for the return value sections. */
#define SECCOMP_RET_ACTION_FULL    0xffff0000U
#define SECCOMP_RET_ACTION    0x7fff0000U
#define SECCOMP_RET_DATA    0x0000ffffU

/*

* All BPF programs must return a 32-bit value.

* The bottom 16-bits are for optional return data.

* The upper 16-bits are ordered from least permissive values to most,

* as a signed value (so 0x8000000 is negative).

*

* The ordering ensures that a min_t() over composed return values always

* selects the least permissive choice.

*/

#define SECCOMP_RET_KILL_PROCESS 0x80000000U /* kill the process */

#define SECCOMP_RET_KILL_THREAD 0x00000000U /* kill the thread */

#define SECCOMP_RET_KILL SECCOMP_RET_KILL_THREAD

#define SECCOMP_RET_TRAP 0x00030000U /* disallow and force a SIGSYS */

#define SECCOMP_RET_ERRNO 0x00050000U /* returns an errno */

#define SECCOMP_RET_USER_NOTIF 0x7fc00000U /* notifies userspace */

#define SECCOMP_RET_TRACE 0x7ff00000U /* pass to a tracer or disallow */

#define SECCOMP_RET_LOG 0x7ffc0000U /* allow after logging */

#define SECCOMP_RET_ALLOW 0x7fff0000U /* allow */

/* Masks for the return value sections. */

#define SECCOMP_RET_ACTION_FULL 0xffff0000U

#define SECCOMP_RET_ACTION 0x7fff0000U

#define SECCOMP_RET_DATA 0x0000ffffU

struct seccomp_data {
  int nr ;                    /* 系统调用号（依赖于体系架构） */
  __u32 arch ;                /* 架构（如AUDIT_ARCH_X86_64） */
  __u64 instruction_pointer ; /* CPU指令指针 */
  __u64 args [6];             /* 系统调用参数，最多有6个参数 */
};

struct seccomp_data {

int nr ; /* 系统调用号（依赖于体系架构） */

__u32 arch ; /* 架构（如AUDIT_ARCH_X86_64） */

__u64 instruction_pointer ; /* CPU指令指针 */

__u64 args [6]; /* 系统调用参数，最多有6个参数 */

};

#include <sys/prctl.h>
 
int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);

#include <sys/prctl.h>

int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);

prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);

prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
 
void configure_seccomp() {
  printf("Configuring seccomp\n");
  prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
}
 
int main(int argc, char* argv[]) {
  int infd, outfd;
  ssize_t read_bytes;
  char buffer[1024];
 
  if (argc < 3) {
    printf("Usage:\n\tdup_file <input path> <output_path>\n");
    return -1;
  }
 
  configure_seccomp(); /* 配置seccomp */
 
  printf("Opening '%s' for reading\n", argv[1]);
  if ((infd = open(argv[1], O_RDONLY)) > 0) { /* open() 被禁用，进程会在此终止*/
    printf("Opening '%s' for writing\n", argv[2]);
    if ((outfd = open(argv[2], O_WRONLY | O_CREAT, 0644)) > 0) {
        while((read_bytes = read(infd, &buffer, 1024)) > 0)
          write(outfd, &buffer, (ssize_t)read_bytes);
    }
  }
  close(infd);
  close(outfd);
  return 0;
}

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/prctl.h>

#include <linux/seccomp.h>

void configure_seccomp() {

printf("Configuring seccomp\n");

prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);

}

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

int infd, outfd;

ssize_t read_bytes;

char buffer[1024];

if (argc < 3) {

printf("Usage:\n\tdup_file <input path> <output_path>\n");

return -1;

}

configure_seccomp(); /* 配置seccomp */

printf("Opening '%s' for reading\n", argv[1]);

if ((infd = open(argv[1], O_RDONLY)) > 0) { /* open() 被禁用，进程会在此终止*/

printf("Opening '%s' for writing\n", argv[2]);

if ((outfd = open(argv[2], O_WRONLY | O_CREAT, 0644)) > 0) {

while((read_bytes = read(infd, &buffer, 1024)) > 0)

write(outfd, &buffer, (ssize_t)read_bytes);

}

close(infd);

close(outfd);

return 0;

}

null@ubuntu:~/seccomp$ gcc -o seccomp_strict seccomp_strict.c
null@ubuntu:~/seccomp$ ./seccomp_strict /etc/passwd output
Configuring seccomp
Opening '/etc/passwd' for reading
Killed

null@ubuntu:~/seccomp$ gcc -o seccomp_strict seccomp_strict.c

null@ubuntu:~/seccomp$ ./seccomp_strict /etc/passwd output

Configuring seccomp

Opening '/etc/passwd' for reading

Killed

#include <stdio.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
struct sock_filter filter[] = {
    BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0), //将帧的偏移0处，取4个字节数据，也就是系统调用号的值载入累加器
    BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1), //判断系统调用号是否为59，是则顺序执行，否则跳过下一条
    BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL), //返回KILL
    BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW), //返回ALLOW
};
struct sock_fprog prog = {
    .len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),//规则条数
    .filter = filter,                                         //结构体数组指针
};
    prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);             //设置NO_NEW_PRIVS
    prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);
    write(0,"test\n",5);
    system("/bin/sh");
    return 0;
}

#include <stdio.h>

#include <sys/prctl.h>

#include <linux/seccomp.h>

#include <linux/filter.h>

#include <stdlib.h>

#include <unistd.h>

int main()

{

struct sock_filter filter[] = {

BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0), //将帧的偏移0处，取4个字节数据，也就是系统调用号的值载入累加器

BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1), //判断系统调用号是否为59，是则顺序执行，否则跳过下一条

BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL), //返回KILL

BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW), //返回ALLOW

};

struct sock_fprog prog = {

.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),//规则条数

.filter = filter, //结构体数组指针

};

prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0); //设置NO_NEW_PRIVS

prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);

write(0,"test\n",5);

system("/bin/sh");

return 0;

}

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stddef.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/unistd.h>
 
void configure_seccomp() {
  struct sock_filter filter [] = {
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, nr))), //将系统调用号载入累加器
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_write, 0, 1), //测试系统调用号是否匹配'__NR__write',如果是允许其他syscall，如果不是则跳过下一条指令，
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_open, 0, 3),//测试是否为'__NR_open',不是直接退出，
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, args[1]))),//第二个参数送入累加器
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, O_RDONLY, 0, 1),//判断是否是'O_RDONLY'的方式，是则允许
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL)
  };
  struct sock_fprog prog = {
       .len = (unsigned short)(sizeof(filter) / sizeof (filter[0])),
       .filter = filter,
  };
 
  printf("Configuring seccomp\n");
  prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
  prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);
}
 
int main(int argc, char* argv[]) {
  int infd, outfd;
  ssize_t read_bytes;
  char buffer[1024];
 
  if (argc < 3) {
    printf("Usage:\n\tdup_file <input path> <output_path>\n");
    return -1;
  }
  printf("Ducplicating file '%s' to '%s'\n", argv[1], argv[2]);
 
  configure_seccomp(); //配置seccomp
 
  printf("Opening '%s' for reading\n", argv[1]);
  if ((infd = open(argv[1], O_RDONLY)) > 0) {
    printf("Opening '%s' for writing\n", argv[2]);
    if ((outfd = open(argv[2], O_WRONLY | O_CREAT, 0644)) > 0) {
        while((read_bytes = read(infd, &buffer, 1024)) > 0)
          write(outfd, &buffer, (ssize_t)read_bytes);
    }
  }
  close(infd);
  close(outfd);
  return 0;
}

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

#include <stddef.h>

#include <sys/prctl.h>

#include <linux/seccomp.h>

#include <linux/filter.h>

#include <linux/unistd.h>

void configure_seccomp() {

struct sock_filter filter [] = {

BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, nr))), //将系统调用号载入累加器

BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_write, 0, 1), //测试系统调用号是否匹配'__NR__write',如果是允许其他syscall，如果不是则跳过下一条指令，

BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),

BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_open, 0, 3),//测试是否为'__NR_open',不是直接退出，

BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, args[1]))),//第二个参数送入累加器

BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, O_RDONLY, 0, 1),//判断是否是'O_RDONLY'的方式，是则允许

BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),

BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL)

};

struct sock_fprog prog = {

.len = (unsigned short)(sizeof(filter) / sizeof (filter[0])),

.filter = filter,

};

printf("Configuring seccomp\n");

prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);

prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

}

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

int infd, outfd;

ssize_t read_bytes;

char buffer[1024];

if (argc < 3) {

printf("Usage:\n\tdup_file <input path> <output_path>\n");

return -1;

}

printf("Ducplicating file '%s' to '%s'\n", argv[1], argv[2]);

configure_seccomp(); //配置seccomp

printf("Opening '%s' for reading\n", argv[1]);

if ((infd = open(argv[1], O_RDONLY)) > 0) {

printf("Opening '%s' for writing\n", argv[2]);

if ((outfd = open(argv[2], O_WRONLY | O_CREAT, 0644)) > 0) {

while((read_bytes = read(infd, &buffer, 1024)) > 0)

write(outfd, &buffer, (ssize_t)read_bytes);

}

close(infd);

close(outfd);

return 0;

}

$ ./seccomp_filter /etc/passwd output
Ducplicating file '/etc/passwd' to 'output'
Configuring seccomp
Opening '/etc/passwd' for reading
Opening 'output' for writing
Bad system call

$ ./seccomp_filter /etc/passwd output

Ducplicating file '/etc/passwd' to 'output'

Configuring seccomp

Opening '/etc/passwd' for reading

Opening 'output' for writing

Bad system call

null@ubuntu:~/seccomp$ sudo apt install libseccomp-dev libseccomp2 seccomp

//gcc -g simple_syscall_seccomp.c -o simple_syscall_seccomp -lseccomp
#include <unistd.h>
#include <seccomp.h>
#include <linux/seccomp.h>
 
int main(void){
    scmp_filter_ctx ctx;
    ctx = seccomp_init(SCMP_ACT_ALLOW);
    seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);
    seccomp_load(ctx);
 
    char * filename = "/bin/sh";
    char * argv[] = {"/bin/sh",NULL};
    char * envp[] = {NULL};
    write(1,"i will give you a shell\n",24);
    syscall(59,filename,argv,envp);//execve
    return 0;
}

//gcc -g simple_syscall_seccomp.c -o simple_syscall_seccomp -lseccomp

#include <unistd.h>

#include <seccomp.h>

#include <linux/seccomp.h>

int main(void){

scmp_filter_ctx ctx;

ctx = seccomp_init(SCMP_ACT_ALLOW);

seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);

seccomp_load(ctx);

char * filename = "/bin/sh";

char * argv[] = {"/bin/sh",NULL};

char * envp[] = {NULL};

write(1,"i will give you a shell\n",24);

syscall(59,filename,argv,envp);//execve

return 0;

}

null@ubuntu:~/seccomp$ gcc -g simple_syscall_seccomp.c -o simple_syscall_seccomp -lseccomp
null@ubuntu:~/seccomp$ ./simple_syscall_seccomp
i will give you a shell
Bad system call (core dumped)

null@ubuntu:~/seccomp$ gcc -g simple_syscall_seccomp.c -o simple_syscall_seccomp -lseccomp

null@ubuntu:~/seccomp$ ./simple_syscall_seccomp

i will give you a shell

Bad system call (core dumped)

seccomp_init(uint32_t def_action)

SCMP_ACT_ALLOW：即初始化为允许所有系统调用，过滤为黑名单模式； 
SCMP_ACT_KILL：则为白名单模式过滤。
SCMP_ACT_KILL_PROCESS：整个进程将被内核终止
SCMP_ACT_TRAP:如果所有系统调用都不匹配，则给线程发送一个SIGSYS信号
SCMP_ACT_TRACE(uint16_t msg_num)：在使用ptrace根据进程时的相关选项
SCMP_ACT_ERRNO(uint16_t errno)：不匹配会收到errno的返回值
SCMP_ACT_LOG：不影响系统调用，但是会被记录；

SCMP_ACT_ALLOW：即初始化为允许所有系统调用，过滤为黑名单模式；

SCMP_ACT_KILL：则为白名单模式过滤。

SCMP_ACT_KILL_PROCESS：整个进程将被内核终止

SCMP_ACT_TRAP:如果所有系统调用都不匹配，则给线程发送一个SIGSYS信号

SCMP_ACT_TRACE(uint16_t msg_num)：在使用ptrace根据进程时的相关选项

SCMP_ACT_ERRNO(uint16_t errno)：不匹配会收到errno的返回值

SCMP_ACT_LOG：不影响系统调用，但是会被记录；

int seccomp_rule_add(scmp_filter_ctx ctx, uint32_t action,int syscall, unsigned int arg_cnt, ...);

#include <unistd.h>
#include <seccomp.h>
#include <linux/seccomp.h>
 
int main(void){
    scmp_filter_ctx ctx;
    ctx = seccomp_init(SCMP_ACT_ALLOW);
    seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(write),1,SCMP_A2(SCMP_CMP_GT,0x10));//第2(从0)个参数大于0x10
    seccomp_load(ctx);
    write(1,"1234567812345678",0x10);//不被拦截
    write(1,"i will give you a shell\n",24);//会拦截    
    return 0;
}

#include <unistd.h>

#include <seccomp.h>

#include <linux/seccomp.h>

int main(void){

scmp_filter_ctx ctx;

ctx = seccomp_init(SCMP_ACT_ALLOW);

seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(write),1,SCMP_A2(SCMP_CMP_GT,0x10));//第2(从0)个参数大于0x10

seccomp_load(ctx);

write(1,"1234567812345678",0x10);//不被拦截

write(1,"i will give you a shell\n",24);//会拦截

return 0;

}

null@ubuntu:~/seccomp$ gcc -g seccomp_write_limit.c -o seccomp_write_limit -lseccomp
null@ubuntu:~/seccomp$ ./seccomp_write_limit
1234567812345678Bad system call (core dumped)

null@ubuntu:~/seccomp$ gcc -g seccomp_write_limit.c -o seccomp_write_limit -lseccomp

null@ubuntu:~/seccomp$ ./seccomp_write_limit

1234567812345678Bad system call (core dumped)

...
...
 
/**
 * Comparison operators
 */
enum scmp_compare {
    _SCMP_CMP_MIN = 0,
    SCMP_CMP_NE = 1,        /**< not equal */
    SCMP_CMP_LT = 2,        /**< less than */
    SCMP_CMP_LE = 3,        /**< less than or equal */
    SCMP_CMP_EQ = 4,        /**< equal */
    SCMP_CMP_GE = 5,        /**< greater than or equal */
    SCMP_CMP_GT = 6,        /**< greater than */
    SCMP_CMP_MASKED_EQ = 7,        /**< masked equality */
    _SCMP_CMP_MAX,
};
 ...
 struct scmp_arg_cmp {
    unsigned int arg;    /**< argument number, starting at 0 */
    enum scmp_compare op;    /**< the comparison op, e.g. SCMP_CMP_* */
    scmp_datum_t datum_a;
    scmp_datum_t datum_b;
};
 ....
/**
 * Specify a 32-bit argument comparison struct for use in declaring rules
 * @param arg the argument number, starting at 0
 * @param op the comparison operator, e.g. SCMP_CMP_*
 * @param datum_a dependent on comparison (32-bits)
 * @param datum_b dependent on comparison, optional (32-bits)
 */
#define SCMP_CMP32(x, y, ...) \
    _SCMP_MACRO_DISPATCHER(_SCMP_CMP32_, __VA_ARGS__)(x, y, __VA_ARGS__)
 
/**
 * Specify a 64-bit argument comparison struct for argument 0
 */
#define SCMP_A0_64(...)        SCMP_CMP64(0, __VA_ARGS__)
#define SCMP_A0            SCMP_A0_64
 
/**
 * Specify a 32-bit argument comparison struct for argument 0
 */
#define SCMP_A0_32(x, ...)    SCMP_CMP32(0, x, __VA_ARGS__)
 
/**
 * Specify a 64-bit argument comparison struct for argument 1
 */
#define SCMP_A1_64(...)        SCMP_CMP64(1, __VA_ARGS__)
#define SCMP_A1            SCMP_A1_64
 
/**
 * Specify a 32-bit argument comparison struct for argument 1
 */
#define SCMP_A1_32(x, ...)    SCMP_CMP32(1, x, __VA_ARGS__)
 
/**
 * Specify a 64-bit argument comparison struct for argument 2
 */
#define SCMP_A2_64(...)        SCMP_CMP64(2, __VA_ARGS__)
#define SCMP_A2            SCMP_A2_64
 
/**
 * Specify a 32-bit argument comparison struct for argument 2
 */
#define SCMP_A2_32(x, ...)    SCMP_CMP32(2, x, __VA_ARGS__)
 
/**
 * Specify a 64-bit argument comparison struct for argument 3
 */
#define SCMP_A3_64(...)        SCMP_CMP64(3, __VA_ARGS__)
#define SCMP_A3            SCMP_A3_64
 
/**
 * Specify a 32-bit argument comparison struct for argument 3
 */
#define SCMP_A3_32(x, ...)    SCMP_CMP32(3, x, __VA_ARGS__)
 
/**
 * Specify a 64-bit argument comparison struct for argument 4
 */
#define SCMP_A4_64(...)        SCMP_CMP64(4, __VA_ARGS__)
#define SCMP_A4            SCMP_A4_64
 
/**
 * Specify a 32-bit argument comparison struct for argument 4
 */
#define SCMP_A4_32(x, ...)    SCMP_CMP32(4, x, __VA_ARGS__)
 
/**
 * Specify a 64-bit argument comparison struct for argument 5
 */
#define SCMP_A5_64(...)        SCMP_CMP64(5, __VA_ARGS__)
#define SCMP_A5            SCMP_A5_64
 
/**
 * Specify a 32-bit argument comparison struct for argument 5
 */
#define SCMP_A5_32(x, ...)    SCMP_CMP32(5, x, __VA_ARGS__)
 
     ...
     ...

...

/**

* Comparison operators

*/

enum scmp_compare {

_SCMP_CMP_MIN = 0,

SCMP_CMP_NE = 1, /**< not equal */

SCMP_CMP_LT = 2, /**< less than */

SCMP_CMP_LE = 3, /**< less than or equal */

SCMP_CMP_EQ = 4, /**< equal */

SCMP_CMP_GE = 5, /**< greater than or equal */

SCMP_CMP_GT = 6, /**< greater than */

SCMP_CMP_MASKED_EQ = 7, /**< masked equality */

_SCMP_CMP_MAX,

};

...

struct scmp_arg_cmp {

unsigned int arg; /**< argument number, starting at 0 */

enum scmp_compare op; /**< the comparison op, e.g. SCMP_CMP_* */

scmp_datum_t datum_a;

scmp_datum_t datum_b;

};

....

/**

* Specify a 32-bit argument comparison struct for use in declaring rules

* @param arg the argument number, starting at 0

* @param op the comparison operator, e.g. SCMP_CMP_*

* @param datum_a dependent on comparison (32-bits)

* @param datum_b dependent on comparison, optional (32-bits)

*/

#define SCMP_CMP32(x, y, ...) \

_SCMP_MACRO_DISPATCHER(_SCMP_CMP32_, __VA_ARGS__)(x, y, __VA_ARGS__)

/**

* Specify a 64-bit argument comparison struct for argument 0

*/

#define SCMP_A0_64(...) SCMP_CMP64(0, __VA_ARGS__)

#define SCMP_A0 SCMP_A0_64

/**

* Specify a 32-bit argument comparison struct for argument 0

*/

#define SCMP_A0_32(x, ...) SCMP_CMP32(0, x, __VA_ARGS__)

/**

* Specify a 64-bit argument comparison struct for argument 1

*/

#define SCMP_A1_64(...) SCMP_CMP64(1, __VA_ARGS__)

#define SCMP_A1 SCMP_A1_64

/**

* Specify a 32-bit argument comparison struct for argument 1

*/

#define SCMP_A1_32(x, ...) SCMP_CMP32(1, x, __VA_ARGS__)

/**

* Specify a 64-bit argument comparison struct for argument 2

*/

#define SCMP_A2_64(...) SCMP_CMP64(2, __VA_ARGS__)

#define SCMP_A2 SCMP_A2_64

/**

* Specify a 32-bit argument comparison struct for argument 2

*/

#define SCMP_A2_32(x, ...) SCMP_CMP32(2, x, __VA_ARGS__)

/**

* Specify a 64-bit argument comparison struct for argument 3

*/

#define SCMP_A3_64(...) SCMP_CMP64(3, __VA_ARGS__)

#define SCMP_A3 SCMP_A3_64

/**

* Specify a 32-bit argument comparison struct for argument 3

*/

#define SCMP_A3_32(x, ...) SCMP_CMP32(3, x, __VA_ARGS__)

/**

* Specify a 64-bit argument comparison struct for argument 4

*/

#define SCMP_A4_64(...) SCMP_CMP64(4, __VA_ARGS__)

#define SCMP_A4 SCMP_A4_64

/**

* Specify a 32-bit argument comparison struct for argument 4

*/

#define SCMP_A4_32(x, ...) SCMP_CMP32(4, x, __VA_ARGS__)

/**

* Specify a 64-bit argument comparison struct for argument 5

*/

#define SCMP_A5_64(...) SCMP_CMP64(5, __VA_ARGS__)

#define SCMP_A5 SCMP_A5_64

/**

* Specify a 32-bit argument comparison struct for argument 5

*/

#define SCMP_A5_32(x, ...) SCMP_CMP32(5, x, __VA_ARGS__)

...

int seccomp_load(scmp_filter_ctx ctx);

int seccomp_reset（scmp_filter_ctx ctx ，uint32_t def_action ）

...
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)
 
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)
...

...

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)

登录后可查看完整内容

传播安全知识、拓宽行业人脉——看雪讲师团队等你加入！

最后于 2022-7-1 14:19 被ZxyNull编辑，原因：

#漏洞分析 #Linux

收藏・20

免费・15

支持

打赏 + 50.00雪花

Editor

打赏次数 1

雪花 + 50.00

Editor

+50.00

2022/07/18

恭喜您获得“雪花”奖励，安全圈有你而精彩！

最新回复 (6)
悟皈雪币： 79 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 5 粉丝 0 关注私信	悟皈 2 楼论坛因你更精彩 2022-7-4 05:50 0
莫灰灰雪币： 2647 活跃值： (2665) 能力值： (RANK：400 ) 在线值：发帖 22 回帖 718 粉丝 54 关注私信	莫灰灰 9 3 楼写的不错，666 2022-7-5 11:13 0
飘零丶雪币： 10102 活跃值： (168735) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 21 粉丝 5 关注私信	飘零丶 4 楼感谢分享 2022-7-7 11:11 0
saloyun 雪币： 1730 活跃值： (4673) 能力值： ( LV2，RANK：10 ) 在线值：发帖 7 回帖 267 粉丝 4 关注私信	saloyun 5 楼膜拜大佬的好文章。 2022-8-22 15:31 0
mb_qmomcleg 雪币： 895 活跃值： (1204) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 31 粉丝 0 关注私信	mb_qmomcleg 6 楼 2025-3-2 16:55 0
frankpi 雪币： 244 活跃值： (576) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 26 粉丝 0 关注私信	frankpi 7 楼 636 2025-6-6 15:57 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

ZxyNull

发帖

回帖

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (6)
悟皈雪币： 79 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 5 粉丝 0 关注私信	悟皈 2 楼论坛因你更精彩 2022-7-4 05:50 0
莫灰灰雪币： 2647 活跃值： (2665) 能力值： (RANK：400 ) 在线值：发帖 22 回帖 718 粉丝 54 关注私信	莫灰灰 9 3 楼写的不错，666 2022-7-5 11:13 0
飘零丶雪币： 10102 活跃值： (168735) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 21 粉丝 5 关注私信	飘零丶 4 楼感谢分享 2022-7-7 11:11 0
saloyun 雪币： 1730 活跃值： (4673) 能力值： ( LV2，RANK：10 ) 在线值：发帖 7 回帖 267 粉丝 4 关注私信	saloyun 5 楼膜拜大佬的好文章。 2022-8-22 15:31 0
mb_qmomcleg 雪币： 895 活跃值： (1204) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 31 粉丝 0 关注私信	mb_qmomcleg 6 楼 2025-3-2 16:55 0
frankpi 雪币： 244 活跃值： (576) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 26 粉丝 0 关注私信	frankpi 7 楼 636 2025-6-6 15:57 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复