PHP Type Confusion 漏洞：利用 Union Types 的 Zval 位域非预期转换进行内存操作
大家好！今天我们来深入探讨一个在 PHP 中比较隐蔽但威力强大的安全漏洞：利用 Union Types 导致的 Zval 位域非预期转换进行内存操作，也就是常说的 Type Confusion 漏洞。这个漏洞利用了 PHP 动态类型的特性和 Union Types 引入后对 Zval 结构的改变，攻击者可以精心构造输入，导致 PHP 引擎将一个变量错误地解释为另一种类型，从而实现任意内存读写，最终导致代码执行。
1. PHP 动态类型系统与 Zval 结构
PHP 是一种动态类型语言，这意味着变量的类型不是在声明时确定的，而是在运行时根据变量的值来确定的。PHP 的底层实现中，使用 zval 结构体来存储变量的值和类型信息。zval 结构体在不同的 PHP 版本中可能有所不同，但基本概念保持一致。下面我们以 PHP 7.x 为例，说明 zval 的结构：
typedef struct _zval_struct {
zend_value value; /* 变量的值 */
zend_uchar type; /* 变量的类型 */
zend_uchar is_refcounted; /* 是否是引用计数变量 */
} zval;
typedef union _zend_value {
zend_long lval; /* long value */
double dval; /* double value */
zend_object *obj; /* object value */
zend_string *str; /* string value */
zend_array *arr; /* array value */
zend_resource *res; /* resource value */
zend_reference *ref; /* reference value */
zend_ast *ast; /* AST node */
zval *zv;
void *ptr;
zend_class_entry *ce;
zend_function *func;
struct {
uint32_t w1;
uint32_t w2;
} ww;
} zend_value;关键在于 zend_value 这个 union。它允许一个变量在不同的时刻存储不同类型的值。type 字段则记录了当前 zend_value 存储的值的类型。常见的类型包括：
| 类型常量 | 描述 |
|---|---|
| IS_UNDEF | 未定义 |
| IS_NULL | NULL |
| IS_FALSE | FALSE |
| IS_TRUE | TRUE |
| IS_LONG | 整数 |
| IS_DOUBLE | 浮点数 |
| IS_STRING | 字符串 |
| IS_ARRAY | 数组 |
| IS_OBJECT | 对象 |
| IS_RESOURCE | 资源 |
| IS_REFERENCE | 引用 |
PHP 引擎会根据 type 字段的值来决定如何解释 zend_value 中的数据。这就是动态类型的核心机制。
2. Union Types 的引入及其潜在问题
在 PHP 8.0 中，引入了 Union Types 的特性。Union Types 允许在一个类型声明中指定多个可能的类型。例如：
function process(int|string $input): void {
// ...
}这个函数 process 接受一个参数 $input，它的类型可以是 int 或者 string。
虽然 Union Types 增强了类型系统的灵活性，但也引入了新的安全风险。由于 PHP 仍然是动态类型的，即使使用了 Union Types，类型检查仍然是在运行时进行的。这意味着，如果我们可以找到一种方法来绕过类型检查，就有可能将一个变量错误地解释为另一种类型，从而触发 Type Confusion 漏洞。
3. Zval 位域的非预期转换
Zval 结构体中，zend_value 是一个 union，这意味着不同的类型共享同一块内存区域。当 PHP 引擎错误地将一个类型的值读取为另一种类型时，就会发生位域的非预期转换。
一个典型的例子是利用 IS_LONG 和 IS_DOUBLE 之间的转换。这两个类型都使用 zend_value 的 lval 和 dval 成员来存储数据。由于 lval 是一个整数，而 dval 是一个浮点数，它们在内存中的表示方式完全不同。
假设我们有一个变量，它的 type 是 IS_LONG，lval 的值是一个精心构造的整数。如果我们可以设法让 PHP 引擎将这个变量的 type 错误地解释为 IS_DOUBLE，那么 PHP 引擎就会将 lval 中的整数数据按照浮点数的格式来解释，从而得到一个完全不同的浮点数值。
更重要的是，如果我们能够控制这个整数的值，那么我们就可以控制这个浮点数的值。由于浮点数的内存布局是固定的，我们就可以利用这个特性来构造特定的内存地址，并进行读写操作。
4. 利用示例：整数溢出与浮点数构造
下面我们来看一个具体的利用示例。假设我们有以下 PHP 代码：
<?php
function trigger_vulnerability(array $data): void {
$a = $data['a'];
$b = $data['b'];
if (is_int($a) && is_int($b)) {
$result = $a + $b;
if (is_float($result)) {
// 触发漏洞：将浮点数作为整数处理
$address = (int)$result;
echo "Attempting to read memory at address: " . dechex($address) . "n";
$value = unpack("Q", pack("P", $address))[1];
echo "Value at address: " . dechex($value) . "n";
}
}
}
$data = $_GET;
trigger_vulnerability($data);
?>这个代码存在一个潜在的 Type Confusion 漏洞。攻击者可以通过构造特定的 $a 和 $b 的值，使得 $a + $b 的结果发生整数溢出，从而得到一个浮点数。然后，代码将这个浮点数强制转换为整数，并将其作为内存地址进行读取。
攻击步骤：
- 构造整数溢出： 我们需要找到两个整数
$a和$b，使得$a + $b的结果大于 PHP 整数的最大值，从而导致溢出，得到一个浮点数。 - 控制浮点数值： 我们需要控制
$a和$b的值，使得溢出后的浮点数值对应的整数部分是我们想要读取的内存地址。 - 触发漏洞： 将构造好的
$a和$b的值通过 GET 请求传递给 PHP 脚本，触发漏洞。
具体实现：
PHP 整数的最大值通常是 PHP_INT_MAX，在 64 位系统中，它的值是 9223372036854775807。我们可以通过以下 PHP 代码来获取：
<?php
echo PHP_INT_MAX . "n";
?>为了简化计算，我们先确定一个要读取的内存地址，例如 0x4141414141414141 ( "AAAAAAAA" 的 ASCII 码)。然后，我们需要找到两个整数 $a 和 $b，使得 $a + $b 溢出后，得到的浮点数转换为整数后等于 0x4141414141414141。
我们可以使用以下公式来计算 $a 和 $b：
$target_address = 0x4141414141414141;
$a = PHP_INT_MAX;
$b = $target_address - $a; // 这会导致溢出，得到一个负数，但 PHP 会自动转换为浮点数
在实际的攻击中，我们需要进行一些调整，因为 PHP 的类型转换规则比较复杂。我们可以使用二分法来调整 $a 和 $b 的值，直到 $a + $b 溢出后，得到的浮点数转换为整数后等于我们想要读取的内存地址。
一种更可靠的方法是直接利用浮点数的表示方式。IEEE 754 标准定义了浮点数的表示方式。64 位浮点数由 1 位符号位、11 位指数位和 52 位尾数位组成。我们可以直接构造一个浮点数，使得它的内存布局等于我们想要读取的内存地址。
例如，我们可以使用以下 PHP 代码来构造一个浮点数：
<?php
$address = 0x4141414141414141;
$float_value = unpack("d", pack("Q", $address))[1];
echo "Float value: " . $float_value . "n";
echo "Integer value: " . (int)$float_value . "n";
?>这段代码首先将地址 0x4141414141414141 转换为一个 64 位整数，然后将这个整数打包成一个二进制字符串，最后将这个二进制字符串解包成一个 64 位浮点数。这样，我们就得到了一个浮点数，它的内存布局等于我们想要读取的内存地址。
然后，我们可以使用以下 GET 请求来触发漏洞：
http://example.com/vuln.php?a=9223372036854775807&b=-4914896713057640703这个请求会将 $a 设置为 9223372036854775807，将 $b 设置为 -4914896713057640703。当 PHP 引擎执行 $a + $b 时，会发生整数溢出，得到一个浮点数，它的值接近 4611686018427387904，也就是 0x4000000000000000。 然后，这个浮点数会被强制转换为整数，并作为内存地址进行读取。由于地址是可读的，所以不会崩溃，但如果我们将地址换成不可读的地址，就会导致PHP崩溃。
5. 防御措施
要防御这种 Type Confusion 漏洞，可以采取以下措施：
- 严格的类型检查： 尽可能使用严格的类型检查，避免隐式类型转换。可以使用
strict_types=1指令来强制执行严格的类型检查。 - 输入验证： 对所有输入进行严格的验证，确保输入的值在预期的范围内。特别是对于整数和浮点数，要检查是否存在溢出或下溢的风险。
- 代码审计： 定期进行代码审计，查找潜在的 Type Confusion 漏洞。
- 使用静态分析工具： 使用静态分析工具来检测代码中的类型错误。
- 更新 PHP 版本： 及时更新 PHP 版本，修复已知的安全漏洞。
6. 其他利用方式
除了 IS_LONG 和 IS_DOUBLE 之间的转换，还有其他的 Type Confusion 利用方式。例如，可以利用 IS_STRING 和 IS_ARRAY 之间的转换，或者 IS_OBJECT 和 IS_RESOURCE 之间的转换。这些利用方式的原理类似，都是通过控制变量的值和类型，使得 PHP 引擎错误地解释变量的数据，从而实现任意内存读写。
示例：利用 IS_STRING 和 IS_ARRAY
假设我们有如下代码:
<?php
function type_confusion(array $data) {
$array = $data['array'];
$index = $data['index'];
if (is_string($index)) {
// 将字符串索引转换为数组索引
$value = $array[$index];
echo "Value: " . $value . "n";
}
}
$data = $_GET;
type_confusion($data);
?>如果我们可以控制$array的值，并且让 $index 看起来像一个字符串，实际上却是一个整数，那么就可以实现任意地址读取。
假设 $array是一个字符串，$index 的值为’0’，那么 $array[$index] 实际上是在读取字符串的第一个字符。如果我们可以控制 $index 的值，就可以读取字符串的任意位置。
这种攻击方式通常需要更精细的控制，例如利用哈希冲突来控制数组的键值对，或者利用字符串的内存布局来构造特定的内存地址。
7. Union Types 的正确使用
Union Types 本身并不是一个坏特性。它可以提高代码的可读性和可维护性。但是，在使用 Union Types 时，我们需要特别小心，避免引入 Type Confusion 漏洞。
- 明确类型： 尽量明确变量的类型，避免使用过于宽泛的 Union Types。
- 类型检查： 在使用 Union Types 的变量时，一定要进行类型检查，确保变量的类型符合预期。
- 避免隐式类型转换： 尽量避免隐式类型转换，使用显式类型转换来确保类型安全。
- 防御性编程： 编写防御性代码，处理可能出现的类型错误。
总结
Type Confusion 漏洞是一种非常危险的安全漏洞，攻击者可以利用它来实现任意内存读写，最终导致代码执行。要防御这种漏洞，我们需要严格的类型检查，输入验证，代码审计和使用静态分析工具。同时，我们需要正确使用 Union Types，避免引入新的安全风险。
漏洞的本质
Type Confusion 漏洞的本质在于 PHP 动态类型的特性和 Union Types 引入后对 Zval 结构的改变。攻击者利用类型检查的不足，将一个类型的值错误地解释为另一种类型，从而实现任意内存读写。
防御的关键
防御 Type Confusion 漏洞的关键在于严格的类型检查和输入验证。我们需要确保变量的类型符合预期，并且输入的值在预期的范围内。
未来的方向
未来的 PHP 版本可能会加强类型系统，例如引入更严格的静态类型检查，从而减少 Type Confusion 漏洞的风险。同时，我们需要不断学习新的安全知识，提高安全意识，才能更好地保护我们的 PHP 应用。