知识了解

Seccomp

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并立即终止进程。

 #include <stdio.h>
 #include <sys/prctl.h> 
 #include <linux/seccomp.h>
 ​
 int main() {
     //prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
     char *buf = "hello world!n";
     write(0,buf,0xc);
     printf("%s",buf);
 }
 // 未使用 seccomp:hello world!hello world!
 // 使用 seccomp:hello world!Killed

Seccomp-BPF

Seccomp – Berkley Packet Filter(Seccomp-BPF),它允许用户使用可配置的策略过滤系统调用,该策略使用Berkeley Packet Filter规则实现,它可以对任意系统调用及其参数(仅常数,无指针取消引用)进行过滤。Seccomp-BPF在3.5版(2012年7月21日)的Linux内核中(用于x86 / x86_64系统)和Linux内核3.10版(2013年6月30日)被引入Linux内核。

BPF 目的是为了提供一种过滤包的方法并且要避免从内核空间到用户空间的无用的数据包复制行为。它最初是由从用户空间注入到内核的一个简单的字节码构成,它在那个位置利用一个校验器进行检查 —— 以避免内核崩溃或者安全问题 —— 并附着到一个套接字上。其简化的语言以及存在于内核中的即时编译器(JIT),使 BPF 成为一个性能卓越的工具。

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

  • 简单指令集

    • 小型指令集

    • 所有的指令大小相同

    • 实现过程简单、快速

  • 只有分支向前指令

    • 程序是有向无环图(DAGs),没有循环

  • 易于验证程序的有效性/安全性

    • 简单的指令集⇒可以验证操作码和参数

    • 可以检测死代码

    • 程序必须以 Return 结束

    • BPF过滤器程序仅限于4096条指令

BPF 程序在Linux内核中主要在 filter.hbpf_common.h中实现,主要的数据结构包括以下几个:

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

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

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

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

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

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

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

  • 加载指令

  • 存储指令

  • 跳转指令

  • 算术逻辑指令

    • 包括:ADD、SUB、 MUL、 DIV、 MOD、 NEG、OR、 AND、XOR、 LSH、 RSH

  • Return 指令

  • 条件跳转指令

    • 有两个跳转目标,jt为真,jf为假

    • jmp 目标是指令偏移量,最大 255

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

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

 /*
  * 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_STMT有两个参数,操作码(code)和值(k),举个例子:

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

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

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

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

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

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

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

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

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
};

bpf_common.h中给出了 BPF_STMTBPF_JUMP相关的操作码:

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#ifndef _UAPI__LINUX_BPF_COMMON_H__
#define _UAPI__LINUX_BPF_COMMON_H__
<p>/* Instruction classes */<br />
#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           // 其他类别</p>
<p>/* ld/ldx fields <em>/
#define BPF_SIZE(code)  ((code) & 0x18)
#define     BPF_W       0x00 /</em> 32-bit <em>///字
#define     BPF_H       0x08 /</em> 16-bit <em>///半字
#define     BPF_B       0x10 /</em>  8-bit <em>///字节
/</em> eBPF     BPF_DW      0x18    64-bit */       //双字
#define BPF_MODE(code)  ((code) & 0xe0)
#define     BPF_IMM     0x00                  //常数<br />
#define     BPF_ABS     0x20                  //固定偏移量的数据包数据(绝对偏移)
#define     BPF_IND     0x40                  //可变偏移量的数据包数据(相对偏移)
#define     BPF_MEM     0x60                  //暂存器中的一个字
#define     BPF_LEN     0x80                  //数据包长度
#define     BPF_MSH     0xa0</p>
<p>/* alu/jmp fields */
#define BPF_OP(code)    ((code) & 0xf0)       //当操作码类型为ALU时,指定具体运算符<br />
#define     BPF_ADD     0x00<br />
#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                    //索引寄存器</p>
<p>#ifndef BPF_MAXINSNS
#define BPF_MAXINSNS 4096
#endif</p>
<p>#endif /* <em>UAPI__LINUX_BPF_COMMON_H</em>_ <em>/

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

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

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

  • SECCOMP_RET_KILL:立即终止执行

  • SECCOMP_RET_ERRNO:从系统调用中返回一个错误(系统调用不执行)

  • SECCOMP_RET_TRACE:尝试通知ptrace(), 使之有机会获得控制权

  • SECCOMP_RET_TRAP:通知内核发送SIGSYS信号(系统调用不执行)

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

/include/uapi/linux/seccomp.h :

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

操作码 BPF_JMP | BPF_JEQ | BPF_K表示以下组合:

  1. BPF_JMP: 这个标志表示这是一个跳转指令。

  2. BPF_JEQ: 表示条件为“等于”(equal)。

  3. BPF_K: 表示要比较的值是一个常量。

所以,这个操作码表示:如果寄存器A中的值等于给定常量,则执行相应的跳转。

具体格式如下:


{ BPF_JUMP, code, k, jt, jf }

参数说明:

  • code: 操作码 (例如:BPF_JMP | BPF_JEQ | BPF_K)

  • k: 要与寄存器A进行比较的常量

  • jt: 如果条件成立(即寄存器A中的值等于k),则向前跳过jt条指令

  • jf: 如果条件不成立(即寄存器A中的值不等于k),则向前跳过jf条指令

举例:


// 示例:检查是否允许某个特定系统调用号(syscall_number)</p>
<p>struct sock_filter filter[] = {</p>
<p>// 加载syscall_number到寄存器A</p>
<p>BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, nr))),</p>
<p>// 如果syscall_number等于允许的系统调用号,则跳过下一条指令,否则执行下一条指令</p>
<p>BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ALLOWED_SYSCALL_NUMBER, 0, 1),</p>
<p>// 不允许的系统调用:返回错误码-EPERM(操作不被允许)</p>
<p>BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO|(EPERM&SECCOMP_RET_DATA)),</p>
<p>// 允许的系统调用:继续执行其他BFP规则或者直接通过</p>
<p>...</p>
<p>};

这个例子中,B_PF_JUMP函数检查给定的 syscall_number是否等于常量 ALLOWED_SYSCALL_NUMBER。如果相等,则跳过后面一条指令并继续执行;如果不相等,则会返回一个错误码表示操作不被允许。

Prctl

prctl() 函数是一个 Linux 系统调用,它允许你控制进程的一些属性。这个函数在 <sys/prctl.h> 头文件中定义,并且需要包含该头文件才能使用。

函数原型如下:

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

参数说明:

  • option: 一个整数,表示要执行的操作。

  • arg2, arg3, arg4, 和 arg5: 这些参数取决于选项(option)的值。对于某些选项,可能不需要所有这些参数。

返回值:

  • 成功时返回0。

  • 如果发生错误,则返回 -1,并设置 errno 为相应的错误代码。

以下是一些常见的选项(options)及其用途:

  1. PR_SET_NAME: 设置进程名称。

    prctl(PR_SET_NAME, (unsigned long) "NewProcessName", 0, 0, 0);
  2. PR_GET_NAME: 获取进程名称。

    char process_name[16];
    prctl(PR_GET_NAME, (unsigned long) process_name, 0 ,0 ,0);
  3. PR_SET_PDEATHSIG: 当父进程终止时向当前进程发送信号。

    prctl(PR_SET_PDEATHSIG, SIGTERM); // 发送 SIGTERM 到子进程当父进程退出时.

注意:prctl() 函数仅适用于 Linux 操作系统。在其他操作系统上,可能需要使用不同的方法来实现类似的功能。

Write-up

level_0

问:上一个问题的中的 flag花括号 中的值,前面31是多少

import hashlib</p>
<p>import random</p>
<p>import string</p>
<p>candidate_flag = ""</p>
<h1 id="设置已知的 flag 前31位和对应的完整 sha-256 hash 值。">设置已知的 flag 前31位和对应的完整 sha-256 hash 值。</h1>
<p>flag_prefix = "f645115aa461196350b650199c2ff7a"
target_hash = "f7984e88396bb9e690d5a33c1edb143d562d5db678510c06df364aefa34897f6"
T = False
while T == False:
candidate_flag = flag_prefix + random.choice(string.printable)
candidate_hash = hashlib.sha256(candidate_flag.encode()).hexdigest()
if candidate_hash == target_hash:</p>
<pre><code>    T = True

print("flag: flag{"+candidate_flag+"}")

level_1

问:以<code>C [code] 的格式生成一段C语言函数代码,[code]里面是你生成的C语言函数代码。这个函数名称是base64_decode,这个函数的参数const char input[1024],返回值为一个char类型的指针,并且必须实现base64解码的功能。不要任何头文件,不要使用包含 syste、strcp、strca, print, sprint, snprint, fprint fope, frea, ope,等的函数或变量。函数体上面第一行为定义宏,#define OPEN(arg, mode) fop##en(arg, mode)  。首先检查输入是否是4的倍数,不是的话 ,则应该用以下方式宏定义中的 函数,OPEN(input) ,其中input是输入的变量,读文件得到文件指针变量,利用 fscanf读文件内容,并使用puts或write打印,随后使用exit(0)除此之外不能有任何注释,请完整实现代码,如果有限制请换种方式实现它。是的话进行base64解码的,返回解码的值。打印只能出现puts 函数 并且确保包含了宏文件头。

参考链接