protobuf 协议恢复与利用的实战研究
更近一步的针对protobuf协议分析的技巧的总结
protobuf 协议恢复与利用的实战研究
题目是2025ciscn半决的一道题目,名称叫prompt
通过网盘分享的文件:EiDk3oi1evx4b2kcbXfGUAR6F5RalmAhPc8TwUFHZ18nXiB1utxlY22JbFTBGsSi.zip
链接: https://pan.baidu.com/s/1MyQluP0YKBpmDrv18uwq-w?pwd=aaaa 提取码: aaaa
--来自百度网盘超级会员v5的分享
我们之前写了一篇文章
这里还是不是很详细,也很局限,我们重新拿一道题目进行分析
很多人第一次在二进制题里碰到 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 = add2 = free3 = edit4 = show5 = 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,最后再谈利用。这样做看起来慢一点,实际反而是最快的。
这样之后我们就能和程序进行交互了。
本文详解CISCN半决赛题中protobuf-c协议恢复、四字节长度头解析及edit功能堆溢出利用链。
由 AI 根据全文自动生成,仅供参考,以原文为准