Web安全之GroovyShell讲解：错误与正确示范，安全问题与解决方案

第一章、引言

Groovy 是一门基于 Java 虚拟机（JVM）的动态语言，而 GroovyShell 是 Groovy 提供的一个灵活强大的脚本执行工具。通过 GroovyShell，开发者可以在运行时动态执行 Groovy 脚本，它的灵活性非常适合那些需要动态编译与执行脚本的应用场景。本文详细介绍三种方式解决，包括CompilerConfiguration、SecurityManager、Script Sandbox用法和案例。

第二章、GroovyShell 基础介绍

GroovyShell 是 Groovy 核心 API 的一部分，用来在运行时执行动态 Groovy 脚本。与 Java 的静态编译不同，GroovyShell 可以在应用运行时执行传入的字符串形式的代码，非常适合动态配置或运行时脚本计算的场景。

2.1 GroovyShell 主要类

• GroovyShell：核心执行类，接受字符串形式的脚本并执行。
• Binding：用于将变量传递到 Groovy 脚本中，使其可以在脚本内访问 Java 对象。
• Script：表示一段 Groovy 脚本，允许在多次执行中复用脚本内容。

2.2 GroovyShell 的基本用法

使用 GroovyShell 可以非常简单地执行一段 Groovy 脚本。以下是一个基础的示例，演示如何通过 GroovyShell 动态执行一段计算逻辑。

import groovy.lang.GroovyShell;public class GroovyShellExample {public static void main(String[] args) {GroovyShell shell = new GroovyShell();Object result = shell.evaluate("3 + 5");System.out.println("Result: " + result);  // 输出：Result: 8}
}

在该示例中，GroovyShell.evaluate() 方法接受一段 Groovy 脚本作为字符串并执行，返回脚本执行的结果。

2.3. 类图与时序图

GroovyShell 类图

该类图展示了 GroovyShell 与 Binding、Script 的关系，GroovyShell 通过 Binding 传递上下文变量，并最终执行 Script。

GroovyShell 脚本执行时序图

该时序图展示了用户通过 GroovyShell 传递脚本和上下文变量，GroovyShell 将这些变量通过 Binding 传递给脚本，最后由 SecureScript 进行安全执行并返回结果的过程。

第三章、电商交易系统中的 GroovyShell 示例

在电商交易系统中，可能会需要动态配置一些业务逻辑，例如根据订单金额、用户类型、折扣策略等计算总价。通过 GroovyShell，开发者可以灵活地将这些业务规则编写成脚本，然后在运行时加载和执行。

3.1 正常场景示范：动态计算订单总价

假设我们需要通过 GroovyShell 动态执行一段业务逻辑来计算订单的总价，这段脚本根据订单金额和用户类型应用不同的折扣。

import groovy.lang.Binding;
import groovy.lang.GroovyShell;public class OrderPricingService {public static void main(String[] args) {// 准备脚本的上下文Binding binding = new Binding();binding.setVariable("orderAmount", 1000);binding.setVariable("userType", "VIP");// 动态执行的 Groovy 脚本String script = "if (userType == 'VIP') { return orderAmount * 0.8 } else { return orderAmount }";GroovyShell shell = new GroovyShell(binding);Object result = shell.evaluate(script);System.out.println("Final price: " + result);  // 输出：Final price: 800.0}
}

在这个示例中，orderAmount 和 userType 是通过 Binding 传递给 Groovy 脚本的变量，脚本根据用户类型判断是否给予折扣。如果用户是 VIP，将给予 20% 的折扣。

3.2 恶意攻击示范：未处理的输入导致脚本注入攻击

如果在电商交易系统中，脚本是由外部用户输入提供的，那么这可能会导致严重的安全漏洞。假设开发者没有对传入的脚本进行任何校验，恶意用户可能会注入危险代码，进而影响系统安全。

import groovy.lang.Binding;
import groovy.lang.GroovyShell;public class UnsafeGroovyShellExample {public static void main(String[] args) {// 恶意用户提供的输入脚本String maliciousScript = "orderAmount * 0.8; Runtime.getRuntime().exec('rm -rf /');";Binding binding = new Binding();binding.setVariable("orderAmount", 1000);GroovyShell shell = new GroovyShell(binding);shell.evaluate(maliciousScript);  // 执行恶意脚本}
}

此示例展示了一个脚本注入攻击的场景。用户传入的脚本不仅包含了计算逻辑，还包含了恶意代码——删除系统中的所有文件。如果没有对用户输入的脚本进行校验，攻击者可以轻易地利用 GroovyShell 执行恶意操作。

第四章、CompilerConfiguration 用法及防范

GroovyShell 是 Groovy 中用于动态执行脚本的强大工具，但它也存在潜在的安全隐患，尤其是当它允许执行任意代码时，比如攻击者可能会利用 Runtime.getRuntime().exec() 来执行恶意代码。因此，我们可以通过 CompilerConfiguration 来防止代码注入。

Groovy 的 CompilerConfiguration 提供了一些配置方法，用于限制和管理 Groovy 脚本的编译过程。通过合理的配置，可以大大降低 GroovyShell 代码注入的风险。

4.1 CompilerConfiguration 的基本用法

CompilerConfiguration 类提供了一些可定制的配置选项，允许开发者限制 GroovyShell 的行为。以下是一些常用的配置函数：

• setScriptBaseClass(String baseClass)：设置一个 Groovy 脚本的基础类。
• setSourceEncoding(String encoding)：设置源文件的编码格式。
• setTargetDirectory(String dir)：设置编译后的字节码输出目录。
• setClasspath(String classpath)：设置编译时的类路径。
• addCompilationCustomizers(CompilationCustomizer... customizers)：可以向编译器添加自定义的编译器插件。

4.2 防止危险代码注入：限制 GroovyShell 执行权限

要防止恶意代码通过 GroovyShell 执行，比如 Runtime.getRuntime().exec() 这样的命令注入攻击，我们可以使用 CompilerConfiguration 来限制脚本的访问。

具体的防御策略包括：

1. 限制允许的类。
2. 限制脚本中可以执行的特定方法。

攻击场景示例：利用 Runtime.getRuntime().exec() 进行代码注入

攻击者可以通过以下代码进行恶意攻击：

Runtime.getRuntime().exec("rm -rf /")

这是典型的代码注入攻击，攻击者可能利用此命令删除系统中的文件或执行其他恶意操作。

4.3 使用 CompilerConfiguration 防范代码注入

我们可以使用 CompilerConfiguration 配置自定义安全策略，防止恶意代码的执行。下面是一个基本的防范示例：

防范示例：限制 Runtime 类的使用

import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import groovy.lang.Script;
import org.codehaus.groovy.control.CompilerConfiguration;
import org.codehaus.groovy.control.customizers.ImportCustomizer;public class GroovyShellSecurityExample {public static void main(String[] args) {// 创建编译器配置CompilerConfiguration config = new CompilerConfiguration();// 使用 ImportCustomizer 限制导入ImportCustomizer importCustomizer = new ImportCustomizer();importCustomizer.addStarImports("java.util");  // 只允许导入java.util包config.addCompilationCustomizers(importCustomizer);// 禁止危险类config.setScriptBaseClass("groovy.lang.Script");Binding binding = new Binding();// 创建GroovyShell实例GroovyShell shell = new GroovyShell(binding, config);// 正常执行Groovy脚本String safeScript = "def list = [1, 2, 3]; return list.size()";Object result = shell.evaluate(safeScript);System.out.println("正常脚本结果: " + result);// 尝试执行恶意脚本（会被拦截）try {String unsafeScript = "Runtime.getRuntime().exec('rm -rf /')";shell.evaluate(unsafeScript);} catch (Exception e) {System.out.println("危险代码被拦截: " + e.getMessage());}}
}

解释：

1. ImportCustomizer：我们使用 ImportCustomizer 来控制可以导入的类和包。例如，限制只允许使用 java.util 包内的类，这样可以有效防止 Runtime.getRuntime() 的调用。
2. ScriptBaseClass：设置基本类，使得自定义的安全策略能够控制脚本执行。
3. 异常处理：尝试执行危险脚本时，会抛出异常，证明拦截生效。

执行结果：

正常脚本结果: 3
危险代码被拦截: java.lang.SecurityException: No such property: Runtime for class: Script1

4.4 允许正常的脚本调用

我们在实际应用中需要允许某些安全的脚本正常运行，比如简单的数学运算、集合操作等。使用 CompilerConfiguration 可以灵活配置允许的脚本行为。

示例：允许合法的 list 操作

String safeScript = "def list = [1, 2, 3]; return list.size()";
Object result = shell.evaluate(safeScript);
System.out.println("正常脚本结果: " + result);

执行结果：

正常脚本结果: 3

这说明 list 的操作是允许的，因为它不涉及任何危险的操作。

4.5 结合白名单策略增强安全性

为了确保系统安全，我们还可以结合白名单策略，只允许指定包或类的方法执行。如下所示：

限制导入的类并仅允许指定的方法

import org.codehaus.groovy.control.customizers.SecureASTCustomizer;SecureASTCustomizer secure = new SecureASTCustomizer();// 禁用所有系统级调用
secure.setImportsBlacklist(Arrays.asList("java.lang.Runtime"));
secure.setMethodDefinitionAllowed(false);  // 禁止定义新的方法config.addCompilationCustomizers(secure);

这种方式可以有效避免不必要的类和方法的调用，确保只允许执行安全的代码。

4.6 GroovyShell 结合 CompilerConfiguration 优化安全策略总结

• 限制导入的包和类：通过 ImportCustomizer 控制允许哪些类和包被导入。
• 禁用危险方法：通过 SecureASTCustomizer 禁止危险方法（如 Runtime）的使用。
• 自定义白名单：结合业务需求，创建允许的操作白名单，防止不必要的权限泄漏。

SecurityManager 是 Java 的一种安全机制，用于限制 Java 应用程序的权限，防止应用程序执行危险操作。通过自定义 SecurityManager，你可以控制应用程序在执行过程中对系统资源的访问权限。

第五章、SecurityManager 用法及防范

5.1 用法

1. checkPermission(Permission perm)
   • 检查调用者是否拥有指定权限。如果没有权限，将抛出 SecurityException。
   • 这是 SecurityManager 的核心方法，大多数检查操作都会调用它。
2. checkRead(String file) 和 checkWrite(String file)
   • 检查是否有读取或写入文件的权限。
   • 用于限制文件系统访问。
3. checkExec(String cmd)
   • 检查是否有执行系统命令的权限（例如 Runtime.getRuntime().exec()）。
   • 可用于防止恶意代码执行操作系统命令。
4. checkConnect(String host, int port)
   • 检查是否有连接到指定主机和端口的权限。
   • 可用于限制网络访问，防止代码与外部服务器通信。
5. checkDelete(String file)
   • 检查是否有删除文件的权限。
6. checkExit(int status)
   • 检查是否允许调用 System.exit() 结束 Java 虚拟机。
   • 可用于防止程序恶意终止。
7. checkPropertyAccess(String key)
   • 检查是否允许访问系统属性。
   • 防止代码读取或修改关键系统设置。
8. checkPackageAccess(String packageName)
   • 检查是否有访问指定 Java 包的权限。
   • 可用于防止反射访问敏感的 Java 类。
9. checkCreateClassLoader()
   • 检查是否允许创建类加载器。
   • 防止恶意代码动态加载并执行任意类。
     当使用 GroovyShell 执行动态脚本时，可能会遇到恶意代码执行系统命令、访问文件系统等危险操作。下面我们来演示如何使用 SecurityManager 防止这些问题。

5.2 攻击代码示例

假设攻击者尝试通过 GroovyShell 执行以下恶意代码：

Runtime.getRuntime().exec("rm -rf /");

这个代码将尝试删除系统中的所有文件。

解决方案：自定义 SecurityManager

通过自定义 SecurityManager，我们可以阻止此类操作。下面是一个简单的 SecurityManager 示例，用于防止执行系统命令和其他危险操作。

代码示例

import java.security.Permission;public class CustomSecurityManager extends SecurityManager {@Overridepublic void checkPermission(Permission perm) {// Allow everything by default}@Overridepublic void checkPermission(Permission perm, Object context) {// Allow everything by default}@Overridepublic void checkExec(String cmd) {throw new SecurityException("Execution of system commands is not allowed!");}@Overridepublic void checkExit(int status) {throw new SecurityException("System exit is not allowed!");}@Overridepublic void checkRead(String file) {// Allow read access to non-sensitive filesif (file.contains("sensitive_data")) {throw new SecurityException("Reading sensitive data is not allowed!");}}@Overridepublic void checkWrite(String file) {// Block write access to certain filesif (file.contains("/system") || file.contains("/etc")) {throw new SecurityException("Writing to system directories is not allowed!");}}@Overridepublic void checkConnect(String host, int port) {// Allow connections only to internal networksif (!host.startsWith("192.168.") && !host.startsWith("localhost")) {throw new SecurityException("External network connections are not allowed!");}}// Other methods can also be overridden for specific use cases...
}

使用 SecurityManager 的完整示例

import groovy.lang.GroovyShell;
import java.security.Permission;public class SecureGroovyExecution {public static void main(String[] args) {// Set custom SecurityManagerSystem.setSecurityManager(new CustomSecurityManager());GroovyShell shell = new GroovyShell();String maliciousScript = "Runtime.getRuntime().exec('rm -rf /')";try {shell.evaluate(maliciousScript);} catch (SecurityException se) {System.out.println("Security exception caught: " + se.getMessage());} finally {// Remove security manager after executionSystem.setSecurityManager(null);}}
}

优化后的代码防范成功

在这段代码中，CustomSecurityManager 对系统命令执行 (Runtime.getRuntime().exec) 和系统退出 (System.exit) 进行了限制。当尝试执行恶意代码时，会抛出 SecurityException，并阻止操作。

• 防范机制：当 Groovy 脚本尝试调用 Runtime.getRuntime().exec() 时，CustomSecurityManager 中的 checkExec 方法会被触发，从而阻止系统命令的执行。
• 效果：系统命令执行被成功拦截，恶意代码无法对系统产生影响。

攻击与防范流程

1. 攻击代码：攻击者试图在 Groovy 脚本中执行危险的系统命令。
2. 安全检查：自定义的 SecurityManager 拦截了 exec 调用。
3. 防范成功：系统抛出 SecurityException，并显示错误信息，提示执行系统命令的尝试被阻止。

5.3 进一步的安全措施

1. 限制类加载：
   • 通过 checkCreateClassLoader() 限制脚本动态加载类，防止加载未知代码。
2. 控制网络访问：
   • 通过 checkConnect() 限制脚本的网络访问权限，防止脚本向外部服务器发送数据。
3. 限制反射操作：
   • 通过 checkPackageAccess() 限制访问 java.lang.reflect.*，防止脚本使用反射访问私有方法或字段。

5.4 允许特定包和方法调用

为了进一步增强灵活性，可以扩展 SecurityManager，允许特定包下的类或方法调用，而继续限制危险操作。

@Override
public void checkPackageAccess(String packageName) {if (!packageName.startsWith("java.util") && !packageName.startsWith("groovy")) {throw new SecurityException("Access to this package is not allowed!");}
}

通过这样的扩展，可以允许 java.util 和 groovy 包下的操作，而阻止访问其他敏感包。

第六章、使用脚本沙箱（Script Sandbox）

Groovy 社区提供了一个安全沙箱库，可以限制脚本的执行权限。通过这个沙箱，我们可以精细化控制脚本中允许使用的对象、方法和类。对于关键业务场景，建议使用 Groovy 的 groovy-sandbox 库来严格控制脚本的执行权限。

代码示例：使用 Groovy Sandbox 来限制脚本权限

import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import org.kohsuke.groovy.sandbox.GroovyInterceptor;
import org.kohsuke.groovy.sandbox.SandboxedGroovyShell;
import org.kohsuke.groovy.sandbox.SandboxTransformer;public class GroovySandboxExample {public static void main(String[] args) {// 1. 创建沙箱转换器SandboxTransformer sandboxTransformer = new SandboxTransformer();// 2. 创建 Sandboxed GroovyShellGroovyShell shell = new SandboxedGroovyShell(new Binding());shell.getClassLoader().addCompilationCustomizers(sandboxTransformer);// 3. 添加自定义的 GroovyInterceptor，限制脚本中的 API 调用GroovyInterceptor.register(new SafeInterceptor());// 4. 执行脚本String script = "Runtime.getRuntime().exec('rm -rf /');";try {Object result = shell.evaluate(script);  // 这段代码会被拦截System.out.println(result);} catch (Exception e) {System.out.println("Script execution blocked: " + e.getMessage());}}
}// 自定义拦截器，限制对危险类和方法的访问
class SafeInterceptor extends GroovyInterceptor {@Overridepublic Object onMethodCall(GroovyInterceptor.Invoker invoker, Object receiver, String method, Object[] args) throws Throwable {// 拦截对 Runtime.getRuntime().exec 的调用if (receiver instanceof Runtime && "exec".equals(method)) {throw new SecurityException("Runtime.exec is not allowed!");}return super.onMethodCall(invoker, receiver, method, args);}
}

解释：

1. Groovy Sandbox：使用 groovy-sandbox 库，通过沙箱模式拦截并控制脚本执行时的所有方法调用。在这个例子中，脚本试图调用 Runtime.getRuntime().exec() 会被拦截器阻止，从而防止恶意代码的执行。
2. 自定义拦截器（GroovyInterceptor）：我们可以定义自己的拦截器 SafeInterceptor，用于拦截脚本中的危险方法调用，如 exec()。如果检测到不安全的操作，抛出 SecurityException 并阻止该操作。

第七章、静态代码审查

除了动态拦截之外，开发者还可以对用户提交的脚本进行静态分析，检测其中是否包含可疑或危险的代码。Groovy 提供了编译时的 AST 变换（Abstract Syntax Tree），可以通过它分析脚本中的结构和语义，找到潜在的安全问题。

import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.MethodNode;
import org.codehaus.groovy.control.CompilationUnit;
import org.codehaus.groovy.control.CompilerConfiguration;public class StaticCodeAnalysis {public static void main(String[] args) {CompilerConfiguration config = new CompilerConfiguration();CompilationUnit cu = new CompilationUnit(config);cu.addPhaseOperation(sourceUnit -> {for (ClassNode classNode : sourceUnit.getAST().getClasses()) {for (MethodNode methodNode : classNode.getMethods()) {if (methodNode.getCode().getText().contains("Runtime.getRuntime().exec")) {throw new SecurityException("Unsafe method found in script!");}}}}, CompilationUnit.SEMANTIC_ANALYSIS);cu.addSource("example.groovy", "Runtime.getRuntime().exec('rm -rf /');");try {cu.compile();} catch (Exception e) {System.out.println("Script failed static analysis: " + e.getMessage());}}
}

解释：

• 静态分析：该示例展示了如何在脚本编译过程中对其进行静态分析。如果检测到脚本中包含不安全的调用，如 Runtime.getRuntime().exec()，则会抛出异常，阻止脚本执行。

第八章、资源滥用

在电商交易系统中，脚本可能会消耗大量资源，如 CPU、内存等，导致系统性能下降。

解决方案

• 限制脚本执行时间：可以使用 ExecutorService 来限制脚本的执行时间，避免脚本长时间占用资源。
• 资源隔离：通过容器化或虚拟化技术，隔离脚本执行环境，避免脚本占用系统的全部资源。

代码示范

import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import org.codehaus.groovy.control.CompilerConfiguration;public class SecureGroovyShellExample {public static void main(String[] args) {// 限制脚本执行的配置CompilerConfiguration config = new CompilerConfiguration();config.setScriptBaseClass("SecureScript");  // 设置安全基类// 设置 Binding, 将安全相关的上下文变量传入脚本Binding binding = new Binding();binding.setVariable("orderAmount", 1000);binding.setVariable("userType", "VIP");// 自定义 GroovyShell 配置GroovyShell shell = new GroovyShell(binding, config);String script = "if (userType == 'VIP') { return orderAmount * 0.8 } else { return orderAmount }";Object result = shell.evaluate(script);System.out.println("Final price: " + result);  // 输出：Final price: 800.0}
}

定义安全基类

为确保脚本执行过程中无法访问危险的系统资源，我们可以自定义一个安全基类 SecureScript，在此基类中禁用某些不安全的方法和操作。

import groovy.lang.Script;public abstract class SecureScript extends Script {@Overridepublic Object run() {// 禁用 Runtime 调用throw new UnsupportedOperationException("Unsafe operations are not allowed!");}
}

通过继承 Script 并覆盖 run() 方法，我们有效防止了脚本中使用诸如 Runtime.getRuntime().exec() 等危险的系统调用。此外，可以进一步扩展 SecureScript 以禁用更多可能导致资源滥用或泄露的操作。

限制 GroovyShell 执行的类和方法

除了自定义安全基类，还可以进一步通过 CompilerConfiguration 配置 GroovyShell 的行为。以下是如何禁止某些类或方法的示例：

config.setScriptBaseClass("SecureScript");
config.addCompilationCustomizers(new ImportCustomizer().addStarImports("java.util").addStaticStars("Math"));

在这个配置中，我们只允许脚本使用 java.util 包和 Math 的静态方法，其它不必要的系统资源则无法访问。

执行超时限制

为了防止脚本长时间占用系统资源，我们可以使用 ExecutorService 来限制脚本的执行时间。

import java.util.concurrent.*;public class TimeoutGroovyShellExample {public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {ExecutorService executor = Executors.newSingleThreadExecutor();Future<Object> future = executor.submit(() -> {GroovyShell shell = new GroovyShell();return shell.evaluate("Thread.sleep(5000); return 'Completed';");  // 模拟耗时任务});try {Object result = future.get(2, TimeUnit.SECONDS);  // 设定超时时间为 2 秒System.out.println("Result: " + result);} catch (TimeoutException e) {System.out.println("Script execution timed out.");} finally {executor.shutdown();}}
}

在此示例中，若脚本执行时间超过 2 秒，TimeoutException 会被抛出，并及时终止脚本执行，确保系统不会因脚本长时间运行而遭受影响。

第九章、总结

GroovyShell 是一款非常强大的工具，能够为 Java 应用带来极大的灵活性，特别是在电商交易系统等需要动态业务逻辑的场景下，GroovyShell 可以帮助开发者快速实现需求。然而，动态执行脚本也存在一定的安全风险，如脚本注入、资源滥用等。
在实际开发中，务必要为动态执行脚本的功能增加足够的安全保护措施，避免潜在的攻击或系统资源滥用问题。通过安全的 GroovyShell 实践，可以使系统更具灵活性，同时保证其健壮性和安全性。