Allow dynamic code generation in Jest environment

Author: mrbbot

packages/jest-environment-miniflare/src/index.ts

@@ -11,7 +11,7 @@ import {
 } from "@miniflare/durable-objects";
 import { HTMLRewriterPlugin } from "@miniflare/html-rewriter";
 import { KVPlugin } from "@miniflare/kv";
-import { VMScriptRunner, proxiedGlobals } from "@miniflare/runner-vm";
+import { VMScriptRunner, makeProxiedGlobals } from "@miniflare/runner-vm";
 import { Context, NoOpLog } from "@miniflare/shared";
 import { SitesPlugin } from "@miniflare/sites";
 import { WebSocketPlugin } from "@miniflare/web-sockets";
@@ -66,11 +66,12 @@ export default class MiniflareEnvironment implements JestEnvironment {
 
   constructor(config: Config.ProjectConfig) {
     this.config = config;
-    this.context = vm.createContext(
-      {},
-      { codeGeneration: { strings: false, wasm: false } }
+    // Intentionally allowing code generation as some coverage tools require it
+    this.context = vm.createContext({});
+    this.scriptRunner = new VMScriptRunner(
+      this.context,
+      /* blockCodeGeneration */ false
     );
-    this.scriptRunner = new VMScriptRunner(this.context);
 
     const global = (this.global = vm.runInContext("this", this.context));
     global.global = global;
@@ -168,7 +169,7 @@ export default class MiniflareEnvironment implements JestEnvironment {
     // Make sure Miniflare's global scope is assigned to Jest's global context,
     // even if we didn't run a script because we had no Durable Objects
     Object.assign(global, mfGlobalScope);
-    Object.assign(global, proxiedGlobals);
+    Object.assign(global, makeProxiedGlobals(/* blockCodeGeneration */ false));
 
     // Add a way of getting bindings in modules mode to allow seeding data.
     // These names are intentionally verbose so they don't collide with anything

packages/jest-environment-miniflare/test/fixtures/core.worker.spec.js

@@ -10,10 +10,6 @@ test("includes custom globals", () => {
   expect(KEY).toBe("value");
 });
 
-test("dynamic code generation disallowed", () => {
-  expect(() => eval("console.log('evil')")).toThrow(EvalError);
-});
-
 test("uses Jest console", () => {
   console.log("hello!");
 });

packages/runner-vm/src/index.ts

@@ -9,14 +9,17 @@ import {
 } from "@miniflare/shared";
 import { VMScriptRunnerError } from "./error";
 import { ModuleLinker } from "./linker";
-import { proxiedGlobals } from "./proxied";
+import { makeProxiedGlobals } from "./proxied";
 
 export * from "./error";
 export * from "./proxied";
 
 // noinspection JSMethodCanBeStatic
 export class VMScriptRunner implements ScriptRunner {
-  constructor(private context?: vm.Context) {}
+  constructor(
+    private context?: vm.Context,
+    private blockCodeGeneration = true
+  ) {}
 
   private runAsScript(context: vm.Context, blueprint: ScriptBlueprint) {
     const script = new vm.Script(blueprint.code, {
@@ -58,7 +61,7 @@ export class VMScriptRunner implements ScriptRunner {
 
     // Add proxied globals so cross-realm instanceof works correctly.
     // globalScope will be fresh for each call of run so it's fine to mutate it.
-    Object.assign(globalScope, proxiedGlobals);
+    Object.assign(globalScope, makeProxiedGlobals(this.blockCodeGeneration));
 
     let context = this.context;
     if (context) {
@@ -67,8 +70,9 @@ export class VMScriptRunner implements ScriptRunner {
       Object.assign(context, globalScope);
     } else {
       // Create a new context with eval/new Function/WASM compile disabled
+      const allow = !this.blockCodeGeneration;
       context = vm.createContext(globalScope, {
-        codeGeneration: { strings: false, wasm: false },
+        codeGeneration: { strings: allow, wasm: allow },
       });
     }
 

packages/runner-vm/src/proxied.ts

@@ -38,30 +38,38 @@ function proxyHasInstance<T extends object>(
   });
 }
 
-export const proxiedGlobals = {
-  Object: proxyHasInstance(Object, isObject),
-  Array: proxyHasInstance(Array, Array.isArray),
-  Promise: proxyHasInstance(Promise, types.isPromise),
-  RegExp: proxyHasInstance(RegExp, types.isRegExp),
-  Error: proxyHasInstance(Error, isError(Error)),
-  EvalError: proxyHasInstance(EvalError, isError(EvalError)),
-  RangeError: proxyHasInstance(RangeError, isError(RangeError)),
-  ReferenceError: proxyHasInstance(ReferenceError, isError(ReferenceError)),
-  SyntaxError: proxyHasInstance(SyntaxError, isError(SyntaxError)),
-  TypeError: proxyHasInstance(TypeError, isError(TypeError)),
-  URIError: proxyHasInstance(URIError, isError(URIError)),
-  Function: proxyHasInstance(Function, isFunction, {
-    construct() {
-      // We set `codeGeneration: { strings: false }` in our vm context, but
-      // because we're passing the Function constructor from outside the realm,
-      // we have to prevent construction ourselves.
-      //
-      // Constructing with the Function constructor obtained from
-      // `Object.getPrototypeOf(function(){}).constructor` will still throw
-      // though because of `strings: false`.
-      throw new EvalError(
-        "Code generation from strings disallowed for this context"
-      );
-    },
-  }),
-};
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function makeProxiedGlobals(blockCodeGeneration?: boolean) {
+  if (!blockCodeGeneration) blockCodeGeneration = undefined;
+  return {
+    Object: proxyHasInstance(Object, isObject),
+    Array: proxyHasInstance(Array, Array.isArray),
+    Promise: proxyHasInstance(Promise, types.isPromise),
+    RegExp: proxyHasInstance(RegExp, types.isRegExp),
+    Error: proxyHasInstance(Error, isError(Error)),
+    EvalError: proxyHasInstance(EvalError, isError(EvalError)),
+    RangeError: proxyHasInstance(RangeError, isError(RangeError)),
+    ReferenceError: proxyHasInstance(ReferenceError, isError(ReferenceError)),
+    SyntaxError: proxyHasInstance(SyntaxError, isError(SyntaxError)),
+    TypeError: proxyHasInstance(TypeError, isError(TypeError)),
+    URIError: proxyHasInstance(URIError, isError(URIError)),
+    Function: proxyHasInstance(
+      Function,
+      isFunction,
+      blockCodeGeneration && {
+        construct() {
+          // We set `codeGeneration: { strings: false }` in our vm context, but
+          // because we're passing the Function constructor from outside the
+          // realm, we have to prevent construction ourselves.
+          //
+          // Constructing with the Function constructor obtained from
+          // `Object.getPrototypeOf(function(){}).constructor` will still throw
+          // though because of `strings: false`.
+          throw new EvalError(
+            "Code generation from strings disallowed for this context"
+          );
+        },
+      }
+    ),
+  };
+}

packages/runner-vm/test/index.spec.ts

@@ -100,6 +100,18 @@ test("VMScriptRunner: run: disallows WebAssembly compilation", async (t) => {
       "WebAssembly.compile(): Wasm code generation disallowed by embedder",
   });
 });
+test("VMScriptRunner: run: allows dynamic code generation if enabled", async (t) => {
+  const runner = new VMScriptRunner(undefined, false);
+  const addModule = await fs.readFile(path.join(fixturesPath, "add.wasm"));
+  await runner.run({}, { code: 'eval("1 + 1")', filePath: "test.js" });
+  await runner.run({}, { code: 'new Function("1 + 1")', filePath: "test.js" });
+  await runner.run(
+    { addModule },
+    { code: "await WebAssembly.compile(addModule)", filePath: "test.js" },
+    []
+  );
+  t.pass();
+});
 test("VMScriptRunner: run: supports cross-realm instanceof", async (t) => {
   const result = await runner.run(
     { outsideRegexp: /a/ },

packages/runner-vm/test/proxied.spec.ts

@@ -1,7 +1,9 @@
 import vm from "vm";
-import { proxiedGlobals } from "@miniflare/runner-vm";
+import { makeProxiedGlobals } from "@miniflare/runner-vm";
 import test, { Macro } from "ava";
 
+const proxiedGlobals = makeProxiedGlobals(false);
+
 const instanceOfMacro: Macro<
   [type: string, create: () => any, invert?: boolean]
 > = (t, type, create, invert) => {