js-confuser 1.5.8 → 1.6.0

package/dist/traverse.js

@@ -3,13 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.assertNoCircular = assertNoCircular;
 exports.default = traverse;
 exports.getBlock = getBlock;
 exports.isBlock = isBlock;
 exports.walk = walk;
 
-var _identifiers = require("./util/identifiers");
-
 /**
  * A block refers to any object that has a **`.body`** property where code is nested.
  *
@@ -40,21 +39,11 @@ function isBlock(object) {
 }
 
 function walk(object, parents, onEnter) {
-  let seen = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Set();
-
   if (typeof object === "object" && object) {
-    if (seen.has(object)) {
-      console.log(object);
-      throw new Error("Already seen: " + object.type);
-    }
-
-    seen.add(object);
-    var newParents = [object, ...parents];
-
-    if (!Array.isArray(object)) {
-      (0, _identifiers.validateChain)(object, parents);
-    } // 1. Call `onEnter` function and remember any onExit callback returned
-
+    var newParents = [object, ...parents]; // if (!Array.isArray(object)) {
+    //   validateChain(object, parents);
+    // }
+    // 1. Call `onEnter` function and remember any onExit callback returned
 
     var onExit = onEnter(object, parents); // 2. Traverse children
 
@@ -66,8 +55,6 @@ function walk(object, parents, onEnter) {
           return "EXIT";
         }
       }
-
-      copy.forEach(x => {});
     } else {
       var keys = Object.keys(object);
 
@@ -108,4 +95,23 @@ function walk(object, parents, onEnter) {
 
 function traverse(tree, onEnter) {
   walk(tree, [], onEnter);
+}
+/**
+ * This is debugging function used to test for circular references.
+ */
+
+
+function assertNoCircular(object) {
+  var seen = new Set();
+  traverse(object, (node, nodeParents) => {
+    if (node && typeof node === "object") {
+      if (seen.has(node)) {
+        console.log(nodeParents);
+        console.log(node);
+        throw new Error("FOUND CIRCULAR REFERENCE");
+      }
+
+      seen.add(node);
+    }
+  });
 }

package/dist/util/compare.js

@@ -59,8 +59,8 @@ function isValidIdentifier(name) {
     return false;
   }
 
-  var x = name.match(/^[A-z$_][A-z0-9$_]*/);
-  return x && x[0] == name;
+  var x = name.match(/^[A-Za-z$_][A-Za-z0-9$_]*/);
+  return !!(x && x[0] == name);
 }
 
 function isInsideType(type, object, parents) {

package/dist/util/gen.js

@@ -15,6 +15,7 @@ exports.BreakStatement = BreakStatement;
 exports.CallExpression = CallExpression;
 exports.CatchClause = CatchClause;
 exports.ClassDeclaration = ClassDeclaration;
+exports.ClassExpression = ClassExpression;
 exports.ConditionalExpression = ConditionalExpression;
 exports.DebuggerStatement = DebuggerStatement;
 exports.ExpressionStatement = ExpressionStatement;
@@ -537,6 +538,20 @@ function ClassDeclaration(id) {
   };
 }
 
+function ClassExpression(id) {
+  let superClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  let body = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  return {
+    type: "ClassExpression",
+    id: id,
+    superClass: superClass,
+    body: {
+      type: "ClassBody",
+      body: body
+    }
+  };
+}
+
 function ThrowStatement(argument) {
   return {
     type: "ThrowStatement",

package/dist/util/insert.js

@@ -139,8 +139,12 @@ function getDefiningContext(o, p) {
     var variableDeclaration = p.find(x => x.type == "VariableDeclaration");
     (0, _assert.ok)(variableDeclaration);
 
-    if (variableDeclaration.kind === "let") {
-      return getLexContext(o, p);
+    if (variableDeclaration.kind === "let" || variableDeclaration.kind === "const") {
+      var context = getVarContext(o, p);
+
+      if (context && context.type === "Program") {
+        return getLexContext(o, p);
+      }
     }
   }
 
@@ -287,17 +291,33 @@ function prepend(block) {
   }
 
   if (block.type == "Program") {
-    var decs = 0;
+    var moveBy = 0;
     block.body.forEach((stmt, i) => {
       if (stmt.type == "ImportDeclaration") {
-        if (decs == i) {
-          decs++;
+        if (moveBy == i) {
+          moveBy++;
+        }
+      }
+
+      if (stmt.type === "ExpressionStatement" && typeof stmt.directive === "string") {
+        if (moveBy == i) {
+          moveBy++;
         }
       }
     });
-    block.body.splice(decs, 0, ...nodes);
+    block.body.splice(moveBy, 0, ...nodes);
+  } else if (block.type === "SwitchCase") {
+    block.consequent.unshift(...nodes);
   } else {
-    getBlockBody(block).unshift(...nodes);
+    var bodyArray = getBlockBody(block); // Check for 'use strict'
+
+    if (bodyArray[0] && bodyArray[0].directive) {
+      // Insert under 'use strict' directive
+      bodyArray.splice(1, 0, ...nodes);
+    } else {
+      // Prepend at the top of the block
+      bodyArray.unshift(...nodes);
+    }
   }
 }
 
@@ -351,6 +371,10 @@ function isForInitialize(o, p) {
   (0, _identifiers.validateChain)(o, p);
   var forIndex = p.findIndex(x => x.type == "ForStatement" || x.type == "ForInStatement" || x.type == "ForOfStatement");
 
+  if (p.slice(0, forIndex).find(x => ["ArrowFunctionExpression", "BlockStatement"].includes(x.type))) {
+    return false;
+  }
+
   if (forIndex !== -1) {
     if (p[forIndex].type == "ForStatement") {
       if (p[forIndex].init == (p[forIndex - 1] || o)) {

package/dist/util/random.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.alphabeticalGenerator = alphabeticalGenerator;
+exports.chance = chance;
 exports.choice = choice;
 exports.getRandom = getRandom;
 exports.getRandomFalseExpression = getRandomFalseExpression;
@@ -17,10 +18,24 @@ var _assert = require("assert");
 
 var _gen = require("./gen");
 
+/**
+ * Returns a random element from the given array
+ * @param choices Array of items
+ * @returns One of the items in the array at random
+ */
 function choice(choices) {
   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%
+ */
+
+
+function chance(percentChance) {
+  return Math.random() < percentChance / 100;
+}
 /**
  * **Mutates the given array**
  * @param array

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "js-confuser",
-  "version": "1.5.8",
+  "version": "1.6.0",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",
   "scripts": {
     "dev": "node ./dev.js",
     "build": "./node_modules/.bin/babel src --out-dir dist --copy-files --extensions \".ts\"",
-    "test": "jest",
+    "test": "jest --forceExit",
     "test:coverage": "jest --coverage",
-    "prepublishOnly": "npm run build & npm run test"
+    "prepublishOnly": "npm run build & npm run test --forceExit"
   },
   "keywords": [
     "obfuscator",
@@ -36,7 +36,7 @@
     "@types/jest": "^26.0.24",
     "@types/node": "^15.14.9",
     "babel-jest": "^26.6.3",
-    "jest": "^26.6.3"
+    "jest": "^29.5.0"
   },
   "repository": {
     "type": "git",
@@ -45,7 +45,7 @@
   "bugs": {
     "url": "https://github.com/MichaelXF/js-confuser/issues"
   },
-  "homepage": "https://master--hungry-shannon-c1ce6b.netlify.app/",
+  "homepage": "https://js-confuser.com",
   "jest": {
     "coverageReporters": [
       "html"

package/src/index.ts

@@ -85,8 +85,8 @@ var JsConfuser: IJsConfuser = async function (
   return result;
 } as any;
 
-export var debugTransformations: IJsConfuserDebugTransformations =
-  async function debugTransformations(
+export const debugTransformations: IJsConfuserDebugTransformations =
+  async function (
     code: string,
     options: ObfuscateOptions
   ): Promise<{ name: string; code: string; ms: number }[]> {
@@ -115,28 +115,66 @@ export var debugTransformations: IJsConfuserDebugTransformations =
     return frames;
   };
 
-export var debugObfuscation: IJsConfuserDebugObfuscation =
-  async function debugTransformations(
-    code: string,
-    options: ObfuscateOptions,
-    callback: (name: string, complete: number, totalTransforms: number) => void
-  ): Promise<string> {
-    validateOptions(options);
-    options = await correctOptions(options);
+/**
+ * This method is used by the obfuscator website to display a progress bar and additional information
+ * about the obfuscation.
+ *
+ * @param code - Source code to obfuscate
+ * @param options - Options
+ * @param callback - Progress callback, called after each transformation
+ * @returns
+ */
+export const debugObfuscation: IJsConfuserDebugObfuscation = async function (
+  code: string,
+  options: ObfuscateOptions,
+  callback: (name: string, complete: number, totalTransforms: number) => void,
+  performance: Performance
+) {
+  const startTime = performance.now();
 
-    var tree = parseSync(code);
-    var obfuscator = new Obfuscator(options);
-    var totalTransforms = obfuscator.array.length;
+  validateOptions(options);
+  options = await correctOptions(options);
 
-    obfuscator.on("debug", (name: string, tree: Node, i: number) => {
-      callback(name, i, totalTransforms);
-    });
+  const beforeParseTime = performance.now();
 
-    await obfuscator.apply(tree, true);
+  var tree = parseSync(code);
+
+  const parseTime = performance.now() - beforeParseTime;
+
+  var obfuscator = new Obfuscator(options);
+  var totalTransforms = obfuscator.array.length;
+
+  var transformationTimes = Object.create(null);
+  var currentTransformTime = performance.now();
+
+  obfuscator.on("debug", (name: string, tree: Node, i: number) => {
+    var nowTime = performance.now();
+    transformationTimes[name] = nowTime - currentTransformTime;
+    currentTransformTime = nowTime;
+
+    callback(name, i, totalTransforms);
+  });
+
+  await obfuscator.apply(tree, true);
+
+  const beforeCompileTime = performance.now();
+
+  var output = await compileJs(tree, options);
+
+  const compileTime = performance.now() - beforeCompileTime;
+
+  const endTime = performance.now();
 
-    var output = compileJs(tree, options);
-    return output;
+  return {
+    obfuscated: output,
+    transformationTimes: transformationTimes,
+    obfuscationTime: endTime - startTime,
+    parseTime: parseTime,
+    compileTime: compileTime,
+    totalTransforms: totalTransforms,
+    totalPossibleTransforms: obfuscator.totalPossibleTransforms,
   };
+};
 
 JsConfuser.obfuscate = obfuscate;
 JsConfuser.obfuscateAST = obfuscateAST;

package/src/obfuscator.ts

@@ -7,7 +7,7 @@ import { ProbabilityMap, isProbabilityMapProbable } from "./probability";
 
 import Transform from "./transforms/transform";
 
-import Preparation from "./transforms/preparation/preparation";
+import Preparation from "./transforms/preparation";
 import ObjectExtraction from "./transforms/extraction/objectExtraction";
 import Lock from "./transforms/lock/lock";
 import Dispatcher from "./transforms/dispatcher";
@@ -17,8 +17,9 @@ import Calculator from "./transforms/calculator";
 import ControlFlowFlattening from "./transforms/controlFlowFlattening/controlFlowFlattening";
 import Eval from "./transforms/eval";
 import GlobalConcealing from "./transforms/identifier/globalConcealing";
-import StringConcealing from "./transforms/string/stringConcealing";
 import StringSplitting from "./transforms/string/stringSplitting";
+import StringConcealing from "./transforms/string/stringConcealing";
+import StringCompression from "./transforms/string/stringCompression";
 import DuplicateLiteralsRemoval from "./transforms/extraction/duplicateLiteralsRemoval";
 import Shuffle from "./transforms/shuffle";
 import MovedDeclarations from "./transforms/identifier/movedDeclarations";
@@ -26,15 +27,12 @@ import RenameVariables from "./transforms/identifier/renameVariables";
 import RenameLabels from "./transforms/renameLabels";
 import Minify from "./transforms/minify";
 import ES5 from "./transforms/es5/es5";
-import StringEncoding from "./transforms/string/stringEncoding";
 import RGF from "./transforms/rgf";
 import Flatten from "./transforms/flatten";
 import Stack from "./transforms/stack";
-import StringCompression from "./transforms/string/stringCompression";
 import NameRecycling from "./transforms/identifier/nameRecycling";
 import AntiTooling from "./transforms/antiTooling";
-import HideInitializingCode from "./transforms/hideInitializingCode";
-import HexadecimalNumbers from "./transforms/hexadecimalNumbers";
+import Finalizer from "./transforms/finalizer";
 
 /**
  * The parent transformation holding the `state`.
@@ -47,17 +45,19 @@ export default class Obfuscator extends EventEmitter {
   state: "transform" | "eval" = "transform";
   generated: Set<string>;
 
+  totalPossibleTransforms: number;
+
   constructor(public options: ObfuscateOptions) {
     super();
 
     this.varCount = 0;
     this.transforms = Object.create(null);
     this.generated = new Set();
-
-    this.push(new Preparation(this));
-    this.push(new RenameLabels(this));
+    this.totalPossibleTransforms = 0;
 
     const test = <T>(map: ProbabilityMap<T>, ...transformers: any[]) => {
+      this.totalPossibleTransforms += transformers.length;
+
       if (isProbabilityMapProbable(map)) {
         // options.verbose && console.log("+ Added " + transformer.name);
 
@@ -68,36 +68,33 @@ export default class Obfuscator extends EventEmitter {
     };
 
     // Optimization: Only add needed transformers. If a probability always return false, no need in running that extra code.
-    test(options.objectExtraction, ObjectExtraction);
-    test(options.deadCode, DeadCode);
+    test(true, Preparation);
+    test(true, RenameLabels);
 
+    test(options.objectExtraction, ObjectExtraction);
+    test(options.flatten, Flatten);
+    test(options.rgf, RGF);
     test(options.dispatcher, Dispatcher);
+    test(options.deadCode, DeadCode);
+    test(options.calculator, Calculator);
     test(options.controlFlowFlattening, ControlFlowFlattening);
-    test(options.globalConcealing, GlobalConcealing);
-    test(options.stringCompression, StringCompression);
-    test(options.stringConcealing, StringConcealing);
-    test(options.stringEncoding, StringEncoding);
-    test(options.stringSplitting, StringSplitting);
-    test(options.renameVariables, RenameVariables);
-    test(options.nameRecycling, NameRecycling);
-
     test(options.eval, Eval);
+    test(options.globalConcealing, GlobalConcealing);
     test(options.opaquePredicates, OpaquePredicates);
+    test(options.stringSplitting, StringSplitting);
+    test(options.stringConcealing, StringConcealing);
+    test(options.stringCompression, StringCompression);
+    test(options.stack, Stack);
     test(options.duplicateLiteralsRemoval, DuplicateLiteralsRemoval);
-    test(options.minify, Minify);
-
-    test(options.calculator, Calculator);
+    test(options.shuffle, Shuffle);
+    test(options.nameRecycling, NameRecycling);
     test(options.movedDeclarations, MovedDeclarations);
-
+    test(options.minify, Minify);
+    test(options.renameVariables, RenameVariables);
     test(options.es5, ES5);
-    test(options.shuffle, Shuffle);
 
-    test(options.flatten, Flatten);
-    test(options.rgf, RGF);
-    test(options.stack, Stack);
     test(true, AntiTooling);
-    test(options.hideInitializingCode, HideInitializingCode);
-    test(options.hexadecimalNumbers, HexadecimalNumbers);
+    test(true, Finalizer); // String Encoding, Hexadecimal Numbers, BigInt support is included
 
     if (
       options.lock &&

package/src/options.ts

@@ -10,9 +10,9 @@ export interface ObfuscateOptions {
    *
    * | Preset | Transforms | Performance Reduction | Sample |
    * | --- | --- | --- | --- |
-   * | High | 21/22 | 98% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/high.js) |
-   * | Medium | 15/22 | 52% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/medium.js) |
-   * | Low | 10/22 | 30% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/low.js) |
+   * | High | 22/25 | 98% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/high.js) |
+   * | Medium | 19/25 | 52% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/medium.js) |
+   * | Low | 15/25 | 30% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/low.js) |
    *
    * You can extend each preset or all go without them entirely. (`"high"/"medium"/"low"`)
    *
@@ -53,7 +53,7 @@ export interface ObfuscateOptions {
   /**
    * ### `hexadecimalNumbers`
    *
-   * Uses the hexadecimal representation (`50` -> `0x32`) for numbers. (`true/false`)
+   * Uses the hexadecimal representation for numbers. (`true/false`)
    */
   hexadecimalNumbers?: boolean;
 
@@ -144,6 +144,8 @@ export interface ObfuscateOptions {
   /**
    * ### `nameRecycling`
    *
+   * (Experimental feature)
+   *
    * Attempts to reuse released names.
    *
    * - Potency Medium
@@ -189,19 +191,6 @@ export interface ObfuscateOptions {
    */
   controlFlowFlattening?: ProbabilityMap<boolean>;
 
-  /**
-   * ### `hideInitializingCode`
-   *
-   * Hides initializing code with complex ternary expressions. (`true/false`)
-   *
-   * - Potency High
-   * - Resilience High
-   * - Cost High
-   *
-   * [See all settings here](https://github.com/MichaelXF/js-confuser/blob/master/README.md#options)
-   */
-  hideInitializingCode?: ProbabilityMap<boolean>;
-
   /**
    * ### `globalConcealing`
    *
@@ -691,7 +680,6 @@ const validProperties = new Set([
   "identifierGenerator",
   "nameRecycling",
   "controlFlowFlattening",
-  "hideInitializingCode",
   "globalConcealing",
   "stringCompression",
   "stringConcealing",
@@ -726,7 +714,7 @@ const validBrowsers = new Set([
 ]);
 
 export function validateOptions(options: ObfuscateOptions) {
-  if (Object.keys(options).length <= 1) {
+  if (!options || Object.keys(options).length <= 1) {
     /**
      * Give a welcoming introduction to those who skipped the documentation.
      */
@@ -867,8 +855,7 @@ export async function correctOptions(
     options.compact = true; // self defending forcibly enables this
   }
 
-  // options.globalVariables was never used.
-  // GlobalConcealing implicitly determines a global to be a variable referenced but never defined or modified.
+  // options.globalVariables outlines generic globals that should be present in the execution context
   if (!options.hasOwnProperty("globalVariables")) {
     options.globalVariables = new Set([]);
 
@@ -908,6 +895,10 @@ export async function correctOptions(
       "Array",
       "Proxy",
       "Error",
+      "TypeError",
+      "ReferenceError",
+      "RangeError",
+      "EvalError",
       "setTimeout",
       "clearTimeout",
       "setInterval",
@@ -919,6 +910,11 @@ export async function correctOptions(
       "module",
       "isNaN",
       "isFinite",
+      "Set",
+      "Map",
+      "WeakSet",
+      "WeakMap",
+      "Symbol",
     ].forEach((x) => options.globalVariables.add(x));
   }
 

package/src/order.ts

@@ -32,8 +32,6 @@ export enum ObfuscateOrder {
 
   StringCompression = 18,
 
-  HideInitializingCode = 19,
-
   Stack = 20,
 
   DuplicateLiteralsRemoval = 22,
@@ -44,17 +42,15 @@ export enum ObfuscateOrder {
 
   MovedDeclarations = 26,
 
-  RenameVariables = 27,
+  RenameLabels = 27,
 
-  RenameLabels = 28,
+  Minify = 28,
 
-  Minify = 30,
+  RenameVariables = 30,
 
   ES5 = 31,
 
-  StringEncoding = 32,
-
   AntiTooling = 34,
 
-  HexadecimalNumbers = 35,
+  Finalizer = 35,
 }

package/src/probability.ts

@@ -87,6 +87,8 @@ export function ComputeProbabilityMap<T>(
  * @param map
  */
 export function isProbabilityMapProbable<T>(map: ProbabilityMap<T>): boolean {
+  ok(!Number.isNaN(map), "Numbers cannot be NaN");
+
   if (!map || typeof map === "undefined") {
     return false;
   }
@@ -97,9 +99,6 @@ export function isProbabilityMapProbable<T>(map: ProbabilityMap<T>): boolean {
     if (map > 1 || map < 0) {
       throw new Error(`Numbers must be between 0 and 1 for 0% - 100%`);
     }
-    if (isNaN(map)) {
-      throw new Error("Numbers cannot be NaN");
-    }
   }
   if (Array.isArray(map)) {
     ok(

package/src/templates/bufferToString.ts

@@ -0,0 +1,68 @@
+import Template from "./template";
+
+export const BufferToStringTemplate = Template(`
+  function __getGlobal(){
+    try {
+      return global||window|| ( new Function("return this") )();
+    } catch ( e ) {
+      try {
+        return this;
+      } catch ( e ) {
+        return {};
+      }
+    }
+  }
+
+  var __globalObject = __getGlobal() || {};
+  var __TextDecoder = __globalObject["TextDecoder"];
+  var __Uint8Array = __globalObject["Uint8Array"];
+  var __Buffer = __globalObject["Buffer"];
+  var __String = __globalObject["String"] || String;
+  var __Array = __globalObject["Array"] || Array;
+
+  var utf8ArrayToStr = (function () {
+    var charCache = new __Array(128);  // Preallocate the cache for the common single byte chars
+    var charFromCodePt = __String["fromCodePoint"] || __String["fromCharCode"];
+    var result = [];
+
+    return function (array) {
+        var codePt, byte1;
+        var buffLen = array["length"];
+
+        result["length"] = 0;
+
+        for (var i = 0; i < buffLen;) {
+            byte1 = array[i++];
+
+            if (byte1 <= 0x7F) {
+                codePt = byte1;
+            } else if (byte1 <= 0xDF) {
+                codePt = ((byte1 & 0x1F) << 6) | (array[i++] & 0x3F);
+            } else if (byte1 <= 0xEF) {
+                codePt = ((byte1 & 0x0F) << 12) | ((array[i++] & 0x3F) << 6) | (array[i++] & 0x3F);
+            } else if (__String["fromCodePoint"]) {
+                codePt = ((byte1 & 0x07) << 18) | ((array[i++] & 0x3F) << 12) | ((array[i++] & 0x3F) << 6) | (array[i++] & 0x3F);
+            } else {
+                codePt = 63;    // Cannot convert four byte code points, so use "?" instead
+                i += 3;
+            }
+
+            result["push"](charCache[codePt] || (charCache[codePt] = charFromCodePt(codePt)));
+        }
+
+        return result["join"]('');
+    };
+  })();
+
+  function {name}(buffer){
+    if(typeof __TextDecoder !== "undefined" && __TextDecoder) {
+      return new __TextDecoder()["decode"](new __Uint8Array(buffer));
+    } else if(typeof __Buffer !== "undefined" && __Buffer) {
+      return __Buffer["from"](buffer)["toString"]("utf-8");
+    } else {          
+      return utf8ArrayToStr(buffer);
+    }
+  }
+
+  
+`);