js-confuser-vm 0.1.1 → 0.1.2

package/src/transforms/bytecode/stringConcealing.ts

@@ -1,130 +0,0 @@
-// String Concealing
-//
-// Encodes every string constant in each function with base64, then inserts a
-// decode closure (atob) that is called immediately after each LOAD_CONST to
-// recover the original value at runtime.
-//
-// ── How it works ─────────────────────────────────────────────────────────────
-//
-// Each function that contains at least one string LOAD_CONST gets:
-//
-//   rClosure — a register holding the decode closure, created ONCE at function
-//              entry (hoisted).  All decode calls within the function reuse it.
-//
-// The decode function is compiled ONCE (shared across all functions) from a
-// Template:
-//
-//   function decode(encoded) { return atob(encoded); }
-//
-// String constant transformations:
-//
-//   Original:  LOAD_CONST  rDst, "hello"
-//   Becomes:   LOAD_CONST  rDst, "aGVsbG8="        (base64-encoded)
-//              CALL        rDst, rClosure, 1, rDst  (decode in-place)
-//
-// ── Pipeline position ─────────────────────────────────────────────────────────
-// Runs BEFORE resolveRegisters and resolveLabels (same slot as Dispatcher/CFF).
-
-import { Compiler } from "../../compiler.ts";
-import { Template } from "../../template.ts";
-import type { Bytecode, RegisterOperand } from "../../types.ts";
-import * as b from "../../types.ts";
-import { ref, buildMaxIdMap, allocReg, forEachFunction } from "../../utils/pass-utils.ts";
-
-// ── Per-function transformation ──────────────────────────────────────────────
-
-function processFunctionBlock(
-  instrs: Bytecode,
-  fnId: number,
-  compiler: Compiler,
-  maxId: Map<number, number>,
-  decodeDesc: any,
-): { instrs: Bytecode } {
-  const OP = compiler.OP;
-
-  // Only transform functions that contain string constants.
-  const hasStringConst = instrs.some((instr) => {
-    if (instr[0] !== OP.LOAD_CONST) return false;
-    const operands = instr.slice(1);
-    return (
-      operands.length === 2 &&
-      (operands[1] as any)?.type === "constant" &&
-      typeof (operands[1] as any).value === "string"
-    );
-  });
-  if (!hasStringConst) return { instrs };
-
-  const rClosure = allocReg(fnId, maxId);
-  const out: Bytecode = [];
-
-  // Hoist: create the decode closure once at function entry.
-  out.push([
-    OP.MAKE_CLOSURE!,
-    ref(rClosure),
-    { type: "label", label: decodeDesc.entryLabel },
-    decodeDesc.paramCount, // 1 (encoded)
-    b.fnRegCountOperand(decodeDesc._fnIdx),
-    0, // no upvalues
-    0, // hasRest = false
-  ]);
-
-  // Transform each instruction.
-  for (const instr of instrs) {
-    if (
-      instr[0] === OP.LOAD_CONST &&
-      instr.length === 3 &&
-      (instr[2] as any)?.type === "constant" &&
-      typeof (instr[2] as any).value === "string"
-    ) {
-      const dst = instr[1] as RegisterOperand;
-      const constOp = instr[2] as any;
-
-      // Encode the string in-place.
-      constOp.value = Buffer.from(constOp.value as string, "utf-8").toString(
-        "base64",
-      );
-
-      out.push(instr);
-
-      // Decode: rDst = decode(rDst)
-      out.push([
-        OP.CALL!,
-        ref(dst),       // dst — receives decoded string
-        ref(rClosure),  // the hoisted decode closure
-        1,              // argc
-        ref(dst),       // arg[0] = encoded value
-      ]);
-    } else {
-      out.push(instr);
-    }
-  }
-
-  return { instrs: out };
-}
-
-// ── Pass entry point ──────────────────────────────────────────────────────────
-export function stringConcealing(
-  bc: Bytecode,
-  compiler: Compiler,
-): { bytecode: Bytecode } {
-  const maxId = buildMaxIdMap(bc);
-
-  // Compile the decode function ONCE — all functions share the same closure body.
-  const decodeTemplate = new Template(`
-    function decode(encoded) {
-      return atob(encoded);
-    }
-  `).compile({}, compiler);
-  const decodeDesc = decodeTemplate.functions[0];
-
-  const { bytecode } = forEachFunction(bc, compiler, (fnInstrs, fnId) =>
-    processFunctionBlock(fnInstrs, fnId, compiler, maxId, decodeDesc),
-  );
-
-  // Append the decode function's bytecode at the end (defines its entryLabel).
-  // This is a single shared closure, not per-function, so it lives outside
-  // forEachFunction's tail mechanism.
-  bytecode.push(...decodeTemplate.bytecode);
-
-  return { bytecode };
-}

package/src/transforms/runtime/aliasedOpcodes.ts

@@ -1,191 +0,0 @@
-import * as t from "@babel/types";
-import traverseImport from "@babel/traverse";
-import { ok } from "assert";
-import { Compiler } from "../../compiler.ts";
-
-const traverse = (traverseImport.default ||
-  traverseImport) as typeof traverseImport.default;
-
-// Extract the real statement list from a SwitchCase consequent.
-function extractCaseBody(switchCase: t.SwitchCase): t.Statement[] {
-  let stmts: t.Statement[];
-  if (
-    switchCase.consequent.length === 1 &&
-    t.isBlockStatement(switchCase.consequent[0])
-  ) {
-    stmts = (switchCase.consequent[0] as t.BlockStatement).body;
-  } else {
-    stmts = switchCase.consequent as t.Statement[];
-  }
-  return stmts.filter((s) => !t.isBreakStatement(s) && !t.isEmptyStatement(s));
-}
-
-// Replace every `this._operand()` call in bodyStmts with `_operands[i]`
-// where i is the call's sequential index (0-based).
-// Returns the number of replacements performed.
-function replaceOperandCalls(bodyStmts: t.Statement[]): number {
-  let replaced = 0;
-
-  traverse(t.blockStatement(bodyStmts), {
-    noScope: true,
-    CallExpression(path) {
-      const callee = path.node.callee;
-
-      const isMethodCall = (methodName) => {
-        return (
-          t.isMemberExpression(callee) &&
-          t.isThisExpression(callee.object) &&
-          t.isIdentifier(callee.property, { name: methodName }) &&
-          path.node.arguments.length === 0
-        );
-      };
-
-      // Replace with _operands[i]
-      const createOperandAccess = () => {
-        return t.memberExpression(
-          t.identifier("_operands"),
-          t.numericLiteral(replaced++),
-          true, // computed
-        );
-      };
-
-      if (isMethodCall("_operand")) {
-        path.replaceWith(createOperandAccess());
-      }
-
-      if (isMethodCall("_constant")) {
-        path.node.arguments = [createOperandAccess(), createOperandAccess()];
-      }
-    },
-  });
-
-  return replaced;
-}
-
-// Appends a generated switch case for every entry in compiler.ALIASED_OPS.
-// Each alias case:
-//   1. Reads all operands eagerly into `_unsortedOperands` (in the shuffled
-//      bytecode order) via sequential this._operand() calls.
-//   2. Restores the original operand order into `_operands` using the INVERSE
-//      of the stored `order` permutation:
-//        inverseOrder[order[i]] = i
-//        _operands[j] = _unsortedOperands[inverseOrder[j]]
-//      This is necessary because the bytecode stored originalOperands[order[i]]
-//      at slot i, so recovering originalOperands[j] requires the inverse lookup.
-//   3. Executes a clone of the original handler body where every
-//      this._operand() has been replaced by the corresponding `_operands[i]`.
-//
-// Must run AFTER applyMacroOpcodes / applySpecializedOpcodes (so original
-// cases already exist) but BEFORE applyShuffleOpcodes (so the new alias
-// cases are also shuffled into the handler order).
-export function applyAliasedOpcodes(ast: t.File, compiler: Compiler): void {
-  if (!compiler.ALIASED_OPS || Object.keys(compiler.ALIASED_OPS).length === 0)
-    return;
-
-  let switchStatement: t.SwitchStatement | null = null;
-  traverse(ast, {
-    SwitchStatement(path) {
-      if (path.node.leadingComments?.some((c) => c.value.includes("@SWITCH"))) {
-        switchStatement = path.node;
-        path.stop();
-      }
-    },
-  });
-
-  ok(switchStatement, "Could not find @SWITCH statement for aliased opcodes");
-
-  // Build opName → SwitchCase map from existing OP.xxx case tests.
-  const nameToCaseMap = new Map<string, t.SwitchCase>();
-  for (const sc of (switchStatement as t.SwitchStatement).cases) {
-    const test = sc.test;
-    if (
-      test &&
-      t.isMemberExpression(test) &&
-      t.isIdentifier(test.object, { name: "OP" }) &&
-      t.isIdentifier(test.property)
-    ) {
-      nameToCaseMap.set((test.property as t.Identifier).name, sc);
-    }
-  }
-
-  for (const [aliasOpStr, info] of Object.entries(compiler.ALIASED_OPS)) {
-    const aliasOpCode = Number(aliasOpStr);
-    const { originalOp, order } = info;
-    const arity = order.length;
-
-    const originalName = compiler.OP_NAME[originalOp];
-    if (!originalName) continue;
-
-    const originalCase = nameToCaseMap.get(originalName);
-    if (!originalCase) continue;
-
-    // Clone the original handler body (deep clone so we don't mutate the source)
-    const bodyStmts: t.Statement[] = extractCaseBody(originalCase).map(
-      (s) => t.cloneNode(s, true) as t.Statement,
-    );
-
-    // Replace this._operand() calls with _operands[i]
-    const replaced = replaceOperandCalls(bodyStmts);
-
-    // If the handler has a different number of _operand() calls than our
-    // recorded arity, skip this alias (variable-operand handler guard).
-    if (replaced !== arity) continue;
-
-    // Build: var _unsortedOperands = [this._operand(), this._operand(), ...]
-    // Reads operands in the NEW (shuffled) bytecode order.
-    const unsortedInit = t.variableDeclaration("let", [
-      t.variableDeclarator(
-        t.identifier("_unsortedOperands"),
-        t.arrayExpression(
-          Array.from({ length: arity }, () =>
-            t.callExpression(
-              t.memberExpression(t.thisExpression(), t.identifier("_operand")),
-              [],
-            ),
-          ),
-        ),
-      ),
-    ]);
-
-    // The inverse permutation maps original position j → unsorted index i,
-    // because the bytecode stored originalOperands[order[i]] at slot i.
-    // inverseOrder[j] = i  means: original operand j lives at _unsortedOperands[i]
-    const inverseOrder = new Array<number>(arity);
-    for (let i = 0; i < arity; i++) {
-      inverseOrder[order[i]] = i;
-    }
-
-    // Build: var _operands = [_unsortedOperands[inverseOrder[0]], ...]
-    // Restores the original operand order expected by the handler body.
-    const operandsInit = t.variableDeclaration("let", [
-      t.variableDeclarator(
-        t.identifier("_operands"),
-        t.arrayExpression(
-          inverseOrder.map((idx) =>
-            t.memberExpression(
-              t.identifier("_unsortedOperands"),
-              t.numericLiteral(idx),
-              true, // computed
-            ),
-          ),
-        ),
-      ),
-    ]);
-
-    const allStmts: t.Statement[] = [unsortedInit, operandsInit, ...bodyStmts];
-
-    // Add a leading comment for readability in non-minified output
-    t.addComment(
-      allStmts[0],
-      "leading",
-      ` ${compiler.OP_NAME[aliasOpCode]} (order: [${order.join(",")}])`,
-      true,
-    );
-
-    allStmts.push(t.breakStatement());
-
-    (switchStatement as t.SwitchStatement).cases.push(
-      t.switchCase(t.numericLiteral(aliasOpCode), [t.blockStatement(allStmts)]),
-    );
-  }
-}

package/src/transforms/runtime/classObfuscation.ts

@@ -1,59 +0,0 @@
-import { Compiler } from "../../compiler.ts";
-import * as t from "@babel/types";
-import { shuffle } from "../../utils/random-utils.ts";
-
-function hasComment(node: t.Node, text: string): boolean {
-  const all = [
-    ...((node as any).leadingComments ?? []),
-    ...((node as any).innerComments ?? []),
-    ...((node as any).trailingComments ?? []),
-  ];
-  return all.some((c) => c.value.includes(text));
-}
-
-function isPrototypeAssignment(stmt: t.Statement): boolean {
-  if (!t.isExpressionStatement(stmt)) return false;
-  const expr = stmt.expression;
-  if (!t.isAssignmentExpression(expr)) return false;
-  const left = expr.left;
-  return (
-    t.isMemberExpression(left) &&
-    t.isMemberExpression(left.object) &&
-    t.isIdentifier((left.object as t.MemberExpression).property, {
-      name: "prototype",
-    })
-  );
-}
-
-export function applyClassObfuscation(ast: t.File, _compiler: Compiler): void {
-  const body = ast.program.body;
-
-  // Split at the first statement that carries the @BOOT comment.
-  // Everything from that statement onward is the boot section and must stay last.
-  let bootIdx = body.findIndex((stmt) => hasComment(stmt, "@BOOT"));
-  if (bootIdx === -1) bootIdx = body.length;
-
-  const shufflable = body.slice(0, bootIdx);
-  const boot = body.slice(bootIdx);
-
-  // Partition the shufflable section into two independent groups.
-  // Group A: variable/function declarations (constructors, standalone vars).
-  // Group B: prototype method assignments (X.prototype.Y = ...).
-  // Both groups are shuffled independently; A always precedes B so that
-  // constructors are defined before methods reference them.
-  const varDecls: t.Statement[] = [];
-  const methodDefs: t.Statement[] = [];
-
-  for (const stmt of shufflable) {
-    if (isPrototypeAssignment(stmt)) {
-      methodDefs.push(stmt);
-    } else {
-      varDecls.push(stmt);
-    }
-  }
-
-  shuffle(varDecls);
-  shuffle(methodDefs);
-
-  ast.program.body = [...varDecls, ...methodDefs, ...boot];
-}

package/src/transforms/runtime/macroOpcodes.ts

@@ -1,138 +0,0 @@
-import * as t from "@babel/types";
-import traverseImport from "@babel/traverse";
-import { ok } from "assert";
-import { Compiler } from "../../compiler.ts";
-import generate from "@babel/generator";
-const traverse = (traverseImport.default ||
-  traverseImport) as typeof traverseImport.default;
-
-// Extract the real statement list from a SwitchCase consequent, normalising
-// the two forms that appear in the runtime:
-//   • A single wrapping BlockStatement  →  use its .body
-//   • Statements listed directly        →  use as-is
-// In both cases trailing BreakStatement / EmptyStatement are filtered out.
-function extractCaseBody(switchCase: t.SwitchCase): t.Statement[] {
-  let stmts: t.Statement[];
-  if (
-    switchCase.consequent.length === 1 &&
-    t.isBlockStatement(switchCase.consequent[0])
-  ) {
-    stmts = (switchCase.consequent[0] as t.BlockStatement).body;
-  } else {
-    stmts = switchCase.consequent as t.Statement[];
-  }
-  return stmts.filter((s) => !t.isBreakStatement(s) && !t.isEmptyStatement(s));
-}
-
-export function getOpcodeToCaseMap(
-  switchStatement: t.SwitchStatement,
-  compiler: Compiler,
-): Map<number, t.SwitchCase> {
-  // Build a map  opName → SwitchCase  from the existing OP.xxx case tests.
-  const opcodeToCaseMap = new Map<number, t.SwitchCase>();
-  for (const sc of (switchStatement as t.SwitchStatement).cases) {
-    const test = sc.test;
-    if (!test) continue;
-
-    let opcode;
-    let opName;
-    if (
-      t.isMemberExpression(test) &&
-      t.isIdentifier(test.object, { name: "OP" }) &&
-      t.isIdentifier(test.property)
-    ) {
-      opName = test.property.name;
-      opcode = +Object.keys(compiler.OP_NAME).find(
-        (key) => compiler.OP_NAME[key] == opName,
-      );
-    } else if (t.isNumericLiteral(test)) {
-      opcode = test.value;
-    }
-
-    ok(
-      typeof opcode === "number" && !Number.isNaN(opcode),
-      `Failed to parse ${opcode} from ${opName}`,
-    );
-    if (opcode !== undefined) {
-      opcodeToCaseMap.set(opcode, sc);
-    }
-  }
-
-  return opcodeToCaseMap;
-}
-
-// Append a generated switch case for every entry in compiler.MACRO_OPS.
-// Each case inlines the constituent case bodies directly — no operand stack,
-// no substitution needed.  Because every opcode handler now reads its own
-// operands via this._operand(), those calls naturally consume the inline
-// operands that macroOpcodes.ts embedded on the macro instruction.
-// Must be called BEFORE applyShuffleOpcodes so the new cases get shuffled.
-export function applyMacroOpcodes(ast: t.File, compiler: Compiler): void {
-  let switchStatement: t.SwitchStatement | null = null;
-  traverse(ast, {
-    SwitchStatement(path) {
-      if (path.node.leadingComments?.some((c) => c.value.includes("@SWITCH"))) {
-        switchStatement = path.node;
-        path.stop();
-      }
-    },
-  });
-
-  ok(switchStatement, "Could not find @SWITCH statement for macro opcodes");
-
-  const opcodeToCaseMap = getOpcodeToCaseMap(switchStatement, compiler);
-
-  for (const [macroOpStr, constituentOps] of Object.entries(
-    compiler.MACRO_OPS,
-  )) {
-    const macroOpCode = Number(macroOpStr);
-    const N = constituentOps.length;
-
-    // Resolve each constituent op value → case node via OP_NAME lookup.
-    const constituentCases: t.SwitchCase[] = [];
-    let allFound = true;
-    for (const opVal of constituentOps) {
-      const found = opcodeToCaseMap.get(opVal);
-      if (!found) {
-        allFound = false;
-        break;
-      }
-      constituentCases.push(found);
-    }
-    if (!allFound) {
-      throw new Error(
-        `Could not find all constituent ops for macro op ${macroOpCode}`,
-      );
-    }
-
-    const opNames = constituentOps.map((v) => compiler.OP_NAME[v] ?? `OP_${v}`);
-    let newName = opNames.join(",");
-    compiler.OP_NAME[macroOpCode] = newName;
-
-    // ── Build the macro case body ──────────────────────────────────────────
-    // Clone and inline each sub-instruction's case body directly.
-    // No operand substitution needed: each body already calls this._operand()
-    // to read its own operands, which will consume the inline operands that
-    // macroOpcodes.ts embedded on the macro instruction in order.
-    const bodyStmts: t.Statement[] = [];
-
-    for (let i = 0; i < N; i++) {
-      const subStmts = extractCaseBody(constituentCases[i]).map(
-        (s) => t.cloneNode(s, true) as t.Statement,
-      );
-
-      if (subStmts.length > 0) {
-        t.addComment(subStmts[0], "leading", ` ${opNames[i]}`, true);
-        bodyStmts.push(...subStmts);
-      }
-    }
-
-    bodyStmts.push(t.breakStatement());
-
-    (switchStatement as t.SwitchStatement).cases.push(
-      t.switchCase(t.numericLiteral(macroOpCode), [
-        t.blockStatement(bodyStmts),
-      ]),
-    );
-  }
-}

package/src/transforms/runtime/minify.ts

@@ -1 +0,0 @@
-export { minify as applyMinify } from "../../minify.ts";

package/src/transforms/runtime/shuffleOpcodes.ts

@@ -1,24 +0,0 @@
-import * as t from "@babel/types";
-import traverseImport from "@babel/traverse";
-import { ok } from "assert";
-import { shuffle } from "../../utils/random-utils.ts";
-const traverse = (traverseImport.default ||
-  traverseImport) as typeof traverseImport.default;
-
-// Randomly reorder the switch cases inside the @SWITCH statement so the
-// opcode handler order varies per build.
-export function applyShuffleOpcodes(ast: t.File): void {
-  let switchStatement: t.SwitchStatement | null = null;
-  traverse(ast, {
-    SwitchStatement(path) {
-      if (path.node.leadingComments?.some((c) => c.value.includes("@SWITCH"))) {
-        switchStatement = path.node;
-        path.stop();
-      }
-    },
-  });
-
-  ok(switchStatement, "Could not find opcode handlers switch statement");
-
-  switchStatement.cases = shuffle(switchStatement.cases);
-}