原型污染攻击与防御：一场关于 JavaScript 对象本质的攻防战
大家好，今天我们来聊聊一个在 JavaScript 安全领域越来越受到重视的话题：原型污染攻击。它利用了 JavaScript 原型链的特性，悄无声息地修改对象原型，从而影响到所有基于该原型创建的对象，进而可能导致各种安全问题，例如代码注入、拒绝服务等。
什么是原型污染？
在 JavaScript 中，每个对象都有一个原型（prototype）。当我们访问对象的属性时，如果对象自身没有该属性，JavaScript 引擎会沿着原型链向上查找，直到找到该属性或者到达原型链的顶端（null）。原型污染攻击就是利用这个机制，通过修改对象的原型，使得攻击者可以控制所有基于该原型创建的对象的属性值。
举个简单的例子：
// 创建一个对象
const obj = {};
// 修改 Object.prototype
Object.prototype.isAdmin = true;
// 检查 obj 是否拥有 isAdmin 属性
console.log(obj.isAdmin); // 输出：true
// 创建另一个对象
const obj2 = {};
console.log(obj2.isAdmin); // 输出：true在这个例子中，我们直接修改了 Object.prototype，这导致所有对象都继承了 isAdmin 属性，并且值为 true。 这就是原型污染的简单演示。虽然这个例子很简单，但它揭示了原型污染的核心机制：通过修改原型，影响所有基于该原型创建的对象。
原型污染的攻击原理
原型污染的攻击通常利用了 JavaScript 中一些不安全的 API 和操作，例如：
- 递归合并对象: 一些库或者自定义函数会递归地合并对象，如果目标对象和源对象都包含可控的属性，攻击者就可以通过精心构造的源对象来污染目标对象的原型。
- 利用
__proto__属性:__proto__属性允许直接访问对象的原型，如果程序允许用户控制__proto__属性的值，攻击者就可以直接修改对象的原型。 - JSON 反序列化: 如果程序使用
JSON.parse()函数来处理用户输入，并且没有对输入进行严格的验证，攻击者可以通过构造恶意的 JSON 字符串来污染对象的原型。
下面我们分别通过代码示例来具体说明这些攻击原理。
1. 递归合并对象
许多 JavaScript 库（例如 lodash 的 merge 函数）提供了递归合并对象的功能。如果使用不当，这些函数可能会导致原型污染。
function merge(target, source) {
for (const key in source) {
if (typeof source[key] === 'object' && source[key] !== null && typeof target[key] === 'object' && target[key] !== null) {
merge(target[key], source[key]); // 递归合并
} else {
target[key] = source[key];
}
}
return target;
}
const obj = {};
const source = { "__proto__": { "isAdmin": true } };
merge(obj, source);
console.log(({}).isAdmin); // 输出：true在这个例子中，merge 函数递归地合并 obj 和 source 对象。由于 source 对象的 __proto__ 属性指向了一个包含 isAdmin 属性的对象，因此 Object.prototype 被污染，所有对象都继承了 isAdmin 属性。
2. 利用 __proto__ 属性
__proto__ 属性允许直接访问和修改对象的原型。如果程序允许用户控制 __proto__ 属性的值，攻击者就可以直接修改对象的原型。
const obj = {};
const userInput = '{"__proto__": {"isAdmin": true}}';
try {
const parsed = JSON.parse(userInput);
Object.assign(obj, parsed); // 将解析后的对象合并到 obj 中
} catch (error) {
console.error("Error parsing JSON:", error);
}
console.log(({}).isAdmin); // 输出：true在这个例子中，用户输入 userInput 被解析为 JSON 对象，然后使用 Object.assign() 函数合并到 obj 对象中。由于 userInput 中包含了 __proto__ 属性，因此 Object.prototype 被污染。
3. JSON 反序列化
即使不直接使用 __proto__，攻击者也可以通过构造特定的 JSON 字符串来触发原型污染。某些 JSON 解析器在处理特定格式的 JSON 时，可能会错误地修改对象的原型。
const obj = {};
const userInput = '{"constructor": {"prototype": {"isAdmin": true}}}';
try {
const parsed = JSON.parse(userInput);
Object.assign(obj, parsed); // 将解析后的对象合并到 obj 中
} catch (error) {
console.error("Error parsing JSON:", error);
}
console.log(({}).isAdmin); // 输出：true在这个例子中，攻击者利用了 constructor.prototype 来修改 Object.prototype。 这种利用方式依赖于 JSON 解析器的具体实现和行为，不同的解析器可能会有不同的表现。
原型污染的危害
原型污染攻击的危害是多方面的，主要包括：
- 权限提升: 攻击者可以通过修改对象的原型来添加管理员权限或其他敏感权限，从而控制整个应用程序。
- 代码注入: 攻击者可以通过修改对象的原型来注入恶意代码，例如，修改
Function.prototype.constructor来执行任意代码。 - 拒绝服务: 攻击者可以通过修改对象的原型来导致程序崩溃或变得不稳定，从而实现拒绝服务攻击。
- 信息泄露: 攻击者可以通过修改对象的原型来获取敏感信息，例如，修改
Object.prototype.toString来泄露对象的内部状态。
如何防御原型污染？
防御原型污染需要从多个方面入手，包括：
- 使用安全的 API: 避免使用不安全的 API，例如
eval()、Function()等。 - 输入验证: 对用户输入进行严格的验证，确保输入的数据符合预期的格式和类型。
- 对象冻结: 使用
Object.freeze()或Object.seal()函数来冻结或封闭对象，防止对象被修改。 - 使用
Object.create(null)创建对象:Object.create(null)创建的对象没有原型，因此不会受到原型污染的影响。 - 使用 Map 和 Set 数据结构: Map 和 Set 数据结构不继承自 Object.prototype，因此不会受到原型污染的影响。
- 使用沙箱环境: 在沙箱环境中运行不受信任的代码，限制代码的访问权限。
- 使用静态类型检查: 使用 TypeScript 或 Flow 等静态类型检查工具来检测潜在的原型污染漏洞。
- 代码审查: 进行代码审查，检查代码是否存在原型污染的风险。
- 使用安全库: 使用经过安全审计的库，避免使用存在原型污染漏洞的库。
下面我们详细介绍一些常用的防御方法。
1. 使用安全的 API
尽量避免使用 eval()、Function() 等不安全的 API，因为这些 API 允许执行任意代码，容易受到代码注入攻击，也为原型污染提供了可乘之机。
2. 输入验证
对用户输入进行严格的验证，确保输入的数据符合预期的格式和类型。例如，可以使用正则表达式来验证输入的字符串是否符合预期的模式。
function isValidUsername(username) {
const usernameRegex = /^[a-zA-Z0-9_]{3,20}$/; // 允许字母、数字和下划线，长度为 3-20
return usernameRegex.test(username);
}
const username = "valid_username";
const invalidUsername = "invalid username!";
console.log(isValidUsername(username)); // 输出：true
console.log(isValidUsername(invalidUsername)); // 输出：false3. 对象冻结
使用 Object.freeze() 或 Object.seal() 函数来冻结或封闭对象，防止对象被修改。
Object.freeze()：冻结对象，使其属性既不能修改，也不能添加或删除。Object.seal()：封闭对象，使其属性不能添加或删除，但可以修改。
const obj = { name: "test", isAdmin: false };
Object.freeze(obj);
obj.isAdmin = true; // 尝试修改属性
console.log(obj.isAdmin); // 输出：false，修改失败
obj.newProperty = "value"; // 尝试添加新属性
console.log(obj.newProperty); // 输出：undefined，添加失败
const sealedObj = { name: "test", isAdmin: false };
Object.seal(sealedObj);
sealedObj.isAdmin = true; // 尝试修改属性
console.log(sealedObj.isAdmin); // 输出：true，修改成功
sealedObj.newProperty = "value"; // 尝试添加新属性
console.log(sealedObj.newProperty); // 输出：undefined，添加失败4. 使用 Object.create(null) 创建对象
Object.create(null) 创建的对象没有原型，因此不会受到原型污染的影响。这是一种有效的防御原型污染的方法。
const obj = Object.create(null);
obj.__proto__ = { isAdmin: true }; // 尝试污染原型
console.log(obj.isAdmin); // 输出：undefined，原型污染无效
console.log(({}).isAdmin); // 输出：undefined，全局原型未被污染5. 使用 Map 和 Set 数据结构
Map 和 Set 数据结构不继承自 Object.prototype，因此不会受到原型污染的影响。在需要存储键值对或集合数据时，可以优先考虑使用 Map 和 Set。
const map = new Map();
map.set("__proto__", { isAdmin: true });
console.log(map.get("__proto__").isAdmin); // 输出：true，仅影响 map 对象自身
console.log(({}).isAdmin); // 输出：undefined，全局原型未被污染
const set = new Set();
set.add("__proto__");
console.log(set.has("__proto__")); // 输出：true，仅影响 set 对象自身6. 使用沙箱环境
在沙箱环境中运行不受信任的代码，限制代码的访问权限。沙箱环境可以隔离代码的执行环境，防止恶意代码对系统造成损害。
7. 使用静态类型检查
使用 TypeScript 或 Flow 等静态类型检查工具来检测潜在的原型污染漏洞。静态类型检查工具可以在编译时发现类型错误，从而减少运行时错误的发生。
8. 代码审查
进行代码审查，检查代码是否存在原型污染的风险。代码审查可以发现潜在的安全漏洞，并及时进行修复。
9. 使用安全库
使用经过安全审计的库，避免使用存在原型污染漏洞的库。在选择库时，应仔细评估库的安全性，并选择经过安全审计的库。
防御策略总结
为了更好地理解各种防御策略的适用场景和效果，我们可以用表格进行总结：
| 防御策略 | 描述 | 优点 | 缺点 |
|---|---|---|---|
| 使用安全的 API | 避免使用 eval()、Function() 等不安全的 API。 |
从源头上减少了代码注入和原型污染的风险。 | 可能需要重构代码，替换不安全的 API。 |
| 输入验证 | 对用户输入进行严格的验证，确保输入的数据符合预期的格式和类型。 | 可以防止恶意输入导致的原型污染。 | 需要编写大量的验证代码，并且需要不断更新验证规则。 |
| 对象冻结 | 使用 Object.freeze() 或 Object.seal() 函数来冻结或封闭对象，防止对象被修改。 |
可以防止对象被意外修改，从而避免原型污染。 | 可能会限制对象的灵活性，影响程序的正常运行。 |
使用 Object.create(null) |
使用 Object.create(null) 创建的对象没有原型，因此不会受到原型污染的影响。 |
可以有效地防止原型污染。 | 创建的对象没有继承 Object.prototype 的属性和方法，可能需要手动添加一些常用的属性和方法。 |
| 使用 Map 和 Set 数据结构 | Map 和 Set 数据结构不继承自 Object.prototype，因此不会受到原型污染的影响。 |
可以有效地防止原型污染。 | 不适用于所有场景，只有在需要存储键值对或集合数据时才适用。 |
| 使用沙箱环境 | 在沙箱环境中运行不受信任的代码，限制代码的访问权限。 | 可以隔离代码的执行环境，防止恶意代码对系统造成损害。 | 可能会增加程序的复杂性，并且需要额外的资源来维护沙箱环境。 |
| 使用静态类型检查 | 使用 TypeScript 或 Flow 等静态类型检查工具来检测潜在的原型污染漏洞。 | 可以在编译时发现类型错误，从而减少运行时错误的发生。 | 需要学习和使用新的工具，并且需要修改代码以适应静态类型检查。 |
| 代码审查 | 进行代码审查，检查代码是否存在原型污染的风险。 | 可以发现潜在的安全漏洞，并及时进行修复。 | 需要投入大量的人力和时间，并且需要专业的安全知识。 |
| 使用安全库 | 使用经过安全审计的库，避免使用存在原型污染漏洞的库。 | 可以降低引入安全漏洞的风险。 | 需要仔细评估库的安全性，并且需要及时更新库的版本。 |
总结与防御建议
原型污染是一种严重的安全威胁，攻击者可以通过修改对象的原型来控制整个应用程序。防御原型污染需要从多个方面入手，包括使用安全的 API、输入验证、对象冻结、使用 Object.create(null) 创建对象、使用 Map 和 Set 数据结构、使用沙箱环境、使用静态类型检查、代码审查和使用安全库。
选择合适的防御策略取决于具体的应用场景和安全需求。在开发过程中，应始终关注原型污染的风险，并采取相应的防御措施，确保应用程序的安全性。
持续学习是关键
随着 JavaScript 技术的不断发展，新的攻击方式和防御方法也在不断涌现。我们需要持续学习和关注安全领域的最新动态，才能更好地保护我们的应用程序免受原型污染的威胁。
希望今天的分享对大家有所帮助，谢谢！