PHP对象注入

发表于

虽然这篇文章叫做PHP对象注入，但是本质上还是和PHP的序列化的不正确使用有关。如果阅读了PHP中的SESSION反序列化机制对序列化就会有一个大致的认识。PHP对象注入其实本质上也是由于序列化引起的。

前提知识

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?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>";
    }
}

$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使用serialize()和unserialize()来进行序列化和反序列化的。
而序列化的危害就在于如果序列化的内容是用户可控的，那么用户就可以注入精心构造的payload。当进行发序列化的时候就有可能会出发对象中的一些魔术方法，造成意想不到的危害。

对象注入

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
class LogClass {
    public $logfilename = "";
    public function logdata($text) {
        echo "log data".$text."<br/>";
        file_put_contents($this->logfilename,$text,FILE_APPEBD);
    }

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

在其他类中使用LogClass
logLogin.php

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?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/>";
    }
}

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

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

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

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

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

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

注入点

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?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/>';
    }
}

$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.。这也是一个理想的使用方法。

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

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

漏洞挖掘

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

防御

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

参考

理解对象注入 http://drops.wooyun.org/papers/4820
解析PHP对象注入漏洞 http://blog.csdn.net/u011721501/article/details/43458953