js-confuser-vm 0.0.2 → 0.0.3

package/src/runtimeObf.ts

@@ -3,16 +3,21 @@ import { generate } from "@babel/generator";
 import { parse } from "@babel/parser";
 import traverseImport from "@babel/traverse";
 import { ok } from "assert";
-import { choice, shuffle } from "./random.ts";
+import { shuffle } from "./random.ts";
 import type { Options } from "./options.ts";
-import { escapeRegex } from "./utilts.ts";
 import { minify } from "./minify.ts";
-const traverse = traverseImport.default;
+const traverse = (traverseImport.default ||
+  traverseImport) as typeof traverseImport.default;
 
 export async function obfuscateRuntime(runtime: string, options: Options) {
-  const ast = parse(runtime, {
-    sourceType: "unambiguous",
-  });
+  let ast: t.File;
+  try {
+    ast = parse(runtime, {
+      sourceType: "unambiguous",
+    });
+  } catch (error) {
+    throw new Error("VM-Runtime final parsing failed", { cause: error });
+  }
 
   // shuffle order of opcode handlers
 
@@ -38,10 +43,19 @@ export async function obfuscateRuntime(runtime: string, options: Options) {
     switchStatement.cases = shuffle(switchStatement.cases);
   }
 
-  let generated = generate(ast).code;
+  let generated: string;
+  try {
+    generated = generate(ast).code;
+  } catch (error) {
+    throw new Error("VM-Runtime final generation failed", { cause: error });
+  }
 
   if (options.minify) {
-    generated = await minify(generated);
+    try {
+      generated = await minify(generated);
+    } catch (error) {
+      throw new Error("VM-Runtime final minification failed", { cause: error });
+    }
   }
 
   return generated;

package/src/transforms/controlFlowFlattening.ts

@@ -0,0 +1,30 @@
+import { Instruction } from "../types.ts";
+
+interface BasicBlock {
+  label: string;
+  body: Instruction;
+  jumpLabels?: Set<string>;
+}
+
+/**
+ * Breaks functions into DAGs (Directed Acyclic Graphs)
+ *
+ * - 1. Break bytecode into chunks
+ * - 2. Shuffle chunks but remember their original position
+ * - 3. Create an effectively Switch statement inside a While loop, each case is a chunk, and the while loops exits on the last transition.
+ *
+ * The Switch statement:
+ *
+ * - 1. The state variable controls which case will run next
+ * - 2. At the end of each case, the state variable is updated to the next block of code.
+ * - 3. The while loop continues until the the state variable is the end state.
+ */
+export async function controlFlowFlattening(bytecode: Instruction) {
+  // break bytecode into basic blocks
+  // 1. read bytecode and track the current label from the IR-instruction "defineLabel"
+  // 2. track any potential jumps inside this block using the IR-instruction operand "label"
+  // at this stage in the passing process, may still use these IR-instruction labels for jumps, meaning no effort is required to maintain absolute PCs
+  // create a bare CFF implementation of a simple switch dispatch loop effectively
+  // This CFF implementation should only apply to "easy jumps" such as conditional jump (if-statement)
+  // the complex and specific jumps for for..in shouldn't get flattened
+}

package/src/transforms/resolveContants.ts

@@ -0,0 +1,42 @@
+import type { Bytecode, Instruction } from "../types.ts";
+import { SOURCE_NODE_SYM } from "../compiler.ts";
+
+// Resolve all {type:"constant", value} operands to integer indices into the
+// constants pool.  Returns both the resolved bytecode and the constants array
+// so the Serializer can use it for comment generation and output.
+export function resolveConstants(bc: Bytecode): {
+  bytecode: Bytecode;
+  constants: any[];
+} {
+  const constants: any[] = [];
+  const constantsMap = new Map<any, number>();
+
+  function intern(value: any): number {
+    let idx = constantsMap.get(value);
+    if (typeof idx !== "number") {
+      idx = constants.length;
+      constantsMap.set(value, idx);
+      constants.push(value);
+    }
+    return idx;
+  }
+
+  const resolved: Bytecode = [];
+  for (const instr of bc) {
+    const [op, operand] = instr;
+    if (
+      operand !== undefined &&
+      operand !== null &&
+      typeof operand === "object" &&
+      (operand as any).type === "constant"
+    ) {
+      const newInstr: Instruction = [op, intern((operand as any).value)];
+      (newInstr as any)[SOURCE_NODE_SYM] = (instr as any)[SOURCE_NODE_SYM];
+      resolved.push(newInstr);
+    } else {
+      resolved.push(instr);
+    }
+  }
+
+  return { bytecode: resolved, constants };
+}

package/src/transforms/resolveLabels.ts

@@ -0,0 +1,83 @@
+// --- Label IR ---
+// During compilation, jump targets are symbolic labels instead of hard-coded
+// PC numbers.  Two IR "pseudo operands" carry the label information:
+//
+//   defineLabel operand  : [null, {type:"defineLabel", label:"FN_ENTRY_1"}]
+//     Marks a position in the bytecode array.
+//     resolveLabels() strips these out entirely.
+//
+//   label ref operand      : [OP.JUMP, {type:"label", label:"FN_ENTRY_1"}]
+//     Used as the operand of any jump instruction. resolveLabels() replaces
+//     it with the integer PC that the corresponding defineLabel resolves to.
+
+import type { Instruction } from "../types.ts";
+import { Compiler } from "../compiler.ts";
+
+// Resolve symbolic labels to absolute PC indices within a bytecode array.
+// defineLabel pseudo-instructions are stripped; label-ref operands become ints.
+// Mutates `bc` in place so callers holding a reference see the resolved result.
+export function resolveLabels(
+  bc: Instruction[],
+  compiler: Compiler,
+): {
+  bytecode: Instruction[];
+} {
+  // Pass 1 – walk the array and record each label's real PC, counting only
+  // real instructions (defineLabel pseudo-ops don't occupy a PC slot).
+  const labelToPc = new Map<string, number>();
+  let realPc = 0;
+  for (const instr of bc) {
+    const op = instr[0];
+    const operand = instr[1];
+    if (
+      op === null &&
+      operand !== null &&
+      typeof operand === "object" &&
+      operand.type === "defineLabel"
+    ) {
+      labelToPc.set(operand.label, realPc);
+    } else {
+      realPc++;
+    }
+  }
+
+  // Pass 2 – build the resolved instruction list.
+  const resolved: any[] = [];
+  for (const instr of bc) {
+    const op = instr[0];
+    const operand = instr[1];
+
+    // Strip defineLabel pseudo-ops.
+    if (
+      op === null &&
+      typeof operand === "object" &&
+      operand?.type === "defineLabel"
+    ) {
+      continue;
+    }
+
+    // Replace label-ref operands with integer PCs.
+    if (
+      operand !== undefined &&
+      operand !== null &&
+      typeof operand === "object" &&
+      operand.type === "label"
+    ) {
+      const pc = labelToPc.get(operand.label);
+      if (pc === undefined)
+        throw new Error(`Undefined label: ${operand.label}`);
+      resolved.push([op, pc + (operand.offset ?? 0)]);
+    } else {
+      resolved.push(instr);
+    }
+  }
+
+  // Patch each function descriptor's startPc now that labels are resolved.
+  for (const desc of compiler.fnDescriptors) {
+    desc.startPc = labelToPc.get(desc.startLabel);
+  }
+
+  return {
+    bytecode: resolved,
+  };
+}

package/src/transforms/selfModifying.ts

@@ -0,0 +1,124 @@
+import type { Bytecode, Instruction } from "../types.ts";
+import { Compiler } from "../compiler.ts";
+
+export function selfModifying(
+  bc: Bytecode,
+  compiler: Compiler,
+): { bytecode: Bytecode } {
+  // Walk the bytecode looking for "defineLabel" pseudo-ops, which start basic
+  // blocks. For each block we collect the body (instructions between the label
+  // and the next label/jump terminator), move it to the end of the bytecode
+  // under a fresh "patch_LXX" label, and replace it in-place with:
+  //
+  //   defineLabel ("originalLabel")         ← kept as-is (pseudo-op)
+  //   LOAD_INT  { label: patch_LXX, offset: N }   ← push slice-end PC
+  //   LOAD_INT  { label: patch_LXX }               ← push slice-start PC
+  //   PATCH     { label: originalLabel, offset: 3 } ← destPc = L+3
+  //   LOAD_INT 0  × N                              ← N placeholder instructions
+  //
+  // PATCH pops (start, end) from the stack and copies bytecode[start..end) to
+  // bytecode[destPc..]. Since destPc = L+3 = first placeholder, the body is
+  // written exactly over the placeholder region on the first call.  Subsequent
+  // calls are idempotent (same bytes written again).  Execution falls through
+  // from PATCH into the freshly-patched body at L+3, then continues naturally
+  // to whatever terminator (JUMP/RETURN) follows at L+3+N.
+
+  const { OP, JUMP_OPS } = compiler;
+
+  const result: Bytecode = [];
+  const appended: Bytecode = [];
+  let patchCount = 0;
+
+  let i = 0;
+  while (i < bc.length) {
+    const instr = bc[i];
+    const [op, operand] = instr;
+
+    // Detect a defineLabel pseudo-op — start of a new basic block.
+    if (
+      op === null &&
+      operand !== null &&
+      typeof operand === "object" &&
+      (operand as any).type === "defineLabel"
+    ) {
+      const originalLabel = (operand as any).label as string;
+      result.push(instr); // keep the defineLabel marker
+      i++;
+
+      // Collect body: everything after the label until the next terminator.
+      let j = i;
+      while (j < bc.length) {
+        const [nextOp, nextOperand] = bc[j];
+
+        // Another defineLabel = boundary of the next block.
+        if (
+          nextOp === null &&
+          typeof nextOperand === "object" &&
+          (nextOperand as any)?.type === "defineLabel"
+        ) {
+          break;
+        }
+
+        // Jump instructions, RETURN, and DATA (function header words) all
+        // terminate the body without being included in it.
+        if (
+          nextOp !== null &&
+          (JUMP_OPS.has(nextOp) || nextOp === OP.RETURN || nextOp === OP.DATA)
+        ) {
+          break;
+        }
+
+        j++;
+      }
+
+      const body = bc.slice(i, j);
+      const N = body.length;
+
+      if (N === 0) {
+        // Nothing to transform — label is immediately followed by a terminator.
+        continue;
+      }
+
+      const patchLabel = `patch_${originalLabel}_${patchCount++}`;
+
+      // ── Stub (3 real instructions) ──────────────────────────────────────
+      // LOAD_INT pushes the end-index of the body slice (patchLabel_pc + N).
+      // LOAD_INT pushes the start-index (patchLabel_pc).
+      // Stack before PATCH: [end (bottom), start (top)].
+      // PATCH: slice(pop()=start, pop()=end) copies the body to destPc = L+3.
+      result.push([
+        OP.LOAD_INT as number,
+        { type: "label", label: patchLabel, offset: N },
+      ]);
+      result.push([
+        OP.LOAD_INT as number,
+        { type: "label", label: patchLabel },
+      ]);
+      result.push([
+        OP.PATCH as number,
+        { type: "label", label: originalLabel, offset: 3 },
+      ]);
+
+      // ── Placeholders (N instructions) ───────────────────────────────────
+      // These are overwritten by PATCH on the first execution.  They never
+      // execute as LOAD_INT 0 in a correct run.
+      for (let p = 0; p < N; p++) {
+        result.push([OP.LOAD_INT as number, 0]);
+      }
+
+      // ── Append real body at end ─────────────────────────────────────────
+      appended.push([null, { type: "defineLabel", label: patchLabel }]);
+      for (const bodyInstr of body) {
+        appended.push(bodyInstr);
+      }
+
+      i = j; // skip over the original body in the input array
+      continue;
+    }
+
+    result.push(instr);
+    i++;
+  }
+
+  return { bytecode: [...result, ...appended] };
+}

package/src/types.ts

@@ -0,0 +1,24 @@
+// Bytecode supports both real instructions and IR pseudo-instructions
+// Real instruction: [OP.ADD, 5]
+// IR instruction: [null, { type: "defineLabel", label: "FN_ENTRY_1" }]
+
+// IR instructions are used to hold symbolic information during compilation
+// All "null" instructions are dropped before assembly time
+export type Instruction = [
+  number | null,
+  (
+    | number
+    | { type: "label"; label: string; offset?: number }
+    | { type: "defineLabel"; label: string }
+    | { type: "constant"; value: any }
+  )?,
+];
+
+export type Bytecode = Instruction[];
+
+export function constantOperand(value: any): Instruction[1] {
+  return {
+    type: "constant",
+    value: value,
+  };
+}

package/dist/minify_empty_externs.js

@@ -1,4 +0,0 @@
-var window = {};
-var global = {};
-var atob = {};
-var performance;