js-confuser-vm 0.1.0 → 0.1.2

package/dist/disassembler.js

@@ -0,0 +1,367 @@
+/**
+ * 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+):$/;
+function parseBlock(commentBlock) {
+  const lines = [];
+  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) {
+  // 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 = {
+  ADD: "+",
+  SUB: "-",
+  MUL: "*",
+  DIV: "/",
+  MOD: "%",
+  EXP: "**",
+  BAND: "&",
+  BOR: "|",
+  BXOR: "^",
+  SHL: "<<",
+  SHR: ">>",
+  USHR: ">>>"
+};
+const CMP_SYMBOLS = {
+  LT: "<",
+  GT: ">",
+  LTE: "<=",
+  GTE: ">=",
+  EQ: "===",
+  NEQ: "!==",
+  LOOSE_EQ: "==",
+  LOOSE_NEQ: "!=",
+  IN: "in",
+  INSTANCEOF: "instanceof"
+};
+const UNARY_SYMBOLS = {
+  UNARY_NEG: "-",
+  UNARY_POS: "+",
+  UNARY_NOT: "!",
+  UNARY_BITNOT: "~"
+};
+
+// Extract every identifier-like label inside the leading "[...]" of an
+// annotation, in order, skipping pure numbers. Handles forms where the label
+// comes first (e.g. "[catch_4, 0]" or "[finally_1, 1, 2, finally_throw_3]").
+function extractBracketLabels(annotation) {
+  const stripped = annotation.replace(/\s+\d+:\d+-\d+:\d+\s*$/, "").trim();
+  const m = stripped.match(/\[([^\]]+)\]/);
+  if (!m) return [];
+  return m[1].split(",").map(s => s.trim()).filter(s => /^[a-zA-Z_]\w*$/.test(s));
+}
+
+// Extract trailing source location like "1:0-1:27" from an annotation
+function extractSourceLoc(annotation) {
+  const m = annotation.match(/(\d+:\d+-\d+:\d+)\s*$/);
+  return m ? m[1] : null;
+}
+
+// Extract value from annotation like 'reg[1] = "Hello"' or 'reg[1] = 42'
+function extractConstValue(annotation) {
+  const m = annotation.match(/=\s*(.+?)(?:\s+\d+:\d+-\d+:\d+)?$/);
+  return m ? m[1].trim() : null;
+}
+function disassembleInstr(instr) {
+  const {
+    raw,
+    opName,
+    annotation
+  } = instr;
+  const r = i => `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":
+      {
+        // raw: [constIdx, concealKey, srcReg]; annotation: name = reg[src]
+        const nameMatch = annotation.match(/^(.+?)\s*=\s*reg\[/);
+        const name = nameMatch ? `"${nameMatch[1].trim()}"` : `const[${raw[1]}]`;
+        return `global[${name}] = ${r(3)}`;
+      }
+    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 "EXP":
+    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 = [];
+        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 = [];
+        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.
+    // Emitted as plain call-expression statements (no braces) so the listing
+    // stays parseable as JavaScript for a flat, raw debugging view.
+    case "TRY_SETUP":
+      {
+        const catchLabel = extractBracketLabels(annotation)[0] ?? `pc_${raw[1]}`;
+        return `TrySetup(${catchLabel}, exReg=${r(2)})`;
+      }
+    case "TRY_END":
+      return `TryEnd()`;
+    case "FINALLY_SETUP":
+      {
+        const labels = extractBracketLabels(annotation);
+        const finallyLabel = labels[0] ?? `pc_${raw[1]}`;
+        const throwLabel = labels[1] ?? `pc_${raw[4]}`;
+        return `FinallySetup(${finallyLabel}, cont=${r(2)}, payload=${r(3)}, onThrow=${throwLabel})`;
+      }
+
+    // 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) {
+  const lines = parseBlock(commentBlock);
+
+  // First pass: map function-entry labels to their param/reg counts from MAKE_CLOSURE
+  const funcMeta = new Map();
+  for (const line of lines) {
+    if (line.kind === "instr" && line.instr?.opName === "MAKE_CLOSURE") {
+      const label = extractLabel(line.instr.annotation);
+      if (label) {
+        funcMeta.set(label, {
+          params: line.instr.raw[3],
+          regs: line.instr.raw[4]
+        });
+      }
+    }
+  }
+  let bodies = [];
+  let currentBody = [];
+  for (const line of lines) {
+    if (line.kind === "label") {
+      const meta = funcMeta.get(line.label);
+      const paramList = meta ? `(${Array.from({
+        length: meta.params
+      }, (_, i) => `r${i}`).join(", ")})` : "";
+      let newBody = [];
+      newBody.push(`// ${line.label}${paramList}:`);
+      bodies.push(newBody);
+      currentBody = newBody;
+    } else if (line.instr) {
+      const instrText = disassembleInstr(line.instr);
+      const loc = extractSourceLoc(line.instr.annotation);
+      const outputLine = loc ? `${instrText.padEnd(50)}  // ${loc}` : instrText;
+      currentBody.push(`  ${outputLine}`);
+    }
+  }
+  const out = bodies.flatMap(body => body);
+  return out.join("\n");
+}

package/dist/index.js

@@ -1,10 +1,15 @@
 import { compileAndSerialize } from "./compiler.js";
 import { DEFAULT_OPTIONS } from "./options.js";
+import { disassembleCommentBlock } from "./disassembler.js";
 async function obfuscate(source, options = DEFAULT_OPTIONS) {
-  const result = compileAndSerialize(source, options);
+  const result = await compileAndSerialize(source, options);
   return result;
 }
+async function disassemble(bytecodeComments) {
+  return disassembleCommentBlock(bytecodeComments);
+}
 export const JsConfuserVM = {
-  obfuscate
+  obfuscate,
+  disassemble
 };
 export default JsConfuserVM;