js-confuser-vm 0.1.1 → 0.1.2

package/jest.config.js

@@ -1,64 +0,0 @@
-const OPTIONS_MATRIX = [
-  { displayName: "default", VM_OPTIONS: {} },
-  { displayName: "randomizeOpcodes", VM_OPTIONS: { randomizeOpcodes: true } },
-  { displayName: "shuffleOpcodes", VM_OPTIONS: { shuffleOpcodes: true } },
-  { displayName: "encodeBytecode", VM_OPTIONS: { encodeBytecode: true } },
-  { displayName: "selfModifying", VM_OPTIONS: { selfModifying: true } },
-  { displayName: "timingChecks", VM_OPTIONS: { timingChecks: true } },
-  { displayName: "macroOpcodes", VM_OPTIONS: { macroOpcodes: true } },
-  {
-    displayName: "specializedOpcodes",
-    VM_OPTIONS: { specializedOpcodes: true },
-  },
-  {
-    displayName: "aliasedOpcodes",
-    VM_OPTIONS: { aliasedOpcodes: true },
-  },
-  {
-    displayName: "concealConstants",
-    VM_OPTIONS: { concealConstants: true },
-  },
-  {
-    displayName: "dispatcher",
-    VM_OPTIONS: { dispatcher: true },
-  },
-  {
-    displayName: "controlFlowFlattening",
-    VM_OPTIONS: { controlFlowFlattening: true },
-  },
-  {
-    displayName: "stringConcealing",
-    VM_OPTIONS: { stringConcealing: true },
-  },
-  {
-    displayName: "classObfuscation",
-    VM_OPTIONS: { classObfuscation: true },
-  },
-  {
-    displayName: "all",
-    VM_OPTIONS: {
-      randomizeOpcodes: true,
-      shuffleOpcodes: true,
-      encodeBytecode: true,
-      selfModifying: true,
-      timingChecks: true,
-      macroOpcodes: true,
-      specializedOpcodes: true,
-      aliasedOpcodes: true,
-      concealConstants: true,
-      dispatcher: true,
-      stringConcealing: true,
-      classObfuscation: true,
-    },
-  },
-];
-
-export default {
-  projects: OPTIONS_MATRIX.map(({ displayName, VM_OPTIONS }) => ({
-    displayName,
-    extensionsToTreatAsEsm: [".ts"],
-    moduleFileExtensions: ["ts", "js", "json"],
-    transform: { "\\.ts$": "./jest-strip-types.js" },
-    globals: { VM_OPTIONS },
-  })),
-};

package/output.disassembled.js

@@ -1,41 +0,0 @@
-// fn_0_0:
-  r1 = 969
-  r2 = r1
-// while_top_5:
-  r3 = 4439
-  r4 = r2 !== r3
-  if (!r4) goto: while_exit_6
-  r5 = 969
-  r6 = r2 === r5
-  if (!r6) goto: if_else_7
-  goto: cff_block_2
-// if_else_7:
-  r7 = 1317
-  r8 = r2 === r7
-  if (!r8) goto: if_else_8
-  goto: cff_block_3
-// if_else_8:
-  r9 = 58894
-  r10 = r2 === r9
-  if (!r10) goto: if_else_9
-  goto: if_else_1
-// if_else_9:
-  goto: while_top_5
-// while_exit_6:
-// cff_block_3:
-  r11 = "Hello World"
-  r0 = r11
-  r2 = 58894
-  goto: while_top_5
-// if_else_1:
-  r11 = undefined
-  return r11
-// cff_block_2:
-  r0 = undefined
-  r11 = true
-  if (r11) goto: cff_skip_10
-  r2 = 58894
-  goto: while_top_5
-// cff_skip_10:
-  r2 = 1317
-  goto: while_top_5

package/src/build-runtime.ts

@@ -1,113 +0,0 @@
-import { generate } from "@babel/generator";
-import { parse } from "@babel/parser";
-import type * as t from "@babel/types";
-import type { Options } from "./options.ts";
-import { applyMacroOpcodes } from "./transforms/runtime/macroOpcodes.ts";
-import { applyShuffleOpcodes } from "./transforms/runtime/shuffleOpcodes.ts";
-import { applyMinify } from "./transforms/runtime/minify.ts";
-import { Compiler } from "./compiler.ts";
-import { applySpecializedOpcodes } from "./transforms/runtime/specializedOpcodes.ts";
-import { applyAliasedOpcodes } from "./transforms/runtime/aliasedOpcodes.ts";
-import { applyClassObfuscation } from "./transforms/runtime/classObfuscation.ts";
-import type * as b from "./types.ts";
-import { getSwitchStatement } from "./utils/ast-utils.ts";
-import { now } from "./utils/profile-utils.ts";
-
-export async function buildRuntime(
-  runtime: string,
-  bytecode: b.Bytecode,
-  options: Options,
-  compiler: Compiler,
-  generateBytecodeComment: () => string,
-) {
-  let ast: t.File;
-  try {
-    ast = parse(runtime, { sourceType: "unambiguous" });
-  } catch (error) {
-    throw new Error("VM-Runtime final parsing failed", { cause: error });
-  }
-
-  const switchStatement = getSwitchStatement(ast);
-  const getHandlerCount = () => {
-    return switchStatement.cases.length;
-  };
-
-  const timings: { [name: string]: number } = {};
-  function runAndTime(pass: typeof applySpecializedOpcodes, name: string) {
-    const startedAt = now();
-
-    compiler.log(`Running runtime pass ${name}...`);
-
-    pass(ast, compiler);
-
-    const endedAt = now();
-    const elapsedMs = endedAt - startedAt;
-    timings[name] = elapsedMs;
-
-    compiler.profileData.transforms[name] = {
-      fileSize: null, // TODO: Add option as doing 'generate(ast).code.length' is slow
-      transformTime: elapsedMs,
-      handlerCount: getHandlerCount(),
-    };
-
-    compiler.log(
-      `Runtime pass ${name} completed in ${Math.floor(elapsedMs)}ms`,
-    );
-  }
-
-  // Specialized opcode cases must be applied BEFORE shuffleOpcodes
-  if (options.specializedOpcodes) {
-    runAndTime(applySpecializedOpcodes, "applySpecializedOpcodes");
-  }
-
-  // Macro opcode cases must be applied BEFORE shuffleOpcodes
-  if (options.macroOpcodes && Object.keys(compiler.MACRO_OPS).length > 0) {
-    runAndTime(applyMacroOpcodes, "applyMacroOpcodes");
-  }
-
-  // Aliased opcode cases must be applied BEFORE shuffleOpcodes
-  if (options.aliasedOpcodes) {
-    runAndTime(applyAliasedOpcodes, "applyAliasedOpcodes");
-  }
-
-  // Shuffle opcode handle order
-  if (options.shuffleOpcodes) {
-    runAndTime(applyShuffleOpcodes, "applyShuffleOpcodes");
-  }
-
-  // Shuffle top-level var declarations and prototype method definitions
-  if (options.classObfuscation) {
-    runAndTime(applyClassObfuscation, "applyClassObfuscation");
-  }
-
-  compiler.profileData.handlerCount = getHandlerCount();
-
-  let generated: string;
-  try {
-    generated = generate(ast).code;
-  } catch (error) {
-    throw new Error("VM-Runtime final generation failed", { cause: error });
-  }
-
-  // Add comment here for more accurate opcode names
-  generated = generateBytecodeComment() + "\n" + generated;
-
-  // Minify code?
-  if (options.minify) {
-    try {
-      let startedAt = now();
-      compiler.log("Running minify...");
-      generated = await applyMinify(generated);
-      let elapsedMs = now() - startedAt;
-      compiler.log(`Minify completed in ${Math.floor(elapsedMs)}ms`);
-
-      compiler.profileData.transforms["minify"] = {
-        transformTime: elapsedMs,
-      };
-    } catch (error) {
-      throw new Error("VM-Runtime final minification failed", { cause: error });
-    }
-  }
-
-  return generated;
-}