js-confuser-vm 0.0.9 → 0.1.1

package/dist/transforms/utils/op-utils.js

@@ -1,25 +0,0 @@
-import { getRandomInt } from "./random-utils.js";
-export const U16_MAX = 0xffff; // bytecode operands are u16
-
-/** Returns the next free opcode slot, or -1 when the space is exhausted. */
-export function nextFreeSlot(usedOpcodes) {
-  if (usedOpcodes.size > U16_MAX) return -1;
-  let attempts = 0;
-  while (attempts++ < 512) {
-    const candidate = getRandomInt(0, U16_MAX);
-    if (!usedOpcodes.has(candidate)) {
-      usedOpcodes.add(candidate);
-      return candidate;
-    }
-  }
-  // Fallback: linear scan from a random start
-  const start = getRandomInt(0, U16_MAX);
-  for (let i = 0; i <= U16_MAX; i++) {
-    const v = start + i & U16_MAX;
-    if (!usedOpcodes.has(v)) {
-      usedOpcodes.add(v);
-      return v;
-    }
-  }
-  return -1;
-}

package/dist/transforms/utils/random-utils.js

@@ -1,27 +0,0 @@
-import { ok } from "assert";
-export function getPlaceholder() {
-  return Math.random().toString(36).substring(2, 15);
-}
-export function choice(elements) {
-  ok(elements.length > 0, "choice() called on empty sequence");
-  return elements[Math.floor(Math.random() * elements.length)];
-}
-export function getRandom() {
-  return Math.random();
-}
-export function getRandomInt(min, max) {
-  ok(min <= max, "min must be <= max");
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-/**
- * Shuffles an array in-place using the Fisher-Yates algorithm.
- * @param array - The array to shuffle (mutated)
- */
-export function shuffle(array) {
-  for (let i = array.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [array[i], array[j]] = [array[j], array[i]];
-  }
-  return array;
-}

package/dist/utilts.js

@@ -1,3 +0,0 @@
-export function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/src/transforms/bytecode/microOpcodes.ts

@@ -1,291 +0,0 @@
-import { parse } from "@babel/parser";
-import traverseImport from "@babel/traverse";
-import * as t from "@babel/types";
-import { ok } from "assert";
-import { Compiler, VM_RUNTIME, SOURCE_NODE_SYM } from "../../compiler.ts";
-import type { Bytecode, Instruction } from "../../types.ts";
-import { nextFreeSlot } from "../../utils/op-utils.ts";
-import { nSizedOps } from "./specializedOpcodes.ts";
-import generate from "@babel/generator";
-
-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));
-}
-
-// Count how many IR-level operands a single statement consumes.
-// Returns null if the statement is ineligible (contains a loop, or has
-// _operand()/_constant() calls inside a conditional branch).
-function countStatementOperands(stmt: t.Statement): number | null {
-  let count = 0;
-  let ineligible = false;
-
-  const file = t.file(t.program([t.cloneNode(stmt, true) as t.Statement]));
-
-  traverse(file, {
-    enter(path) {
-      if (ineligible) {
-        path.stop();
-        return;
-      }
-
-      const nodeType = path.node.type;
-
-      // Don't traverse into nested functions
-      if (
-        nodeType === "FunctionDeclaration" ||
-        nodeType === "FunctionExpression" ||
-        nodeType === "ArrowFunctionExpression"
-      ) {
-        path.skip();
-        return;
-      }
-
-      // Count _operand() and _constant() calls
-      if (nodeType === "CallExpression") {
-        const call = path.node as t.CallExpression;
-        const callee = call.callee;
-        if (
-          t.isMemberExpression(callee) &&
-          t.isThisExpression(callee.object) &&
-          t.isIdentifier(callee.property)
-        ) {
-          const name = (callee.property as t.Identifier).name;
-          const operandsConsumed =
-            name === "_operand" ? 1 : name === "_constant" ? 2 : null;
-
-          if (operandsConsumed) {
-            // You are not allowed to use _operand() in loops or branches
-            const ancestors = path.getAncestry();
-
-            if (
-              ancestors.find(
-                (t) =>
-                  t.isLoop() ||
-                  t.isIfStatement() ||
-                  t.isSwitchStatement() ||
-                  t.isConditionalExpression() ||
-                  t.isLogicalExpression(),
-              )
-            ) {
-              ineligible = true;
-              path.stop();
-              return;
-            }
-
-            count += operandsConsumed;
-          }
-        }
-      }
-    },
-  });
-
-  return ineligible ? null : count;
-}
-
-// Analyse the VM runtime's @SWITCH statement to build a per-opcode map of
-// { stmtIndex → irOperandCount } for every case that can be split.
-// Returns a map: opValue → array of per-statement operand counts (null if ineligible).
-function analyzeRuntimeCases(compiler: Compiler): Map<number, number[]> {
-  // Parse the runtime source
-  const ast = parse(VM_RUNTIME, { sourceType: "unambiguous" });
-
-  // Build reverse name→opValue map from original OPs only
-  const nameToOp = new Map<string, number>();
-  for (const [name, val] of Object.entries(compiler.OP)) {
-    if (val !== undefined) nameToOp.set(name, val as number);
-  }
-
-  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 micro opcodes");
-
-  const result = new Map<number, number[]>();
-
-  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)
-    ) {
-      continue;
-    }
-
-    const opName = (test.property as t.Identifier).name;
-    const opVal = nameToOp.get(opName);
-    if (opVal === undefined) continue;
-
-    const stmts = extractCaseBody(sc);
-    if (stmts.length < 2) continue; // need at least 2 statements to split
-
-    const counts: number[] = [];
-    let allEligible = true;
-
-    // Banned patterns:
-    // Return statements (Control flow isn't remembered)
-    traverse(t.file(t.program(stmts)), {
-      ReturnStatement(path) {
-        path.stop();
-        allEligible = false;
-      },
-    });
-
-    for (const stmt of stmts) {
-      const c = countStatementOperands(stmt);
-      if (c === null) {
-        allEligible = false;
-        break;
-      }
-      if (t.isDebuggerStatement(stmt) || t.isThrowStatement(stmt)) {
-        allEligible = false;
-        break;
-      }
-      counts.push(c);
-    }
-
-    if (!allEligible) continue;
-
-    // Verify that the total operand count matches the instruction size expectation
-    // (just store for now; bytecode pass validates operands match)
-    result.set(opVal, counts);
-  }
-
-  return result;
-}
-
-// Main bytecode transform: split frequently-used opcodes into per-statement
-// micro-opcodes so each sub-instruction is as small as possible.
-export function microOpcodes(
-  bc: Bytecode,
-  compiler: Compiler,
-): { bytecode: Bytecode } {
-  // ── Step 1: analyse runtime to discover splittable opcodes ──────────────────
-  const opAnalysis = analyzeRuntimeCases(compiler);
-  if (opAnalysis.size === 0) return { bytecode: bc };
-
-  // ── Step 2: count opcode frequency in bytecode ────────────────────────────
-  const disallowedOps = new Set(nSizedOps.map((name) => compiler.OP[name]));
-
-  disallowedOps.add(compiler.OP.RETURN);
-
-  const freqMap = new Map<number, number>();
-  for (const instr of bc) {
-    const op = instr[0];
-    if (op === null || !opAnalysis.has(op) || disallowedOps.has(op)) continue;
-    freqMap.set(op, (freqMap.get(op) ?? 0) + 1);
-  }
-
-  // ── Step 3: sort by frequency, keep opcodes that actually appear ─────────
-  const candidates = Array.from(freqMap.entries())
-    .filter(([, count]) => count >= 1)
-    .sort(([, a], [, b]) => b - a)
-    .map(([op]) => op);
-
-  if (candidates.length === 0) return { bytecode: bc };
-
-  // ── Step 4: assign free opcode slots for each sub-statement ─────────────
-  // Build: originalOp → [{ microOp, irOperandCount }, ...]
-  const originalToSubOps = new Map<
-    number,
-    { microOp: number; irOperandCount: number }[]
-  >();
-
-  for (const origOp of candidates) {
-    const stmtCounts = opAnalysis.get(origOp)!;
-
-    // Pre-allocate all needed slots; if any slot is unavailable, skip this op.
-    const slots: number[] = [];
-    for (let si = 0; si < stmtCounts.length; si++) {
-      const slot = nextFreeSlot(compiler);
-      if (slot === -1) break;
-
-      compiler.OP_NAME[slot] = `MICRO_${origOp}_${si}`;
-      slots.push(slot);
-    }
-    if (slots.length !== stmtCounts.length) continue;
-
-    const subOps: { microOp: number; irOperandCount: number }[] = [];
-    const origName = compiler.OP_NAME[origOp] ?? `OP_${origOp}`;
-
-    for (let si = 0; si < stmtCounts.length; si++) {
-      const microOp = slots[si];
-      const irOperandCount = stmtCounts[si];
-      subOps.push({ microOp, irOperandCount });
-
-      compiler.OP_NAME[microOp] = `MICRO_${origName}_${si}`;
-      compiler.MICRO_OPS[microOp] = {
-        originalOp: origOp,
-        stmtIndex: si,
-        irOperandCount,
-      };
-    }
-
-    originalToSubOps.set(origOp, subOps);
-  }
-
-  if (originalToSubOps.size === 0) return { bytecode: bc };
-
-  // ── Step 5: replace each matched instruction with sub-instructions ────────
-  const result: Bytecode = [];
-
-  for (const instr of bc) {
-    const op = instr[0];
-    if (op === null || !originalToSubOps.has(op)) {
-      result.push(instr);
-      continue;
-    }
-
-    const subOps = originalToSubOps.get(op)!;
-    const operands = instr.slice(1); // all operands of the original instruction
-
-    // Verify total operand count matches sum of sub-op IR operand counts
-    const expectedTotal = subOps.reduce(
-      (s, { irOperandCount }) => s + irOperandCount,
-      0,
-    );
-    if (operands.length !== expectedTotal) {
-      throw new Error(
-        `Operand count mismatch for opcode ${compiler.OP_NAME[op]}`,
-      );
-    }
-
-    // Split operands among sub-instructions
-    let offset = 0;
-    for (const { microOp, irOperandCount } of subOps) {
-      const subOperands = operands.slice(offset, offset + irOperandCount);
-      offset += irOperandCount;
-
-      const newInstr: Instruction = [microOp, ...subOperands];
-      // Carry source-node info on the first sub-instruction
-      if (offset === irOperandCount) {
-        (newInstr as any)[SOURCE_NODE_SYM] = (instr as any)[SOURCE_NODE_SYM];
-      }
-
-      result.push(newInstr);
-    }
-  }
-
-  return { bytecode: result };
-}

package/src/transforms/runtime/internalVariables.ts

@@ -1,270 +0,0 @@
-// Goes through the switch case for defined identifiers on the statement level
-// Example:
-// case OP.LOAD_CONST: {
-//   var dst = this._operand();
-//   frame.regs[dst] = this._constant();
-//   break;
-// }
-// You find "dst" is defined in this scope.
-// You first check the compiler to see if it's already assigned an index in compiler._internals mapping varName=>index
-// If not found, use compiler._internals.globally.size as the new index (when options.randomizeOpcodes is off, when on, choose random between 0 and 65535), and add varName=>index to compiler._internals
-// Then replace the VariableDeclaration to an AssignmentExpression setting left this._internals[index] = init;
-// Then replace all identifiers of "dst" to this._internals[index] as well (Updates references)
-// Final output:
-// case OP.LOAD_CONST: {
-//   this._internals[index] = this._operand();
-//   frame.regs[this._internals[index]] = this._constant();
-//   break;
-// }
-
-import { Compiler } from "../../compiler.ts";
-import * as t from "@babel/types";
-import traverseImport from "@babel/traverse";
-import { ok } from "assert";
-import { getRandomInt } from "../../utils/random-utils.ts";
-import { U16_MAX } from "../../utils/op-utils.ts";
-
-const traverse = (traverseImport.default ||
-  traverseImport) as typeof traverseImport.default;
-
-export function makeInternalsAccess(index: number): t.MemberExpression {
-  return t.memberExpression(
-    t.memberExpression(t.thisExpression(), t.identifier("_internals")),
-    t.numericLiteral(index),
-    true, // computed
-  );
-}
-
-function collectUsedIndices(compiler: Compiler): Set<number> {
-  const used = new Set<number>();
-  for (const v of compiler._internals.globally.values()) used.add(v);
-  for (const opMap of compiler._internals.opcodes.values()) {
-    for (const v of opMap.values()) used.add(v);
-  }
-  return used;
-}
-
-// Assign or look up the _internals slot index for a variable name within a
-// specific opcode handler.
-//
-// _internals.opcodes[currentOpcode] is the source of truth for this opcode.
-// _internals.globally holds the shared pool written on first sight.
-//
-// randomizeOpcodes OFF → always reuse / create in globally, mirror to opcodes.
-// randomizeOpcodes ON  → first time a name is seen: create global slot.
-//                        subsequent opcodes: 50% reuse global, 50% create an
-//                        opcode-specific random slot (NOT written to globally).
-function assignInternalsIndex(
-  name: string,
-  compiler: Compiler,
-  currentOpcode: number,
-): number {
-  // Ensure per-opcode map exists
-  let opcodeMap = compiler._internals.opcodes.get(currentOpcode);
-  if (!opcodeMap) {
-    opcodeMap = new Map();
-    compiler._internals.opcodes.set(currentOpcode, opcodeMap);
-  }
-
-  // Already registered for this opcode — return immediately
-  const existing = opcodeMap.get(name);
-  if (existing !== undefined) return existing;
-
-  const globalIndex = compiler._internals.globally.get(name);
-  let index: number;
-
-  if (!compiler.options.randomizeOpcodes) {
-    // Non-random: always share the global sequential slot
-    if (globalIndex === undefined) {
-      index = compiler._internals.globally.size;
-      compiler._internals.globally.set(name, index);
-    } else {
-      index = globalIndex;
-    }
-  } else if (globalIndex === undefined) {
-    // First opcode to declare this variable — establish the global slot
-    const used = collectUsedIndices(compiler);
-    let candidate: number;
-    do {
-      candidate = getRandomInt(0, U16_MAX);
-    } while (used.has(candidate));
-    index = candidate;
-    compiler._internals.globally.set(name, index);
-  } else {
-    // Already in global: 50% chance to reuse, 50% opcode-specific new slot
-    if (Math.random() < 0.5) {
-      index = globalIndex;
-    } else {
-      const used = collectUsedIndices(compiler);
-      let candidate: number;
-      do {
-        candidate = getRandomInt(0, U16_MAX);
-      } while (used.has(candidate));
-      index = candidate;
-      // Intentionally NOT written to globally — this slot is opcode-specific
-    }
-  }
-
-  opcodeMap.set(name, index);
-  return index;
-}
-
-export function applyInternalVariablesToSwitchCase(
-  node: t.SwitchCase,
-  compiler: Compiler,
-  currentOpcode: number,
-) {
-  // Work with the actual body array (block body or flat consequent)
-  let bodyArr: t.Statement[];
-  if (node.consequent.length === 1 && t.isBlockStatement(node.consequent[0])) {
-    bodyArr = (node.consequent[0] as t.BlockStatement).body;
-  } else {
-    bodyArr = node.consequent as t.Statement[];
-  }
-
-  // Single traversal: declarations and references handled in one pass.
-  //
-  // Declaration (Identifier is VariableDeclarator.id):
-  //   → register/look-up slot, replace entire VariableDeclaration with
-  //     AssignmentExpression (bare for ForStatement.init, else ExpressionStatement).
-  //
-  // Reference (any other Identifier):
-  //   → look up opcodes[currentOpcode] (source of truth) and replace if found.
-  //     This handles cross-statement refs produced by micro-opcode splitting.
-  const syntheticFile = t.file(t.program(bodyArr as t.Statement[]));
-  const illegalNames = new Set<string>(); // Nested closure names are skipped
-
-  traverse(syntheticFile, {
-    Identifier(path) {
-      const name = path.node.name;
-      if (illegalNames.has(name)) return;
-
-      // Skip non-computed property names: obj.name
-      if (
-        t.isMemberExpression(path.parent) &&
-        !path.parent.computed &&
-        path.parent.property === path.node
-      ) {
-        return;
-      }
-
-      // Skip non-computed object-property keys: { name: value }
-      if (
-        t.isObjectProperty(path.parent) &&
-        !path.parent.computed &&
-        path.parent.key === path.node
-      ) {
-        return;
-      }
-
-      // Don't descend into nested function scopes
-      if (
-        path.find(
-          (p) =>
-            p.isFunctionDeclaration() ||
-            p.isFunctionExpression() ||
-            p.isArrowFunctionExpression(),
-        )
-      ) {
-        return;
-      }
-
-      // ── Declaration binding ──────────────────────────────────────────────
-      if (t.isVariableDeclarator(path.parent) && path.parent.id === path.node) {
-        // Verify it's not referenced in nested closure (illegal)
-        const binding = path.scope.getBinding(name);
-        if (
-          binding?.referencePaths.some((rp) =>
-            rp.findParent(
-              (p) =>
-                p.isFunctionDeclaration() ||
-                p.isFunctionExpression() ||
-                p.isArrowFunctionExpression(),
-            ),
-          )
-        ) {
-          illegalNames.add(name);
-          return;
-        }
-
-        const index = assignInternalsIndex(name, compiler, currentOpcode);
-        const init = (path.parent as t.VariableDeclarator).init;
-
-        const assignment = t.assignmentExpression(
-          "=",
-          makeInternalsAccess(index),
-          init ?? t.identifier("undefined"),
-        );
-
-        // Two levels up: VariableDeclarator → VariableDeclaration
-        const varDeclPath = path.parentPath!.parentPath!;
-
-        if (
-          t.isForStatement(varDeclPath.parent) &&
-          varDeclPath.parent.init === varDeclPath.node
-        ) {
-          // ForStatement.init accepts an Expression directly
-          varDeclPath.replaceWith(assignment);
-        } else {
-          varDeclPath.replaceWith(t.expressionStatement(assignment));
-        }
-        return;
-      }
-
-      // ── Reference ───────────────────────────────────────────────────────
-      // Source of truth for this opcode is its own per-opcode map
-      const opcodeMap = compiler._internals.opcodes.get(currentOpcode);
-      const index = opcodeMap?.get(name);
-      if (index !== undefined) {
-        path.replaceWith(makeInternalsAccess(index));
-        path.skip();
-      }
-    },
-  });
-}
-
-// This takes the AST and finds the runtime switch statement via the leading
-// comment "@SWITCH" then applies the above transformation to each switch case.
-export function applyInteralVariablesToRuntime(
-  ast: t.File,
-  compiler: Compiler,
-) {
-  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 internal variables",
-  );
-
-  for (const sc of (switchStatement as t.SwitchStatement).cases) {
-    const test = sc.test;
-    let currentOpcode: number | null = null;
-
-    if (
-      test &&
-      t.isMemberExpression(test) &&
-      t.isIdentifier(test.object, { name: "OP" }) &&
-      t.isIdentifier(test.property)
-    ) {
-      // case OP.LOAD_CONST: → resolve via compiler.OP
-      const opName = (test.property as t.Identifier).name;
-      const val = compiler.OP[opName as keyof typeof compiler.OP];
-      if (val !== undefined) currentOpcode = val as number;
-    } else if (test && t.isNumericLiteral(test)) {
-      // Already a numeric literal (e.g. generated micro-opcode cases)
-      currentOpcode = test.value;
-    }
-
-    if (currentOpcode === null) continue;
-
-    applyInternalVariablesToSwitchCase(sc, compiler, currentOpcode);
-  }
-}