@agiledigital/pingone-aic-script-tester 0.1.0

package/java/AmClassShutter.java

@@ -0,0 +1,98 @@
+import java.util.ArrayList;
+import java.util.List;
+import org.mozilla.javascript.ClassShutter;
+
+/**
+ * Replica of the AM script sandbox's per-context Java class allow-list.
+ *
+ * <p>AM runs Rhino behind a class shutter that decides, per class and per
+ * script context, whether a Java class is visible at all. The local runner had
+ * none, so every Java name resolved and every iterator worked — which made the
+ * harness strictly MORE permissive than the tenant. A script using
+ * {@code new java.util.HashMap()} or {@code list.iterator()} passed locally and
+ * is refused by AIC.
+ *
+ * <p>The policy is not invented here. It is the {@code allowLists} array of the
+ * context's binding descriptor (for a scripted decision node,
+ * {@code docs/api/bindings/scripted-decision-next.json} — 51 entries), passed in
+ * per job so a second context can supply its own list.
+ *
+ * <p>Rhino gives both of AM's observed failure shapes from this one hook, at no
+ * extra effort — see {@code docs/api/12-script-bindings-matrix.md}:
+ *
+ * <ul>
+ *   <li>a name the script writes itself never resolves past the package object,
+ *       so {@code new java.util.HashMap()} fails as
+ *       {@code TypeError: [JavaPackage java.util.HashMap] is not a function};
+ *   <li>an instance handed to the script by a call or binding throws
+ *       {@code InternalError: Access to Java class "…" is prohibited.}
+ * </ul>
+ *
+ * <p>Patterns are exact names, or a trailing {@code *} meaning prefix. That one
+ * rule covers every form the descriptor uses: {@code java.util.Collections$*},
+ * {@code com.sun.proxy.$*} and
+ * {@code org.forgerock.openam.core.rest.authn.callbackhandlers.*}.
+ */
+final class AmClassShutter implements ClassShutter {
+
+  private final String[] exact;
+  private final String[] prefixes;
+
+  private AmClassShutter(String[] exact, String[] prefixes) {
+    this.exact = exact;
+    this.prefixes = prefixes;
+  }
+
+  /** Build from the descriptor's `allowLists` entries. */
+  static AmClassShutter of(List<String> patterns) {
+    List<String> exactNames = new ArrayList<String>();
+    List<String> prefixNames = new ArrayList<String>();
+    for (String pattern : patterns) {
+      if (pattern == null || pattern.isEmpty()) {
+        continue;
+      }
+      if (pattern.endsWith("*")) {
+        prefixNames.add(pattern.substring(0, pattern.length() - 1));
+      } else {
+        exactNames.add(pattern);
+      }
+    }
+    return new AmClassShutter(
+        exactNames.toArray(new String[0]), prefixNames.toArray(new String[0]));
+  }
+
+  /**
+   * Rhino's own runtime classes, which the shutter must never hide.
+   *
+   * <p>The shutter is consulted for engine internals as well as for classes a
+   * script names. Hiding them does not enforce policy, it breaks the language:
+   * a template literal produces an {@code org.mozilla.javascript.ConsString},
+   * so a shutter built from the allow-list alone fails
+   * {@code `hi ${who}`} with {@code Access to Java class
+   * "org.mozilla.javascript.ConsString" is prohibited} — and template literals
+   * are used by 181 of the 384 scripts in the production corpus and run fine on
+   * AIC. AM is itself running Rhino, so its shutter cannot be hiding these
+   * either.
+   *
+   * <p>This is a requirement of the engine, not an inference about AM's policy.
+   */
+  private static final String ENGINE_PACKAGE = "org.mozilla.javascript.";
+
+  @Override
+  public boolean visibleToScripts(String fullClassName) {
+    if (fullClassName.startsWith(ENGINE_PACKAGE)) {
+      return true;
+    }
+    for (String name : exact) {
+      if (name.equals(fullClassName)) {
+        return true;
+      }
+    }
+    for (String prefix : prefixes) {
+      if (fullClassName.startsWith(prefix)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

package/java/AmContextFactory.java

@@ -0,0 +1,69 @@
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.ContextFactory;
+
+/**
+ * Replica of AM 8.1.1 {@code ObservedContextFactory} + its inner {@code
+ * ObservedJavaScriptContext}, plus the {@code
+ * RhinoScriptEngineFactory.getContext} knobs that constructor does not set.
+ *
+ * <p>Measured:
+ *
+ * <ul>
+ *   <li>{@code makeContext} constructs {@code ObservedJavaScriptContext}
+ *   <li>that constructor: {@code setOptimizationLevel(-1)}, {@code
+ *       setInstructionObserverThreshold(1000)}, and {@code
+ *       setLanguageVersion(200)} only when {@code
+ *       org.forgerock.am.scripting.disableES6} is false. Language version is
+ *       a per-job choice here (AIC's measured JS is {@code VERSION_DEFAULT}).
+ *   <li>{@code observeInstructionCount}: if configured timeout (AM stores it
+ *       in <em>seconds</em>) has elapsed since {@code startTime}, throw {@code
+ *       new Error("Interrupt.")}
+ *   <li>{@code hasFeature(21)} is true ({@code FEATURE_ENABLE_JAVA_MAP_ACCESS})
+ *   <li>{@code getContext} also {@code setMaximumInterpreterStackDepth} (default
+ *       10000). We set that on every context.
+ * </ul>
+ *
+ * <p>Timeout is per-job milliseconds rather than AM's process-wide seconds, so
+ * one runaway script cannot take the runner down. {@code 0} means no timeout,
+ * matching AM's {@code ScriptEngineConfiguration.NO_TIMEOUT}.
+ */
+final class AmContextFactory extends ContextFactory {
+
+  @Override
+  protected boolean hasFeature(Context cx, int featureIndex) {
+    if (featureIndex == Context.FEATURE_ENABLE_JAVA_MAP_ACCESS) {
+      return true;
+    }
+    return super.hasFeature(cx, featureIndex);
+  }
+
+  @Override
+  protected Context makeContext() {
+    return new ObservedContext(this);
+  }
+
+  @Override
+  protected void observeInstructionCount(Context cx, int instructionCount) {
+    ObservedContext observed = (ObservedContext) cx;
+    long timeoutMs = observed.timeoutMs;
+    if (timeoutMs <= 0) {
+      return;
+    }
+    if (System.currentTimeMillis() - observed.startTime > timeoutMs) {
+      throw new Error("Interrupt.");
+    }
+  }
+
+  static final class ObservedContext extends Context {
+    final long startTime;
+    long timeoutMs;
+
+    ObservedContext(ContextFactory factory) {
+      super(factory);
+      this.startTime = System.currentTimeMillis();
+      setOptimizationLevel(-1);
+      setInstructionObserverThreshold(1000);
+      setMaximumInterpreterStackDepth(10000);
+    }
+  }
+}

package/java/AmScopes.java

@@ -0,0 +1,49 @@
+import javax.script.ScriptContext;
+import javax.script.SimpleScriptContext;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+
+/**
+ * AM 8.1.1 {@code RhinoScriptEngine.makeScriptable} / {@code getScope},
+ * measured with {@code javap -p -c}.
+ *
+ * <pre>
+ *   ScriptContextScope scope = new ScriptContextScope(scriptContext);
+ *   ScriptableObject std = cx.initStandardObjects();
+ *   scope.setPrototype(std);
+ *   scope.put("context", scope, scriptContext);
+ *   return scope;
+ * </pre>
+ *
+ * <p>The standard-objects object is the <em>prototype</em>, not the parent
+ * (parent stays {@code null}). {@code getScope} additionally installs CommonJS
+ * {@code require} when {@code LIBRARY_SCRIPT} is on and {@code libraryBindings}
+ * is present; that path is not modelled here (decision-node eval).
+ *
+ * <p>AM calls {@code initStandardObjects()} on every eval — it does not share a
+ * sealed standard-objects parent. We do the same, so {@code Object.prototype}
+ * mutations cannot leak from job N to job N+1.
+ */
+final class AmScopes {
+
+  static final String FILENAME_KEY = "javax.script.filename";
+
+  private AmScopes() {}
+
+  static Scriptable makeScriptable(Context cx, ScriptContext scriptContext) {
+    ScriptContextScope scope = new ScriptContextScope(scriptContext);
+    ScriptableObject std = cx.initStandardObjects();
+    scope.setPrototype(std);
+    scope.put("context", scope, scriptContext);
+    return scope;
+  }
+
+  static SimpleScriptContext newEngineContext(String sourceName) {
+    SimpleScriptContext scriptContext = new SimpleScriptContext();
+    if (sourceName != null) {
+      scriptContext.setAttribute(FILENAME_KEY, sourceName, ScriptContext.ENGINE_SCOPE);
+    }
+    return scriptContext;
+  }
+}

package/java/HostOps.java

@@ -0,0 +1,180 @@
+import java.nio.charset.StandardCharsets;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.MessageDigest;
+import java.security.SecureRandom;
+import java.security.Signature;
+import java.security.spec.ECGenParameterSpec;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.Base64;
+import java.util.UUID;
+import javax.crypto.Cipher;
+import javax.crypto.Mac;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.PBEKeySpec;
+import javax.crypto.spec.SecretKeySpec;
+import org.mozilla.javascript.BaseFunction;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.JavaScriptException;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+import org.mozilla.javascript.Wrapper;
+
+/** Narrow Java bridge captured by trusted mocks, then removed before user code runs. */
+public final class HostOps extends BaseFunction {
+  private static final SecureRandom RANDOM = new SecureRandom();
+  static final java.util.List<String> DIGESTS =
+      java.util.Arrays.asList("SHA-256", "SHA-384", "SHA-1", "SHA-512");
+
+  // A real Java byte[], as AIC returns: the same NativeJavaArray a script gets
+  // from java.lang.String#getBytes, which the shutter already allows.
+  private static Object wrapBytes(Context cx, Scriptable scope, byte[] bytes) {
+    return cx.getWrapFactory().wrap(cx, scope, bytes, byte[].class);
+  }
+
+  private static byte[] toBytes(Object value) {
+    return (byte[]) Context.jsToJava(value, byte[].class);
+  }
+
+  @Override
+  public Object call(Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
+    try {
+      return dispatch(cx, scope, args);
+    } catch (RuntimeException e) {
+      throw e;
+    } catch (Exception e) {
+      throw Context.reportRuntimeError(e.toString());
+    }
+  }
+
+  private Object dispatch(Context cx, Scriptable scope, Object[] args) throws Exception {
+    String op = (String) Context.jsToJava(args[0], String.class);
+    switch (op) {
+      case "base64Encode": {
+        // AIC's encode(byte[]) overload refuses a JS array (measured), where
+        // most of the crypto methods convert one.
+        Object raw = args[1] instanceof Wrapper ? ((Wrapper) args[1]).unwrap() : args[1];
+        if (!(raw instanceof byte[])) {
+          throw Context.reportRuntimeError("Cannot convert " + raw.getClass().getName() + "@"
+              + Integer.toHexString(System.identityHashCode(raw)) + " to byte[]");
+        }
+        byte[] b = (byte[]) raw;
+        boolean url = Context.toBoolean(args[2]);
+        return url ? Base64.getUrlEncoder().withoutPadding().encodeToString(b)
+            : Base64.getEncoder().encodeToString(b);
+      }
+      case "base64Decode": {
+        String s = (String) Context.jsToJava(args[1], String.class);
+        try {
+          return wrapBytes(cx, scope, Context.toBoolean(args[2])
+              ? Base64.getUrlDecoder().decode(s) : Base64.getDecoder().decode(s));
+        } catch (IllegalArgumentException e) {
+          // Thrown as a bare JS value so the mock can rethrow it without a
+          // location suffix, as AIC reports it.
+          throw new JavaScriptException(e.getMessage(), null, 0);
+        }
+      }
+      case "utf8": return wrapBytes(cx, scope,
+          ((String) Context.jsToJava(args[1], String.class)).getBytes(StandardCharsets.UTF_8));
+      case "fromUtf8": return new String(toBytes(args[1]), StandardCharsets.UTF_8);
+      case "uuid": return UUID.randomUUID().toString();
+      case "randomInt32": return Integer.valueOf(RANDOM.nextInt());
+      case "digest": {
+        String alg = (String) Context.jsToJava(args[1], String.class);
+        // AIC's list (measured); anything else is refused before it gets here.
+        if (!DIGESTS.contains(alg)) {
+          throw Context.reportRuntimeError("digest " + alg);
+        }
+        return wrapBytes(cx, scope, MessageDigest.getInstance(alg).digest(toBytes(args[2])));
+      }
+      case "hmac": {
+        String alg = (String) Context.jsToJava(args[1], String.class);
+        if (!DIGESTS.contains(alg)) {
+          throw Context.reportRuntimeError("hmac " + alg);
+        }
+        Mac mac = Mac.getInstance("Hmac" + alg.replace("-", ""));
+        mac.init(new SecretKeySpec(toBytes(args[2]), mac.getAlgorithm()));
+        return wrapBytes(cx, scope, mac.doFinal(toBytes(args[3])));
+      }
+      case "aes": {
+        Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding");
+        c.init(Context.toBoolean(args[1]) ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE,
+            new SecretKeySpec(toBytes(args[2]), "AES"));
+        return wrapBytes(cx, scope, c.doFinal(toBytes(args[3])));
+      }
+      case "pbkdf2": {
+        byte[] password = toBytes(args[1]);
+        // AIC casts the salt rather than converting it, so a JS array fails
+        // (measured); its message also names the webapp class loader.
+        Object rawSalt = args[2] instanceof Wrapper ? ((Wrapper) args[2]).unwrap() : args[2];
+        if (!(rawSalt instanceof byte[])) {
+          throw new JavaScriptException("class " + rawSalt.getClass().getName() + " cannot be cast to class [B", null, 0);
+        }
+        byte[] salt = (byte[]) rawSalt;
+        int iterations = ((Number) Context.jsToJava(args[3], Number.class)).intValue();
+        int bits = ((Number) Context.jsToJava(args[4], Number.class)).intValue();
+        String hash = (String) Context.jsToJava(args[5], String.class);
+        // Reachable through __parent__, so no wider than utils accepts.
+        if (!DIGESTS.contains(hash)) {
+          throw Context.reportRuntimeError("pbkdf2 " + hash);
+        }
+        PBEKeySpec spec = new PBEKeySpec(new String(password, StandardCharsets.UTF_8).toCharArray(), salt, iterations, bits);
+        return wrapBytes(cx, scope, SecretKeyFactory.getInstance("PBKDF2WithHmac" + hash.replace("-", ""))
+            .generateSecret(spec).getEncoded());
+      }
+      case "generateSecret": {
+        // AIC's generated AES and HMAC keys are both 32 bytes (measured).
+        byte[] bytes = new byte[32];
+        RANDOM.nextBytes(bytes);
+        return wrapBytes(cx, scope, bytes);
+      }
+      case "generateKeyPair": {
+        String alg = (String) Context.jsToJava(args[1], String.class);
+        // Reachable through __parent__, so no wider than utils accepts.
+        if (!"RSA".equals(alg) && !"ECDSA".equals(alg)) {
+          throw Context.reportRuntimeError("generateKeyPair " + alg);
+        }
+        KeyPairGenerator gen = KeyPairGenerator.getInstance("ECDSA".equals(alg) ? "EC" : alg);
+        if ("RSA".equals(alg)) gen.initialize(2048);
+        if ("ECDSA".equals(alg)) gen.initialize(new ECGenParameterSpec("secp256r1"));
+        KeyPair pair = gen.generateKeyPair();
+        Scriptable result = cx.newObject(scope);
+        ScriptableObject.putProperty(result, "privateKey", wrapBytes(cx, scope, pair.getPrivate().getEncoded()));
+        ScriptableObject.putProperty(result, "publicKey", wrapBytes(cx, scope, pair.getPublic().getEncoded()));
+        return result;
+      }
+      case "rsa": {
+        boolean encrypt = Context.toBoolean(args[1]);
+        byte[] key = toBytes(args[2]);
+        byte[] data = toBytes(args[3]);
+        // RSA transformation and encoded key formats were not independently measured; use JDK defaults.
+        KeyFactory factory = KeyFactory.getInstance("RSA");
+        Cipher cipher = Cipher.getInstance("RSA");
+        cipher.init(encrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE,
+            encrypt ? factory.generatePublic(new X509EncodedKeySpec(key)) : factory.generatePrivate(new PKCS8EncodedKeySpec(key)));
+        return wrapBytes(cx, scope, cipher.doFinal(data));
+      }
+      case "ecdsaSign": {
+        byte[] key = toBytes(args[1]);
+        Signature sig = Signature.getInstance("SHA256withECDSAinP1363Format");
+        sig.initSign(KeyFactory.getInstance("EC").generatePrivate(new PKCS8EncodedKeySpec(key)), RANDOM);
+        sig.update(toBytes(args[2])); return wrapBytes(cx, scope, sig.sign());
+      }
+      case "ecdsaVerify": {
+        byte[] key = toBytes(args[1]);
+        Signature sig = Signature.getInstance("SHA256withECDSAinP1363Format");
+        sig.initVerify(KeyFactory.getInstance("EC").generatePublic(new X509EncodedKeySpec(key)));
+        sig.update(toBytes(args[2]));
+        // AIC answers false for a DER signature rather than throwing (measured).
+        try {
+          return Boolean.valueOf(sig.verify(toBytes(args[3])));
+        } catch (java.security.SignatureException e) {
+          return Boolean.FALSE;
+        }
+      }
+      default: throw Context.reportRuntimeError("unknown host operation: " + op);
+    }
+  }
+}

package/java/JsValues.java

@@ -0,0 +1,39 @@
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.Undefined;
+
+/** Classify a Rhino completion / binding value for JSON emission. */
+final class JsValues {
+
+  final boolean defined;
+  final String kind;
+  final Object json;
+
+  private JsValues(boolean defined, String kind, Object json) {
+    this.defined = defined;
+    this.kind = kind;
+    this.json = json;
+  }
+
+  static JsValues of(Object raw) {
+    if (raw == Scriptable.NOT_FOUND) {
+      return new JsValues(false, "missing", null);
+    }
+    if (raw == null) {
+      return new JsValues(true, "null", null);
+    }
+    if (Undefined.isUndefined(raw)) {
+      return new JsValues(true, "undefined", null);
+    }
+    if (raw instanceof Boolean) {
+      return new JsValues(true, "boolean", raw);
+    }
+    if (raw instanceof Number) {
+      return new JsValues(true, "number", raw);
+    }
+    if (raw instanceof String) {
+      return new JsValues(true, "string", raw);
+    }
+    return new JsValues(true, "string", Context.toString(raw));
+  }
+}