protobuf 协议恢复与利用的实战研究

题目是2025ciscn半决的一道题目,名称叫prompt

通过网盘分享的文件:EiDk3oi1evx4b2kcbXfGUAR6F5RalmAhPc8TwUFHZ18nXiB1utxlY22JbFTBGsSi.zip
链接:
https://pan.baidu.com/s/1MyQluP0YKBpmDrv18uwq-w?pwd=aaaa 提取码: aaaa
--来自百度网盘超级会员v5的分享

我们之前写了一篇文章

protobuf在高版本堆题中的研究-先知社区

这里还是不是很详细,也很局限,我们重新拿一道题目进行分析

很多人第一次在二进制题里碰到 protobuf,直觉上都会把注意力放在“字段怎么定义”“pb2 怎么生成”这些问题上。但真进到题里以后,很快就会发现,protobuf 真正麻烦的地方并不只在消息结构本身,而是在它常常只是程序输入协议的一部分。也就是说,你把 proto 恢复出来,只是走完了第一步,后面还有消息怎么分发、长度头怎么读、正文怎么解包、不同字段在具体功能里怎么落地这些事。

这次研究就是围绕这样一个样本展开的。目标程序内部使用的是 protobuf-c,输入不是传统的菜单数字,而是一段序列化后的消息。最开始如果只盯着 add/free/edit/show 去猜,很容易越看越乱;但如果先把程序实际接收的消息结构抠出来,整个分析路径会清楚很多。

先把消息结构恢复出来

这题里最有价值的第一步,不是直接读功能函数,而是先恢复 protobuf-c 的描述符。仓库里的 analy.py 干的就是这件事。它不是拍脑袋猜字段名,而是去 ELF 里找 protobuf-c descriptor 的魔数 0x28AAEEF9,然后顺着真实描述符把消息名、字段数量、字段表地址、字段编号、字段类型一项一项读出来,最后生成对应的 .proto 和 *_pb2.py。

先贴一下脚本

#!/usr/bin/python3
from dataclasses import dataclass
from pathlib import Path
from typing import Optional

import argparse
from pwnlib.elf.elf import ELF
from pwnlib.util.packing import p64, u32, u64

try:
    from google.protobuf import descriptor_pb2
except ImportError as exc:
    raise SystemExit(
        "python3 protobuf package not installed. Install it with: pip install protobuf"
    ) from exc


MAGIC = 0x28AAEEF9
AUTO_ADDR = 0xFFFFFFFF
FIELD_ENTRY_SIZE = 0x48
DESCRIPTOR_SIZE = 0x78


@dataclass
class FieldEntry:
    number: int
    name: str
    label_id: int
    type_id: int


class proto:
    def __init__(self, path, addr):
        self.e = ELF(path, checksec=False)
        if self.e.elfclass != 64:
            raise ValueError("only 64-bit protobuf-c descriptors are supported")

        self.addr = addr
        self.lst = []
        self.descriptor_addr = None
        self.fields_addr = None
        self.message_name = "ctf"
        self.package_name = ""
        self.syntax = "proto2"

        self.labels = {
            0: "required",
            1: "optional",
            2: "repeated",
            3: "",
        }
        self.label_enums = {
            0: descriptor_pb2.FieldDescriptorProto.LABEL_REQUIRED,
            1: descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL,
            2: descriptor_pb2.FieldDescriptorProto.LABEL_REPEATED,
            3: descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL,
        }
        self.types = {
            0: "int32",
            1: "sint32",
            2: "sfixed32",
            3: "int64",
            4: "sint64",
            5: "sfixed64",
            6: "uint32",
            7: "fixed32",
            8: "uint64",
            9: "fixed64",
            10: "float",
            11: "double",
            12: "bool",
            13: "enum",
            14: "string",
            15: "bytes",
            16: "message",
        }
        self.type_enums = {
            0: descriptor_pb2.FieldDescriptorProto.TYPE_INT32,
            1: descriptor_pb2.FieldDescriptorProto.TYPE_SINT32,
            2: descriptor_pb2.FieldDescriptorProto.TYPE_SFIXED32,
            3: descriptor_pb2.FieldDescriptorProto.TYPE_INT64,
            4: descriptor_pb2.FieldDescriptorProto.TYPE_SINT64,
            5: descriptor_pb2.FieldDescriptorProto.TYPE_SFIXED64,
            6: descriptor_pb2.FieldDescriptorProto.TYPE_UINT32,
            7: descriptor_pb2.FieldDescriptorProto.TYPE_FIXED32,
            8: descriptor_pb2.FieldDescriptorProto.TYPE_UINT64,
            9: descriptor_pb2.FieldDescriptorProto.TYPE_FIXED64,
            10: descriptor_pb2.FieldDescriptorProto.TYPE_FLOAT,
            11: descriptor_pb2.FieldDescriptorProto.TYPE_DOUBLE,
            12: descriptor_pb2.FieldDescriptorProto.TYPE_BOOL,
            13: descriptor_pb2.FieldDescriptorProto.TYPE_ENUM,
            14: descriptor_pb2.FieldDescriptorProto.TYPE_STRING,
            15: descriptor_pb2.FieldDescriptorProto.TYPE_BYTES,
            16: descriptor_pb2.FieldDescriptorProto.TYPE_MESSAGE,
        }

    def read_ptr(self, addr):
        return u64(self.e.read(addr, 8))

    def read_u32(self, addr):
        return u32(self.e.read(addr, 4))

    def read_cstring(self, addr, limit=0x400):
        if addr == 0:
            return ""

        out = bytearray()
        for offset in range(limit):
            ch = self.e.read(addr + offset, 1)
            if ch == b"\0":
                break
            out.extend(ch)
        return out.decode(errors="replace")

    def is_valid_field_entry(self, addr):
        try:
            name = self.read_cstring(self.read_ptr(addr))
            number = self.read_u32(addr + 8)
            label_id = self.read_u32(addr + 12)
            type_id = self.read_u32(addr + 16)
        except Exception:
            return False

        if not name:
            return False
        if number == 0:
            return False
        if label_id not in self.labels:
            return False
        if type_id not in self.types:
            return False
        return True

    def parse_field_entry(self, addr):
        return FieldEntry(
            number=self.read_u32(addr + 8),
            name=self.read_cstring(self.read_ptr(addr)),
            label_id=self.read_u32(addr + 12),
            type_id=self.read_u32(addr + 16),
        )

    def looks_like_descriptor(self, addr):
        try:
            if self.read_u32(addr) != MAGIC:
                return False

            name = self.read_cstring(self.read_ptr(addr + 8))
            n_fields = self.read_ptr(addr + 0x30)
            fields_addr = self.read_ptr(addr + 0x38)
        except Exception:
            return False

        if not name:
            return False
        if not (0 < n_fields < 0x200):
            return False
        if fields_addr == 0:
            return False

        try:
            for index in range(n_fields):
                if not self.is_valid_field_entry(fields_addr + index * FIELD_ENTRY_SIZE):
                    return False
        except Exception:
            return False

        return True

    def looks_like_fields_table(self, addr):
        try:
            return self.is_valid_field_entry(addr)
        except Exception:
            return False

    def find_descriptor_by_fields_addr(self, fields_addr):
        for candidate in self.e.search(p64(MAGIC)):
            try:
                if self.read_ptr(candidate + 0x38) != fields_addr:
                    continue
            except Exception:
                continue

            if self.looks_like_descriptor(candidate):
                return candidate
        return None

    def get_addr(self):
        for candidate in self.e.search(p64(MAGIC)):
            if self.looks_like_descriptor(candidate):
                self.descriptor_addr = candidate
                self.fields_addr = self.read_ptr(candidate + 0x38)
                return

        raise ValueError("failed to locate a valid protobuf-c message descriptor")

    def parse_descriptor(self, descriptor_addr):
        self.descriptor_addr = descriptor_addr
        self.message_name = self.read_cstring(self.read_ptr(descriptor_addr + 8)) or "ctf"
        self.package_name = self.read_cstring(self.read_ptr(descriptor_addr + 0x20))
        n_fields = self.read_ptr(descriptor_addr + 0x30)
        self.fields_addr = self.read_ptr(descriptor_addr + 0x38)

        self.lst = []
        for index in range(n_fields):
            entry = self.parse_field_entry(self.fields_addr + index * FIELD_ENTRY_SIZE)
            self.lst.append(
                {
                    "id": entry.number,
                    "name": entry.name,
                    "label_id": entry.label_id,
                    "label": self.labels[entry.label_id],
                    "type_id": entry.type_id,
                    "type": self.types[entry.type_id],
                }
            )

        self.lst.sort(key=lambda item: item["id"])
        self.syntax = "proto3" if any(item["label_id"] == 3 for item in self.lst) else "proto2"

    def parse_fields_fallback(self, fields_addr):
        self.fields_addr = fields_addr
        self.lst = []
        seen_ids = set()
        current_addr = fields_addr

        while self.is_valid_field_entry(current_addr):
            entry = self.parse_field_entry(current_addr)
            if entry.number in seen_ids:
                break

            self.lst.append(
                {
                    "id": entry.number,
                    "name": entry.name,
                    "label_id": entry.label_id,
                    "label": self.labels[entry.label_id],
                    "type_id": entry.type_id,
                    "type": self.types[entry.type_id],
                }
            )
            seen_ids.add(entry.number)
            current_addr += FIELD_ENTRY_SIZE

        if not self.lst:
            raise ValueError("failed to parse protobuf field table")

        self.lst.sort(key=lambda item: item["id"])
        self.syntax = "proto3" if any(item["label_id"] == 3 for item in self.lst) else "proto2"

    def resolve(self):
        if self.addr == AUTO_ADDR:
            self.get_addr()
            self.parse_descriptor(self.descriptor_addr)
            return

        if self.looks_like_descriptor(self.addr):
            self.parse_descriptor(self.addr)
            return

        descriptor_addr = self.find_descriptor_by_fields_addr(self.addr)
        if descriptor_addr is not None:
            self.parse_descriptor(descriptor_addr)
            return

        if self.looks_like_fields_table(self.addr):
            self.parse_fields_fallback(self.addr)
            return

        raise ValueError(f"address 0x{self.addr:x} is neither a valid descriptor nor a field table")

    def render_field(self, item):
        label = item["label"]
        if self.syntax == "proto3" and item["label_id"] == 3:
            label = ""

        prefix = f"{label} " if label else ""
        return f"   {prefix}{item['type']} {item['name']} = {item['id']};\n"

    def run(self):
        self.resolve()

        content = f'syntax = "{self.syntax}";\n\n'
        if self.package_name:
            content += f"package {self.package_name};\n\n"

        content += f"message {self.message_name} {{\n"
        for item in self.lst:
            content += self.render_field(item)
        content += "}\n"
        return content

    def build_descriptor(self, proto_name):
        descriptor = descriptor_pb2.FileDescriptorProto()
        descriptor.name = proto_name
        descriptor.syntax = self.syntax

        if self.package_name:
            descriptor.package = self.package_name

        message = descriptor.message_type.add()
        message.name = self.message_name

        for item in self.lst:
            if item["type_id"] in (13, 16):
                raise ValueError(
                    f"field {item['name']} uses unsupported type {item['type']}; "
                    "define enum/message references manually in the generated .proto file"
                )

            field = message.field.add()
            field.name = item["name"]
            field.number = item["id"]
            field.label = self.label_enums[item["label_id"]]
            field.type = self.type_enums[item["type_id"]]

        return descriptor

    def render_pb2(self, module_name, descriptor):
        serialized = descriptor.SerializeToString()
        return (
            "# -*- coding: utf-8 -*-\n"
            "# Generated by analy.py. DO NOT EDIT.\n"
            "from google.protobuf import descriptor_pool as _descriptor_pool\n"
            "from google.protobuf import symbol_database as _symbol_database\n"
            "from google.protobuf.internal import builder as _builder\n"
            "\n"
            "_sym_db = _symbol_database.Default()\n"
            "\n"
            f"DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile({serialized!r})\n"
            f"_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())\n"
            f"_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, '{module_name}', globals())\n"
        )

    def write_pb2(self, proto_path):
        proto_path = Path(proto_path)
        descriptor = self.build_descriptor(proto_path.name)
        pb2_path = proto_path.with_name(f"{proto_path.stem}_pb2.py")
        pb2_path.write_text(
            self.render_pb2(f"{proto_path.stem}_pb2", descriptor),
            encoding="utf-8",
        )
        return pb2_path


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("-f", "--file", required=True)
    parser.add_argument("-a", "--addr", default="0xffffffff")
    parser.add_argument("-o", "--output", default="test.proto")
    args = parser.parse_args()

    path = args.file
    addr = int(args.addr, 16)
    out = args.output

    p = proto(path, addr)
    content = p.run()
    print(content)
    with open(out, "w", encoding="utf-8") as f:
        f.write(content)

    pb2_path = p.write_pb2(out)
    print(f"[+] wrote {out}")
    print(f"[+] wrote {pb2_path}")

对这个样本执行:

python3 analy.py -f pwn -o recovered.proto

拿到的结果是:

syntax = "proto3";

message HeapPayload {
   int32 option = 1;
   repeated int32 chunk_sizes = 2;
   repeated int32 heap_chunks_id = 3;
   bytes heap_content = 4;
}

到这里为止,我们已经知道程序收的正文不是某个手搓结构体,而是一个 HeapPayload。option 控制操作类型,chunk_sizes 和 heap_chunks_id 都是 repeated int32,heap_content 是原始字节串。这个结论非常关键,因为后面无论看汇编还是写 exp,都必须建立在这套字段定义之上。

不过这里也要把边界说清楚:analy.py 解决的是“程序到底收什么消息”,它并不能直接告诉你“外层还有没有长度头”“option = 3 到底是 edit 还是别的”“程序每次交互的 framing 是什么”。这些信息还得回到程序本身继续确认。

protobuf 正文之外,还有一层输入协议

很多人在这里第一次栽坑,就是因为把 SerializeToString() 的结果直接当成全部输入发给程序,或者虽然知道有长度头,但误以为是 8 字节。这个样本真正的读包逻辑,其实在主循环前面就已经说得很明白了。

从反汇编里可以看到,程序先调用了一次 read:

1cf6: lea    rax,[rbp-0x102c]
1cfd: mov    edx,0x4
1d02: mov    rsi,rax
1d05: mov    edi,0x0
1d0a: call   1210

这里 0x1210 在 PLT 里对应的是 read@GLIBC_2.2.5,而 edx = 0x4,说明它第一步只从标准输入读 4 个字节。后面紧跟着的检查也说明,这次读取如果返回值不是 4,程序就直接结束这一轮处理。也就是说,这里不是“先随便读一段缓冲区”,而是很明确地在读取一个固定大小的长度头。

再往下看:

1d2a: mov    eax,DWORD PTR [rbp-0x102c]
1d30: cmp    eax,0x1000

程序把刚才那 4 个字节按 DWORD 解释成长度值,做上界检查,然后 malloc(len),再继续 read(0, buf, len) 去读正文,最后把这段正文交给 protobuf_c_message_unpack。翻成更接近源码的样子,就是:

read(0, &len, 4);
buf = malloc(len);
read(0, buf, len);
msg = protobuf_c_message_unpack(..., len, buf);

这条链一旦理顺,exp 里的 p32 就不是靠感觉改出来的,而是程序逻辑直接逼出来的结论:前四个字节是一个小端的 uint32_t 长度,后面才是真正的 protobuf 正文。

因此发送端应该写成:

def send_msg(pay):
    s(p32(len(pay)))
    s(pay)

而不是:

s(p64(len(pay)))
s(pay)

如果错用 p64,程序第一段 read(0, &len, 4) 仍然只会拿走前四个字节,于是长度值看起来还是对的;但多出来的那四个零字节会残留在输入流里,被第二次 read 当成正文开头一起吃进去,结果 protobuf 数据整体错位,unpack 自然就会失败。很多时候脚本看上去像是“程序没反应”,本质上不是功能没打通,而是 framing 已经错了。

消息结构恢复出来之后,我们开始研究漏洞

在把 HeapPayload 搞清楚以后,接下来要做的不是立刻写利用,而是回到主分发逻辑,把 option 到具体 handler 的映射先固定下来。

这个样本的分发逻辑可以概括成:

if (msg->option >= 1 && msg->option <= 5) {
    handlers[msg->option - 1](msg);
} else {
    printf("Unknown option: %d\n", msg->option);
}

所以这里的菜单编号不是很多旧模板里常见的 0 = add, 1 = free, 2 = edit, 3 = show,而是:

  • 1 = add
  • 2 = free
  • 3 = edit
  • 4 = show
  • 5 = exit

这个映射如果不先确认,后面就算 proto 结构和长度头都对,发包照样会打到错误的处理函数里去。

到这里,其实这道题的“输入协议”已经完整了:前面是一个 4 字节小端长度,后面跟着一段 HeapPayload 的 protobuf 正文,而正文里的 option 决定具体走哪条功能路径。

生成 pb2 之后,exp 里应该怎么写

消息结构恢复出来以后,最稳的做法不是自己手搓字节流,而是直接导入生成好的 recovered_pb2.py。因为像 chunk_sizes、heap_chunks_id 这种字段在 proto 里是 repeated,用现成类去赋值可以少掉很多编码层面的低级错误。

一个比较顺手的封装方式是这样:

from pwn import *
from recovered_pb2 import HeapPayload


def pack_msg(option, ids=None, sizes=None, content=None):
    msg = HeapPayload()
    msg.option = option

    if ids is not None:
        if isinstance(ids, int):
            msg.heap_chunks_id.append(ids)
        else:
            msg.heap_chunks_id.extend(ids)

    if sizes is not None:
        if isinstance(sizes, int):
            msg.chunk_sizes.append(sizes)
        else:
            msg.chunk_sizes.extend(sizes)

    if content is not None:
        msg.heap_content = content

    return msg.SerializeToString()


def send_msg(io, pay):
    io.send(p32(len(pay)))
    io.send(pay)

后面的 add/free/edit/show 其实都只是这层封装的语义化包装。比如:

def add(io, size, content=None):
    send_msg(io, pack_msg(1, sizes=size, content=content))


def edit(io, idx, size, content=None):
    send_msg(io, pack_msg(3, ids=idx, sizes=size, content=content))

注意这里真正重要的不是“把函数名字写好看”,而是把三层东西分开:

第一层是 protobuf 正文怎么构造;第二层是正文之外的长度头怎么发;第三层才是 add/edit/show 这种业务语义。层次一旦分清,后面出了问题也比较容易定位到底是编码错了、framing 错了,还是 handler 打偏了。

这题里真正的漏洞点在 edit

协议和交互理顺以后,再看功能本身就容易得多。当前样本里最关键的问题在 edit。它不是一个普通的“重新写 chunk 内容”的函数,而是存在明显的堆溢出。

把 edit 还原成伪代码,大致是这样:

void edit(HeapPayload *msg) {
    int idx;
    int size;
    size_t n;
    char *ptr;

    if (msg->heap_chunks_id == NULL) return;
    if (msg->chunk_sizes == NULL) return;

    idx  = msg->heap_chunks_id[0];
    size = msg->chunk_sizes[0];

    if (idx < 0 || idx > 0xf) return;
    if (size < 0 || size > 0x500) return;

    chunk_size_table[idx] = size;
    ptr = chunk_table[idx];

    if (msg->heap_content.len != 0 && msg->heap_content.data != NULL) {
        n = min((size_t)size, msg->heap_content.len);
        memcpy(ptr, msg->heap_content.data, n);
    } else {
        memset(ptr, 0, size);
    }
}

这段逻辑的问题很直接:edit 会重新从消息里读一个新的 size,也会检查这个 size 是否不超过 0x500,但它没有检查这个 size 是否小于等于该 chunk 最初申请时的真实大小。

这意味着,如果先申请一个很小的 chunk,比如:

add(io, 0x20, b"A" * 8)

然后再执行:

edit(io, 0, 0x200, b"B" * 0x200)

程序不会重新申请一个 0x200 的新块,而是会把 0x200 字节直接写进原来那块 0x20 的旧 chunk 里。多出来的部分会覆盖相邻 chunk 的数据、metadata,甚至进一步影响 tcache 结构。这就是典型的 heap overflow。

更要命的是,这里甚至不一定非要走 memcpy 路径。就算不给 heap_content,程序也会走 memset(ptr, 0, size)。也就是说,只要 size 比旧 chunk 大,你照样能越界清空后面的堆区。这说明漏洞的核心根本不在“内容有没有限制”,而在“用户可控的 size 没有和旧 chunk 的真实大小绑定”。

为什么这类题不能只看 protobuf

做到这里,这道题里 protobuf 的位置其实已经很清楚了。它不是漏洞本身,但它把输入协议和业务语义都包了一层,让人很容易一上来就走偏。如果只盯着 .proto 看,你最多知道有哪些字段;如果只盯着功能函数看,又会被一堆 offset 和 protobuf-c 生成结构绕晕。

真正有效的分析顺序应该是:

先恢复消息结构,确认程序到底收什么;再确认主分发逻辑,弄清楚 option 和 handler 的关系;接着确认外层 framing,比如长度头到底是 4 字节还是 8 字节;最后再进入具体功能,看这些字段在 add/free/edit/show 里是怎么被消费的。

这也是为什么说,这类题里 protobuf 既不是全部,也不是可以忽略的细节。它更像是一道门槛:门没推开之前,你连正确输入长什么样都不知道;门推开之后,真正的利用分析才刚刚开始。

结语

回头看这个样本,真正帮我们把局面打开的,不是某一条神奇的 gadget,也不是一眼看穿漏洞点,而是先把协议层和业务层分开了。analy.py 负责把 HeapPayload 从二进制里恢复出来,主分发逻辑告诉我们 1..5 的菜单映射,入口的 read(0, &len, 4) 说明长度头必须是 p32,而 edit 最后暴露出来的,则是一个标准但很扎实的堆溢出。

如果把这条链记住,以后再遇到带 protobuf-c 的题,思路就不会乱:先恢复消息,再确认 framing,再看 handler,最后再谈利用。这样做看起来慢一点,实际反而是最快的。

这样之后我们就能和程序进行交互了。