js-confuser-vm 0.1.0 → 0.1.2

package/dist/build-runtime.js

@@ -1,13 +1,14 @@
 import { generate } from "@babel/generator";
 import { parse } from "@babel/parser";
 import { applyMacroOpcodes } from "./transforms/runtime/macroOpcodes.js";
-import { applyMicroOpcodes } from "./transforms/runtime/microOpcodes.js";
-import { applyInteralVariablesToRuntime } from "./transforms/runtime/internalVariables.js";
 import { applyShuffleOpcodes } from "./transforms/runtime/shuffleOpcodes.js";
 import { applyMinify } from "./transforms/runtime/minify.js";
 import { applySpecializedOpcodes } from "./transforms/runtime/specializedOpcodes.js";
 import { applyAliasedOpcodes } from "./transforms/runtime/aliasedOpcodes.js";
-export async function obfuscateRuntime(runtime, bytecode, options, compiler, generateBytecodeComment) {
+import { applyClassObfuscation } from "./transforms/runtime/classObfuscation.js";
+import { getSwitchStatement } from "./utils/ast-utils.js";
+import { now } from "./utils/profile-utils.js";
+export async function buildRuntime(runtime, bytecode, options, compiler, generateBytecodeComment) {
   let ast;
   try {
     ast = parse(runtime, {
@@ -18,34 +19,52 @@ export async function obfuscateRuntime(runtime, bytecode, options, compiler, gen
       cause: error
     });
   }
+  const switchStatement = getSwitchStatement(ast);
+  const getHandlerCount = () => {
+    return switchStatement.cases.length;
+  };
+  const timings = {};
+  function runAndTime(pass, name) {
+    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) {
-    applySpecializedOpcodes(ast, compiler);
-  }
-  if (options.microOpcodes) {
-    applyInteralVariablesToRuntime(ast, compiler);
-  }
-
-  // Micro opcode cases must be applied BEFORE shuffleOpcodes
-  if (options.microOpcodes && Object.keys(compiler.MICRO_OPS).length > 0) {
-    applyMicroOpcodes(ast, compiler);
+    runAndTime(applySpecializedOpcodes, "applySpecializedOpcodes");
   }
 
   // Macro opcode cases must be applied BEFORE shuffleOpcodes
   if (options.macroOpcodes && Object.keys(compiler.MACRO_OPS).length > 0) {
-    applyMacroOpcodes(ast, compiler);
+    runAndTime(applyMacroOpcodes, "applyMacroOpcodes");
   }
 
   // Aliased opcode cases must be applied BEFORE shuffleOpcodes
   if (options.aliasedOpcodes) {
-    applyAliasedOpcodes(ast, compiler);
+    runAndTime(applyAliasedOpcodes, "applyAliasedOpcodes");
   }
 
   // Shuffle opcode handle order
   if (options.shuffleOpcodes) {
-    applyShuffleOpcodes(ast);
+    runAndTime(applyShuffleOpcodes, "applyShuffleOpcodes");
+  }
+
+  // Shuffle top-level var declarations and prototype method definitions
+  if (options.classObfuscation) {
+    runAndTime(applyClassObfuscation, "applyClassObfuscation");
   }
+  compiler.profileData.handlerCount = getHandlerCount();
   let generated;
   try {
     generated = generate(ast).code;
@@ -61,7 +80,14 @@ export async function obfuscateRuntime(runtime, bytecode, options, compiler, gen
   // 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