js-confuser 1.7.2 → 2.0.0-alpha.0

package/src/utils/gen-utils.ts

@@ -0,0 +1,48 @@
+import { reservedKeywords } from "../constants";
+import { shuffle } from "./random-utils";
+
+export function alphabeticalGenerator(index: number) {
+  let name = "";
+  while (index > 0) {
+    var t = (index - 1) % 52;
+    var thisChar =
+      t >= 26 ? String.fromCharCode(65 + t - 26) : String.fromCharCode(97 + t);
+    name = thisChar + name;
+    index = ((index - t) / 52) | 0;
+  }
+  if (!name) {
+    name = "_";
+  }
+  return name;
+}
+
+export function createZeroWidthGenerator() {
+  var maxSize = 0;
+  var currentKeyWordsArray: string[] = [];
+
+  function generateArray() {
+    var result = reservedKeywords
+      .map(
+        (keyWord) =>
+          keyWord + "\u200C".repeat(Math.max(maxSize - keyWord.length, 1))
+      )
+      .filter((craftedVariableName) => craftedVariableName.length == maxSize);
+
+    if (!result.length) {
+      ++maxSize;
+      return generateArray();
+    }
+
+    return shuffle(result);
+  }
+
+  function getNextVariable(): string {
+    if (!currentKeyWordsArray.length) {
+      ++maxSize;
+      currentKeyWordsArray = generateArray();
+    }
+    return currentKeyWordsArray.pop();
+  }
+
+  return { generate: getNextVariable };
+}

package/src/utils/node.ts

@@ -0,0 +1,78 @@
+import * as t from "@babel/types";
+import { ok } from "assert";
+
+export type LiteralValue = string | number | boolean | undefined | null;
+export const createLiteral = (value: LiteralValue) => {
+  if (value === null) return t.nullLiteral();
+  if (value === undefined) return t.identifier("undefined");
+
+  switch (typeof value) {
+    case "string":
+      return t.stringLiteral(value);
+
+    case "number":
+      return numericLiteral(value);
+
+    case "boolean":
+      return t.booleanLiteral(value);
+  }
+
+  ok(false);
+};
+
+/**
+ * Handles both positive and negative numeric literals
+ * @param value
+ * @returns
+ */
+export function numericLiteral(
+  value: number
+): t.NumericLiteral | t.UnaryExpression {
+  ok(typeof value === "number");
+
+  if (value < 0) {
+    return t.unaryExpression("-", t.numericLiteral(-value));
+  }
+  return t.numericLiteral(value);
+}
+
+export function deepClone(node: t.Node | t.Node[]) {
+  function deepClone(obj) {
+    // Handle non-objects like null, undefined, primitive values, or functions
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+
+    // Handle Date
+    if (obj instanceof Date) {
+      return new Date(obj);
+    }
+
+    // Handle Array
+    if (Array.isArray(obj)) {
+      return obj.map(deepClone);
+    }
+
+    // Handle Objects
+    const clonedObj = {};
+
+    // Handle string and symbol property keys
+
+    Object.getOwnPropertyNames(obj).forEach((key) => {
+      const value = obj[key];
+      clonedObj[key] = deepClone(value);
+    });
+
+    // Copy simple symbols (Avoid objects = infinite recursion)
+    Object.getOwnPropertySymbols(obj).forEach((symbol) => {
+      const value = obj[symbol];
+      if (typeof value !== "object") {
+        clonedObj[symbol] = deepClone(value);
+      }
+    });
+
+    return clonedObj;
+  }
+
+  return deepClone(node);
+}

package/src/utils/object-utils.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates an object from the given keys and values arrays.
+ * @param keys
+ * @param values
+ */
+export function createObject<T>(
+  keys: string[],
+  values: T[]
+): { [key: string]: T } {
+  if (keys.length !== values.length) {
+    throw new Error("length mismatch");
+  }
+
+  var newObject = {};
+
+  keys.forEach((x, i) => {
+    newObject[x] = values[i];
+  });
+
+  return newObject;
+}

package/src/utils/random-utils.ts

@@ -0,0 +1,79 @@
+import { ok } from "assert";
+
+/**
+ * Returns a random element from the given array
+ * @param choices Array of items
+ * @returns One of the items in the array at random
+ */
+export function choice<T>(choices: T[]): T {
+  var index = Math.floor(Math.random() * choices.length);
+  return choices[index];
+}
+
+/**
+ * Returns a true/false based on the percent chance (0%-100%)
+ * @param percentChance AS A PERCENTAGE 0 - 100%
+ */
+export function chance(percentChance: number): boolean {
+  return Math.random() < percentChance / 100;
+}
+
+/**
+ * **Mutates the given array**
+ * @param array
+ */
+export function shuffle<T>(array: T[]): T[] {
+  array.sort(() => Math.random() - 0.5);
+  return array;
+}
+
+/**
+ * Returns a random hexadecimal string.
+ *
+ * @example getRandomHexString(6) => "CA96BF"
+ * @param length
+ * @returns
+ */
+export function getRandomHexString(length: number) {
+  return [...Array(length)]
+    .map(() => Math.floor(Math.random() * 16).toString(16))
+    .join("")
+    .toUpperCase();
+}
+
+/**
+ * Returns a random string.
+ */
+export function getRandomString(length: number) {
+  var result = "";
+  var characters =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  var charactersLength = characters.length;
+  for (var i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+
+export function getRandom(min: number, max: number) {
+  return Math.random() * (max - min) + min;
+}
+
+export function getRandomInteger(min: number, max: number) {
+  return Math.floor(getRandom(min, max));
+}
+
+export function splitIntoChunks(str: string, size: number) {
+  ok(typeof str === "string", "str must be typeof string");
+  ok(typeof size === "number", "size must be typeof number");
+  ok(Math.floor(size) === size, "size must be integer");
+
+  const numChunks = Math.ceil(str.length / size);
+  const chunks: string[] = new Array(numChunks);
+
+  for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
+    chunks[i] = str.substr(o, size);
+  }
+
+  return chunks;
+}

package/src/utils/static-utils.ts

@@ -0,0 +1,66 @@
+import * as t from "@babel/types";
+
+// Function to check if a node is a static value
+export function isStaticValue(node: t.Node): boolean {
+  // Check for literals which are considered static
+  if (
+    t.isStringLiteral(node) ||
+    t.isNumericLiteral(node) ||
+    t.isBooleanLiteral(node) ||
+    t.isNullLiteral(node)
+  ) {
+    if (t.isDirectiveLiteral(node)) return false;
+
+    return true;
+  }
+
+  // Handle unary expressions like -42
+  if (t.isUnaryExpression(node)) {
+    // Only consider certain operators as static (e.g., -, +)
+    if (["-", "+", "!", "~", "void"].includes(node.operator)) {
+      return isStaticValue(node.argument);
+    }
+    return false;
+  }
+
+  // Handle binary expressions with static values only
+  if (t.isBinaryExpression(node)) {
+    return isStaticValue(node.left) && isStaticValue(node.right);
+  }
+
+  // Handle logical expressions (&&, ||) with static values only
+  if (t.isLogicalExpression(node)) {
+    return isStaticValue(node.left) && isStaticValue(node.right);
+  }
+
+  // Handle conditional (ternary) expressions with static values
+  if (t.isConditionalExpression(node)) {
+    return (
+      isStaticValue(node.test) &&
+      isStaticValue(node.consequent) &&
+      isStaticValue(node.alternate)
+    );
+  }
+
+  // Handle array expressions where all elements are static
+  if (t.isArrayExpression(node)) {
+    return node.elements.every(
+      (element) => element !== null && isStaticValue(element)
+    );
+  }
+
+  // Handle object expressions where all properties are static
+  if (t.isObjectExpression(node)) {
+    return node.properties.every((prop) => {
+      if (t.isObjectProperty(prop)) {
+        return isStaticValue(prop.key) && isStaticValue(prop.value);
+      } else if (t.isSpreadElement(prop)) {
+        return isStaticValue(prop.argument);
+      }
+      return false;
+    });
+  }
+
+  // Add more cases as needed, depending on what you consider "static"
+  return false;
+}

package/src/validateOptions.ts

@@ -0,0 +1,256 @@
+import { ok } from "assert";
+import { ObfuscateOptions } from "./options";
+import presets from "./presets";
+
+const validProperties = new Set([
+  "preset",
+  "target",
+  "indent",
+  "compact",
+  "hexadecimalNumbers",
+  "minify",
+  "es5",
+  "renameVariables",
+  "renameGlobals",
+  "renameLabels",
+  "identifierGenerator",
+  "controlFlowFlattening",
+  "globalConcealing",
+  "stringCompression",
+  "stringConcealing",
+  "stringEncoding",
+  "stringSplitting",
+  "duplicateLiteralsRemoval",
+  "dispatcher",
+  "rgf",
+  "objectExtraction",
+  "flatten",
+  "deadCode",
+  "calculator",
+  "lock",
+  "movedDeclarations",
+  "opaquePredicates",
+  "shuffle",
+  "variableMasking",
+  "verbose",
+  "globalVariables",
+  "debugComments",
+  "preserveFunctionLength",
+  "astScrambler",
+  "customStringEncodings",
+  "functionOutlining",
+  "pack",
+]);
+
+const validLockProperties = new Set([
+  "selfDefending",
+  "antiDebug",
+  "tamperProtection",
+  "startDate",
+  "endDate",
+  "domainLock",
+  "integrity",
+  "countermeasures",
+  "customLocks",
+]);
+
+export function validateOptions(options: ObfuscateOptions) {
+  if (!options || Object.keys(options).length <= 1) {
+    /**
+     * Give a welcoming introduction to those who skipped the documentation.
+     */
+    var line = `You provided zero obfuscation options. By default everything is disabled.\nYou can use a preset with:\n\n> {target: '${
+      options.target || "node"
+    }', preset: 'high' | 'medium' | 'low'}.\n\n\nView all settings here:\nhttps://github.com/MichaelXF/js-confuser#options`;
+    throw new Error(
+      `\n\n` +
+        line
+          .split("\n")
+          .map((x) => `\t${x}`)
+          .join("\n") +
+        `\n\n`
+    );
+  }
+
+  ok(options, "options cannot be null");
+  ok(
+    options.target,
+    "Missing options.target option (required, must one the following: 'browser' or 'node')"
+  );
+
+  ok(
+    ["browser", "node"].includes(options.target),
+    `'${options.target}' is not a valid target mode`
+  );
+
+  Object.keys(options).forEach((key) => {
+    if (!validProperties.has(key)) {
+      throw new TypeError("Invalid option: '" + key + "'");
+    }
+  });
+
+  if (options.lock) {
+    ok(typeof options.lock === "object", "options.lock must be an object");
+    Object.keys(options.lock).forEach((key) => {
+      if (!validLockProperties.has(key)) {
+        throw new TypeError("Invalid lock option: '" + key + "'");
+      }
+    });
+
+    // Validate domain-lock option
+    if (
+      options.lock.domainLock &&
+      typeof options.lock.domainLock !== "undefined"
+    ) {
+      ok(Array.isArray(options.lock.domainLock), "domainLock must be an array");
+    }
+
+    // Validate start-date option
+    if (
+      typeof options.lock.startDate !== "undefined" &&
+      options.lock.startDate
+    ) {
+      ok(
+        typeof options.lock.startDate === "number" ||
+          options.lock.startDate instanceof Date,
+        "startDate must be Date object or number"
+      );
+    }
+
+    // Validate end-date option
+    if (typeof options.lock.endDate !== "undefined" && options.lock.endDate) {
+      ok(
+        typeof options.lock.endDate === "number" ||
+          options.lock.endDate instanceof Date,
+        "endDate must be Date object or number"
+      );
+    }
+  }
+
+  if (options.preset) {
+    if (!presets[options.preset]) {
+      throw new TypeError("Unknown preset of '" + options.preset + "'");
+    }
+  }
+}
+
+/**
+ * Sets the default values and validates the configuration.
+ */
+export function applyDefaultsToOptions(
+  options: ObfuscateOptions
+): ObfuscateOptions {
+  if (options.preset) {
+    // Clone and allow overriding
+    options = Object.assign({}, presets[options.preset], options);
+  }
+
+  if (!options.hasOwnProperty("compact")) {
+    options.compact = true; // Compact is on by default
+  }
+  if (!options.hasOwnProperty("renameGlobals")) {
+    options.renameGlobals = true; // RenameGlobals is on by default
+  }
+  if (!options.hasOwnProperty("preserveFunctionLength")) {
+    options.preserveFunctionLength = true; // preserveFunctionLength is on by default
+  }
+  if (!options.hasOwnProperty("renameLabels")) {
+    options.renameLabels = true; // RenameLabels is on by default
+  }
+
+  if (options.globalVariables && !(options.globalVariables instanceof Set)) {
+    options.globalVariables = new Set(Object.keys(options.globalVariables));
+  }
+
+  if (options.lock) {
+    ok(typeof options.lock === "object", "options.lock must be an object");
+
+    if (options.lock.selfDefending) {
+      options.compact = true; // self defending forcibly enables this
+    }
+
+    if (!options.lock.customLocks) {
+      options.lock.customLocks = [];
+    }
+
+    // Convert 'startDate' and 'endDate' to Dates
+    if (typeof options.lock.startDate === "number") {
+      options.lock.startDate = new Date(options.lock.startDate);
+    }
+
+    if (typeof options.lock.endDate === "number") {
+      options.lock.endDate = new Date(options.lock.endDate);
+    }
+  }
+
+  // options.globalVariables outlines generic globals that should be present in the execution context
+  if (!options.hasOwnProperty("globalVariables")) {
+    options.globalVariables = new Set([]);
+
+    if (options.target == "browser") {
+      // browser
+      [
+        "window",
+        "document",
+        "postMessage",
+        "alert",
+        "confirm",
+        "location",
+        "btoa",
+        "atob",
+        "unescape",
+        "encodeURIComponent",
+      ].forEach((x) => options.globalVariables.add(x));
+    } else {
+      // node
+      [
+        "global",
+        "Buffer",
+        "require",
+        "process",
+        "exports",
+        "module",
+        "__dirname",
+        "__filename",
+      ].forEach((x) => options.globalVariables.add(x));
+    }
+
+    [
+      "globalThis",
+      "console",
+      "parseInt",
+      "parseFloat",
+      "Math",
+      "JSON",
+      "RegExp",
+      "Promise",
+      "String",
+      "Boolean",
+      "Function",
+      "Object",
+      "Array",
+      "Proxy",
+      "Error",
+      "TypeError",
+      "ReferenceError",
+      "RangeError",
+      "EvalError",
+      "setTimeout",
+      "clearTimeout",
+      "setInterval",
+      "clearInterval",
+      "setImmediate",
+      "clearImmediate",
+      "queueMicrotask",
+      "isNaN",
+      "isFinite",
+      "Set",
+      "Map",
+      "WeakSet",
+      "WeakMap",
+      "Symbol",
+    ].forEach((x) => options.globalVariables.add(x));
+  }
+
+  return options;
+}

package/tsconfig.json

@@ -1,9 +1,14 @@
 {
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ES6",
-        "noUnusedParameters": false,
-        "strict": false,
-        "noImplicitAny": false,
-    }
-}
+  "compilerOptions": {
+    "module": "esnext",
+    "target": "es6",
+    "strict": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "skipLibCheck": true,
+    "noImplicitAny": false,
+    "strictNullChecks": false
+  },
+  "include": ["src/**/*"]
+}

package/babel.config.js

@@ -1,12 +0,0 @@
-// babel.config.js
-// Jest uses this & for building
-module.exports = {
-  presets: [
-    ["@babel/preset-env", { targets: "defaults, not ie 11, not ie_mob 11" }],
-    "@babel/preset-typescript",
-  ],
-  plugins: [
-    "@babel/plugin-proposal-class-properties",
-    "@babel/plugin-proposal-optional-chaining",
-  ],
-};

package/dev.js

@@ -1,8 +0,0 @@
-require("@babel/register")({
-  presets: ["@babel/preset-typescript"],
-  extensions: [".js", ".ts"],
-  cache: true,
-  retainLines: true,
-});
-
-module.exports = require("./dev.ts");

package/dist/compiler.js

@@ -1,34 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.compileJsSync = compileJsSync;
-exports.default = compileJs;
-const escodegen = require("escodegen");
-async function compileJs(tree, options) {
-  return compileJsSync(tree, options);
-}
-function compileJsSync(tree, options) {
-  var api = {
-    format: {
-      ...escodegen.FORMAT_MINIFY
-    }
-  };
-  if (!options.compact) {
-    api = {};
-    if (options.indent && options.indent != 4) {
-      api.format = {};
-      api.format.indent = {
-        style: {
-          2: "  ",
-          tabs: "\t"
-        }[options.indent] || "    "
-      };
-    }
-  }
-  if (options.debugComments) {
-    api.comment = true;
-  }
-  return escodegen.generate(tree, api);
-}

package/dist/parser.js

@@ -1,59 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = parseJS;
-exports.parseSnippet = parseSnippet;
-exports.parseSync = parseSync;
-var assert = _interopRequireWildcard(require("assert"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const acorn = require("acorn");
-
-/**
- * Uses `acorn` to parse Javascript Code. Returns an AST tree.
- * @param code
- * @returns
- */
-async function parseJS(code) {
-  assert.ok(typeof code === "string", "code must be a string");
-  try {
-    var parsed = parseSync(code);
-    return parsed;
-  } catch (e) {
-    throw e;
-  }
-}
-
-/**
- * Parses a snippet code. Returns an AST Tree.
- * @param code
- * @returns
- */
-function parseSnippet(code) {
-  return acorn.parse(code, {
-    ecmaVersion: "latest",
-    allowReturnOutsideFunction: true,
-    sourceType: "module"
-  });
-}
-
-/**
- * Parses synchronously. Attempts to parse as a es-module, then fallbacks to a script.
- * @param code
- * @returns
- */
-function parseSync(code) {
-  try {
-    return acorn.parse(code, {
-      ecmaVersion: "latest",
-      sourceType: "module"
-    });
-  } catch (e) {
-    return acorn.parse(code, {
-      ecmaVersion: "latest",
-      sourceType: "script"
-    });
-  }
-}