js-confuser-vm 0.0.9 → 0.1.1

package/src/disassembler.ts

@@ -0,0 +1,329 @@
+/**
+ * Simple bytecode disassembler for debugging.
+ *
+ * Takes the bytecode debug comment block (as generated by the compiler)
+ * and produces a flat pseudo-code listing with registers, gotos, and labels.
+ */
+
+// Regex to match a single instruction line from the debug comment block.
+// Groups: raw array, opcode name, annotation (rest of line after opcode name)
+const INSTR_RE = /^\s*\/\/\s*\[([^\]]+)\],\s+(\w+)\s+(.*?)$/;
+
+// Label line: // label_name:
+const LABEL_RE = /^\s*\/\/\s*(\w+):$/;
+
+interface ParsedInstr {
+  raw: number[];
+  opName: string;
+  annotation: string;
+}
+
+interface Line {
+  kind: "label" | "instr";
+  label?: string;
+  instr?: ParsedInstr;
+}
+
+function parseBlock(commentBlock: string): Line[] {
+  const lines: Line[] = [];
+  for (const raw of commentBlock.split("\n")) {
+    const trimmed = raw.trim();
+    if (!trimmed || !trimmed.startsWith("//")) continue;
+
+    const instrMatch = trimmed.match(INSTR_RE);
+    if (instrMatch) {
+      const nums = instrMatch[1].split(",").map((s) => parseInt(s.trim(), 10));
+      lines.push({
+        kind: "instr",
+        instr: {
+          raw: nums,
+          opName: instrMatch[2],
+          annotation: instrMatch[3].trim(),
+        },
+      });
+      continue;
+    }
+
+    const labelMatch = trimmed.match(LABEL_RE);
+    if (labelMatch) {
+      lines.push({ kind: "label", label: labelMatch[1] });
+    }
+  }
+  return lines;
+}
+
+// Extract a label name from an annotation string like "[4, while_exit_8]" or "while_top_7"
+// Also handles "PC=fn_1_1" for closures
+function extractLabel(annotation: string): string | null {
+  // Strip trailing source location info like "3:4-7:5"
+  const stripped = annotation.replace(/\s+\d+:\d+-\d+:\d+\s*$/, "").trim();
+
+  const bracketMatch = stripped.match(/\[\d+,\s*(\w+)\]/);
+  if (bracketMatch) return bracketMatch[1];
+
+  const pcMatch = stripped.match(/\bPC=(\w+)/);
+  if (pcMatch) return pcMatch[1];
+
+  const gotoMatch = stripped.match(/\bgoto\s+(\w+)/);
+  if (gotoMatch) return gotoMatch[1];
+
+  // Bare label at end: last whitespace-separated token
+  const lastToken = stripped.split(/\s+/).pop();
+  if (lastToken && /^[a-zA-Z_]\w*$/.test(lastToken)) return lastToken;
+
+  return null;
+}
+
+const ARITH_SYMBOLS: Record<string, string> = {
+  ADD: "+",
+  SUB: "-",
+  MUL: "*",
+  DIV: "/",
+  MOD: "%",
+  BAND: "&",
+  BOR: "|",
+  BXOR: "^",
+  SHL: "<<",
+  SHR: ">>",
+  USHR: ">>>",
+};
+
+const CMP_SYMBOLS: Record<string, string> = {
+  LT: "<",
+  GT: ">",
+  LTE: "<=",
+  GTE: ">=",
+  EQ: "===",
+  NEQ: "!==",
+  LOOSE_EQ: "==",
+  LOOSE_NEQ: "!=",
+  IN: "in",
+  INSTANCEOF: "instanceof",
+};
+
+const UNARY_SYMBOLS: Record<string, string> = {
+  UNARY_NEG: "-",
+  UNARY_POS: "+",
+  UNARY_NOT: "!",
+  UNARY_BITNOT: "~",
+};
+
+// Extract value from annotation like 'reg[1] = "Hello"' or 'reg[1] = 42'
+function extractConstValue(annotation: string): string | null {
+  const m = annotation.match(/=\s*(.+?)(?:\s+\d+:\d+-\d+:\d+)?$/);
+  return m ? m[1].trim() : null;
+}
+
+function disassembleInstr(instr: ParsedInstr): string {
+  const { raw, opName, annotation } = instr;
+  const r = (i: number) => `r${raw[i]}`;
+
+  switch (opName) {
+    case "LOAD_CONST": {
+      const val = extractConstValue(annotation);
+      return `${r(1)} = ${val ?? `const[${raw[2]}]`}`;
+    }
+    case "LOAD_INT":
+      return `${r(1)} = ${raw[2]}`;
+    case "LOAD_GLOBAL": {
+      const val = extractConstValue(annotation);
+      return `${r(1)} = ${val ?? `global[${raw[2]}]`}`;
+    }
+    case "LOAD_UPVALUE":
+      return `${r(1)} = upvalue[${raw[2]}]`;
+    case "LOAD_THIS":
+      return `${r(1)} = this`;
+    case "MOVE":
+      return `${r(1)} = ${r(2)}`;
+
+    case "STORE_GLOBAL": {
+      // annotation: globals[name] = reg[src]
+      const val = extractConstValue(annotation);
+      return `global[${val ?? raw[1]}] = ${r(2)}`;
+    }
+    case "STORE_UPVALUE":
+      return `upvalue[${raw[1]}] = ${r(2)}`;
+
+    case "GET_PROP":
+      return `${r(1)} = ${r(2)}[${r(3)}]`;
+    case "SET_PROP":
+      return `${r(1)}[${r(2)}] = ${r(3)}`;
+    case "DELETE_PROP":
+      return `${r(1)} = delete ${r(2)}[${r(3)}]`;
+
+    // Arithmetic / bitwise
+    case "ADD":
+    case "SUB":
+    case "MUL":
+    case "DIV":
+    case "MOD":
+    case "BAND":
+    case "BOR":
+    case "BXOR":
+    case "SHL":
+    case "SHR":
+    case "USHR":
+      return `${r(1)} = ${r(2)} ${ARITH_SYMBOLS[opName]} ${r(3)}`;
+
+    // Comparison
+    case "LT":
+    case "GT":
+    case "LTE":
+    case "GTE":
+    case "EQ":
+    case "NEQ":
+    case "LOOSE_EQ":
+    case "LOOSE_NEQ":
+    case "IN":
+    case "INSTANCEOF":
+      return `${r(1)} = ${r(2)} ${CMP_SYMBOLS[opName]} ${r(3)}`;
+
+    // Unary
+    case "UNARY_NEG":
+    case "UNARY_POS":
+    case "UNARY_NOT":
+    case "UNARY_BITNOT":
+      return `${r(1)} = ${UNARY_SYMBOLS[opName]}${r(2)}`;
+    case "TYPEOF":
+      return `${r(1)} = typeof ${r(2)}`;
+    case "VOID":
+      return `${r(1)} = void ${r(2)}`;
+    case "TYPEOF_SAFE": {
+      const val = extractConstValue(annotation);
+      return `${r(1)} = typeof ${val ?? `safe[${raw[2]}]`}`;
+    }
+
+    // Control flow
+    case "JUMP": {
+      const label = extractLabel(annotation);
+      return `goto: ${label ?? `pc:${raw[1]}`}`;
+    }
+    case "JUMP_IF_FALSE": {
+      const label = extractLabel(annotation);
+      return `if (!${r(1)}) goto: ${label ?? `pc:${raw[2]}`}`;
+    }
+    case "JUMP_IF_TRUE": {
+      const label = extractLabel(annotation);
+      return `if (${r(1)}) goto: ${label ?? `pc:${raw[2]}`}`;
+    }
+    case "JUMP_REG":
+      return `goto: *${r(1)}`;
+
+    // Calls
+    case "CALL": {
+      const dst = r(1);
+      const callee = r(2);
+      const argc = raw[3];
+      const args = raw.slice(4, 4 + argc).map((_, i) => `r${raw[4 + i]}`);
+      return `${dst} = ${callee}(${args.join(", ")})`;
+    }
+    case "CALL_METHOD": {
+      const dst = r(1);
+      const recv = r(2);
+      const callee = r(3);
+      const argc = raw[4];
+      const args = raw.slice(5, 5 + argc).map((_, i) => `r${raw[5 + i]}`);
+      return `${dst} = ${callee}.call(${recv}, ${args.join(", ")})`;
+    }
+    case "NEW": {
+      const dst = r(1);
+      const callee = r(2);
+      const argc = raw[3];
+      const args = raw.slice(4, 4 + argc).map((_, i) => `r${raw[4 + i]}`);
+      return `${dst} = new ${callee}(${args.join(", ")})`;
+    }
+
+    case "RETURN":
+      return `return ${r(1)}`;
+    case "THROW":
+      return `throw ${r(1)}`;
+
+    // Closures
+    case "MAKE_CLOSURE": {
+      const dst = r(1);
+      const startPc = raw[2];
+      const paramCount = raw[3];
+      const regCount = raw[4];
+      const uvCount = raw[5];
+      const label = extractLabel(annotation);
+      const uvParts: string[] = [];
+      for (let i = 0; i < uvCount; i++) {
+        const isLocal = raw[6 + i * 2];
+        const idx = raw[6 + i * 2 + 1];
+        uvParts.push(isLocal ? `local[${idx}]` : `uv[${idx}]`);
+      }
+      const uvStr = uvCount > 0 ? `, upvalues=[${uvParts.join(", ")}]` : "";
+      return `${dst} = MakeClosure(${label ?? `pc:${startPc}`}, params=${paramCount}, regs=${regCount}${uvStr})`;
+    }
+
+    // Collections
+    case "BUILD_ARRAY": {
+      const dst = r(1);
+      const count = raw[2];
+      const elems = raw.slice(3, 3 + count).map((_, i) => `r${raw[3 + i]}`);
+      return `${dst} = [${elems.join(", ")}]`;
+    }
+    case "BUILD_OBJECT": {
+      const dst = r(1);
+      const pairCount = raw[2];
+      const pairs: string[] = [];
+      for (let i = 0; i < pairCount; i++) {
+        pairs.push(`[r${raw[3 + i * 2]}]: r${raw[4 + i * 2]}`);
+      }
+      return `${dst} = {${pairs.join(", ")}}`;
+    }
+
+    // Property definitions
+    case "DEFINE_GETTER":
+      return `Object.defineGetter(${r(1)}, ${r(2)}, ${r(3)})`;
+    case "DEFINE_SETTER":
+      return `Object.defineSetter(${r(1)}, ${r(2)}, ${r(3)})`;
+
+    // For-in
+    case "FOR_IN_SETUP":
+      return `${r(1)} = ForInSetup(${r(2)})`;
+    case "FOR_IN_NEXT": {
+      const label = extractLabel(annotation);
+      return `${r(1)} = ForInNext(${r(2)}) else goto ${label ?? `pc:${raw[3]}`}`;
+    }
+
+    // Exception handling
+    case "TRY_SETUP": {
+      return `try { catch -> pc:${raw[1]}, exReg=${r(2)}`;
+    }
+    case "TRY_END":
+      return `} // end try`;
+
+    // Self-modifying
+    case "PATCH":
+      return `patch(dest=pc:${raw[1]}, src=pc:${raw[2]}..${raw[3]})`;
+
+    case "DEBUGGER":
+      return `debugger`;
+
+    default:
+      return `??? ${opName} [${raw.join(", ")}]`;
+  }
+}
+
+export function disassembleCommentBlock(commentBlock: string): string {
+  const lines = parseBlock(commentBlock);
+
+  let bodies: string[][] = [];
+  let currentBody: string[] = [];
+
+  for (const line of lines) {
+    if (line.kind === "label") {
+      let newBody = [];
+      newBody.push(`// ${line.label}:`);
+      bodies.push(newBody);
+      currentBody = newBody;
+    } else if (line.instr) {
+      currentBody.push(`  ${disassembleInstr(line.instr)}`);
+    }
+  }
+
+  const out: string[] = bodies.flatMap((body) => body);
+
+  return out.join("\n");
+}

package/src/index.ts

@@ -1,14 +1,24 @@
 import { compileAndSerialize } from "./compiler.ts";
 import type { Options } from "./options.ts";
 import { DEFAULT_OPTIONS } from "./options.ts";
+import { disassembleCommentBlock } from "./disassembler.ts";
+import type { ObfuscationResult } from "./types.ts";
 
-async function obfuscate(source, options: Options = DEFAULT_OPTIONS) {
-  const result = compileAndSerialize(source, options);
+async function obfuscate(
+  source: string,
+  options: Options = DEFAULT_OPTIONS,
+): Promise<ObfuscationResult> {
+  const result = await compileAndSerialize(source, options);
 
   return result;
 }
 
+async function disassemble(bytecodeComments: string) {
+  return disassembleCommentBlock(bytecodeComments);
+}
+
 export const JsConfuserVM = {
   obfuscate,
+  disassemble,
 };
 export default JsConfuserVM;

package/src/options.ts

@@ -5,13 +5,20 @@ export interface Options {
   shuffleOpcodes?: boolean; // shuffle order of opcode handlers in the runtime?
   encodeBytecode?: boolean; // encode bytecode? when off, comments for instructions are added
   selfModifying?: boolean; // do self-modifying bytecode for function bodies?
+  dispatcher?: boolean; // create middleman blocks to process jumps?
+  controlFlowFlattening?: boolean; // flatten the control flow of your program into a convoluted state machine?
   macroOpcodes?: boolean; // create combined opcodes for repeated instruction sequences?
-  microOpcodes?: boolean; // break opcodes into sub-opcodes?
   specializedOpcodes?: boolean; // create specialized opcodes for commonly used opcode+operand pairs?
   aliasedOpcodes?: boolean; // create duplicate opcodes for commonly used opcodes?
+  handlerTable?: boolean; // convert switch dispatch to a handler table on the VM prototype?
   timingChecks?: boolean; // add timing checks to detect debuggers?
   concealConstants?: boolean; // conceal strings and integers in the constant pool?
+  classObfuscation?: boolean; // obfuscate the VM runtime classes?
   minify?: boolean; // pass final output through Google Closure Compiler? (Renames VM class properties)
+
+  stringConcealing?: boolean;
+
+  verbose?: boolean;
 }
 
 export const DEFAULT_OPTIONS = {};