PHP反序列化漏洞深度解析：从原理到实战防御

如果你是一名PHP开发者，或者正在维护一个PHP应用，那么“反序列化”这个词，很可能让你既熟悉又警惕。熟悉是因为它作为一种数据交换和对象持久化的手段，在框架、缓存、会话管理中无处不在；警惕则是因为，它几乎是PHP安全漏洞中最常见、也最危险的“雷区”之一。

很多人对PHP反序列化的理解，还停留在“把字符串变回对象”的层面。这没错，但远远不够。真正的风险在于，这个看似简单的“变回”过程，如果处理不当，会成为一个不受控的代码执行入口。攻击者精心构造的序列化字符串，一旦被 unserialize() 函数处理，就可能触发对象中的 __wakeup() 、 __destruct() 、 __toString() 等魔术方法，进而执行任意系统命令、读取敏感文件，甚至直接获取服务器权限。这绝不是危言耸听，从早期的Joomla、ThinkPHP框架漏洞，到各种CMS和自研系统的安全事件，反序列化漏洞的身影频频出现。

本文要解决的，正是这个核心矛盾： 如何在享受序列化/反序列化带来的开发便利的同时，彻底规避其安全风险？ 我们将不止于复述概念，而是深入剖析其工作原理、攻击链的构建过程，并给出从代码编写、配置加固到安全审计的完整防御方案。无论你是刚接触PHP安全的新手，还是希望加固现有系统的资深开发者，这篇文章都将提供清晰的路径和可落地的实践代码。

1. 为什么PHP反序列化是必须攻克的安全堡垒？

在深入技术细节之前，我们必须先建立共识：为什么PHP反序列化漏洞如此特殊且危险？

首先， 漏洞利用门槛相对较低，但危害极大 。与需要复杂条件组合的SQL注入或XSS不同，一个成功的反序列化漏洞利用，往往只需要向目标接口提交一个精心构造的字符串。一旦触发，攻击者获得的可能是系统级（如 www-data 或 apache 用户）的代码执行权限，相当于拿到了服务器的“后门钥匙”。

其次， 漏洞位置隐蔽，难以通过传统WAF（Web应用防火墙）完全防御 。序列化数据可能出现在Cookie、Session、API参数、数据库存储字段、缓存内容（如Redis、Memcached）等任何地方。攻击载荷（Payload）是一串看似杂乱无章的字符，传统的基于正则表达式的WAF规则很难在不误杀正常业务数据的情况下精准拦截。

最后， 漏洞根植于语言特性本身，而非特定业务逻辑 。只要代码中使用了 unserialize() 且传入参数用户可控，风险就天然存在。更棘手的是，许多流行的PHP框架和库（如Laravel的序列化组件、各种缓存驱动）在底层也依赖此机制，如果开发者不了解其危险性，很容易在无意中引入漏洞。

因此，理解PHP反序列化，不是一项可选的技能，而是PHP开发者保障应用安全的必修课。接下来，我们将从基础开始，一步步拆解这个“潘多拉魔盒”。

2. 核心概念：序列化与反序列化到底是什么？

让我们抛开晦涩的定义，用最直白的场景来理解这两个概念。

序列化（Serialization） ：可以理解为“打包”。想象你要把一个复杂的乐高模型（一个PHP对象）通过快递寄给朋友。你不能把拼好的模型直接寄过去，会散架。你需要把它拆成一块块积木，并附上一张详细的“组装说明书”，写清楚每块积木的类型、颜色、应该放在哪个位置。在PHP中，这个过程就是 serialize() 函数做的——它将一个对象的状态（属性值）转换成一个可存储或传输的字符串（那串“说明书”）。

反序列化（Unserialization） ：自然就是“拆包组装”。你的朋友收到包裹和说明书后，按照说明书的指示，把积木重新拼成原来的模型。在PHP中， unserialize() 函数就是根据序列化字符串，重新创建出与原始对象结构和状态一致的新对象。

来看一个最简单的例子：

<?php
class User {
    public $username;
    public $isAdmin;

    public function __construct($name, $admin) {
        $this->username = $name;
        $this->isAdmin = $admin;
    }

    public function getInfo() {
        return "User: {$this->username}, Admin: " . ($this->isAdmin ? 'Yes' : 'No');
    }
}

// 1. 创建一个对象并序列化（打包）
$user = new User('Alice', false);
$serializedString = serialize($user);
echo "序列化字符串: " . $serializedString . "\n";
// 输出类似：O:4:"User":2:{s:8:"username";s:5:"Alice";s:7:"isAdmin";b:0;}

// 2. 将序列化字符串反序列化（拆包组装）
$restoredUser = unserialize($serializedString);
echo $restoredUser->getInfo(); // 输出：User: Alice, Admin: No
?>

这段代码的输出中， O:4:"User":2:{s:8:"username";s:5:"Alice";s:7:"isAdmin";b:0;} 就是序列化字符串。我们来拆解一下：

• O:4:"User" ：表示一个对象（Object），类名长度为4，是“User”。
• :2: ：表示这个对象有2个属性。
• {s:8:"username";s:5:"Alice"; ：第一个属性，键是长度为8的字符串“username”，值是长度为5的字符串“Alice”。
• s:7:"isAdmin";b:0;} ：第二个属性，键是“isAdmin”，值是布尔值false。

安全问题的核心 就在于： unserialize() 函数在“组装”对象时，会 自动调用 该对象的某些魔术方法（如果它们被定义了）。如果攻击者能够控制传入 unserialize() 的字符串，他就可以指定任意存在的类，并操控其属性值。如果这个类包含危险的魔术方法（比如在 __wakeup() 中执行了 system($_GET['cmd']) ），那么反序列化操作就会变成攻击的触发器。

3. 攻击是如何发生的？剖析反序列化漏洞利用链

理解攻击链，是构建有效防御的前提。一次典型的PHP反序列化攻击通常包含以下几个环节：

环节一：找到反序列化入口点 攻击者会寻找所有用户输入可能传递给 unserialize() 的地方。常见位置包括：

• Cookie，尤其是会话Cookie（如PHPSESSID在某些配置下可能被序列化）。
• 表单参数（POST/GET）。
• API接口的输入参数。
• 从数据库或缓存（Redis）中读取并直接反序列化的数据。

环节二：识别可利用的类（POP链的寻找） 攻击者需要找到应用中存在的、包含“危险”魔术方法的类。这些方法可能执行文件操作、数据库查询、系统命令等。单个类可能无害，但多个类的魔术方法组合起来，就可能形成一条从反序列化起点到危险操作的调用链，这就是所谓的“属性导向编程”（Property-Oriented Programming， POP）链。

一个经典的危险魔术方法示例：

class DangerousClass {
    public $cmd;
    public function __destruct() {
        // 当对象被销毁时，执行系统命令
        system($this->cmd);
    }
}

如果攻击者能控制 $cmd 属性，并让这个类的对象被反序列化后销毁，就能执行任意命令。

环节三：构造并发送恶意序列化字符串 攻击者分析出可利用的类和属性后，会手动构造或使用工具（如PHPGGC）生成对应的序列化字符串，并将其发送到找到的入口点。

环节四：触发漏洞，执行恶意操作 服务器端的 unserialize() 函数处理该字符串，还原对象，自动调用魔术方法，最终执行攻击者预设的恶意代码。

为了更直观地理解，我们来看一个高度简化的漏洞演示环境（ 警告：以下代码仅用于学习，切勿在生产环境或公开服务器上测试 ）。

4. 环境准备：搭建一个安全的漏洞学习环境

在深入研究攻击与防御之前，我们必须在一个 隔离、安全的环境 中进行。强烈建议使用Docker或虚拟机。

4.1 使用Docker快速搭建PHP环境

这是最推荐的方式，可以做到完全隔离。

# 1. 创建一个项目目录
mkdir php-unserialize-lab && cd php-unserialize-lab

# 2. 创建一个简单的Dockerfile
cat > Dockerfile << 'EOF'
FROM php:8.2-apache
RUN docker-php-ext-install mysqli && docker-php-ext-enable mysqli
RUN a2enmod rewrite
COPY src/ /var/www/html/
EOF

# 3. 创建源代码目录和入口文件
mkdir src
cat > src/index.php << 'EOF'
<?php
error_reporting(E_ALL);
ini_set('display_errors', 1);

// 一个存在漏洞的类定义
class VulnerableClass {
    public $data;
    public function __wakeup() {
        // 反序列化时自动调用，这里危险地使用了eval
        if (isset($this->data)) {
            eval($this->data); // 极度危险的操作！
        }
    }
}

// 检查是否有序列化数据传入
if (isset($_POST['input'])) {
    $input = $_POST['input'];
    echo "<h3>反序列化结果：</h3>";
    // 这里直接反序列化用户输入，是漏洞根源
    $obj = unserialize($input);
    var_dump($obj);
}
?>
<!DOCTYPE html>
<html>
<head><title>PHP反序列化实验</title></head>
<body>
    <h2>PHP反序列化漏洞演示（仅供学习）</h2>
    <form method="POST">
        <label for="input">输入序列化字符串：</label><br>
        <textarea name="input" rows="5" cols="80" placeholder='例如：O:15:"VulnerableClass":1:{s:4:"data";s:10:"phpinfo();";}'></textarea><br>
        <input type="submit" value="提交并反序列化">
    </form>
    <hr>
    <h3>生成一个示例序列化字符串：</h3>
    <?php
    $testObj = new VulnerableClass();
    $testObj->data = "echo 'Hello from eval!';";
    echo "serialize(\$testObj): <code>" . htmlspecialchars(serialize($testObj)) . "</code>";
    ?>
</body>
</html>
EOF

# 4. 构建并运行容器
docker build -t php-unserialize-lab .
docker run -d -p 8080:80 --name unserialize-demo php-unserialize-lab

现在，访问 http://localhost:8080 ，你将看到一个简单的表单。这个环境定义了一个危险的 VulnerableClass ，它在 __wakeup() 方法中直接 eval() 了 $data 属性。页面上也提供了生成示例序列化字符串的功能。

4.2 关键安全警告

请务必遵守：

1. 仅在本地或隔离的虚拟网络中运行此环境 。
2. 绝对不要 将此代码部署到任何公网可访问的服务器。
3. 理解这是为了 学习防御 而故意制造的漏洞。

5. 漏洞利用演示：从概念到代码执行

在刚才搭建的环境中，我们已经有了一个明显的漏洞：用户输入的序列化字符串被直接传递给 unserialize() ，并且反序列化出的对象会执行 eval() 。

5.1 手工构造一个简单的攻击载荷

我们的目标是让服务器执行 phpinfo() 函数，以证明代码执行漏洞存在。

我们知道 VulnerableClass 的 __wakeup() 方法会执行 eval($this->data) 。所以，我们需要构造一个序列化字符串，它描述了一个 VulnerableClass 对象，并且其 data 属性的值是字符串 phpinfo(); 。

根据序列化格式，我们可以手工构造：

1. 对象： O:15:"VulnerableClass":1: （一个对象，类名长15，有1个属性）
2. 属性列表开始： {
3. 第一个属性：键是 data （字符串，长度4）： s:4:"data";
4. 第一个属性的值：是 phpinfo(); （字符串，长度10）： s:10:"phpinfo();";
5. 属性列表结束： }

拼接起来： O:15:"VulnerableClass":1:{s:4:"data";s:10:"phpinfo();";}

在网页表单中输入这个字符串并提交，如果环境配置正确，你应该会看到 phpinfo() 函数的输出页面，这证明了任意代码执行成功。

5.2 使用工具生成更复杂的载荷

手工构造对于简单情况可行，但现实中的POP链往往涉及多个类，构造起来非常复杂。安全研究人员开发了诸如 PHPGGC（PHP Generic Gadget Chain） 这样的工具，它收集了各种常见PHP框架和库（如Laravel, Symfony, ThinkPHP, Monolog等）中已知的可利用链，可以一键生成针对特定环境的攻击载荷。

使用示例（在Kali Linux或已安装PHPGGC的环境中）：

# 列出可用的工具链（Gadget Chains）
phpggc -l

# 例如，生成一个针对Laravel框架的反序列化载荷，执行系统命令'id'
phpggc Laravel/RCE1 system 'id'

工具会输出对应的序列化字符串。这提醒我们，即使你没有直接编写危险类，你所依赖的第三方库也可能引入风险。

6. 全面防御：从代码到架构的八层防护

理解了攻击原理后，我们构建防御体系。防御不是单一措施，而是一个多层次的安全纵深。

6.1 第一层：严格的数据源控制（治本之策）

核心原则：永远不要反序列化不可信的数据。 这是最根本、最有效的一层。如果可能，彻底避免使用 unserialize() 。

• 替代方案 ：对于数据交换，使用更安全的标准格式，如JSON。

// 不安全
$data = unserialize($_COOKIE['user_data']);

// 安全：使用JSON
$data = json_decode($_COOKIE['user_data'], true);
if (json_last_error() !== JSON_ERROR_NONE) {
    // 处理JSON解析错误
    throw new InvalidArgumentException('Invalid JSON data.');
}

JSON格式没有执行代码的能力，安全得多。

6.2 第二层：签名与完整性验证

如果业务上必须使用序列化（例如某些复杂的对象缓存），那么必须确保数据在传输或存储后没有被篡改。

• 使用HMAC进行签名 ：在序列化后，对数据生成一个消息认证码（MAC），反序列化前先验证MAC。

function serializeWithSignature($data, $secretKey) {
    $serialized = serialize($data);
    $signature = hash_hmac('sha256', $serialized, $secretKey);
    return base64_encode($signature . '|' . $serialized);
}

function unserializeWithSignature($signedData, $secretKey) {
    $parts = explode('|', base64_decode($signedData), 2);
    if (count($parts) !== 2) {
        throw new Exception('Invalid signed data format.');
    }
    list($expectedSig, $serialized) = $parts;
    $actualSig = hash_hmac('sha256', $serialized, $secretKey);
    if (!hash_equals($expectedSig, $actualSig)) {
        // 签名不匹配，数据可能被篡改
        throw new Exception('Data integrity check failed.');
    }
    return unserialize($serialized);
}

// 使用示例
$secret = 'your-very-secret-key-here';
$obj = new stdClass();
$obj->name = 'Test';

$safeToStore = serializeWithSignature($obj, $secret);
// 存储或传输 $safeToStore

$restoredObj = unserializeWithSignature($safeToStore, $secret);
// 只有签名验证通过，才会执行反序列化

注意 ：这里使用了 hash_equals() 进行恒定时间比较，以避免时序攻击。

6.3 第三层：白名单类限制（PHP 7.0+）

从PHP 7.0开始， unserialize() 函数增加了第二个可选参数 $options ，其中包含 allowed_classes 选项。这允许你指定一个类名的白名单，只有在这个列表中的类才能被反序列化。

// 只允许反序列化 MySafeClass 和 stdClass
$safeData = unserialize($userInput, ['allowed_classes' => ['MySafeClass', 'stdClass']]);

// 或者，完全禁止所有类的反序列化，所有对象都将被反序列化为 __PHP_Incomplete_Class 对象
$safeData = unserialize($userInput, ['allowed_classes' => false]);

最佳实践 ：在生产环境中，除非有绝对必要且经过严格审计，否则应将 allowed_classes 设置为 false 或一个极小的、完全可控的白名单。

6.4 第四层：安全地设计可序列化的类

如果你确实需要定义可序列化的类，请遵循最小权限原则：

• 避免在魔术方法中执行危险操作 ：仔细审查 __wakeup() , __destruct() , __toString() , __call() 等魔术方法。确保它们不包含 eval() , system() , exec() , file_put_contents() 等危险函数的未经验证调用。
• 对属性进行验证 ：在 __wakeup() 方法中，加入对对象属性值的验证逻辑。

class SafeUser {
    public $username;
    public $email;

    public function __wakeup() {
        // 反序列化后，立即验证数据
        if (!is_string($this->username) || !filter_var($this->email, FILTER_VALIDATE_EMAIL)) {
            // 数据无效，可以抛出异常或重置为安全值
            throw new InvalidArgumentException('Invalid user data during unserialization.');
        }
        // 移除任何可能的危险属性（防御性编程）
        foreach ($this as $key => $value) {
            if (strpos($key, 'cmd') !== false || strpos($key, 'eval') !== false) {
                unset($this->$key);
            }
        }
    }
}

6.5 第五层：安全配置与部署

• 及时更新PHP版本 ：新版本PHP会修复已知的反序列化相关漏洞。例如，PHP 7.4对序列化格式进行了改进，PHP 8.x持续增强安全性。
• 使用 open_basedir 和禁用危险函数 ：在 php.ini 中，通过 open_basedir 限制PHP可访问的目录，并通过 disable_functions 禁用如 eval() , system() , exec() , shell_exec() , passthru() 等函数。这能在即使漏洞被触发时，限制攻击者的破坏范围。

; php.ini 配置示例
open_basedir = /var/www/html:/tmp
disable_functions = eval,exec,passthru,shell_exec,system,proc_open,popen,curl_exec,curl_multi_exec,parse_ini_file,show_source

• 配置Web服务器权限 ：运行PHP的进程（如www-data）应具有最小必要权限，避免使用root用户。

6.6 第六层：输入过滤与WAF规则

虽然传统WAF难以完全防御，但可以设置规则拦截已知的、特征明显的攻击载荷。

• 过滤特征字符 ：可以拦截包含明显恶意序列化特征（如 O: 后跟数字和冒号定义对象）的请求，但要注意误杀。
• 使用RASP（运行时应用自我保护） ：RASP技术可以嵌入到应用内部，在 unserialize() 函数被调用时进行深度检测和拦截，比外部WAF更精准。

6.7 第七层：代码审计与依赖管理

• 定期进行代码安全审计 ：重点检查所有 unserialize() 的调用点，确认其输入是否可信。
• 管理第三方依赖 ：使用Composer等工具管理依赖，并定期更新。关注依赖库的安全公告，特别是那些涉及序列化操作的库（如缓存库、序列化组件）。可以使用 composer audit 命令来检查已知漏洞。
• 使用SAST/DAST工具 ：集成静态应用安全测试（SAST）和动态应用安全测试（DAST）工具到CI/CD流程中，自动发现潜在的反序列化漏洞。

6.8 第八层：监控与应急响应

• 记录日志 ：记录所有反序列化操作，包括来源IP、时间、使用的类名（如果允许）等。异常的、高频的或尝试反序列化不存在类的请求，都可能是攻击迹象。
• 部署入侵检测系统（IDS） ：监控服务器上异常的进程启动、网络连接或文件操作。
• 制定应急响应计划 ：一旦发现疑似反序列化攻击，应能快速定位漏洞点、修复代码、更新密钥、清理后门并恢复服务。

7. 实战：安全重构一个存在风险的缓存模块

假设我们有一个简单的用户信息缓存模块，最初版本存在风险：

// 不安全版本：cache_vulnerable.php
class UserCache {
    private $cacheFile = '/tmp/user_cache.dat';

    public function save($user) {
        // 直接将对象序列化后存入文件
        file_put_contents($this->cacheFile, serialize($user));
    }

    public function load() {
        if (file_exists($this->cacheFile)) {
            // 直接从文件读取并反序列化，如果文件被篡改则极其危险
            return unserialize(file_get_contents($this->cacheFile));
        }
        return null;
    }
}

class User {
    public $id;
    public $name;
    public $role; // 假设角色信息
}

风险分析 ：

1. 缓存文件 /tmp/user_cache.dat 可能被其他用户写入（取决于权限）。
2. load() 方法直接反序列化文件内容，没有任何完整性校验。
3. User 类虽然看起来无害，但如果项目中存在其他包含危险魔术方法的类，攻击者可以构造POP链。

安全重构版本 ：

// 安全版本：cache_secure.php
class SecureUserCache {
    private $cacheFile;
    private $secretKey; // 用于签名的密钥

    public function __construct($cacheDir, $secretKey) {
        // 使用更安全的路径和文件名
        $this->cacheFile = rtrim($cacheDir, '/') . '/user_cache_' . hash('sha256', 'secure_prefix') . '.dat';
        $this->secretKey = $secretKey;
        // 确保缓存目录不可被其他用户写入
        if (!is_writable(dirname($this->cacheFile))) {
            throw new RuntimeException('Cache directory is not writable.');
        }
    }

    private function sign($data) {
        return hash_hmac('sha256', $data, $this->secretKey);
    }

    public function save($user) {
        // 1. 使用JSON替代序列化进行存储
        $dataToStore = json_encode($user, JSON_UNESCAPED_UNICODE);
        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new RuntimeException('Failed to encode user data to JSON.');
        }

        // 2. 生成签名并与数据一起存储
        $signature = $this->sign($dataToStore);
        $storageData = base64_encode($signature . '|' . $dataToStore);

        // 3. 原子写入文件，避免竞争条件
        $tmpFile = $this->cacheFile . '.' . uniqid('', true);
        if (file_put_contents($tmpFile, $storageData, LOCK_EX) !== false) {
            rename($tmpFile, $this->cacheFile);
        } else {
            @unlink($tmpFile);
            throw new RuntimeException('Failed to write cache file.');
        }
    }

    public function load() {
        if (!file_exists($this->cacheFile)) {
            return null;
        }

        $storageData = file_get_contents($this->cacheFile);
        if ($storageData === false) {
            return null;
        }

        $decoded = base64_decode($storageData, true);
        if ($decoded === false) {
            // 数据损坏，删除缓存文件
            @unlink($this->cacheFile);
            return null;
        }

        $parts = explode('|', $decoded, 2);
        if (count($parts) !== 2) {
            @unlink($this->cacheFile);
            return null;
        }

        list($expectedSig, $jsonData) = $parts;

        // 关键步骤：验证签名
        if (!hash_equals($expectedSig, $this->sign($jsonData))) {
            // 签名验证失败，数据可能被篡改！记录日志并删除文件。
            error_log('SECURITY ALERT: Cache file integrity check failed for ' . $this->cacheFile);
            @unlink($this->cacheFile);
            return null;
        }

        $userData = json_decode($jsonData, true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            @unlink($this->cacheFile);
            return null;
        }

        // 将数组转换回User对象（假设有合适的构造函数）
        $user = new User();
        $user->id = $userData['id'] ?? null;
        $user->name = $userData['name'] ?? null;
        $user->role = $userData['role'] ?? 'guest'; // 提供默认值
        return $user;
    }
}

// 使用示例
$secretKey = bin2hex(random_bytes(32)); // 生成强密钥
$cache = new SecureUserCache('/var/www/private_cache', $secretKey);

$user = new User();
$user->id = 123;
$user->name = 'Alice';
$user->role = 'user';

$cache->save($user);
$restoredUser = $cache->load();

if ($restoredUser) {
    echo "Loaded user: {$restoredUser->name}\n";
}

重构要点总结 ：

1. 更换数据格式 ：用JSON替代PHP原生序列化，从根本上杜绝反序列化漏洞。
2. 引入完整性验证 ：使用HMAC签名，任何对缓存文件的篡改都会被检测到。
3. 安全存储 ：使用安全的文件路径、权限控制和原子操作。
4. 防御性编程 ：在每一步都进行错误检查，失败时安全地处理（如删除可疑缓存）。
5. 日志记录 ：对安全事件（如签名失败）进行记录，便于审计。

8. 常见问题与排查清单

在实际开发和运维中，你可能会遇到以下问题：

9. 最佳实践与工程化建议

将防御措施工程化，才能形成持久的安全能力。

1. 制定编码规范 ：在团队规范中明确禁止 unserialize($_GET/ $_POST/ $_COOKIE) 等模式，强制使用JSON等安全格式进行数据交换。
2. 依赖库安全审查 ：在引入新的Composer包时，使用 composer audit 检查已知漏洞。定期运行 composer update 更新依赖。特别关注序列化、缓存、RPC相关的库。
3. 安全测试用例 ：在单元测试和集成测试中，加入针对反序列化漏洞的测试用例。例如，向所有接受参数的API端点发送畸形的序列化字符串，验证系统是否返回适当的错误（如400 Bad Request），而不是抛出内部错误或执行代码。
4. 密钥管理 ：如果使用签名方案，必须妥善管理密钥。将密钥存储在环境变量或安全的密钥管理服务中，而不是硬编码在代码里。定期轮换密钥。
5. 防御深度化 ：不要依赖单一防御措施。结合输入验证、签名、白名单、安全配置和运行时监控，构建多层防御体系。
6. 保持更新与教育 ：关注PHP官方安全公告、OWASP Top 10等安全动态。定期对开发团队进行安全培训，让每个人都理解反序列化等核心漏洞的原理与危害。

PHP反序列化漏洞的防御，是一场与攻击者之间关于“信任边界”的博弈。作为开发者，我们的任务就是通过严谨的代码、安全的配置和持续的监控，将这个边界牢牢守住。从今天起，检查你的项目，找到每一个 unserialize() 调用，问自己一句：我信任传入这里的数据吗？如果答案不是百分之百的肯定，那么就是时候按照本文的指南进行加固了。