关注这个专栏的其他相关笔记：[Web 安全] 反序列化漏洞 - 学习笔记-CSDN博客
0x01：PHP 序列化 — Serialize
序列化就是将对象的状态信息转化为可以存储或传输的形式的过程，在 PHP 中，通常使用 serialize() 函数来完成序列化的操作。
下面笔者直接简要点列出各个数据类型序列化之后的结果，不信的崽崽可以自己跑一下：
echo serialize(null); // N;
echo serialize(123); // i:123; => int 类型的值为 123
echo serialize(123.3); // d:123.3; => double 类型的值为 123.3
echo serialize(true); // b:1; => Boolean 类型的值为 True
echo serialize("Blue17"); // s:6:"Blue17"; => String 类型的值为 Blue17
echo serialize(array("Blue17", 17, null));
// a:3:{i:0;s:6:"Blue17";i:1;i:17;i:2;N;}0x0101：序列化结果解析 — Array 类型
这部分笔者就简单分析一下上面 Array 类型序列化后的结果：
echo serialize(array("Blue17", 17, null));
// a:3:{i:0;s:6:"Blue17";i:1;i:17;i:2;N;}
/*
a:3 => array 中有三个元素
i:0;s:6:"Blue17" => index 为 0 的地方是一个长度为 6 的 String 类型的元素，值为 Blue17
i:1;i:17; => index 为 1 的地方是一个 int 类型的元素，值为 17
i:2;N; => index 为 2 的地方是一个 Null 类型的元素。
*/0x0102：序列化结果解析 — 类
类的序列化结果基本大差不差，但是不同 “访问类型” 的变量序列化的结果有很大差异，这部分笔者就按照 “访问类型” 进行分类，并对每个单独进行讲解。
1. 类序列化结果解析 —— Public 型
这里我们开始进入正规，讲讲最常见的类的序列化结果，先来一个最常见的试试水：
<?php
class demo {
public $var1; // 这个变量没有赋值
public $var2 = "Blue17"; // 这个变量赋予了字符串类型的值
var $var3 = 17; // 虽然修饰符是 var 但其实还是 public 类型的
function printVar($var) {
$localVar = $var; // 类方法中的局部变量
echo $localVar;
}
}
// O:4:"demo":3:{s:4:"var1";N;s:4:"var2";s:6:"Blue17";s:4:"var3";i:17;}
echo serialize(new demo(array(123)));下面我们仔细分析一下结果，可以看到，它序列化的结果基本全是变量，类中方法其实是没有被序列化的，类中的局部变量也没有被序列化：
O:4:"demo":3:{s:4:"var1";N;s:4:"var2";s:6:"Blue17";s:4:"var3";i:17;}
// O:4:"demo":3 => Object 对象是一个 4 字的叫 demo，其中有 3 个属性（变量）
// s:4:"var1";N; => 属性名称占 4 字节，叫 var1 其值是 Null 类型
// s:4:"var2";s:6:"Blue17" => 属性名称占 4 字节，叫 var2，其值是 String 类型，长度为 6 内容是 Blue17
// s:4:"var3";i:17; => 属性名称占 4 字节，叫 var3，其值是 int 类型，值为 17。2. 类序列化结果解析 —— Protected 型
下面我们来看看如果类的属性中混入了 Protect 型的变量它序列化的结果长啥样吧：
<?php
class demo {
protected $var1; // 这个变量没有赋值
protected $var2 = "Blue17"; // 这个变量赋予了字符串类型的值
protected $var3 = 17; // 虽然修饰符是 var 但其实还是 public 类型的
}
echo serialize(new demo()) . "\n";
// O:4:"demo":3:{s:7:"*var1";N;s:7:"*var2";s:6:"Blue17";s:7:"*var3";i:17;}
echo urlencode(serialize(new demo()));
// O%3A4%3A%22demo%22%3A3%3A%7Bs%3A7%3A%22%00%2A%00var1%22%3BN%3Bs%3A7%3A%22%00%2A%00var2%22%3Bs%3A6%3A%22Blue17%22%3Bs%3A7%3A%22%00%2A%00var3%22%3Bi%3A17%3B%7D下面我们仔细分析一下结果，这里笔者特意对它序列化后的结果做了一个编码，因为里面其实有一些不可见的字符，不编码是看不出来的，大部分内容其实与 Public 一致，但是被 protected 修饰的变量序列化后的内容就有很大不同了：
O:4:"demo":3:{s:7:"*var1";N;s:7:"*var2";s:6:"Blue17";s:7:"*var3";i:17;}
// s:7:"*var1";N; => 属性名称占 7 个字节？怎么数着只有 5 个？
// 这个是 URL 编码后的内容：s%3A7%3A%22%00%2A%00var1%22%3BN%3B
// 这个是简单解码后的样子：s:7:"%00*%00var1";N;如上，可以发现，Protected 属性序列化后明面看只有 *var1 这样，但其实 * 两边其实还藏了两个 ASCII 码值为 0 的字符 （这也引出后面一个 Bug，在尝试构造反序列化值得时候，不建议通过直接复制就篡改被 Protected 或者 Private 修饰的值，因为你复制得内容一般都不全，会丢掉这个特殊的 %00）。
3. 类序列化结果解析 —— Private 型
下面我们来看看如果类的属性中混入了 Private 型的变量它序列化的结果长啥样吧：
<?php
class demo {
private $var1; // 这个变量没有赋值
private $var2 = "Blue17"; // 这个变量赋予了字符串类型的值
}
echo serialize(new demo()) . "\n";
// O:4:"demo":2:{s:10:"demovar1";N;s:10:"demovar2";s:6:"Blue17";}
echo urlencode(serialize(new demo()));
// O%3A4%3A%22demo%22%3A2%3A%7Bs%3A10%3A%22%00demo%00var1%22%3BN%3Bs%3A10%3A%22%00demo%00var2%22%3Bs%3A6%3A%22Blue17%22%3B%7D下面我们仔细分析一下结果，这里笔者特意对它序列化后的结果做了一个编码，因为里面其实有一些不可见的字符，不编码是看不出来的，大部分内容其实与 Public 一致，但是被 Private 修饰的变量序列化后的内容就有很大不同了：
O:4:"demo":2:{s:10:"demovar1";N;s:10:"demovar2";s:6:"Blue17";}
// s:10:"demovar1";N; => 属性名称占 10 个字节？怎么数着只有 8 个？
// 这个是 URL 编码后的内容：s%3A10%3A%22%00demo%00var1%22%3BN%3B
// 这个是简单解码后的样子：s:10:"%00demo%00var1";N; => %00 算一位，数一数，刚好 10 位如上，可以发现，Private 属性序列化后明面看只有 demovar1 这样，但其实类名两边其实还藏了两个 ASCII 码值为 0 的字符，所以其真实格式为（URL 编码后的哈，不编码的话 ASCII 值为 0 的其实是不可见字符） %00类名%00变量名。
0x02：PHP 反序列化 — Unserialize
以下是反序列化相关的几个特性：
-
反序列化就是将序列化得到的字符串转化为一个对象的过程。
-
反序列化生成的对象成员属性值由被反序列化的字符串决定，与原来类预定义的值无关。
-
PHP 中通过
unserialize()函数进行反序列化，序列化使用serialize()函数。 -
反序列化不触发类的成员方法，需要被调用方法后才会被触发。（不一定，这个后面讲）
下面笔者就以 Public 型的类为例，讲解一下反序列化的用处（另外两种类型，流程一致，但是要特别注意 %00 到底有没有被复制过去，如果报错了，一般就是这个的问题）。
0x0201：反序列化 —— 正常流程
首先是比较简单的 Public 型类的反序列化，我们先创建一个类，假设叫 Note （笔记）类吧，然后我们写笔记就要实例化这个类，然后往这个类的对象里写东西，代码如下：
<?php
class Note {
public $title; // 笔记标题
public $content; // 笔记内容
// 记录标题 & 内容
function write($title, $content) {
$this -> title = $title;
$this -> content = $content;
}
// 读取标题 & 内容
function read() {
echo "Title: " . $this -> title . "\n";
echo "Content: " . $this -> content . "\n";
}
}
// 实例化笔记类
$note = new Note();
// 往笔记里写东西
$note -> write("Hello, World!!", "Today Is a Nice Day!!");如上，我们已经往笔记里写东西了，写了你要保存吧，可是你是个对象你咋保存？这时就可以使用序列化，把 $note 这个对象里的内容序列化然后存储在一个文件里：
// 保存 $note 笔记里的东西
echo serialize($note); // O:4:"Note":2:{s:5:"title";s:14:"Hello, World!!";s:7:"content";s:21:"Today Is a Nice Day!!";}
OK，保存了你过段时间得看吧，给你看下面这个东西你又看不懂是不是：
O:4:"Note":2:{s:5:"title";s:14:"Hello, World!!";s:7:"content";s:21:"Today Is a Nice Day!!";}这个时候就需要用我们软件进行反序列化然后再调用 read 方法了是吧：
// 保存 $note 笔记里的东西
$save = serialize($note); // O:4:"Note":2:{s:5:"title";s:14:"Hello, World!!";s:7:"content";s:21:"Today Is a Nice Day!!";}
// 查看保存的内容
$raw = unserialize($save); // 对序列化的内容进行反序列化
$raw -> read();
如上，可以看到，通过反序列化被保存的值，我们成功还原了用户笔记里写的东西。下面是整个测试的源码（这里笔者特别提醒，反序列化的环境中要有序列化的那个类，不然即使反序列化了也是无法执行类的方法的）：
<?php
// 创建笔记类
class Note {
public $title; // 笔记标题
public $content; // 笔记内容
// 记录标题 & 内容
function write($title, $content) {
$this -> title = $title;
$this -> content = $content;
}
// 读取标题 & 内容
function read() {
echo "Title: " . $this -> title . "\n";
echo "Content: " . $this -> content . "\n";
}
}
// 实例化笔记类
$note = new Note();
// 往笔记里写东西
$note -> write("Hello, World!!", "Today Is a Nice Day!!");
// 保存 $note 笔记里的东西
$save = serialize($note); // O:4:"Note":2:{s:5:"title";s:14:"Hello, World!!";s:7:"content";s:21:"Today Is a Nice Day!!";}
// 查看保存的内容
$raw = unserialize($save); // 对序列化的内容进行反序列化
$raw -> read(); // 执行类的成员方法0x0202：反序列化 —— 异常流程
我们继续假设，我们刚刚是本地的，假设你写了笔记，然后你要上传，那你上传服务端的序列化的内容就是下面这个：
O:4:"Note":2:{s:5:"title";s:14:"Hello, World!!";s:7:"content";s:21:"Today Is a Nice Day!!";}假设，攻击者截获了这个内容，按照 PHP 序列化的格式自己改了一下（主要是改内容和长度）：
O:4:"Note":2:{s:5:"title";s:14:"Hello, World!!";s:7:"content";s:25:"Today Is NOT a Nice Day!!";}如上，我们添加了一个单词 Not ，然后修改了长度，然后我们 “发送” 到服务端，让他读一下，代码如下：
<?php
// 创建笔记类
class Note {
public $title; // 笔记标题
public $content; // 笔记内容
// 记录标题 & 内容
function write($title, $content) {
$this -> title = $title;
$this -> content = $content;
}
// 读取标题 & 内容
function read() {
echo "Title: " . $this -> title . "\n";
echo "Content: " . $this -> content . "\n";
}
}
// 接收的信息
$receive = 'O:4:"Note":2:{s:5:"title";s:14:"Hello, World!!";s:7:"content";s:25:"Today Is NOT a Nice Day!!";}';
$raw = unserialize($receive); // 对序列化的内容进行反序列化
$raw -> read(); // 调用读方法
如上，可以看到，结果就这样被修改了。这就是前面介绍的反序列化的一个特性 “反序列化生成的对象成员属性值由被反序列化的字符串决定，与原来类预定义的值无关。”，也是我们后面 “反序列化漏洞的依据”。
