js-confuser-vm 0.1.1 → 0.1.2

package/src/transforms/runtime/specializedOpcodes.ts

@@ -1,161 +0,0 @@
-import * as t from "@babel/types";
-import traverseImport from "@babel/traverse";
-import { ok } from "assert";
-import { Compiler } from "../../compiler.ts";
-import { getOpcodeToCaseMap } from "./macroOpcodes.ts";
-
-const traverse = (traverseImport.default ||
-  traverseImport) as typeof traverseImport.default;
-
-// Extract the real statement list from a SwitchCase consequent (identical to the
-// helper used by applyMacroOpcodes so the two files stay in sync).
-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));
-}
-
-// Inline a fixed numeric operand in place of every `this._operand()` call.
-// Because specialized opcodes are only created for instructions that have
-// *exactly one* numeric operand, every `_operand()` call inside the original
-// handler is replaced by the constant value that was baked into the opcode.
-function inlineFixedOperands(
-  newName: string, // for debugging
-  info: any,
-  bodyStmts: t.Statement[],
-  resolvedValues: number[],
-): void {
-  // Wrap the statements in a temporary BlockStatement so traverse has a root.
-  // The replacement mutates the original statement objects in place.
-  var replaced = 0;
-  function consumeOperand() {
-    const resolvedValue = resolvedValues[replaced++];
-    ok(
-      typeof resolvedValue === "number",
-      `Expected a numeric operand value, got ${resolvedValue}`,
-    );
-    return t.numericLiteral(resolvedValue);
-  }
-
-  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
-        );
-      };
-
-      if (isMethodCall("_operand")) {
-        path.replaceWith(consumeOperand());
-      }
-
-      if (isMethodCall("_constant")) {
-        path.node.arguments = [consumeOperand(), consumeOperand()];
-      }
-    },
-  });
-
-  if (replaced !== resolvedValues.length) {
-    console.error(resolvedValues, info);
-    throw new Error(
-      `Specialized Opcode Inline Error: Given ${resolvedValues.length} operands to replace, but only found ${replaced} for ${newName}`,
-    );
-  }
-}
-
-// Append a generated switch case for every entry in compiler.SPECIALIZED_OPS.
-// Each case is a clone of the original opcode’s handler with `this._operand()`
-// replaced by the constant integer that was captured at compile time.
-// Must be called AFTER applyMacroOpcodes (so the original cases exist) but
-// BEFORE applyShuffleOpcodes so the new specialized cases also get shuffled.
-export function applySpecializedOpcodes(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 specialized opcodes",
-  );
-
-  // Build a map  opName → SwitchCase  from the existing OP.xxx case tests.
-  const opcodeToCaseMap = getOpcodeToCaseMap(switchStatement, compiler);
-
-  if (!compiler.SPECIALIZED_OPS) return;
-
-  for (const [specialOpStr, info] of Object.entries(compiler.SPECIALIZED_OPS)) {
-    const specialOpCode = Number(specialOpStr);
-    const { originalOp, operands } = info;
-
-    let newName = compiler.OP_NAME[specialOpCode];
-    const originalName = compiler.OP_NAME[originalOp];
-    const originalCase = opcodeToCaseMap.get(originalOp);
-
-    ok(
-      originalCase,
-      `Could not find original case for opcode ${originalName} (${originalOp})`,
-    );
-
-    // Clone the original handler body
-    const bodyStmts: t.Statement[] = extractCaseBody(originalCase).map(
-      (s) => t.cloneNode(s, true) as t.Statement,
-    );
-
-    const placedOperands = info.operands;
-    ok(placedOperands, `Could not find operand for original opcode ${newName}`);
-
-    const resolvedValues = placedOperands
-      // .filter((x) => !(x as any)?.placeholder)
-      .map((placedOperand) => {
-        return (placedOperand as any)?.resolvedValue ?? placedOperand;
-      });
-
-    if (resolvedValues.find((v) => typeof v !== "number")) {
-      throw new Error("Expected all resolved operand values to be numbers");
-    }
-
-    newName = `${originalName}_${resolvedValues.join("_")}`;
-    compiler.OP_NAME[specialOpCode] = newName;
-
-    // Replace this._operand() with the baked-in constant
-    inlineFixedOperands(newName, info, bodyStmts, resolvedValues);
-
-    // Add a leading comment so the generated source stays readable
-    if (bodyStmts.length > 0) {
-      t.addComment(
-        bodyStmts[0],
-        "leading",
-        ` ${compiler.OP_NAME[specialOpCode]} (specialized)`,
-        true,
-      );
-    }
-
-    bodyStmts.push(t.breakStatement());
-
-    // Insert the new specialized case into the big switch
-    (switchStatement as t.SwitchStatement).cases.push(
-      t.switchCase(t.numericLiteral(specialOpCode), [
-        t.blockStatement(bodyStmts),
-      ]),
-    );
-  }
-}

package/src/types.ts

@@ -1,134 +0,0 @@
-// Bytecode supports both real instructions and IR pseudo-instructions
-// Real instruction: [OP.ADD, 5]  or multi-operand: [OP.MAKE_CLOSURE, labelRef, 2, 3, 0, 0]
-// 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.
-// Instructions may carry any number of operands; the flat output serializes
-// each operand as a separate u16 slot in the bytecode array.
-// A virtual register reference emitted by the compiler.
-// fnId identifies which function's register file this belongs to.
-// resolveRegisters() replaces these with concrete slot indices (type:"number").
-export type RegisterOperand = Op<{
-  type: "register";
-  id: number;
-  fnId: number;
-  kind?: string;
-  scopeId?: string | number;
-  // If true, resolveRegisters always assigns this register to the "local::"
-  // pool (no slot reuse).  Set by passes that emit registers whose live ranges
-  // span CFF dispatch-loop back-edges — regions the linear-scan liveness
-  // analysis cannot reason about.
-  pinned?: boolean;
-}>;
-
-// A placeholder for a function's concrete regCount, emitted in MAKE_CLOSURE.
-// resolveRegisters() fills resolvedValue once it knows the concrete slot count.
-export type FnRegCountOperand = Op<{ type: "fnRegCount"; fnId: number }>;
-
-// IR pseudo-instruction that marks the end of a register's live range.
-// Emitted as [null, FreeRegOperand] so it is dropped before final assembly.
-//
-// NOTE: resolveRegisters() already computes correct lastUse from the last real
-// operand appearance, so freeReg is EXTRANEOUS for any programmatically generated
-// IR — the scanner will find the tightest possible range without it.
-// It is only useful when a register has a late syntactic appearance that does
-// NOT reflect its true logical end-of-life (e.g. a read emitted purely for
-// side-effects long after the value is logically dead). No current pass in this
-// codebase emits freeReg; it is kept as an extension point only.
-export type FreeRegOperand = Op<{
-  type: "freeReg";
-  fnId: number;
-  id: number;
-  kind?: string;
-  scopeId?: string | number;
-}>;
-
-export type InstrOperand =
-  | number
-  | Op<{ type: "number"; value?: number }>
-  | Op<{
-      type: "label";
-      label: string;
-      offset?: number;
-      transform?: (resolvedPC: number) => number;
-    }>
-  | Op<{ type: "defineLabel"; label: string }>
-  | Op<{ type: "constant"; value: any }>
-  | RegisterOperand
-  | FnRegCountOperand
-  | FreeRegOperand;
-
-export interface Operand {
-  type: string;
-  placeholder?: boolean; // This operand will not be emitted in the final bytecode, but used as a reference
-  resolvedValue?: number; // This operand knows its resolved value, but kept as a object to keep metadata info available
-}
-
-type Op<T extends object> = Operand & T;
-
-export type Instruction = [number | null, ...InstrOperand[]];
-
-export type Bytecode = Instruction[];
-
-export function constantOperand(value: any): Instruction[1] {
-  return {
-    type: "constant",
-    value: value,
-  };
-}
-
-export function registerOperand(
-  id: number,
-  fnId: number,
-  metadata: Partial<Pick<RegisterOperand, "kind" | "scopeId">> = {},
-): RegisterOperand {
-  return { type: "register", id, fnId, ...metadata };
-}
-
-export function fnRegCountOperand(fnId: number): FnRegCountOperand {
-  return { type: "fnRegCount", fnId };
-}
-
-export function freeRegOperand(reg: RegisterOperand): FreeRegOperand {
-  const op: FreeRegOperand = { type: "freeReg", fnId: reg.fnId, id: reg.id };
-  if (reg.kind !== undefined) op.kind = reg.kind;
-  if (reg.scopeId !== undefined) op.scopeId = reg.scopeId;
-  return op;
-}
-
-export interface ObfuscationResult {
-  code: string;
-  profileData?: {
-    handlerCount: number;
-
-    /**
-     * How long the entire obfuscation process takes (ms)
-     */
-    obfuscationTime?: number;
-
-    /**
-     * How long @babel/parser takes (ms)
-     */
-    parseTime?: number;
-
-    /**
-     * How long @babel/generator takes (ms)
-     */
-    generateTime?: number;
-
-    /**
-     * How long the Compiler#compileAST takes (ms)
-     */
-    compileTime?: number;
-
-    transforms: {
-      [transformName: string]: {
-        fileSize?: number;
-        bytecodeSize?: number;
-        transformTime?: number;
-        handlerCount?: number;
-      };
-    };
-  };
-}

package/src/utils/ast-utils.ts

@@ -1,19 +0,0 @@
-import * as t from "@babel/types";
-import traverseImport from "@babel/traverse";
-
-const traverse = (traverseImport.default ||
-  traverseImport) as typeof traverseImport.default;
-
-export function getSwitchStatement(ast: t.File) {
-  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();
-      }
-    },
-  });
-
-  return switchStatement;
-}

package/src/utils/op-utils.ts

@@ -1,46 +0,0 @@
-import { getRandomInt } from "./random-utils.ts";
-import * as b from "../types.ts";
-import { Compiler } from "../compiler.ts";
-
-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(compiler: Compiler): number {
-  // ── Collect used opcodes exactly as specified ─────────────────────────────
-  const usedOpcodes = new Set<number>(
-    Object.keys(compiler.OP_NAME)
-      .map((k) => parseInt(k, 10))
-      .filter((v) => !isNaN(v)) as number[],
-  );
-
-  if (usedOpcodes.size > U16_MAX) return -1;
-
-  // Random opcode
-  if (compiler.options.randomizeOpcodes) {
-    let attempts = 0;
-    while (attempts++ < 512) {
-      const candidate = getRandomInt(0, U16_MAX);
-      if (!usedOpcodes.has(candidate)) {
-        return candidate;
-      }
-    }
-  }
-
-  // Fallback: linear scan from a random start
-  const start = Object.keys(compiler.OP_NAME).length;
-  for (let i = 0; i <= U16_MAX; i++) {
-    const v = (start + i) & U16_MAX;
-    if (!usedOpcodes.has(v)) {
-      return v;
-    }
-  }
-  return -1;
-}
-
-export function getInstructionSize(instr: b.Instruction): number {
-  if (instr[0] === null) return 0;
-
-  const size = instr.filter((op) => (op as any)?.placeholder !== true).length;
-
-  return size;
-}

package/src/utils/pass-utils.ts

@@ -1,126 +0,0 @@
-// Shared utilities for bytecode transformation passes.
-//
-// All three patterns below are identical across dispatcher, controlFlowFlattening,
-// and stringConcealing.  Centralising them here keeps each pass focused on its
-// own logic and makes the shared contract explicit.
-
-import type { Bytecode, RegisterOperand, InstrOperand } from "../types.ts";
-import * as b from "../types.ts";
-import { Compiler } from "../compiler.ts";
-
-// Return a fresh RegisterOperand object with the same (id, fnId).
-// IMPORTANT: operand objects must be unique throughout compilation —
-// other passes (e.g. specializedOpcodes) mutate operands in-place and a
-// shared reference would corrupt both sites.
-export function ref(r: RegisterOperand): RegisterOperand {
-  return b.registerOperand(r.id, r.fnId);
-}
-
-// Scan bc and return the highest virtual register id seen for each fnId.
-// Used by passes that allocate new registers after the compiler has finished.
-export function buildMaxIdMap(bc: Bytecode): Map<number, number> {
-  const maxId = new Map<number, number>();
-  for (const instr of bc) {
-    for (let j = 1; j < instr.length; j++) {
-      const op = instr[j] as any;
-      if (op && op.type === "register") {
-        const cur = maxId.get(op.fnId) ?? -1;
-        if (op.id > cur) maxId.set(op.fnId, op.id);
-      }
-    }
-  }
-  return maxId;
-}
-
-// Allocate the next virtual register id for fnId, updating maxId in-place.
-export function allocReg(
-  fnId: number,
-  maxId: Map<number, number>,
-): RegisterOperand {
-  const next = (maxId.get(fnId) ?? -1) + 1;
-  maxId.set(fnId, next);
-  return b.registerOperand(next, fnId);
-}
-
-// Return the label string if the operand is a { type:"label" } object,
-// otherwise return null.  Used by passes that need to identify jump targets.
-export function extractLabel(op: InstrOperand | undefined): string | null {
-  if (op && typeof op === "object" && (op as any).type === "label")
-    return (op as any).label as string;
-  return null;
-}
-
-// Walk bc, call transform() for every function body, and reassemble the output.
-//
-// For each function entry label the scanner collects all instructions up to the
-// next entry label (or end-of-bytecode) into fnInstrs and passes them to
-// transform() along with the function's fnId.
-//
-// The transform callback returns:
-//   instrs — the (possibly rewritten) function body to emit in place of fnInstrs
-//   tail   — optional bytecode to append AFTER all function bodies
-//             (e.g. template-compiled decode closures)
-//
-// Instructions that appear before any entry label (the top-level preamble) are
-// passed through unchanged.
-export function forEachFunction(
-  bc: Bytecode,
-  compiler: Compiler,
-  transform: (
-    fnInstrs: Bytecode,
-    fnId: number,
-  ) => { instrs: Bytecode; tail?: Bytecode },
-): { bytecode: Bytecode } {
-  const entryLabels = new Set(compiler.fnDescriptors.map((d) => d.entryLabel));
-  const entryLabelToFnId = new Map(
-    compiler.fnDescriptors.map((d) => [d.entryLabel!, d._fnIdx!]),
-  );
-
-  const result: Bytecode = [];
-  const tails: Bytecode[] = [];
-  let i = 0;
-
-  while (i < bc.length) {
-    const instr = bc[i];
-    const [op, operand0] = instr;
-    const isEntryLabel =
-      op === null &&
-      (operand0 as any)?.type === "defineLabel" &&
-      entryLabels.has((operand0 as any).label);
-
-    if (!isEntryLabel) {
-      result.push(instr);
-      i++;
-      continue;
-    }
-
-    const entryLabel = (operand0 as any).label as string;
-    const fnId = entryLabelToFnId.get(entryLabel)!;
-    i++; // step past the defineLabel itself
-
-    const fnInstrs: Bytecode = [];
-    while (i < bc.length) {
-      const next = bc[i];
-      const [nextOp, nextOp0] = next;
-      if (
-        nextOp === null &&
-        (nextOp0 as any)?.type === "defineLabel" &&
-        entryLabels.has((nextOp0 as any).label)
-      )
-        break;
-      fnInstrs.push(next);
-      i++;
-    }
-
-    result.push(instr); // emit the entry defineLabel
-    const { instrs, tail } = transform(fnInstrs, fnId);
-    result.push(...instrs);
-    if (tail && tail.length > 0) tails.push(tail);
-  }
-
-  for (const tail of tails) {
-    result.push(...tail);
-  }
-
-  return { bytecode: result };
-}

package/src/utils/profile-utils.ts

@@ -1,3 +0,0 @@
-export function now() {
-  return performance?.now() || Date.now();
-}

package/src/utils/random-utils.ts

@@ -1,31 +0,0 @@
-import { ok } from "assert";
-
-export function getPlaceholder() {
-  return Math.random().toString(36).substring(2, 15);
-}
-
-export function choice<T>(elements: T[]): T {
-  ok(elements.length > 0, "choice() called on empty sequence");
-  return elements[Math.floor(Math.random() * elements.length)];
-}
-
-export function getRandom(): number {
-  return Math.random();
-}
-
-export function getRandomInt(min: number, max: number): number {
-  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<T>(array: T[]): T[] {
-  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/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "nodenext",
-    "outDir": "./dist",
-    "rootDir": "./",
-    "strict": false,
-    "noEmit": true,
-    "types": ["node", "jest"],
-    "allowImportingTsExtensions": true
-  }
-}