*本文原创作者：PHITHON，本文属FreeBuf原创奖励计划，未经许可禁止转载
JavaScript是一门非常灵活的语言，我感觉在某些方面可能比PHP更加灵活。所以，除了传统的SQL注入、代码执行等注入型漏洞外，也会有一些独有的安全问题，比如今天要说这个prototype污染。
0x01 prototype和proto分别是什么？
JavaScript中，我们如果要定义一个类，需要以定义“构造函数”的方式来定义：
function Foo() {
this.bar = 1
}
new Foo()
Foo函数的内容，就是Foo类的构造函数，而this.bar就是Foo类的一个属性。
为了简化编写JavaScript代码，ECMAScript 6后增加了class语法，但class其实只是一个语法糖。
一个类必然有一些方法，类似属性this.bar，我们也可以将方法定义在构造函数内部：
function Foo() {
this.bar = 1
this.show = function() {
console.log(this.bar)
}
}
(new Foo()).show()
但这样写有一个问题，就是每当我们新建一个Foo对象时，this.show = function…就会执行一次，这个show方法实际上是绑定在对象上的，而不是绑定在“类”中。
我希望在创建类的时候只创建一次show方法，这时候就则需要使用原型（prototype）了：
function Foo() {
this.bar = 1
}
Foo.prototype.show = function show() {
console.log(this.bar)
}
let foo = new Foo()
foo.show()
我们可以认为原型prototype是类Foo的一个属性，而所有用Foo类实例化的对象，都将拥有这个属性中的所有内容，包括变量和方法。比如上图中的foo对象，其天生就具有foo.show()方法。
我们可以通过Foo.prototype来访问Foo类的原型，但Foo实例化出来的对象，是不能通过prototype访问原型的。这时候，就该proto登场了。
一个Foo类实例化出来的foo对象，可以通过foo.proto属性来访问Foo类的原型，也就是说：
foo.__proto__ == Foo.prototype
所以，总结一下：
1.prototype是一个类的属性，所有类对象在实例化的时候将会拥有prototype中的属性和方法
2.一个对象的proto属性，指向这个对象所在的类的prototype属性
0x02 JavaScript原型链继承
所有类对象在实例化的时候将会拥有prototype中的属性和方法，这个特性被用来实现JavaScript中的继承机制。
比如：
function Father() {
this.first_name = 'Donald'
this.last_name = 'Trump'
}
function Son() {
this.first_name = 'Melania'
}
Son.prototype = new Father()
let son = new Son()
console.log(`Name: ${son.first_name} ${son.last_name}`)
Son类继承了Father类的last_name属性，最后输出的是Name: Melania Trump。
总结一下，对于对象son，在调用son.last_name的时候，实际上JavaScript引擎会进行如下操作：
1.在对象son中寻找last_name
2.如果找不到，则在son.proto中寻找last_name
3.如果仍然找不到，则继续在son.proto.proto中寻找last_name
4.依次寻找，直到找到null结束。比如，Object.prototype的proto就是null
JavaScript的这个查找的机制，被运用在面向对象的继承中，被称作prototype继承链。
以上就是最基础的JavaScript面向对象编程，我们并不深入研究更细节的内容，只要牢记以下几点即可：
1.每个构造函数(constructor)都有一个原型对象(prototype)
2.对象的proto属性，指向类的原型对象prototype
3.JavaScript使用prototype链实现继承机制
0x03 原型链污染是什么
第一章中说到，foo.proto指向的是Foo类的prototype。那么，如果我们修改了foo.proto中的值，是不是就可以修改Foo类呢？
做个简单的实验：
// foo是一个简单的JavaScript对象
let foo = {bar: 1}
// foo.bar 此时为1
console.log(foo.bar)
// 修改foo的原型（即Object）
foo.__proto__.bar = 2
// 由于查找顺序的原因，foo.bar仍然是1
console.log(foo.bar)
// 此时再用Object创建一个空的zoo对象
let zoo = {}
// 查看zoo.bar
console.log(zoo.bar)
最后，虽然zoo是一个空对象{}，但zoo.bar的结果居然是2：
原因也显而易见：因为前面我们修改了foo的原型foo.proto.bar = 2，而foo是一个Object类的实例，所以实际上是修改了Object这个类，给这个类增加了一个属性bar，值为2。
后来，我们又用Object类创建了一个zoo对象let zoo = {}，zoo对象自然也有一个bar属性了。
那么，在一个应用中，如果攻击者控制并修改了一个对象的原型，那么将可以影响所有和这个对象来自同一个类、父祖类的对象。这种攻击方式就是原型链污染。
0x04 哪些情况下原型链会被污染？
在实际应用中，哪些情况下可能存在原型链能被攻击者修改的情况呢？
我们思考一下，哪些情况下我们可以设置proto的值呢？其实找找能够控制数组（对象）的“键名”的操作即可：
1.对象merge
2.对象clone（其实内核就是将待操作的对象merge到一个空对象中）
以对象merge为例，我们想象一个简单的merge函数：
function merge(target, source) {
for (let key in source) {
if (key in source && key in target) {
merge(target[key], source[key])
} else {
target[key] = source[key]
}
}
}
在合并的过程中，存在赋值的操作target[key] = source[key]，那么，这个key如果是proto，是不是就可以原型链污染呢？
我们用如下代码实验一下：
let o1 = {}
let o2 = {a: 1, "__proto__": {b: 2}}
merge(o1, o2)
console.log(o1.a, o1.b)
o3 = {}
console.log(o3.b)
结果是，合并虽然成功了，但原型链没有被污染：
这是因为，我们用JavaScript创建o2的过程（let o2 = {a: 1, “proto“: {b: 2}}）中，proto已经代表o2的原型了，此时遍历o2的所有键名，你拿到的是[a, b]，proto并不是一个key，自然也不会修改Object的原型。
那么，如何让proto被认为是一个键名呢？
我们将代码改成如下：
let o1 = {}
let o2 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}')
merge(o1, o2)
console.log(o1.a, o1.b)
o3 = {}
console.log(o3.b)
可见，新建的o3对象，也存在b属性，说明Object已经被污染：
这是因为，JSON解析的情况下，proto会被认为是一个真正的“键名”，而不代表“原型”，所以在遍历o2的时候会存在这个键。
merge操作是最常见可能控制键名的操作，也最能被原型链攻击，很多常见的库都存在这个问题。
0x05 Code-Breaking 2018 Thejs 分析
我在Code-Breaking 2018中出了一道原型链污染的CTF题目，为了更加贴合真实环境，我没有刻意加太多自己的代码，后端主要代码如下（完整代码可参考这里）：
// ...
const lodash = require('lodash')
// ...
app.engine('ejs', function (filePath, options, callback) {
// define the template engine
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
let compiled = lodash.template(content)
let rendered = compiled({...options})
return callback(null, rendered)
})
})
//...
app.all('/', (req, res) => {
let data = req.session.data || {language: [], category: []}
if (req.method == 'POST') {
data = lodash.merge(data, req.body)
req.session.data = data
}
res.render('index', {
language: data.language,
category: data.category
})
})
lodash是为了弥补JavaScript原生函数功能不足而提供的一个辅助功能集，其中包含字符串、数组、对象等操作。这个Web应用中，使用了lodash提供的两个工具：
1.lodash.template 一个简单的模板引擎
2.lodash.merge 函数或对象的合并
其实整个应用逻辑很简单，用户提交的信息，用merge方法合并到session里，多次提交，session里最终保存你提交的所有信息。
而这里的lodash.merge操作实际上就存在原型链污染漏洞。
在污染原型链后，我们相当于可以给Object对象插入任意属性，这个插入的属性反应在最后的lodash.template中。我们看到lodash.template的代码：
https://github.com/lodash/lodash/blob/4.17.4-npm/template.js#L165
// Use a sourceURL for easier debugging.
var sourceURL = 'sourceURL' in options ? '//# sourceURL=' + options.sourceURL + '\n' : '';
// ...
var result = attempt(function() {
return Function(importsKeys, sourceURL + 'return ' + source)
.apply(undefined, importsValues);
});
options是一个对象，sourceURL取到了其options.sourceURL属性。这个属性原本是没有赋值的，默认取空字符串。
但因为原型链污染，我们可以给所有Object对象中都插入一个sourceURL属性。最后，这个sourceURL被拼接进new Function的第二个参数中，造成任意代码执行漏洞。
我将带有ptoto的Payload以json的形式发送给后端，因为express框架支持根据Content-Type来解析请求Body，这里给我们注入原型提供了很大方便：
点击查看大图
可见，我们代码执行成功，返回了id命令的结果。
整个案例我觉得是一个非常经典的原型链污染漏洞教程，代码不多，逻辑不复杂，没有刻意创造漏洞，真正触发漏洞的代码在库中。
我一直觉得，出题不要刻意创造漏洞，而是找找你的知识点是否能在真实环境下找到应用。
相关文章
*本文原创作者：PHITHON，本文属FreeBuf原创奖励计划，未经许可禁止转载
来源：freebuf.com 2019-04-16 08:00:35 by: phithon
请登录后发表评论
注册