怎么在Java中安全地执行不可信JavaScript代码?

作者:工具松鼠时间:2026-11-16 18:13:32浏览:434

讲解在Java中安全执行不可信JavaScript代码的具体方案:分析越权、死循环与内存耗尽风险,对比Nashorn、Rhino与GraalVM Polyglot,给出关闭宿主权限、限制语句配额、外部强制超时及进程级隔离的完整实现与注意事项。

怎么在Java中安全地执行不可信JavaScript代码?
Java 安全执行不可信 JavaScript 代码的核心隔离模型

在 Java 中安全执行不可信 JavaScript 代码,核心做法是使用 GraalVM Polyglot(GraalJS)构建默认拒绝所有宿主权限的沙箱上下文,再配合语句配额和外部线程强制中断;如果脚本来自完全不可信的外部用户或多租户环境,还需要把沙箱放到独立子进程或受限容器中,用操作系统资源边界兜底内存与 CPU 消耗。单纯依赖历史引擎的类过滤无法防住死循环和内存耗尽。

一、为什么在 Java 中直接执行 JS 会失控?

把一段外部传入的 JavaScript 放进 Java 应用里直接求值,风险并不止于“脚本能调用多少个 Java 类”。只要脚本与核心业务运行在同一个 JVM 进程中,失控可能从权限、CPU、内存和入参对象四个方向同时发生。

怎么在Java中安全地执行不可信JavaScript代码?
图 1:不可信 JS 脚本在无保护的 JVM 环境中可能触发的四类典型失控路径

尤其是路径 B 和路径 C,在实际生产事故中往往比“执行系统命令”更容易发生。因为哪怕脚本没有访问任何 Java 类,只需要写一行 while (true) {},就能让当前请求线程一直卡在纯计算循环里,而 Java 的 Thread.interrupt() 并不会自动打断正在运行的 JS 解释执行。

二、Java 执行 JS 的常见方案怎么选?

在决定具体代码怎么写之前,需要先选对引擎和运行边界。Java 生态里能执行 JS 的常见方式主要有四类,它们在 JDK 兼容性、权限控制和抗 DoS 能力上差异很大。

怎么在Java中安全地执行不可信JavaScript代码?
图 2:Java 中执行不可信 JS 的四种常见方案及选型边界

选型时可以按脚本来源直接判断:如果你跑的是受过平台审核、主要防误写或越权调用的轻量公式或业务规则,在应用内使用 GraalVM Polyglot 并做好超时与语句配额通常足够;如果你要运行匿名用户提交的任意脚本、多租户自定义插件,或无法预估内存占用的复杂逻辑,就必须把 GraalVM 沙箱放进独立子进程或容器中。

对于历史项目中还在使用的 JDK 8 Nashorn,需要注意 JDK 11 已正式标记废弃(JEP 335),JDK 15 已将其彻底移除(JEP 372),继续依赖它不仅面临升级障碍,也缺少现代沙箱必需的语句级配额与中断能力。

三、用 GraalVM Polyglot 搭建最小权限沙箱

即使最终要部署到独立 Worker 进程里,引擎本身的沙箱配置依然是第一道防线。GraalVM Polyglot 不要求你把整个生产环境都换成 GraalVM JDK,在标准的 OpenJDK(如 JDK 17 或 JDK 21)项目中直接通过 Maven 引入 Polyglot API 与 JavaScript 语言实现包即可使用。

怎么在Java中安全地执行不可信JavaScript代码?
图 3:使用 GraalVM Polyglot 搭建受限 JavaScript 沙箱的五步实施流程

第一步:确认 Maven 依赖

在项目的 pom.xml 中引入 GraalVM Polyglot API 与 JavaScript 语言依赖。由于不同 GraalVM 大版本在包坐标和 Java 最低版本要求上有所调整,请在 Maven Central 或 GraalVM 官方文档中确认与你当前 JDK 匹配的稳定版本号后再填入:

<dependencies>
  <!-- Polyglot 核心 API -->
  <dependency>
    <groupId>org.graalvm.polyglot</groupId>
    <artifactId>polyglot</artifactId>
    <version>请替换为与当前JDK匹配的稳定版本</version>
  </dependency>
  <!-- JavaScript 语言实现(部分版本坐标为 org.graalvm.js:js,请以官方文档为准) -->
  <dependency>
    <groupId>org.graalvm.polyglot</groupId>
    <artifactId>js</artifactId>
    <version>与上面一致的稳定版本</version>
  </dependency>
</dependencies>

第二步:编写受限沙箱执行器

下面给出一个可直接参考的沙箱执行器示例 SafeJsSandbox.java。它把“权限全关”“语句上限”“外部硬超时取消”“JSON 纯数据交换”和“异常分类”串在了一起:

package com.example.sandbox;

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Engine;
import org.graalvm.polyglot.EnvironmentAccess;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.PolyglotException;
import org.graalvm.polyglot.ResourceLimits;
import org.graalvm.polyglot.Source;
import org.graalvm.polyglot.Value;
import org.graalvm.polyglot.io.IOAccess;

import java.time.Duration;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class SafeJsSandbox implements AutoCloseable {

    private static final int MAX_SCRIPT_LENGTH = 16_384;
    private static final long MAX_STATEMENTS = 50_000L;

    private final Engine sharedEngine;
    private final ScheduledExecutorService timeoutScheduler;

    public SafeJsSandbox() {
        this.sharedEngine = Engine.newBuilder("js")
                .option("engine.WarnInterpreterOnly", "false")
                .build();
        this.timeoutScheduler = Executors.newScheduledThreadPool(2, r -> {
            Thread t = new Thread(r, "js-sandbox-watchdog");
            t.setDaemon(true);
            return t;
        });
    }

    public String execute(String userScript, String inputJson, Duration timeout) {
        if (userScript == null || userScript.isBlank()) {
            throw new IllegalArgumentException("脚本内容不能为空");
        }
        if (userScript.length() > MAX_SCRIPT_LENGTH) {
            throw new IllegalArgumentException("脚本长度超出允许上限");
        }

        ResourceLimits limits = ResourceLimits.newBuilder()
                .statementLimit(MAX_STATEMENTS, null)
                .build();

        try (Context context = Context.newBuilder("js")
                .engine(sharedEngine)
                .allowHostAccess(HostAccess.NONE)
                .allowHostClassLookup(className -> false)
                .allowIO(IOAccess.NONE)
                .allowCreateThread(false)
                .allowNativeAccess(false)
                .allowCreateProcess(false)
                .allowEnvironmentAccess(EnvironmentAccess.NONE)
                .allowPolyglotAccess(org.graalvm.polyglot.PolyglotAccess.NONE)
                .resourceLimits(limits)
                .build()) {

            // 超时后由守护线程强制取消执行,避免死循环卡死工作线程
            ScheduledFuture<?> watchdog = timeoutScheduler.schedule(
                    () -> context.close(true),
                    timeout.toMillis(),
                    TimeUnit.MILLISECONDS
            );

            try {
                // 通过纯字符串传入上下文数据,不直接暴露 Java 业务对象
                context.getBindings("js").putMember("__rawInputJson", inputJson == null ? "{}" : inputJson);
                context.eval("js", "const input = JSON.parse(__rawInputJson);");

                // 包装在函数作用域中,避免全局命名空间被随意污染,并要求显式返回结果
                String wrappedScript = "(function(input) {\n" + userScript + "\n})(input);";
                Source source = Source.newBuilder("js", wrappedScript, "user-script.js").buildLiteral();

                Value result = context.eval(source);
                Value jsonResult = context.eval("js", "JSON.stringify")
                        .execute(result);
                return jsonResult.isString() ? jsonResult.asString() : "null";
            } finally {
                watchdog.cancel(false);
            }
        } catch (PolyglotException ex) {
            if (ex.isCancelled()) {
                throw new SandboxTimeoutException("脚本执行超时已被强制终止", ex);
            }
            if (ex.isResourceExhausted()) {
                throw new SandboxLimitException("脚本执行步数超出安全配额", ex);
            }
            if (ex.isSyntaxError()) {
                throw new IllegalArgumentException("脚本语法错误: " + ex.getMessage(), ex);
            }
            throw new SandboxExecutionException("脚本运行异常: " + ex.getMessage(), ex);
        }
    }

    @Override
    public void close() {
        timeoutScheduler.shutdownNow();
        sharedEngine.close();
    }

    public static class SandboxTimeoutException extends RuntimeException {
        public SandboxTimeoutException(String message, Throwable cause) { super(message, cause); }
    }

    public static class SandboxLimitException extends RuntimeException {
        public SandboxLimitException(String message, Throwable cause) { super(message, cause); }
    }

    public static class SandboxExecutionException extends RuntimeException {
        public SandboxExecutionException(String message, Throwable cause) { super(message, cause); }
    }
}
版本兼容提示:上面示例中的 allowIO(IOAccess.NONE) 适用于较新的 GraalVM Polyglot API;如果你引入的是早期版本,该方法签名可能是 allowIO(false),同时 allowPolyglotAccess 等选项也需以对应版本的 API 文档为准。

第三步:验证正常逻辑与恶意拦截效果

编写一个简短的测试入口 SandboxDemo.java,分别验证正常计算、尝试访问 Java 类、以及死循环三类场景的表现:

package com.example.sandbox;

import java.time.Duration;

public class SandboxDemo {
    public static void main(String[] args) {
        try (SafeJsSandbox sandbox = new SafeJsSandbox()) {
            // 1. 正常规则计算
            String ok = sandbox.execute(
                    "return { total: input.price * input.count, vip: input.price > 100 };",
                    "{\"price\": 120, \"count\": 3}",
                    Duration.ofMillis(300)
            );
            System.out.println("正常执行结果: " + ok);

            // 2. 恶意访问 Java 系统类
            try {
                sandbox.execute(
                        "const Runtime = Java.type('java.lang.Runtime'); return Runtime.getRuntime();",
                        "{}",
                        Duration.ofMillis(300)
                );
            } catch (Exception e) {
                System.out.println("越权访问拦截: " + e.getMessage());
            }

            // 3. 死循环攻击
            try {
                sandbox.execute(
                        "while (true) {}",
                        "{}",
                        Duration.ofMillis(300)
                );
            } catch (Exception e) {
                System.out.println("死循环拦截: " + e.getMessage());
            }
        }
    }
}
示例输出(非现场执行结果,用于说明预期拦截行为):
正常执行结果: {"total":360,"vip":true}
越权访问拦截: 脚本运行异常: ReferenceError: Java is not defined
死循环拦截: 脚本执行步数超出安全配额

可以看到两个细节:关闭了 HostAccess 与类查找后,Java.type 在 JS 运行时里甚至不可见;而对于死循环,如果在 300 毫秒超时前就先撞到了 50,000 条语句的配额,引擎会直接抛出资源耗尽异常并退出,不必等到超时窗口结束;如果脚本执行的是单条耗时操作而未触发语句上限,300 毫秒后守护线程也会通过 context.close(true) 强行中止。

四、单靠引擎沙箱还不够时,怎么防内存爆破与进程连带崩溃?

上面的代码解决了越权访问和 CPU 死循环,但它有一个明确边界:脚本依然运行在主业务应用的同一个 JVM 堆里。如果恶意脚本只用几行语句就分配巨量内存,例如:

let s = "a";
for (let i = 0; i < 28; i++) {
  s = s + s;
}
return s.length;

这段循环只跑了 28 次,远低于 50,000 条语句上限,耗时也可能不到几百毫秒,但指数级拼接会让字符串瞬间膨胀到几百 MB,直接把主 JVM 挤出 OutOfMemoryError 或触发长时间 Full GC,影响同一进程里的正常业务接口。

要在生产环境中真正抗住高风险脚本,需要按“纵深防御”把沙箱放到更完整的四层结构中:

怎么在Java中安全地执行不可信JavaScript代码?
图 4:生产环境中执行不可信 JavaScript 的四层纵深防御总结

对应到实际工程落地,有四条具体手段可以直接加上:

  • 隔离专用线程池(舱壁模式):不要在 Web 容器(如 Tomcat)的请求线程里直接运行 JS,而是交给单独的有界线程池与限流队列,防止大量慢脚本把正常接口线程占满。
  • 全局复用 Engine,单次重建 Context:为每个请求创建 Engine 会导致编译缓存与元空间快速膨胀;正确做法是全局复用同一个 Engine,每次请求只创建轻量的 Context 并在 finally 块中关闭,确保脚本之间不共享全局变量或原型链修改。
  • 拆出独立的沙箱 Worker 进程:当脚本完全不可信时,单独部署一个只跑 SafeJsSandbox 的轻量 Java 进程(或容器),启动参数强制设置较小的堆上限(如 -Xmx128m),并配合容器的 CPU 配额、内存硬限与只读文件系统;主服务通过本地 RPC 或标准输入输出向 Worker 派发任务。
  • 失败即销毁策略:如果 Worker 进程因为恶意脚本触发 OutOfMemoryError 或超时无响应,主进程在 RPC 超时后直接返回受控失败,由进程守护或容器编排层拉起干净的新 Worker,主业务进程全程不受波及。

五、实施时最容易踩的三个误区

  1. 试图继续用 Java SecurityManager 兜底:SecurityManager 已在 JDK 17(JEP 411)中被标记为废弃待移除,后续版本也在逐步取消其可用性,配置复杂且在现代库生态下兼容性差,新项目不要把它作为沙箱防线。
  2. 图方便直接向 JS 传入领域对象并放开 HostAccess.ALL:如果一定要向 JS 暴露少量 Java 辅助方法(例如格式化日期或查询只读字典),应当单独定义一个极简的 DTO 或门面类,使用 HostAccess.EXPLICIT 仅对明确标注了 @HostAccess.Export 的方法放行,绝不能把包含数据库连接、Service 引用或通用反射入口的对象直接塞进脚本作用域。
  3. 只用 Future.get(timeout) 等待超时而不取消 Context:很多实现会在外层用 CompletableFuture 或线程池的 future.get(300, MILLISECONDS) 做超时,超时后调用 future.cancel(true)。这种写法只能让调用方提前返回异常,后台线程里的死循环 JS 依然会继续跑下去,直到把 CPU 跑满。必须由超时回调调用 context.close(true) 通知引擎主动中止执行。
作者最新文章
相关文章
更多