进入题目环境，首先进入sign up创建一个admin用户，下方有勾选 is admin，打上勾
随便填写Invite Code，进行抓包
如果是新手看不懂是什么意思无所谓，这是一道JavaScript原型链污染
测试了一会儿，发现加上__proto__ 这个继承对象的属性payload后，不需要管Invite Code是什么，也能注册成功
admin/admin登录进去后就能够看到flag
CatCTF{test_flag_h0w_c@n_I_l1ve_w1th0ut_nilou}
一、下面是对__proto__的解释：
在 JavaScript 中，proto 是一个对象属性，用于实现原型继承（Prototype Inheritance）。它指向该对象的原型对象（即创建该对象的构造函数的 prototype 属性），从而允许对象继承其他对象的属性和方法。以下是其核心作用和详细说明：
一、基本概念与作用
原型链机制
JavaScript 是基于原型的语言，对象通过 proto 链接到其原型对象，形成原型链。
当访问一个对象的属性 / 方法时，JavaScript 首先在对象本身查找，若不存在则沿 proto 向上查找，直到原型链末尾（Object.prototype）或找到为止。
proto 与 prototype 的区别
proto：实例对象的属性，指向其原型对象（即构造函数的 prototype）。
prototype：构造函数的属性，是一个普通对象，用于为实例提供共享属性和方法。
javascript
const obj = new Object();
obj.__proto__ === Object.prototype; // true（实例的 __proto__ 指向构造函数的 prototype）
二、proto 的具体用途
动态修改原型
可通过 proto 为现有对象动态添加或替换原型，改变继承关系。
javascript
const animal = { speak() { console.log("Animal sound"); } };
const dog = {};
dog.__proto__ = animal; // dog 继承 animal 的方法
dog.speak(); // 输出: "Animal sound"
实现继承
在 ES6 之前，常通过 proto 手动实现继承（ES6 后推荐使用 class 和 extends）。
javascript
function Animal() { this.type = "animal"; }
Animal.prototype.speak = function() { console.log("Sound"); };
function Dog() { this.breed = "Labrador"; }
Dog.prototype.__proto__ = Animal.prototype; // Dog 继承 Animal
const dog = new Dog();
dog.speak(); // 输出: "Sound"
检查原型链
通过 proto 可逐层访问对象的原型链，用于调试或验证继承关系。
javascript
const arr = [];
arr.__proto__ === Array.prototype; // true
arr.__proto__.__proto__ === Object.prototype; // true
三、注意事项与替代方案
性能与兼容性问题
性能开销：动态修改 proto 会影响对象属性查找速度，现代引擎对此有优化但仍需谨慎。
兼容性：proto 是历史遗留特性（ES6 才标准化），部分旧环境（如 IE10 及以下）不支持。
推荐替代方案
Object.create()
：创建新对象时直接指定原型。
javascript
const animal = { speak() { console.log("Sound"); } };
const dog = Object.create(animal); // 等价于 dog.__proto__ = animal
ES6 class/extends
：更简洁的继承语法（本质仍基于原型）。
javascript
class Animal { speak() { console.log("Sound"); } }
class Dog extends Animal {}
Object.setPrototypeOf()
：显式修改原型（不推荐频繁使用）。
javascript
Object.setPrototypeOf(dog, animal); // 等价于 dog.__proto__ = animal
四、与现代 JavaScript 的关系
proto 的设计初衷：提供一种直观但非标准的方式访问原型（早期 JavaScript 未暴露原型机制）。
现代实践：优先使用 Object.create()、class、extends 等语法，避免直接操作 proto 以提升性能和代码可维护性。
总结
proto 是 JavaScript 原型链的核心机制，允许对象继承其他对象的属性和方法。尽管它提供了动态修改继承关系的灵活性，但由于性能和兼容性问题，现代开发中更推荐使用标准化的替代方案。理解 proto 有助于深入掌握 JavaScript 的继承原理，但实际编码中应谨慎使用。
二、下面是关于js原型链污染的原理和防御：
一、原型链污染的核心原理
- JavaScript 原型继承机制
JavaScript 是基于原型的语言，每个对象都有一个内部属性[[Prototype]]（可通过__proto__访问），指向其原型对象。当访问一个对象的属性时，JavaScript 会：
先在对象本身查找
如果找不到，沿原型链向上查找
直到Object.prototype为止
例如：
const person = { name: "Alice" };
console.log(person.toString()); // 继承自Object.prototype
这里toString()方法并非person对象自身的属性，而是通过原型链从Object.prototype继承而来。
- 动态原型修改
JavaScript 允许动态修改对象的原型，包括内置对象的原型。原型链污染攻击就是利用这一点，通过修改Object.prototype或其他原型对象，向其中注入恶意属性或方法。
关键方法包括：
直接修改__proto__属性
使用Object.setPrototypeOf()
利用漏洞函数（如merge()、JSON.parse()的自定义解析器）
二、攻击实例解析
- 经典案例：利用不安全的对象合并函数
许多 JavaScript 库提供对象合并功能（如lodash.merge、Object.assign），但如果实现不当，可能导致原型污染。
漏洞代码示例：
function merge(target, source) {
for (let key in source) {
if (source.hasOwnProperty(key)) {
if (typeof source[key] === 'object' && source[key] !== null) {
if (typeof target[key] !== 'object') {
target[key] = {};
}
merge(target[key], source[key]); // 递归合并
} else {
target[key] = source[key];
}
}
}
return target;
}
// 攻击者可控的输入
const payload = JSON.parse('{"__proto__":{"isAdmin":true}}');
const obj = {};
merge(obj, payload); // 合并操作
console.log(obj.isAdmin); // 输出: undefined
console.log({}.isAdmin); // 输出: true！污染了Object.prototype
攻击路径：
攻击者构造特殊 JSON 数据，包含__proto__键
应用使用有漏洞的合并函数处理该数据
合并过程中，Object.prototype被修改，添加了isAdmin属性
所有对象（包括新创建的对象）都会继承这个属性
2. 实际应用场景：绕过权限检查
在 Web 应用中，权限检查可能依赖于用户对象的isAdmin属性：
function checkAdmin(request) {
return request.user.isAdmin === true;
}
// 正常情况下
const normalUser = { username: "user" };
checkAdmin({ user: normalUser }); // false
// 原型污染后
checkAdmin({ user: {} }); // true！空对象也被认为是管理员
三、防御策略详解
- 禁止直接修改原型
安全合并函数改进：
function safeMerge(target, source) {
for (let key in source) {
if (source.hasOwnProperty(key)) {
// 跳过原型属性
if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
continue;
}
if (typeof source[key] === 'object' && source[key] !== null) {
if (typeof target[key] !== 'object') {
target[key] = {};
}
safeMerge(target[key], source[key]);
} else {
target[key] = source[key];
}
}
}
return target;
}
- 使用不可变对象
通过Object.freeze()防止对象被修改：
// 冻结Object.prototype
Object.freeze(Object.prototype);
// 尝试污染
const payload = JSON.parse('{"__proto__":{"isAdmin":true}}');
merge({}, payload);
console.log({}.isAdmin); // 输出: undefined（污染失败）
- 输入验证与过滤
对用户输入进行严格验证，拒绝包含__proto__、constructor等敏感键的数据
使用安全的 JSON 解析库（如secure-json-parse）
const secureParse = require('secure-json-parse');
const input = '{"__proto__":{"evil":"payload"}}';
try {
const data = secureParse(input); // 自动防御原型链污染
} catch (e) {
console.error('恶意输入:', e.message);
}
- 框架和库的安全配置
使用经过安全审计的库
避免使用body-parser等易受攻击的中间件（改用express.json()并配置strict: true）
定期更新依赖，修复已知漏洞
四、高级渗透测试技巧 - 自动化检测工具
使用 AST（抽象语法树）分析工具检测潜在的原型链污染点
结合 fuzz 测试，自动生成恶意输入
推荐工具：PrototypePolluted、Retire.js - 实战中的漏洞挖掘
在代码审计中重点关注
递归合并函数
动态属性赋值
自定义 JSON 解析器
使用eval()或Function()动态执行代码的位置
检测代码示例：
// 查找潜在的原型链污染点
const acorn = require('acorn');
const fs = require('fs');
const code = fs.readFileSync('vulnerable.js', 'utf8');
const ast = acorn.parse(code, { ecmaVersion: 2020, sourceType: 'module' });
// 查找所有for...in循环
function findForInLoops(node) {
if (node.type === 'ForInStatement') {
console.log('潜在风险: 未过滤的for...in循环', node.loc);
}
for (let key in node) {
if (typeof node[key] === 'object' && node[key] !== null) {
findForInLoops(node[key]);
}
}
}
findForInLoops(ast);
五、总结
JavaScript 原型链污染是一种隐蔽但危害极大的漏洞，利用了 JavaScript 动态原型系统的特性。作为安全工程师，我们需要：
深入理解 JavaScript 原型机制
在开发阶段实施严格的防御措施
在渗透测试中重点关注潜在风险点
持续监控和更新依赖库
扫一扫
8073
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
