Light, fluffy, and always free - The AWS Local Emulator alternative
fix(apigateway,appsync): sandbox VTL rendering with SecureUberspector and execution limits (#3542)
Niels Kootstra144b90e6fa86
diff --git a/docs/services/api-gateway.md b/docs/services/api-gateway.mdindex 7358369a64..8dc9ec86f0 100644--- a/docs/services/api-gateway.md+++ b/docs/services/api-gateway.md@@ -332,6 +332,19 @@ setups, and `floci:override-id` wins when both are present. Every other tag is p|---|---|---|| `FLOCI_SERVICES_APIGATEWAY_ENABLED` | `true` | Enable or disable API Gateway v1 (REST APIs) || `FLOCI_SERVICES_APIGATEWAYV2_ENABLED` | `true` | Enable or disable API Gateway v2 (HTTP and WebSocket APIs) |+| `FLOCI_SERVICES_APIGATEWAY_VTL_MAX_LOOPS` | `10000` | Maximum `#foreach` iterations a VTL mapping template may execute |+| `FLOCI_SERVICES_APIGATEWAY_VTL_MAX_OUTPUT_CHARS` | `1048576` | Maximum characters a VTL mapping template may render |+| `FLOCI_SERVICES_APIGATEWAY_VTL_TIMEOUT_MILLIS` | `5000` | Maximum wall-clock time a VTL mapping template may spend evaluating |++VTL (Velocity Template Language) mapping templates render inside a reflection-restricted sandbox+(`SecureUberspector`, with `Class`, `ClassLoader`, `Runtime`, `ProcessBuilder`, `System`, `Thread`,+`java.io.File` and related classes/packages blocked) and are subject to the three limits above.+The loop cap truncates a `#foreach` at the configured iteration count and lets the template finish+rendering with whatever output it produced up to that point; it does not fail the template.+Exceeding the output-size or execution-time limit does fail the template, the same way any other+Velocity evaluation error does; neither introduces a new error shape. This applies to both API+Gateway v1 (`AWS`/Lambda mapping templates) and the AppSync resolver templates described in+[appsync.md](appsync.md).## API Gateway v2 (HTTP and WebSocket APIs) {#v2}diff --git a/docs/services/appsync.md b/docs/services/appsync.mdindex 9fcee65b56..72e398c3c8 100644--- a/docs/services/appsync.md+++ b/docs/services/appsync.md@@ -286,6 +286,18 @@ These AWS AppSync capabilities are not yet implemented and are tracked in future| Variable | Default | Description ||---|---|---|| `FLOCI_SERVICES_APPSYNC_ENABLED` | `true` | Enable or disable the service |+| `FLOCI_SERVICES_APPSYNC_VTL_MAX_LOOPS` | `10000` | Maximum `#foreach` iterations a VTL resolver template may execute |+| `FLOCI_SERVICES_APPSYNC_VTL_MAX_OUTPUT_CHARS` | `1048576` | Maximum characters a VTL resolver template may render |+| `FLOCI_SERVICES_APPSYNC_VTL_TIMEOUT_MILLIS` | `5000` | Maximum wall-clock time a VTL resolver template may spend evaluating |++Request/response mapping templates render inside the same VTL reflection sandbox described for+API Gateway in [api-gateway.md](api-gateway.md#configuration) (`SecureUberspector`, with `Class`,+`ClassLoader`, `Runtime`, `ProcessBuilder`, `System`, `Thread`, `java.io.File` and related+classes/packages blocked), and are subject to the same three limits above. The loop cap truncates+a `#foreach` at the configured iteration count and lets the template finish rendering with+whatever output it produced up to that point; it does not fail the resolver. Exceeding the+output-size or execution-time limit does fail the resolver, the same way any other VTL evaluation+error does.## Examplesdiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 13a2bcdafd..e7890cb421 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -1177,6 +1177,21 @@ public interface EmulatorConfig {interface ApiGatewayServiceConfig {@WithDefault("true")boolean enabled();++ /** Maximum #foreach loop iterations allowed in a single VTL mapping template render, as a+ * hard backstop against runaway loops. Env: FLOCI_SERVICES_APIGATEWAY_VTL_MAX_LOOPS */+ @WithDefault("10000")+ int vtlMaxLoops();++ /** Maximum rendered output size, in characters, for a single VTL mapping template render.+ * Env: FLOCI_SERVICES_APIGATEWAY_VTL_MAX_OUTPUT_CHARS */+ @WithDefault("1048576")+ int vtlMaxOutputChars();++ /** Wall-clock execution budget, in milliseconds, for a single VTL mapping template render.+ * Env: FLOCI_SERVICES_APIGATEWAY_VTL_TIMEOUT_MILLIS */+ @WithDefault("5000")+ long vtlTimeoutMillis();}interface IamServiceConfig {@@ -1968,6 +1983,21 @@ public interface EmulatorConfig {/** Seconds to wait for in-flight schema workers on shutdown. Env: FLOCI_SERVICES_APPSYNC_SCHEMA_WORKER_SHUTDOWN_TIMEOUT_SECONDS */@WithDefault("30")int schemaWorkerShutdownTimeoutSeconds();++ /** Maximum #foreach loop iterations allowed in a single VTL resolver template render, as a+ * hard backstop against runaway loops. Env: FLOCI_SERVICES_APPSYNC_VTL_MAX_LOOPS */+ @WithDefault("10000")+ int vtlMaxLoops();++ /** Maximum rendered output size, in characters, for a single VTL resolver template render.+ * Env: FLOCI_SERVICES_APPSYNC_VTL_MAX_OUTPUT_CHARS */+ @WithDefault("1048576")+ int vtlMaxOutputChars();++ /** Wall-clock execution budget, in milliseconds, for a single VTL resolver template render.+ * Env: FLOCI_SERVICES_APPSYNC_VTL_TIMEOUT_MILLIS */+ @WithDefault("5000")+ long vtlTimeoutMillis();}interface OamServiceConfig {diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/BoundedWriter.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/BoundedWriter.javanew file mode 100644index 0000000000..539624111a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/BoundedWriter.java@@ -0,0 +1,45 @@+package io.github.hectorvent.floci.services.apigateway;++import java.io.IOException;+import java.io.Writer;++/**+ * Wraps a delegate {@link Writer} and throws {@link VtlLimitExceededException} once the total+ * number of characters written would exceed a configured budget.+ *+ * <p>This defends against unbounded VTL template output regardless of cause (a huge+ * {@code #foreach} range, a single oversized reference, or repeated small writes that add up),+ * complementing the loop-iteration cap and the execution-time deadline, neither of which observe+ * output size directly.+ */+public class BoundedWriter extends Writer {++ private final Writer delegate;+ private final long maxChars;+ private long written;++ public BoundedWriter(Writer delegate, long maxChars) {+ this.delegate = delegate;+ this.maxChars = maxChars;+ }++ @Override+ public void write(char[] cbuf, int off, int len) throws IOException {+ if (written + len > maxChars) {+ throw new VtlLimitExceededException(+ "VTL template output exceeded the configured size limit of " + maxChars + " characters");+ }+ delegate.write(cbuf, off, len);+ written += len;+ }++ @Override+ public void flush() throws IOException {+ delegate.flush();+ }++ @Override+ public void close() throws IOException {+ delegate.close();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/SandboxedForeach.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/SandboxedForeach.javanew file mode 100644index 0000000000..83c77a88c0--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/SandboxedForeach.java@@ -0,0 +1,26 @@+package io.github.hectorvent.floci.services.apigateway;++import org.apache.velocity.context.InternalContextAdapter;+import org.apache.velocity.runtime.directive.Foreach;+import org.apache.velocity.runtime.parser.node.Node;++import java.io.IOException;+import java.io.Writer;++/**+ * Drop-in replacement for Velocity's built-in {@code #foreach} directive that checks the current+ * thread's {@link VtlExecutionGuard} deadline before rendering each loop iteration.+ *+ * <p>Registered in place of {@code org.apache.velocity.runtime.directive.Foreach} by+ * {@link VtlSandbox#installSandboxedForeach(org.apache.velocity.app.VelocityEngine)}, so it applies+ * identically to every {@code #foreach} loop evaluated by either the API Gateway or the AppSync+ * VTL engine.+ */+public class SandboxedForeach extends Foreach {++ @Override+ protected void renderBlock(InternalContextAdapter context, Writer writer, Node node) throws IOException {+ VtlExecutionGuard.checkDeadline();+ super.renderBlock(context, writer, node);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlExecutionGuard.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlExecutionGuard.javanew file mode 100644index 0000000000..edfdfc12fb--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlExecutionGuard.java@@ -0,0 +1,50 @@+package io.github.hectorvent.floci.services.apigateway;++import java.time.Duration;+import java.time.Instant;++/**+ * Tracks a wall-clock execution deadline for the VTL template render currently in progress on+ * the calling thread.+ *+ * <p>Both {@link VtlTemplateEngine} and the AppSync VTL engine call {@link #begin(Duration)}+ * immediately before delegating to Velocity's {@code VelocityEngine.evaluate(...)}, and+ * {@link #end()} in a {@code finally} block right after. {@link SandboxedForeach} calls+ * {@link #checkDeadline()} before rendering each loop iteration's body, which is what actually+ * stops a runaway {@code #foreach} (whether over a huge range, or one whose body does something+ * increasingly expensive per iteration, such as {@code #set} string doubling): each iteration's+ * own cost grows with the doubling, so the next iteration's check reliably trips shortly after+ * the configured time budget is crossed, well before memory would otherwise be exhausted.+ *+ * <p>A {@link ThreadLocal} is used because template evaluation is synchronous and single-threaded+ * per call, and Velocity does not offer a per-render context slot for deadline plumbing that both+ * a custom writer and a custom directive can reach without changing Velocity's own APIs.+ */+public final class VtlExecutionGuard {++ private static final ThreadLocal<Instant> DEADLINE = new ThreadLocal<>();++ private VtlExecutionGuard() {+ }++ /** Starts a new deadline, {@code timeout} from now, for the current thread. */+ public static void begin(Duration timeout) {+ DEADLINE.set(Instant.now().plus(timeout));+ }++ /** Clears the current thread's deadline. Must be called after every {@link #begin(Duration)}. */+ public static void end() {+ DEADLINE.remove();+ }++ /**+ * Throws {@link VtlLimitExceededException} if the current thread has an active deadline that+ * has already passed. Does nothing if no deadline is active.+ */+ public static void checkDeadline() {+ Instant deadline = DEADLINE.get();+ if (deadline != null && Instant.now().isAfter(deadline)) {+ throw new VtlLimitExceededException("VTL template execution exceeded the configured time limit");+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlLimitExceededException.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlLimitExceededException.javanew file mode 100644index 0000000000..5227e0016f--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlLimitExceededException.java@@ -0,0 +1,17 @@+package io.github.hectorvent.floci.services.apigateway;++/**+ * Thrown when a VTL (Velocity Template Language) template render exceeds one of the configured+ * sandbox limits: loop iteration count, wall-clock execution time, or rendered output size.+ *+ * <p>This is a plain unchecked exception, matching Velocity's own {@code VelocityException}+ * hierarchy (which also extends {@link RuntimeException}), so it propagates through both the+ * API Gateway and AppSync VTL engines exactly like any other template rendering failure already+ * does today, without requiring any new catch or error-mapping logic at their call sites.+ */+public class VtlLimitExceededException extends RuntimeException {++ public VtlLimitExceededException(String message) {+ super(message);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlSandbox.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlSandbox.javanew file mode 100644index 0000000000..8b8926b515--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlSandbox.java@@ -0,0 +1,100 @@+package io.github.hectorvent.floci.services.apigateway;++import org.apache.velocity.app.VelocityEngine;+import org.apache.velocity.runtime.RuntimeConstants;+import org.apache.velocity.util.introspection.SecureUberspector;++/**+ * Applies Floci's VTL reflection sandbox to a {@link VelocityEngine}, shared by both the+ * API Gateway and AppSync VTL engines.+ *+ * <p>Velocity normally reads {@code introspector.uberspect.class} and+ * {@code introspector.restrict.*} from the classpath resource+ * {@code org/apache/velocity/runtime/defaults/velocity.properties}, which this project shadows+ * (see {@code src/main/resources/org/apache/velocity/runtime/defaults/velocity.properties}) to+ * select {@link SecureUberspector} instead of Velocity's insecure default {@code UberspectImpl}.+ * That shadowed file is kept for any embedding that resolves the resource normally, but it is+ * <strong>not</strong> the actual enforcement point in this codebase: under Quarkus's custom+ * test/runtime classloader, {@code ClassLoader#getResourceAsStream} for that exact path can+ * resolve to the copy bundled inside the {@code velocity-engine-core} jar instead of this+ * project's shadowed copy, silently leaving the insecure {@code UberspectImpl} active. This was+ * confirmed empirically: with only the properties file changed, reflection-escape tests+ * (e.g. {@code $obj.getClass().forName(...)}) still passed against the vulnerable engine.+ *+ * <p>Setting these properties directly on the {@link VelocityEngine} via its Java API, before+ * {@link VelocityEngine#init()}, is unaffected by that classloader ambiguity, so it is the real,+ * verified enforcement mechanism. Both {@code VtlTemplateEngine} and {@code AppSyncVtlEngine}+ * call {@link #restrictIntrospection(VelocityEngine)} before {@code init()} and+ * {@link #installSandboxedForeach(VelocityEngine)} after {@code init()}.+ */+public final class VtlSandbox {++ /**+ * Packages blocked outright: any method call on an object from these packages is rejected,+ * regardless of which method. {@code java.lang.reflect} and {@code java.lang.invoke} close+ * off reflective/handle-based sandbox escapes; {@code javax.script} closes off the scripting+ * engine escape; {@code java.nio.file} closes off filesystem access alongside+ * {@code java.io.File} below.+ */+ private static final String[] RESTRICTED_PACKAGES = {+ "java.lang.reflect",+ "java.lang.invoke",+ "javax.script",+ "java.nio.file",+ };++ /**+ * Individual classes blocked outright. Mirrors Velocity's own recommended secure-introspector+ * defaults ({@code Class}, {@code ClassLoader}, {@code Runtime}, {@code ProcessBuilder},+ * {@code System}, {@code Thread}, etc.), plus {@code java.io.File} so templates cannot read or+ * write arbitrary files on the host.+ */+ private static final String[] RESTRICTED_CLASSES = {+ "java.lang.Class",+ "java.lang.ClassLoader",+ "java.lang.Compiler",+ "java.lang.InheritableThreadLocal",+ "java.lang.Package",+ "java.lang.Process",+ "java.lang.ProcessBuilder",+ "java.lang.Runtime",+ "java.lang.RuntimePermission",+ "java.lang.SecurityManager",+ "java.lang.System",+ "java.lang.Thread",+ "java.lang.ThreadGroup",+ "java.lang.ThreadLocal",+ "java.net.Socket",+ "javax.management.MBeanServer",+ "javax.script.ScriptEngine",+ "java.io.File",+ };++ private VtlSandbox() {+ }++ /**+ * Configures {@code engine} to use {@link SecureUberspector} with the restricted+ * packages/classes above. Must be called before {@link VelocityEngine#init()}.+ */+ public static void restrictIntrospection(VelocityEngine engine) {+ engine.setProperty(RuntimeConstants.UBERSPECT_CLASSNAME, SecureUberspector.class.getName());+ for (String pkg : RESTRICTED_PACKAGES) {+ engine.addProperty(RuntimeConstants.INTROSPECTOR_RESTRICT_PACKAGES, pkg);+ }+ for (String cls : RESTRICTED_CLASSES) {+ engine.addProperty(RuntimeConstants.INTROSPECTOR_RESTRICT_CLASSES, cls);+ }+ }++ /**+ * Replaces the built-in {@code #foreach} directive with {@link SandboxedForeach}, so every+ * loop iteration is subject to {@link VtlExecutionGuard}'s execution deadline check. Must be+ * called after {@link VelocityEngine#init()} (the built-in directive is only registered during+ * {@code init()}, so calling this beforehand would have nothing to remove/replace).+ */+ public static void installSandboxedForeach(VelocityEngine engine) {+ engine.removeDirective("foreach");+ engine.loadDirective(SandboxedForeach.class.getName());+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlTemplateEngine.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlTemplateEngine.javaindex 621eb95b5f..7fc6caa84d 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlTemplateEngine.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/VtlTemplateEngine.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.apigateway;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.core.common.vtl.VtlUtilFunctions;+import io.github.hectorvent.floci.config.EmulatorConfig;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import io.quarkus.runtime.annotations.RegisterForReflection;@@ -24,11 +25,13 @@ import org.apache.velocity.runtime.resource.ResourceManagerImpl;import org.apache.velocity.runtime.resource.loader.FileResourceLoader;import org.apache.velocity.runtime.resource.loader.StringResourceLoader;import org.apache.velocity.runtime.resource.util.StringResourceRepositoryImpl;+import org.apache.velocity.util.introspection.SecureUberspector;import org.apache.velocity.util.introspection.TypeConversionHandlerImpl;import org.apache.velocity.util.introspection.UberspectImpl;import java.io.StringWriter;import java.util.AbstractMap;+import java.time.Duration;import java.util.HashMap;import java.util.Map;import java.util.Set;@@ -46,6 +49,7 @@ import java.util.Set;VtlTemplateEngine.UtilVariable.class,VtlTemplateEngine.ResponseOverride.class,UberspectImpl.class,+ SecureUberspector.class,TypeConversionHandlerImpl.class,ResourceManagerImpl.class,ResourceCacheImpl.class,@@ -54,6 +58,7 @@ import java.util.Set;StringResourceLoader.class,StringResourceRepositoryImpl.class,Foreach.class,+ SandboxedForeach.class,Include.class,Parse.class,Macro.class,@@ -67,17 +72,22 @@ public class VtlTemplateEngine {private final VelocityEngine engine;private final ObjectMapper objectMapper;+ private final EmulatorConfig config;@Inject- public VtlTemplateEngine(ObjectMapper objectMapper) {+ public VtlTemplateEngine(ObjectMapper objectMapper, EmulatorConfig config) {this.objectMapper = objectMapper;+ this.config = config;this.engine = new VelocityEngine();engine.setProperty(RuntimeConstants.INPUT_ENCODING, "UTF-8");engine.setProperty(RuntimeConstants.RUNTIME_LOG_NAME, "io.github.hectorvent.floci.vtl");engine.setProperty(RuntimeConstants.RESOURCE_LOADERS, "string");engine.setProperty("resource.loader.string.class","org.apache.velocity.runtime.resource.loader.StringResourceLoader");+ engine.setProperty(RuntimeConstants.MAX_NUMBER_LOOPS, config.services().apigateway().vtlMaxLoops());+ VtlSandbox.restrictIntrospection(engine);engine.init();+ VtlSandbox.installSandboxedForeach(engine);}/**@@ -110,10 +120,16 @@ public class VtlTemplateEngine {vc.put("context", buildContextMap(ctx, override));vc.put("stageVariables", ctx.stageVariables() != null ? ctx.stageVariables() : Map.of());- StringWriter writer = new StringWriter();- engine.evaluate(vc, writer, "apigw-template", template);+ StringWriter rawWriter = new StringWriter();+ BoundedWriter writer = new BoundedWriter(rawWriter, config.services().apigateway().vtlMaxOutputChars());+ VtlExecutionGuard.begin(Duration.ofMillis(config.services().apigateway().vtlTimeoutMillis()));+ try {+ engine.evaluate(vc, writer, "apigw-template", template);+ } finally {+ VtlExecutionGuard.end();+ }return new EvaluateResult(- writer.toString(),+ rawWriter.toString(),override.getStatus(),override.getHeader().isEmpty() ? Map.of() : Map.copyOf(override.getHeader()));}diff --git a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncVtlEngine.java b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncVtlEngine.javaindex 07857842ec..ab5747b309 100644--- a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncVtlEngine.java+++ b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncVtlEngine.java@@ -1,5 +1,9 @@package io.github.hectorvent.floci.services.appsync.graphql;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.apigateway.BoundedWriter;+import io.github.hectorvent.floci.services.apigateway.VtlExecutionGuard;+import io.github.hectorvent.floci.services.apigateway.VtlSandbox;import io.github.hectorvent.floci.services.appsync.graphql.util.AppSyncUtil;import io.github.hectorvent.floci.services.appsync.graphql.util.VtlErrorSignal;import jakarta.enterprise.context.ApplicationScoped;@@ -9,6 +13,7 @@ import org.apache.velocity.app.VelocityEngine;import org.apache.velocity.runtime.RuntimeConstants;import java.io.StringWriter;+import java.time.Duration;import java.util.List;import java.util.Map;@@ -16,9 +21,11 @@ import java.util.Map;public class AppSyncVtlEngine {private final VelocityEngine engine;+ private final EmulatorConfig config;@Inject- public AppSyncVtlEngine() {+ public AppSyncVtlEngine(EmulatorConfig config) {+ this.config = config;this.engine = new VelocityEngine();engine.setProperty(RuntimeConstants.INPUT_ENCODING, "UTF-8");engine.setProperty(RuntimeConstants.RUNTIME_LOG_NAME,@@ -29,7 +36,10 @@ public class AppSyncVtlEngine {engine.setProperty(RuntimeConstants.RUNTIME_REFERENCES_STRICT, false);engine.setProperty("userdirective","io.github.hectorvent.floci.services.appsync.graphql.ReturnDirective");+ engine.setProperty(RuntimeConstants.MAX_NUMBER_LOOPS, config.services().appsync().vtlMaxLoops());+ VtlSandbox.restrictIntrospection(engine);engine.init();+ VtlSandbox.installSandboxedForeach(engine);}public AppSyncVtlResult evaluate(String template, AppSyncVtlContext ctx) {@@ -51,7 +61,9 @@ public class AppSyncVtlEngine {vc.put("util", util);vc.put("utils", util);- StringWriter writer = new StringWriter();+ StringWriter rawWriter = new StringWriter();+ BoundedWriter writer = new BoundedWriter(rawWriter, config.services().appsync().vtlMaxOutputChars());+ VtlExecutionGuard.begin(Duration.ofMillis(config.services().appsync().vtlTimeoutMillis()));try {engine.evaluate(vc, writer, "appsync-template", template);} catch (ReturnSignal signal) {@@ -65,9 +77,11 @@ public class AppSyncVtlEngine {cause = cause.getCause();}throw new RuntimeException("VTL evaluation failed", e);+ } finally {+ VtlExecutionGuard.end();}- return new AppSyncVtlResult(writer.toString(), null, ctx.getAppendedErrors());+ return new AppSyncVtlResult(rawWriter.toString(), null, ctx.getAppendedErrors());}}diff --git a/src/main/resources/META-INF/native-image/reflect-config.json b/src/main/resources/META-INF/native-image/reflect-config.jsonindex e7563033db..2840004808 100644--- a/src/main/resources/META-INF/native-image/reflect-config.json+++ b/src/main/resources/META-INF/native-image/reflect-config.json@@ -23,6 +23,18 @@"allDeclaredMethods": true,"allDeclaredFields": true},+ {+ "name": "org.apache.velocity.util.introspection.SecureUberspector",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true,+ "allDeclaredFields": true+ },+ {+ "name": "io.github.hectorvent.floci.services.apigateway.SandboxedForeach",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true,+ "allDeclaredFields": true+ },{"name": "org.apache.velocity.util.introspection.TypeConversionHandlerImpl","allDeclaredConstructors": true,diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 857288cb94..c2a8e788b0 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -319,6 +319,9 @@ floci:enabled: falseapigateway:enabled: true+ vtl-max-loops: 10000 # Maximum #foreach iterations a VTL mapping template may execute (truncates the loop, does not fail the template)+ vtl-max-output-chars: 1048576 # Maximum characters a VTL mapping template may render before it fails+ vtl-timeout-millis: 5000 # Maximum wall-clock time a VTL mapping template may spend evaluating before it failsapigatewayv2:enabled: trueiam:@@ -658,6 +661,9 @@ floci:enabled: trueschema-worker-threads: 4schema-worker-shutdown-timeout-seconds: 30+ vtl-max-loops: 10000 # Maximum #foreach iterations a VTL resolver template may execute (truncates the loop, does not fail the template)+ vtl-max-output-chars: 1048576 # Maximum characters a VTL resolver template may render before it fails+ vtl-timeout-millis: 5000 # Maximum wall-clock time a VTL resolver template may spend evaluating before it failss3vectors:enabled: trues3tables:diff --git a/src/main/resources/org/apache/velocity/runtime/defaults/velocity.properties b/src/main/resources/org/apache/velocity/runtime/defaults/velocity.propertiesindex e790f79069..0b17278a39 100644--- a/src/main/resources/org/apache/velocity/runtime/defaults/velocity.properties+++ b/src/main/resources/org/apache/velocity/runtime/defaults/velocity.properties@@ -198,7 +198,7 @@ parser.pool.size = 20# Allows alternative introspection and all that can of worms brings.# -----------------------------------------------------------------------------introspector.uberspect.class = org.apache.velocity.util.introspection.UberspectImpl+introspector.uberspect.class = org.apache.velocity.util.introspection.SecureUberspector# ----------------------------------------------------------------------------# CONVERSION HANDLER@@ -242,6 +242,16 @@ introspector.restrict.classes = java.net.Socketintrospector.restrict.classes = javax.management.MBeanServerintrospector.restrict.classes = javax.script.ScriptEngine+# Additional restrictions beyond Velocity's own defaults above. SecureIntrospectorImpl matches+# package/class names by exact string equality (no wildcards), so sun.*/jdk.internal.* packages+# are deliberately not enumerated here: the only realistic path to them from an arbitrary VTL+# object graph is via java.lang.Class or a ClassLoader, both already fully blocked above.++introspector.restrict.packages = java.lang.invoke+introspector.restrict.packages = javax.script+introspector.restrict.packages = java.nio.file+introspector.restrict.classes = java.io.File+# ----------------------------------------------------------------------------# SPACE GOBBLING# ----------------------------------------------------------------------------diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/BoundedWriterTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/BoundedWriterTest.javanew file mode 100644index 0000000000..e1d0b9648a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/BoundedWriterTest.java@@ -0,0 +1,68 @@+package io.github.hectorvent.floci.services.apigateway;++import org.junit.jupiter.api.Test;++import java.io.StringWriter;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;++/**+ * Isolated, non-CDI unit tests for {@link BoundedWriter}, exercising writes under, at, and over+ * the configured character budget directly, without going through Velocity or Quarkus.+ */+class BoundedWriterTest {++ @Test+ void write_underLimit_passesThroughToDelegate() throws Exception {+ StringWriter delegate = new StringWriter();+ BoundedWriter writer = new BoundedWriter(delegate, 10);++ writer.write("hello".toCharArray(), 0, 5);++ assertEquals("hello", delegate.toString());+ }++ @Test+ void write_exactlyAtLimit_isAllowed() throws Exception {+ StringWriter delegate = new StringWriter();+ BoundedWriter writer = new BoundedWriter(delegate, 5);++ writer.write("hello".toCharArray(), 0, 5);++ assertEquals("hello", delegate.toString());+ }++ @Test+ void write_overLimit_throwsAndDoesNotWriteToDelegate() {+ StringWriter delegate = new StringWriter();+ BoundedWriter writer = new BoundedWriter(delegate, 4);++ assertThrows(VtlLimitExceededException.class, () -> writer.write("hello".toCharArray(), 0, 5));+ assertEquals("", delegate.toString(), "a write that exceeds the budget must not partially land");+ }++ @Test+ void write_multipleWritesAccumulate_andTripOnceTotalExceedsLimit() throws Exception {+ StringWriter delegate = new StringWriter();+ BoundedWriter writer = new BoundedWriter(delegate, 6);++ writer.write("abc".toCharArray(), 0, 3);+ writer.write("def".toCharArray(), 0, 3);+ assertEquals("abcdef", delegate.toString());++ assertThrows(VtlLimitExceededException.class, () -> writer.write("g".toCharArray(), 0, 1));+ }++ @Test+ void flushAndClose_delegateToUnderlyingWriter() throws Exception {+ StringWriter delegate = new StringWriter();+ BoundedWriter writer = new BoundedWriter(delegate, 10);++ writer.write("ok".toCharArray(), 0, 2);+ writer.flush();+ writer.close();++ assertEquals("ok", delegate.toString());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/SandboxedForeachTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/SandboxedForeachTest.javanew file mode 100644index 0000000000..e96cb11239--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/SandboxedForeachTest.java@@ -0,0 +1,90 @@+package io.github.hectorvent.floci.services.apigateway;++import org.apache.velocity.VelocityContext;+import org.apache.velocity.app.VelocityEngine;+import org.apache.velocity.runtime.RuntimeConstants;+import org.junit.jupiter.api.Test;++import java.io.StringWriter;+import java.time.Duration;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Isolated, non-CDI test proving that {@link VtlSandbox#installSandboxedForeach(VelocityEngine)}+ * actually wires {@link SandboxedForeach}'s per-iteration {@link VtlExecutionGuard#checkDeadline()}+ * call into a real {@code #foreach} render.+ *+ * <p>This is deliberately distinct from the loop-count cap test in {@code VtlTemplateEngineTest}+ * (which only proves Velocity's own native {@code directive.foreach.max_loops}) and from+ * {@link BoundedWriterTest} (which only proves the output-size cap): the template below never+ * writes its growing {@code $s} to the output writer at all, so a failure here can only come from+ * the execution-time deadline tripping inside the loop body, which is exactly the "runaway+ * {@code #set} string doubling that never reaches the output writer" scenario the deadline check+ * exists to catch.+ */+class SandboxedForeachTest {++ private VelocityEngine sandboxedEngine() {+ VelocityEngine engine = new VelocityEngine();+ engine.setProperty(RuntimeConstants.RESOURCE_LOADERS, "string");+ engine.setProperty("resource.loader.string.class",+ "org.apache.velocity.runtime.resource.loader.StringResourceLoader");+ VtlSandbox.restrictIntrospection(engine);+ engine.init();+ VtlSandbox.installSandboxedForeach(engine);+ return engine;+ }++ @Test+ void runawayStringDoublingNeverWrittenToOutput_isStoppedByDeadline_notByOutputCap() {+ VelocityEngine engine = sandboxedEngine();+ // Doubling a 2-character seed 40 times would reach roughly 2 billion characters, well+ // past what any sane loop-count cap (10,000) would prevent, and $s is never written to+ // the output writer, so BoundedWriter cannot be what stops this either.+ String template = "#set($s = \"xy\")#foreach($i in [1..40])#set($s = \"$s$s\")#end";+ StringWriter writer = new StringWriter();++ VtlExecutionGuard.begin(Duration.ofMillis(20));+ try {+ RuntimeException ex = assertThrows(RuntimeException.class,+ () -> engine.evaluate(new VelocityContext(), writer, "runaway-doubling", template));+ assertTrue(causedByDeadline(ex),+ "expected the failure to be caused by VtlLimitExceededException (the deadline check), but was: "+ + ex);+ } finally {+ VtlExecutionGuard.end();+ }++ assertEquals("", writer.toString(),+ "nothing should have reached the output writer before the deadline tripped inside the loop");+ }++ @Test+ void shortLoopWithinDeadline_completesNormally() {+ VelocityEngine engine = sandboxedEngine();+ String template = "#foreach($i in [1..5])x#end";+ StringWriter writer = new StringWriter();++ VtlExecutionGuard.begin(Duration.ofSeconds(30));+ try {+ engine.evaluate(new VelocityContext(), writer, "short-loop", template);+ } finally {+ VtlExecutionGuard.end();+ }++ assertEquals("xxxxx", writer.toString());+ }++ private static boolean causedByDeadline(Throwable t) {+ while (t != null) {+ if (t instanceof VtlLimitExceededException) {+ return true;+ }+ t = t.getCause();+ }+ return false;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/VtlExecutionGuardTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/VtlExecutionGuardTest.javanew file mode 100644index 0000000000..525a7f4d12--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/VtlExecutionGuardTest.java@@ -0,0 +1,67 @@+package io.github.hectorvent.floci.services.apigateway;++import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.Test;++import java.time.Duration;++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertThrows;++/**+ * Isolated, non-CDI unit tests for {@link VtlExecutionGuard}, run directly against the thread's+ * deadline state without going through Velocity or Quarkus, for fast deterministic coverage of+ * the execution-time deadline mechanism itself.+ */+class VtlExecutionGuardTest {++ @AfterEach+ void clearAnyLeftoverDeadline() {+ // Guard against a failed assertion mid-test leaking a deadline into later tests on the+ // same thread (JUnit5 reuses threads across test methods by default).+ VtlExecutionGuard.end();+ }++ @Test+ void checkDeadline_withNoActiveDeadline_doesNothing() {+ assertDoesNotThrow(VtlExecutionGuard::checkDeadline);+ }++ @Test+ void checkDeadline_beforeDeadlinePasses_doesNothing() throws InterruptedException {+ VtlExecutionGuard.begin(Duration.ofSeconds(30));+ assertDoesNotThrow(VtlExecutionGuard::checkDeadline);+ }++ @Test+ void checkDeadline_afterDeadlinePasses_throws() throws InterruptedException {+ VtlExecutionGuard.begin(Duration.ofMillis(1));+ Thread.sleep(20);+ VtlLimitExceededException ex =+ assertThrows(VtlLimitExceededException.class, VtlExecutionGuard::checkDeadline);+ assertNotNullMessage(ex);+ }++ @Test+ void end_clearsDeadline_soCheckDeadlineNoLongerThrows() throws InterruptedException {+ VtlExecutionGuard.begin(Duration.ofMillis(1));+ Thread.sleep(20);+ VtlExecutionGuard.end();+ assertDoesNotThrow(VtlExecutionGuard::checkDeadline);+ }++ @Test+ void begin_replacesAnyPreviousDeadline() throws InterruptedException {+ VtlExecutionGuard.begin(Duration.ofMillis(1));+ Thread.sleep(20);+ // A fresh begin() must reset the deadline, not extend the expired one.+ VtlExecutionGuard.begin(Duration.ofSeconds(30));+ assertDoesNotThrow(VtlExecutionGuard::checkDeadline);+ }++ private static void assertNotNullMessage(VtlLimitExceededException ex) {+ if (ex.getMessage() == null || ex.getMessage().isBlank()) {+ throw new AssertionError("expected a descriptive message on VtlLimitExceededException");+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/VtlTemplateEngineTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/VtlTemplateEngineTest.javaindex 1ee6da07ce..9594002aee 100644--- a/src/test/java/io/github/hectorvent/floci/services/apigateway/VtlTemplateEngineTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/VtlTemplateEngineTest.java@@ -485,4 +485,77 @@ class VtlTemplateEngineTest {assertNull(result.statusOverride());assertTrue(result.headerOverrides().isEmpty());}++ // ────────── Sandbox: reflection escapes must be blocked ──────────++ @Test+ void security_getClassLoaderIsNotReachable() {+ // When SecureUberspector blocks a method call, Velocity (in non-strict mode, the default+ // here) renders the literal, unresolved reference text instead of throwing or evaluating+ // it. Getting the raw template text back verbatim (rather than an actual ClassLoader+ // instance's toString, e.g. "...ClassLoader@<hash>") proves the call was blocked. Note+ // this literal text still contains the substring "ClassLoader" (it's the method name), so+ // a plain assertFalse(result.contains("ClassLoader")) would wrongly fail here.+ String template = "$util.getClass().getClassLoader()";+ String result = engine.evaluate(template, ctx("{}")).body();+ assertEquals(template, result,+ "expected getClassLoader() to be blocked by SecureUberspector and rendered as an "+ + "unresolved literal reference, but got: " + result);+ }++ @Test+ void security_classForNameIsNotReachable() {+ String result = engine.evaluate(+ "$util.getClass().forName('java.lang.System').getName()", ctx("{}")).body();+ assertNotEquals("java.lang.System", result,+ "expected Class.forName(...) to be blocked by SecureUberspector, but it resolved: " + result);+ }++ @Test+ void security_runtimeClassIsNotLoadableByName() {+ String result = engine.evaluate(+ "$util.getClass().forName('java.lang.Runtime').getName()", ctx("{}")).body();+ assertNotEquals("java.lang.Runtime", result,+ "expected Class.forName('java.lang.Runtime') to be blocked, but it resolved: " + result);+ }++ @Test+ void security_processBuilderClassIsNotLoadableByName() {+ String result = engine.evaluate(+ "$util.getClass().forName('java.lang.ProcessBuilder').getName()", ctx("{}")).body();+ assertNotEquals("java.lang.ProcessBuilder", result,+ "expected Class.forName('java.lang.ProcessBuilder') to be blocked, but it resolved: " + result);+ }++ @Test+ void security_getClassStillPermitsGetName() {+ // getName() on a Class receiver must remain permitted (SecureUberspector's one exception),+ // so ordinary reflection-free VTL idioms relying on it (if any) keep working.+ String result = engine.evaluate("$util.getClass().getName()", ctx("{}")).body();+ assertTrue(result.contains("UtilVariable"), "expected getName() on Class to still work, got: " + result);+ }++ // ────────── Sandbox: runaway loop and output limits ──────────++ @Test+ void security_foreachLoopCountIsBounded() {+ // 50,000 requested iterations, each writing a single character. With no cap this renders+ // 50,000 characters; the configured default (ApiGatewayServiceConfig.vtlMaxLoops = 10000)+ // must cap the loop well before that.+ String template = "#foreach($i in [1..50000])x#end";+ String result = engine.evaluate(template, ctx("{}")).body();+ assertEquals(10000, result.length(),+ "expected #foreach to be capped at the configured vtlMaxLoops, but rendered " + result.length()+ + " characters");+ }++ @Test+ void security_outputSizeIsBounded() {+ // 21 doublings of a 2-character seed produce roughly 4 million characters, comfortably+ // over the default 1,048,576-character output cap, in only 21 loop iterations (well under+ // the 10,000-iteration loop cap), so this exercises the output limit specifically.+ String template = "#set($s = \"xy\")#foreach($i in [1..21])#set($s = \"$s$s\")#end$s";+ assertThrows(RuntimeException.class, () -> engine.evaluate(template, ctx("{}")),+ "expected output exceeding the configured vtlMaxOutputChars to throw");+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncVtlEngineTest.java b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncVtlEngineTest.javaindex 2ac9b37d61..93495df632 100644--- a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncVtlEngineTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncVtlEngineTest.java@@ -765,4 +765,82 @@ class AppSyncVtlEngineTest {engine.evaluate("#if(true)", defaultCtx()));}}++ // ────────── Sandbox: reflection escapes, and runaway loop/output limits ──────────++ @Nested+ class CategoryK_Sandbox {++ @Test+ void k1_getClassLoaderIsNotReachable() {+ // When SecureUberspector blocks a method call, Velocity (non-strict mode, the default+ // here) renders the literal, unresolved reference text instead of throwing or+ // evaluating it. Getting the raw template text back verbatim (rather than an actual+ // ClassLoader instance's toString) proves the call was blocked.+ String template = "$util.getClass().getClassLoader()";+ var result = engine.evaluate(template, defaultCtx());+ assertEquals(template, result.output(),+ "expected getClassLoader() to be blocked by SecureUberspector and rendered as "+ + "an unresolved literal reference, but got: " + result.output());+ }++ @Test+ void k2_classForNameIsNotReachable() {+ var result = engine.evaluate(+ "$util.getClass().forName('java.lang.System').getName()", defaultCtx());+ assertNotEquals("java.lang.System", result.output(),+ "expected Class.forName(...) to be blocked by SecureUberspector, but it resolved: "+ + result.output());+ }++ @Test+ void k3_runtimeClassIsNotLoadableByName() {+ var result = engine.evaluate(+ "$util.getClass().forName('java.lang.Runtime').getName()", defaultCtx());+ assertNotEquals("java.lang.Runtime", result.output(),+ "expected Class.forName('java.lang.Runtime') to be blocked, but it resolved: "+ + result.output());+ }++ @Test+ void k4_processBuilderClassIsNotLoadableByName() {+ var result = engine.evaluate(+ "$util.getClass().forName('java.lang.ProcessBuilder').getName()", defaultCtx());+ assertNotEquals("java.lang.ProcessBuilder", result.output(),+ "expected Class.forName('java.lang.ProcessBuilder') to be blocked, but it resolved: "+ + result.output());+ }++ @Test+ void k5_getClassStillPermitsGetName() {+ // getName() on a Class receiver must remain permitted (SecureUberspector's one+ // exception), so ordinary reflection-free VTL idioms relying on it keep working.+ var result = engine.evaluate("$util.getClass().getName()", defaultCtx());+ assertTrue(result.output().toString().contains("AppSyncUtil"),+ "expected getName() on Class to still work, got: " + result.output());+ }++ @Test+ void k6_foreachLoopCountIsBounded() {+ // 50,000 requested iterations, each writing a single character. With no cap this+ // renders 50,000 characters; the configured default+ // (AppSyncServiceConfig.vtlMaxLoops = 10000) must cap the loop well before that.+ String template = "#foreach($i in [1..50000])x#end";+ var result = engine.evaluate(template, defaultCtx());+ assertEquals(10000, result.output().toString().length(),+ "expected #foreach to be capped at the configured vtlMaxLoops, but rendered "+ + result.output().toString().length() + " characters");+ }++ @Test+ void k7_outputSizeIsBounded() {+ // 21 doublings of a 2-character seed produce roughly 4 million characters, comfortably+ // over the default 1,048,576-character output cap, in only 21 loop iterations (well+ // under the 10,000-iteration loop cap), so this exercises the output limit+ // specifically.+ String template = "#set($s = \"xy\")#foreach($i in [1..21])#set($s = \"$s$s\")#end$s";+ assertThrows(RuntimeException.class, () -> engine.evaluate(template, defaultCtx()),+ "expected output exceeding the configured vtlMaxOutputChars to throw");+ }+ }}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex 935df9dc17..b0557a6316 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -135,6 +135,9 @@ floci:enabled: trueapigateway:enabled: true+ vtl-max-loops: 10000+ vtl-max-output-chars: 1048576+ vtl-timeout-millis: 5000apigatewayv2:enabled: trueiam:@@ -368,6 +371,9 @@ floci:enabled: trueschema-worker-threads: 4schema-worker-shutdown-timeout-seconds: 30+ vtl-max-loops: 10000+ vtl-max-output-chars: 1048576+ vtl-timeout-millis: 5000s3vectors:enabled: trues3tables: