原型链污染（Prototype Pollution）攻击：原理、复现与 `Object.freeze` 防御策略 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位同仁，各位开发者，大家下午好！

今天，我们将共同探讨一个在JavaScript世界中既基础又隐蔽的安全漏洞——原型链污染（Prototype Pollution）攻击。这是一个能让攻击者在运行时向JavaScript应用程序中注入或修改任意属性的强大漏洞，其影响范围之广，足以动摇整个应用的基石。作为一名编程专家，我希望通过这次讲座，不仅带大家深入理解其原理，掌握复现方法，更能学会如何构筑坚实的防御体系，特别是利用Object.freeze等机制来有效抵御此类攻击。

我们将从JavaScript原型机制的本质出发，逐步揭示原型链污染的攻击面，并通过丰富的代码示例，模拟真实世界的攻击场景。最后，我们将重点讨论如何通过严谨的防御策略，尤其是Object.freeze，来保护我们的应用。

第一章：JavaScript原型机制的基石

在深入探讨原型链污染之前，我们必须对JavaScript的核心机制——原型和原型链有一个清晰而深刻的理解。这是理解一切后续攻击的基础。

1.1 什么是原型？

在JavaScript中，几乎所有的对象都是Object的实例，并从Object.prototype继承属性和方法。每个JavaScript对象都有一个指向其原型对象的内部链接。这个原型对象又会有它自己的原型，如此往复，直到某个原型为null为止。这种链接形成了一个所谓的“原型链”。

简单来说，原型就是一个普通对象，它包含一组属性和方法，供其他对象共享和继承。当你试图访问一个对象的某个属性时，如果该对象本身没有这个属性，JavaScript引擎就会沿着原型链向上查找，直到找到该属性或到达原型链的末端（null）。

1.2 `proto` 与 `prototype`：易混淆但至关重要

这两个属性是JavaScript原型机制的核心，但它们的用途和指向的对象截然不同。

prototype (仅存在于函数对象上)
- prototype是函数对象的一个属性，它指向一个原型对象。
- 当你使用new关键字创建一个实例时，新创建的实例的__proto__会指向这个构造函数的prototype对象。
- 例如：MyFunction.prototype
__proto__ (所有对象都有，但不推荐直接使用)
- __proto__是一个访问器属性（getter/setter），它指向当前对象的原型。
- 它是ECMAScript标准中[[Prototype]]内部槽的暴露，用于在运行时访问或设置一个对象的原型。
- 例如：myObject.__proto__
- 重要提示：在现代JavaScript中，推荐使用Object.getPrototypeOf()和Object.setPrototypeOf()来安全地操作原型，而不是直接使用__proto__，因为它可能在某些环境下有性能问题或行为不一致。然而，在原型链污染的语境下，__proto__正是攻击者利用的关键点。

让我们通过一个简单的代码示例来理解它们：

// 1. 定义一个构造函数
function Person(name) {
    this.name = name;
}

// 2. 在构造函数的prototype上添加方法
Person.prototype.greet = function() {
    console.log(`Hello, my name is ${this.name}`);
};

// 3. 创建一个Person实例
const alice = new Person('Alice');

// 4. 观察原型链
console.log("Alice's name:", alice.name); // Alice
alice.greet(); // Hello, my name is Alice

// 实例的__proto__指向构造函数的prototype
console.log("alice.__proto__ === Person.prototype:", alice.__proto__ === Person.prototype); // true

// Person.prototype的原型是Object.prototype
console.log("Person.prototype.__proto__ === Object.prototype:", Person.prototype.__proto__ === Object.prototype); // true

// Object.prototype的原型是null，原型链的终点
console.log("Object.prototype.__proto__:", Object.prototype.__proto__); // null

// 尝试访问一个不存在的属性
console.log("alice.toString === Object.prototype.toString:", alice.toString === Object.prototype.toString); // true
// 解释：alice没有toString方法，沿着原型链找到Person.prototype也没有，最终在Object.prototype上找到。

1.3 原型链的工作原理

当你访问一个对象的属性时，JavaScript引擎会执行以下步骤：

直接查找：首先检查对象自身是否拥有该属性（即使用hasOwnProperty()）。
沿链查找：如果对象本身没有，引擎会沿着其__proto__指向的原型对象继续查找。
递归查找：这个过程会递归地进行，直到找到该属性或者到达原型链的顶端——Object.prototype。
终点：如果到了Object.prototype仍然没有找到，并且Object.prototype的__proto__是null，那么就认为该属性不存在，返回undefined。

这种继承机制使得对象可以共享共同的行为和数据，极大地提高了代码的复用性。然而，也正是这种机制，为原型链污染攻击埋下了伏笔。

第二章：揭秘原型链污染攻击

2.1 什么是原型链污染？

原型链污染（Prototype Pollution）是一种在JavaScript环境中，攻击者能够通过某种手段，修改Object.prototype或构造函数（如Array.prototype）的原型，从而影响所有继承自该原型的对象的行为的漏洞。

由于几乎所有JavaScript对象都最终继承自Object.prototype，一旦Object.prototype被污染，攻击者注入的属性或方法将存在于应用程序中所有对象的原型链上。这意味着，任何后续创建的对象，或者在运行时没有该属性的对象，都将“继承”这个被污染的属性。

2.2 攻击如何发生：修改 `Object.prototype`

原型链污染的核心在于攻击者能够以某种方式向Object.prototype添加或修改属性。这通常发生在应用程序处理用户输入时，特别是在以下场景：

不安全的递归合并（Deep Merge）函数：许多库和框架提供了深层合并对象的功能，例如将用户提供的配置与默认配置合并。如果这些函数没有正确地处理特殊键（如__proto__、constructor、prototype），攻击者就可以构造恶意输入来修改原型。
不安全的属性设置函数：当应用程序允许用户通过点分路径或方括号路径（如obj[key1][key2] = value）来设置对象属性时，如果key1或key2能被控制为__proto__，就可能导致污染。
不安全的克隆（Clone）或序列化/反序列化（Serialization/Deserialization）操作：在某些情况下，不安全的克隆或反序列化过程也可能在处理恶意输入时，意外地将属性写入Object.prototype。

一旦Object.prototype被污染，其后果可能非常严重，包括但不限于：

拒绝服务（Denial of Service, DoS）：通过修改核心方法（如toString），导致应用崩溃。
权限绕过：通过注入isAdmin: true之类的标志，绕过权限检查。
远程代码执行（Remote Code Execution, RCE）：在特定上下文中，如与模板引擎结合时，攻击者可能通过污染某些属性来执行任意代码。
数据泄露：通过修改序列化行为，泄露敏感数据。

2.3 核心攻击载荷（Payload）

攻击者通常会构造如下形式的JSON数据作为输入，以尝试污染原型：

直接通过 __proto__：
```
{
  "__proto__": {
    "isAdmin": true
  }
}
```
当一个不安全的合并或属性设置函数处理这个JSON时，它可能会尝试将isAdmin: true设置到Object.prototype上。
通过 constructor.prototype：
```
{
  "constructor": {
    "prototype": {
      "isAdmin": true
    }
  }
}
```
这种形式利用了constructor属性，它指向对象的构造函数。而构造函数有一个prototype属性，它通常就是该对象实例的原型。在某些特定的场景或旧版JavaScript引擎中，这种方式也可能奏效。
链式攻击：
攻击者可能需要通过多层嵌套才能达到__proto__，例如：
```
{
  "user": {
    "settings": {
      "__proto__": {
        "isAdmin": true
      }
    }
  }
}
```
这取决于应用程序解析输入和设置属性的具体逻辑。

这些载荷的关键在于，它们都试图以某种方式触及并修改Object.prototype。

第三章：复现原型链污染攻击

现在，让我们通过具体的代码示例来模拟几种常见的原型链污染场景。

3.1 场景一：不安全的递归合并函数

许多JavaScript应用会使用自定义的或第三方库提供的递归合并函数来合并配置对象、默认值与用户输入等。如果这些函数没有对特殊属性名进行过滤，就可能成为污染的入口。

考虑一个简单的，但有缺陷的深层合并函数：

// 模拟一个存在原型链污染漏洞的深层合并函数
function unsafeDeepMerge(target, source) {
    for (const key in source) {
        // 关键漏洞点：没有检查key是否为__proto__或constructor
        if (Object.prototype.hasOwnProperty.call(source, key)) {
            if (typeof target[key] === 'object' && target[key] !== null &&
                typeof source[key] === 'object' && source[key] !== null &&
                !Array.isArray(target[key]) && !Array.isArray(source[key])) {
                // 如果是对象，则递归合并
                target[key] = unsafeDeepMerge(target[key] || {}, source[key]);
            } else {
                // 否则直接赋值
                target[key] = source[key];
            }
        }
    }
    return target;
}

console.log("--- 场景一：不安全的递归合并函数 ---");

// 1. 初始状态：Object.prototype是干净的
let obj = {};
console.log("初始状态，obj.polluted:", obj.polluted); // undefined
let anotherObj = {};
console.log("初始状态，anotherObj.polluted:", anotherObj.polluted); // undefined

// 2. 构造恶意载荷
const maliciousPayload = JSON.parse('{"__proto__": {"polluted": "I am polluted from merge!"}}');

// 3. 模拟一个应用程序的行为：将用户输入与一个空对象合并
// 在某些情况下，用户输入可能直接作为source传递给合并函数
let config = {};
unsafeDeepMerge(config, maliciousPayload);

// 4. 检查污染效果
console.log("在合并后，config.polluted:", config.polluted); // undefined (因为config本身没有该属性)

// 关键点：检查新创建的或之前没有该属性的对象的行为
let newObject = {};
console.log("新创建的newObject.polluted:", newObject.polluted); // I am polluted from merge!
let yetAnotherObject = {};
console.log("yetAnotherObject.polluted:", yetAnotherObject.polluted); // I am polluted from merge!

// 5. 验证Object.prototype是否被修改
console.log("Object.prototype.polluted:", Object.prototype.polluted); // I am polluted from merge!

// 6. 模拟一个实际的攻击场景：权限绕过
function checkAdmin(user) {
    if (user.isAdmin) { // 如果user对象本身没有isAdmin，会沿着原型链查找
        console.log(`User ${user.name} is an administrator.`);
    } else {
        console.log(`User ${user.name} is a regular user.`);
    }
}

let regularUser = { name: "Bob" };
console.log("n--- 权限检查前 ---");
checkAdmin(regularUser); // User Bob is a regular user.

// 攻击者发起污染
const adminPayload = JSON.parse('{"__proto__": {"isAdmin": true}}');
unsafeDeepMerge({}, adminPayload); // 假设在某个不显眼的地方触发了合并

console.log("n--- 权限检查后（原型被污染）---");
checkAdmin(regularUser); // User Bob is an administrator. (权限被绕过！)

// 清理污染，便于后续演示
delete Object.prototype.polluted;
delete Object.prototype.isAdmin;

解释： 在unsafeDeepMerge函数中，当处理到source中的__proto__键时，target[key]（即target['__proto__']）会指向Object.prototype。随后的递归合并操作会将{"polluted": "I am polluted from merge!"}合并到Object.prototype上，从而实现污染。

3.2 场景二：不安全的属性设置函数

许多框架和库允许通过一个字符串路径来设置对象的深层属性，例如将"user.profile.name"设置为"Alice"。如果这些函数没有对路径中的特殊字符串（如__proto__）进行过滤，也可能导致原型链污染。

考虑一个有缺陷的属性设置函数：

// 模拟一个存在原型链污染漏洞的属性设置函数
function unsafeSet(obj, path, value) {
    const parts = path.split('.');
    let current = obj;
    for (let i = 0; i < parts.length - 1; i++) {
        const part = parts[i];
        // 关键漏洞点：没有检查part是否为__proto__或constructor
        if (!current[part] || typeof current[part] !== 'object') {
            current[part] = {};
        }
        current = current[part];
    }
    current[parts[parts.length - 1]] = value;
}

console.log("n--- 场景二：不安全的属性设置函数 ---");

// 1. 初始状态
let data = {};
console.log("初始状态，data.config.debug:", data.config?.debug); // undefined
console.log("初始状态，Object.prototype.debugMode:", Object.prototype.debugMode); // undefined

// 2. 模拟应用程序接收用户输入并设置属性
// 攻击者构造恶意路径
const maliciousPath = '__proto__.debugMode';
const maliciousValue = true;

unsafeSet(data, maliciousPath, maliciousValue);

// 3. 检查污染效果
console.log("data.debugMode:", data.debugMode); // undefined (因为data本身没有)

// 关键点：检查新创建的或之前没有该属性的对象的行为
let newSettings = {};
console.log("新创建的newSettings.debugMode:", newSettings.debugMode); // true
let anotherObjectForDebug = {};
console.log("anotherObjectForDebug.debugMode:", anotherObjectForDebug.debugMode); // true

// 4. 验证Object.prototype是否被修改
console.log("Object.prototype.debugMode:", Object.prototype.debugMode); // true

// 5. 模拟一个实际的攻击场景：修改全局配置
let appConfig = {
    env: 'production',
    logLevel: 'info'
};

if (appConfig.debugMode) { // 这会沿着原型链查找
    console.log("--- 应用程序处于调试模式 ---");
} else {
    console.log("--- 应用程序处于生产模式 ---");
}
// 此时输出：--- 应用程序处于调试模式 --- (即使appConfig本身没有debugMode)

// 清理污染
delete Object.prototype.debugMode;

解释： 在unsafeSet函数中，当path是__proto__.debugMode时，parts[0]是__proto__。current会首先指向obj，然后current['__proto__']会指向Object.prototype。接下来，current[parts[parts.length - 1]] = value就变成了Object.prototype['debugMode'] = true，从而污染了Object.prototype。

3.3 场景三：通过 `constructor.prototype` 进行污染（较少见但可能）

这种方法依赖于某些场景下对constructor属性的处理，它可能在某些特定的库或框架中奏效。

// 模拟一个可能被constructor.prototype污染的场景
// 这种场景通常发生在不安全的克隆或对象处理函数中，
// 它们会递归地处理对象的属性，并且没有正确处理constructor。

function unsafeClone(obj) {
    if (obj === null || typeof obj !== 'object') {
        return obj;
    }
    let clone = {};
    for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
            // 关键漏洞点：没有检查key是否为constructor，并对其prototype进行递归处理
            clone[key] = unsafeClone(obj[key]);
        }
    }
    return clone;
}

console.log("n--- 场景三：通过 constructor.prototype 污染 ---");

// 1. 初始状态
let initialObj = {};
console.log("初始状态，initialObj.exploit:", initialObj.exploit); // undefined

// 2. 构造恶意载荷
const constructorPayload = JSON.parse('{"constructor": {"prototype": {"exploit": "RCE possibility!"}}}');

// 3. 尝试通过不安全的克隆触发污染
unsafeClone(constructorPayload); // 假设某个应用逻辑调用了它

// 4. 检查污染效果
let victimObject = {};
console.log("victimObject.exploit:", victimObject.exploit); // RCE possibility!

// 5. 验证Object.prototype是否被修改
console.log("Object.prototype.exploit:", Object.prototype.exploit); // RCE possibility!

// 清理污染
delete Object.prototype.exploit;

解释： 在unsafeClone函数中，当处理到constructorPayload的constructor键时，clone.constructor会被设置为一个对象{"prototype": {"exploit": "RCE possibility!"}}。由于JavaScript的constructor属性的特殊性（它通常指向构造函数，而构造函数有prototype），在某些特定的递归处理逻辑下，如果内部没有做严格的类型检查和属性过滤，这个prototype对象就可能被误认为是真正的Object.prototype，从而被写入exploit属性。这种攻击方式相对复杂，且依赖于特定的实现细节。

第四章：防御策略

原型链污染的防御需要多方面、深层次的考虑。它不仅仅是修补一个bug，更是要建立一套健壮的输入处理和对象操作机制。

4.1 输入验证与净化

这是最基本也是最重要的防御手段。永远不要相信任何来自外部的输入，即使它们看起来是无害的。

白名单机制：明确指定允许的属性名称。对于来自用户输入的键，只接受白名单中列出的键。

示例：

function sanitizeInput(input) {
    const allowedKeys = ['name', 'email', 'age']; // 允许的属性
    const sanitized = {};
    for (const key of allowedKeys) {
        if (input.hasOwnProperty(key)) {
            sanitized[key] = input[key];
        }
    }
    return sanitized;
}
let userInput = { name: "Alice", "__proto__": { "isAdmin": true }, age: 30 };
let cleanInput = sanitizeInput(userInput);
console.log("n--- 防御策略：输入验证 ---");
console.log("清理后的输入:", cleanInput); // { name: "Alice", age: 30 }
let testObj = {};
console.log("Object.prototype.isAdmin (after sanitize):", testObj.isAdmin); // undefined

黑名单机制（不推荐作为唯一手段）：明确禁止__proto__、constructor和prototype这些特殊键。虽然黑名单可以捕获已知的恶意键，但攻击者总可能找到新的绕过方式。白名单更加安全。

示例：

function filterDangerousKeys(obj) {
    const dangerousKeys = ['__proto__', 'constructor', 'prototype'];
    if (typeof obj !== 'object' || obj === null) return obj;

    if (Array.isArray(obj)) {
        return obj.map(filterDangerousKeys);
    }

    const newObj = {};
    for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key) && !dangerousKeys.includes(key)) {
            newObj[key] = filterDangerousKeys(obj[key]);
        }
    }
    return newObj;
}

let pollutedInput = JSON.parse('{"user": {"name": "Eve", "__proto__": {"isAdmin": true}}}');
let cleaned = filterDangerousKeys(pollutedInput);
console.log("过滤危险键后的输入:", cleaned); // { user: { name: 'Eve' } }
let anotherTestObj = {};
console.log("Object.prototype.isAdmin (after filter):", anotherTestObj.isAdmin); // undefined

4.2 安全的对象合并与克隆函数

如果应用程序需要深层合并或克隆对象，务必使用经过安全审计的库，或者实现一个严格检查特殊键的自定义函数。

安全深层合并函数：在遍历source对象的键时，显式检查键名。

示例：

function isObject(item) {
    return (item && typeof item === 'object' && !Array.isArray(item));
}

function safeDeepMerge(target, source) {
    let output = Object.assign({}, target); // 浅克隆目标对象
    if (isObject(target) && isObject(source)) {
        Object.keys(source).forEach(key => {
            // 核心防御：跳过危险键
            if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
                return; // 忽略这些键，不进行合并
            }
            if (isObject(source[key])) {
                if (!(key in target)) {
                    // 如果目标对象没有这个键，则直接赋值（注意这里也需要深拷贝，防止子对象被引用）
                    Object.assign(output, { [key]: safeDeepMerge({}, source[key]) });
                } else {
                    output[key] = safeDeepMerge(target[key], source[key]);
                }
            } else {
                Object.assign(output, { [key]: source[key] });
            }
        });
    }
    return output;
}

console.log("n--- 防御策略：安全深层合并 ---");
let baseConfig = { a: 1, b: { c: 2 } };
let maliciousInput = JSON.parse('{"__proto__": {"pollutedBySafeMerge": true}, "b": {"d": 3}}');

let mergedConfig = safeDeepMerge(baseConfig, maliciousInput);
console.log("安全合并后的配置:", mergedConfig); // { a: 1, b: { c: 2, d: 3 } }
let testObjAfterSafeMerge = {};
console.log("Object.prototype.pollutedBySafeMerge:", testObjAfterSafeMerge.pollutedBySafeMerge); // undefined

4.3 使用 `Object.create(null)` 创建无原型对象

对于用作字典或哈希表的简单对象，如果不需要继承任何Object.prototype上的方法（如toString、hasOwnProperty等），可以使用Object.create(null)来创建一个完全没有原型链的对象。这样的对象不会受到Object.prototype污染的影响。

console.log("n--- 防御策略：Object.create(null) ---");

// 1. 模拟Object.prototype被污染
Object.prototype.globalSetting = "polluted value";

// 2. 创建一个普通对象，它会受到污染
let normalObj = {};
console.log("普通对象继承污染:", normalObj.globalSetting); // polluted value

// 3. 创建一个无原型对象
let safeDict = Object.create(null);
safeDict.myKey = "myValue";
console.log("无原型对象属性:", safeDict.myKey); // myValue
console.log("无原型对象不受污染:", safeDict.globalSetting); // undefined

// 4. 尝试向safeDict中直接添加一个名为__proto__的键
// 这不会导致污染Object.prototype，因为safeDict没有原型链
safeDict.__proto__ = { malicious: true };
console.log("safeDict.__proto__:", safeDict.__proto__); // { malicious: true }
let anotherNormalObj = {};
console.log("另一个普通对象是否被污染:", anotherNormalObj.malicious); // undefined
// 解释：safeDict.__proto__在这里只是一个普通的键，而不是原型链的链接器。

// 清理污染
delete Object.prototype.globalSetting;

注意： 使用Object.create(null)创建的对象不会继承Object.prototype上的任何方法，包括hasOwnProperty。因此，在操作这些对象时，需要使用Object.prototype.hasOwnProperty.call(obj, key)等显式调用方式，或者直接使用in操作符来检查属性是否存在。

4.4 始终使用 `hasOwnProperty` 进行属性检查

当访问或迭代对象的属性时，尤其是当这些属性可能来自外部输入或其来源不可信时，始终使用obj.hasOwnProperty(key)来确保属性是对象自身的，而不是从原型链上继承的。

console.log("n--- 防御策略：使用 hasOwnProperty ---");

// 模拟Object.prototype被污染
Object.prototype.defaultConfig = "global_default";

let userConfig = {
    userId: 123
};

// 1. 错误的属性检查（直接访问）
if (userConfig.defaultConfig) { // 这会从原型链上找到并返回 "global_default"
    console.log("错误检查：用户配置包含defaultConfig:", userConfig.defaultConfig);
} else {
    console.log("错误检查：用户配置不包含defaultConfig");
}

// 2. 正确的属性检查
if (userConfig.hasOwnProperty('defaultConfig') && userConfig.defaultConfig) {
    console.log("正确检查：用户配置包含defaultConfig:", userConfig.defaultConfig);
} else {
    console.log("正确检查：用户配置不包含defaultConfig"); // 输出此行
}

// 清理污染
delete Object.prototype.defaultConfig;

hasOwnProperty能够有效区分对象自身的属性和继承而来的属性，避免因原型污染而导致的意外行为。

4.5 `Object.freeze(Object.prototype)`：最强防线

这是一种非常激进但有效的防御策略。通过在应用程序启动的早期阶段冻结Object.prototype，可以防止对其进行任何添加、删除或修改属性的操作。

console.log("n--- 防御策略：Object.freeze(Object.prototype) ---");

// 1. 在应用程序启动时，立即冻结Object.prototype
// 确保在任何可能导致污染的代码执行之前调用此函数。
Object.freeze(Object.prototype);
console.log("Object.prototype 已被冻结.");

// 验证冻结效果
try {
    Object.prototype.newProp = "Attempt to add"; // 严格模式下会抛出TypeError，非严格模式下静默失败
} catch (e) {
    console.error("尝试向冻结的Object.prototype添加属性失败:", e.message);
}
console.log("Object.prototype.newProp:", Object.prototype.newProp); // undefined

// 再次尝试污染场景一：不安全的递归合并函数
function unsafeDeepMerge_afterFreeze(target, source) {
    for (const key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
            if (typeof target[key] === 'object' && target[key] !== null &&
                typeof source[key] === 'object' && source[key] !== null &&
                !Array.isArray(target[key]) && !Array.isArray(source[key])) {
                target[key] = unsafeDeepMerge_afterFreeze(target[key] || {}, source[key]);
            } else {
                target[key] = source[key];
            }
        }
    }
    return target;
}

let configAfterFreeze = {};
const maliciousPayloadAfterFreeze = JSON.parse('{"__proto__": {"isAdminAfterFreeze": true}}');

try {
    unsafeDeepMerge_afterFreeze(configAfterFreeze, maliciousPayloadAfterFreeze);
} catch (e) {
    // 某些操作可能在严格模式下抛出，非严格模式下静默失败
    console.warn("在冻结后，不安全的合并可能在尝试修改原型时失败:", e.message);
}

let newObjectAfterFreeze = {};
console.log("Object.prototype.isAdminAfterFreeze:", newObjectAfterFreeze.isAdminAfterFreeze); // undefined
console.log("newObjectAfterFreeze.isAdminAfterFreeze:", newObjectAfterFreeze.isAdminAfterFreeze); // undefined

// 讨论Object.freeze的局限性：
// - 必须在应用启动早期执行，否则如果Object.prototype已经被污染，冻结后污染依然存在。
// - 可能会影响一些不规范的第三方库，这些库可能在运行时尝试修改Object.prototype。
//   但这通常被认为是糟糕的实践，冻结Object.prototype也能帮助发现并修复这些问题。
// - 冻结只影响Object.prototype对象本身，不影响从它继承的实例对象。
//   实例对象仍然可以添加、删除或修改自己的属性。

Object.freeze()工作原理：

防止属性添加：不能向冻结的对象添加新属性。
防止属性删除：不能从冻结的对象中删除现有属性。
防止属性修改：不能修改冻结对象中现有属性的值、可写性、可配置性。
防止原型修改：不能修改冻结对象的原型（[[Prototype]]）。

当Object.freeze(Object.prototype)被调用后，任何试图通过__proto__或constructor.prototype向Object.prototype添加新属性或修改其现有属性（如toString）的操作都会失败（在严格模式下抛出TypeError，非严格模式下静默失败）。这提供了一个强大的、全局性的防御措施。

表格：原型链污染防御策略总结

防御策略	描述	优点	缺点/注意事项
输入验证与净化	使用白名单机制严格过滤用户输入的属性键和值。	精准，从源头阻止恶意数据。	需要全面覆盖所有输入点，易遗漏。
安全的对象操作函数	实现或使用经过安全审计的深层合并、克隆、属性设置函数，显式禁止`__proto__`、`constructor`等特殊键。	针对常见攻击向量，提高代码健壮性。	需要确保所有相关操作都使用安全函数，可能增加代码复杂性。
`Object.create(null)`	对于不需要原型继承的纯字典对象，使用`Object.create(null)`创建。	完全免疫`Object.prototype`污染。	对象不具备`Object.prototype`上的方法，如`hasOwnProperty`，需注意使用。
`hasOwnProperty`	在访问或迭代对象属性时，始终使用`hasOwnProperty`检查属性是否为对象自身所有。	防止误用继承属性，避免因污染造成的逻辑错误。	不能阻止污染发生，仅能防止污染属性被意外使用。
`Object.freeze(Object.prototype)`	在应用程序启动早期冻结`Object.prototype`，阻止对其的任何修改。	最强的全局防御措施，一劳永逸。	必须在应用启动早期执行；可能影响不规范的第三方库。

第五章：总结与展望

原型链污染攻击揭示了JavaScript原型机制的强大与脆弱并存的特性。它提醒我们，在构建复杂的Web应用程序时，对核心语言机制的深入理解至关重要，特别是当应用程序需要处理不可信的外部输入时。

通过今天的讲座，我们不仅学习了原型链污染的原理和复现方法，更重要的是掌握了多种有效的防御策略。从源头的输入验证，到安全的业务逻辑实现，再到最终的全局性防御措施如Object.freeze(Object.prototype)，这些策略共同构筑了一道坚固的安全防线。

请记住，安全是一个持续的过程，而非一次性的任务。在日常开发中，始终保持警惕，定期审查代码，并关注最新的安全实践，才能确保我们的应用程序在不断演进的威胁环境中保持安全与稳定。希望这次讲座能为大家在JavaScript安全编程的道路上提供有益的指引。