js-confuser-vm 0.1.0 → 0.1.2

package/babel-plugin-inline-runtime.cjs

@@ -1,34 +0,0 @@
-const { readFileSync } = require("fs");
-const { join } = require("path");
-const babel = require("@babel/core");
-const { stripTypeScriptTypes } = require("node:module");
-
-module.exports = function inlineRuntimePlugin({ types: t }) {
-  const rawContent = readFileSync(join(__dirname, "./src/runtime.ts"), "utf-8");
-
-  const runtimeContent = stripTypeScriptTypes(rawContent);
-
-  return {
-    name: "inline-runtime",
-    visitor: {
-      VariableDeclarator(path) {
-        if (
-          path.node.id?.name === "readVMRuntimeFile" &&
-          (path.node.init?.type === "ArrowFunctionExpression" ||
-            path.node.init?.type === "FunctionExpression")
-        ) {
-          path.node.init = t.arrowFunctionExpression(
-            [],
-            t.stringLiteral(runtimeContent),
-          );
-        }
-      },
-      ImportDeclaration(path) {
-        const src = path.node.source.value;
-        if (src === "fs" || src === "path") {
-          path.remove();
-        }
-      },
-    },
-  };
-};

package/babel.config.json

@@ -1,23 +0,0 @@
-{
-  "presets": [
-    [
-      "@babel/preset-env",
-      {
-        "targets": {
-          "node": "18"
-        },
-        "modules": false
-      }
-    ],
-    ["@babel/preset-typescript"]
-  ],
-  "plugins": [
-    "./babel-plugin-inline-runtime.cjs",
-    [
-      "replace-import-extension",
-      {
-        "extMapping": { ".ts": ".js" }
-      }
-    ]
-  ]
-}

package/index.ts

@@ -1,38 +0,0 @@
-import JsConfuserVM from "./src/index.ts";
-import { readFileSync, writeFileSync } from "fs";
-
-async function main() {
-  // Compile and write the output to a file
-  const sourceCode = readFileSync("input.js", "utf-8");
-
-  const { code: orginalOutput } = await JsConfuserVM.obfuscate(sourceCode, {});
-
-  const { code: output } = await JsConfuserVM.obfuscate(sourceCode, {
-    target: "browser", // or "node"
-    randomizeOpcodes: true, // randomize the opcode numbers?
-    shuffleOpcodes: true, // shuffle order of opcode handlers in the runtime?
-    encodeBytecode: true, // encode the bytecode array?
-    concealConstants: true, // conceal strings and integers in the constant pool?
-    dispatcher: true, // create middleman blocks to process jumps?
-    selfModifying: true, // do self-modifying bytecode for function bodies?
-    macroOpcodes: true, // create combined opcodes for repeated instruction sequences?
-    microOpcodes: true, // break opcodes into sub-opcodes?
-    specializedOpcodes: true, // create specialized opcodes for commonly used opcode+operand pairs?
-    aliasedOpcodes: true, // create duplicate opcodes for commonly used opcodes?
-    timingChecks: true, // add timing checks to detect debuggers?
-    minify: true, // pass final output through Google Closure Compiler? (Renames VM class properties)
-  });
-
-  writeFileSync("output.original.js", orginalOutput, "utf-8");
-  writeFileSync("output.js", output, "utf-8");
-
-  // Eval the code like our test suite does
-  var window = { TEST_OUTPUT: null };
-  eval(output);
-  console.log(window.TEST_OUTPUT);
-
-  // Minify using Google Closure Compiler (optional)
-  // import("./minify.js");
-}
-
-main();

package/jest-strip-types.js

@@ -1,10 +0,0 @@
-import { stripTypeScriptTypes } from 'node:module';
-
-export default {
-  process(code, filePath) {
-    if (filePath.endsWith('.ts')) {
-      return { code: stripTypeScriptTypes(code) };
-    }
-    return { code };
-  },
-};

package/jest.config.js

@@ -1,52 +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: "microOpcodes", VM_OPTIONS: { microOpcodes: 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: "all",
-    VM_OPTIONS: {
-      randomizeOpcodes: true,
-      shuffleOpcodes: true,
-      encodeBytecode: true,
-      selfModifying: true,
-      timingChecks: true,
-      macroOpcodes: true,
-      microOpcodes: true,
-      specializedOpcodes: true,
-      aliasedOpcodes: true,
-      concealConstants: true,
-      dispatcher: 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/src/build-runtime.ts

@@ -1,78 +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 { applyMicroOpcodes } from "./transforms/runtime/microOpcodes.ts";
-import { applyInteralVariablesToRuntime } from "./transforms/runtime/internalVariables.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 type * as b from "./types.ts";
-
-export async function obfuscateRuntime(
-  runtime: string,
-  bytecode: b.Bytecode,
-  options: Options,
-  compiler: Compiler,
-  generateBytecodeComment,
-) {
-  let ast: t.File;
-  try {
-    ast = parse(runtime, { sourceType: "unambiguous" });
-  } catch (error) {
-    throw new Error("VM-Runtime final parsing failed", { cause: error });
-  }
-
-  // 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);
-  }
-
-  // Macro opcode cases must be applied BEFORE shuffleOpcodes
-  if (options.macroOpcodes && Object.keys(compiler.MACRO_OPS).length > 0) {
-    applyMacroOpcodes(ast, compiler);
-  }
-
-  // Aliased opcode cases must be applied BEFORE shuffleOpcodes
-  if (options.aliasedOpcodes) {
-    applyAliasedOpcodes(ast, compiler);
-  }
-
-  // Shuffle opcode handle order
-  if (options.shuffleOpcodes) {
-    applyShuffleOpcodes(ast);
-  }
-
-  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 {
-      generated = await applyMinify(generated);
-    } catch (error) {
-      throw new Error("VM-Runtime final minification failed", { cause: error });
-    }
-  }
-
-  return generated;
-}