js-confuser 1.7.1 → 1.7.2

package/dist/util/insert.js

@@ -17,18 +17,20 @@ exports.getIndexDirect = getIndexDirect;
 exports.getLexContext = getLexContext;
 exports.getReferencingContexts = getReferencingContexts;
 exports.getVarContext = getVarContext;
+exports.isClass = isClass;
 exports.isContext = isContext;
 exports.isForInitialize = isForInitialize;
 exports.isFunction = isFunction;
 exports.isLexContext = isLexContext;
+exports.isStrictModeFunction = isStrictModeFunction;
 exports.isVarContext = isVarContext;
 exports.prepend = prepend;
-
 var _assert = require("assert");
-
 var _traverse = require("../traverse");
-
 var _identifiers = require("./identifiers");
+function isClass(object) {
+  return object.type === "ClassDeclaration" || object.type === "ClassExpression";
+}
 
 /**
  * - `FunctionDeclaration`
@@ -40,6 +42,11 @@ var _identifiers = require("./identifiers");
 function isFunction(object) {
   return ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(object && object.type);
 }
+function isStrictModeFunction(object) {
+  (0, _assert.ok)(isFunction(object));
+  return object.body.type === "BlockStatement" && object.body.body[0] && object.body.body[0].type === "ExpressionStatement" && object.body.body[0].directive === "use strict";
+}
+
 /**
  * The function context where the object is.
  *
@@ -49,189 +56,154 @@ function isFunction(object) {
  * @param object
  * @param parents
  */
-
-
 function getFunction(object, parents) {
   return parents.find(x => isFunction(x));
 }
+
 /**
  * Refers to the current function or Root node
  * @param parents
  */
-
-
 function getVarContext(object, parents) {
   var fn = getFunction(object, parents);
-
   if (fn) {
     return fn;
   }
-
   var top = parents[parents.length - 1] || object;
-
   if (top) {
     (0, _assert.ok)(top.type == "Program", "Root node not program, its " + top.type);
     return top;
   }
-
   throw new Error("Missing root node");
 }
+
 /**
  * `Function` or root node
  * @param object
  * @returns
  */
-
-
 function isVarContext(object) {
   return isFunction(object) || object.type == "Program" || object.type == "DoExpression"; // Stage 1
 }
+
 /**
  * `Block` or root node
  * @param object
  * @returns
  */
-
-
 function isLexContext(object) {
   return (0, _traverse.isBlock)(object) || object.type == "Program";
 }
+
 /**
  * Either a `var context` or `lex context`
  * @param object
  * @returns
  */
-
-
 function isContext(object) {
   return isVarContext(object) || isLexContext(object);
 }
-
 function getContexts(object, parents) {
   return [object, ...parents].filter(x => isContext(x));
 }
+
 /**
  * Refers to the current lexical block or Root node.
  * @param parents
  */
-
-
 function getLexContext(object, parents) {
   var block = (0, _traverse.getBlock)(object, parents);
-
   if (block) {
     return block;
   }
-
   var top = parents[parents.length - 1];
-
   if (!top) {
     throw new Error("Missing root node");
   }
 }
-
 function getDefiningContext(o, p) {
   (0, _identifiers.validateChain)(o, p);
   (0, _assert.ok)(o.type == "Identifier");
   var info = (0, _identifiers.getIdentifierInfo)(o, p);
   (0, _assert.ok)(info.spec.isDefined);
-
   if (info.isVariableDeclaration) {
     var variableDeclaration = p.find(x => x.type == "VariableDeclaration");
     (0, _assert.ok)(variableDeclaration);
-
     if (variableDeclaration.kind === "let" || variableDeclaration.kind === "const") {
       var context = getVarContext(o, p);
-
       if (context && context.type === "Program") {
         return getLexContext(o, p);
       }
     }
   }
-
   if (info.isFunctionDeclaration) {
     return getVarContext(p[0], p.slice(1));
   }
-
   return getVarContext(o, p);
 }
+
 /**
  * A more accurate context finding function.
  * @param o Object
  * @param p Parents
  * @returns Contexts
  */
-
-
 function getAllDefiningContexts(o, p) {
   var contexts = [getDefiningContext(o, p)];
   var info = (0, _identifiers.getIdentifierInfo)(o, p);
-
   if (info.isFunctionParameter) {
     // Get Function
-    var fn = getFunction(o, p); // contexts.push(fn.body);
-  }
+    var fn = getFunction(o, p);
 
+    // contexts.push(fn.body);
+  }
   if (info.isClauseParameter) {
     var catchClause = p.find(x => x.type === "CatchClause");
-
     if (catchClause) {
       return [catchClause];
     }
   }
-
   return contexts;
 }
-
 function getReferencingContexts(o, p, info) {
   (0, _identifiers.validateChain)(o, p);
   (0, _assert.ok)(o.type == "Identifier");
-
   if (!info) {
     info = (0, _identifiers.getIdentifierInfo)(o, p);
   }
-
   (0, _assert.ok)(info.spec.isReferenced);
   return [getVarContext(o, p), getLexContext(o, p)];
 }
-
 function getBlockBody(block) {
   if (!block) {
     throw new Error("no block body");
   }
-
   if (Array.isArray(block)) {
     return block;
   }
-
   return getBlockBody(block.body);
 }
-
 function getIndexDirect(object, parent) {
   return Object.keys(parent).find(x => parent[x] == object);
 }
+
 /**
  * Attempts to a delete a variable/functions declaration.
  * @param object
  * @param parents
  */
-
-
 function deleteDeclaration(object, parents) {
-  (0, _identifiers.validateChain)(object, parents); // variables
+  (0, _identifiers.validateChain)(object, parents);
 
+  // variables
   var list = [object, ...parents];
   var declaratorIndex = list.findIndex(x => x.type == "VariableDeclarator");
-
   if (declaratorIndex != -1) {
     var declarator = list[declaratorIndex]; // {type: VariableDeclarator, id: Identifier, init: Literal|Expression...}
-
     var declarations = list[declaratorIndex + 1]; // declarator[]
-
     var VariableDeclaration = list[declaratorIndex + 2];
     var body = list[declaratorIndex + 3];
     deleteDirect(declarator, declarations);
-
     if (VariableDeclaration.declarations.length == 0) {
       deleteDirect(VariableDeclaration, body);
     }
@@ -239,30 +211,24 @@ function deleteDeclaration(object, parents) {
     if (object.type != "FunctionDeclaration") {
       throw new Error("No method to delete: " + object.type);
     }
-
     deleteDirect(object, parents[0]);
   }
 }
+
 /**
  * Object must be directly nested in parent
  */
-
-
 function deleteDirect(object, parent) {
   if (!object) {
     throw new Error("object undefined");
   }
-
   if (!parent) {
     throw new Error("parent undefined");
   }
-
   (0, _identifiers.validateChain)(object, [parent]);
-
   if (typeof parent === "object") {
     if (Array.isArray(parent)) {
       var index = parent.indexOf(object);
-
       if (index != -1) {
         // delete
         parent.splice(index, 1);
@@ -273,7 +239,6 @@ function deleteDirect(object, parent) {
       }
     } else {
       var keyName = Object.keys(parent).find(x => parent[x] == object);
-
       if (keyName) {
         delete parent[keyName];
       } else {
@@ -282,14 +247,11 @@ function deleteDirect(object, parent) {
     }
   }
 }
-
 function prepend(block) {
   (0, _assert.ok)(!Array.isArray(block), "block should not be array");
-
   for (var _len = arguments.length, nodes = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
     nodes[_key - 1] = arguments[_key];
   }
-
   if (block.type == "Program") {
     var moveBy = 0;
     block.body.forEach((stmt, i) => {
@@ -298,7 +260,6 @@ function prepend(block) {
           moveBy++;
         }
       }
-
       if (stmt.type === "ExpressionStatement" && typeof stmt.directive === "string") {
         if (moveBy == i) {
           moveBy++;
@@ -309,8 +270,9 @@ function prepend(block) {
   } else if (block.type === "SwitchCase") {
     block.consequent.unshift(...nodes);
   } else {
-    var bodyArray = getBlockBody(block); // Check for 'use strict'
+    var bodyArray = getBlockBody(block);
 
+    // Check for 'use strict'
     if (bodyArray[0] && bodyArray[0].directive) {
       // Insert under 'use strict' directive
       bodyArray.splice(1, 0, ...nodes);
@@ -320,17 +282,13 @@ function prepend(block) {
     }
   }
 }
-
 function append(block) {
   (0, _assert.ok)(!Array.isArray(block), "block should not be array");
-
   for (var _len2 = arguments.length, nodes = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
     nodes[_key2 - 1] = arguments[_key2];
   }
-
   getBlockBody(block).push(...nodes);
 }
-
 function clone(object) {
   if (typeof object === "object" && object) {
     if (Array.isArray(object)) {
@@ -349,9 +307,9 @@ function clone(object) {
       return newObject;
     }
   }
-
   return object;
 }
+
 /**
  * | Return Value | Description |
  * | --- | --- |
@@ -365,16 +323,12 @@ function clone(object) {
  * @param p
  * @returns
  */
-
-
 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)) {
@@ -386,20 +340,17 @@ function isForInitialize(o, p) {
       }
     }
   }
-
   return false;
 }
+
 /**
  * Computes the `function.length` property given the parameter nodes.
  *
  * @param params
  * @returns
  */
-
-
 function computeFunctionLength(params) {
   var count = 0;
-
   for (var parameterNode of params) {
     if (parameterNode.type === "Identifier" || parameterNode.type === "ObjectPattern" || parameterNode.type === "ArrayPattern") {
       count++;
@@ -407,6 +358,5 @@ function computeFunctionLength(params) {
       break;
     }
   }
-
   return count;
 }

package/dist/util/math.js

@@ -4,19 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getFactors = getFactors;
-
 function getFactors(num) {
   const isEven = num % 2 === 0;
   const max = Math.sqrt(num);
   const inc = isEven ? 1 : 2;
   let factors = [1, num];
-
   for (let curFactor = isEven ? 2 : 3; curFactor <= max; curFactor += inc) {
     if (num % curFactor !== 0) continue;
     factors.push(curFactor);
     let compliment = num / curFactor;
     if (compliment !== curFactor) factors.push(compliment);
   }
-
   return factors;
 }

package/dist/util/object.js

@@ -5,33 +5,29 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createObject = createObject;
 exports.remove$Properties = remove$Properties;
-
 function createObject(keys, values) {
   if (keys.length != values.length) {
     throw new Error("length mismatch");
   }
-
   var newObject = {};
   keys.forEach((x, i) => {
     newObject[x] = values[i];
   });
   return newObject;
 }
+
 /**
  * Removes all `$`-prefixed properties on a deeply nested object.
  *
  * - Modifies the object.
  */
-
-
 function remove$Properties(object) {
   let seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set();
-
   if (typeof object === "object" && object) {
-    if (seen.has(object)) {// console.log(object);
+    if (seen.has(object)) {
+      // console.log(object);
       // throw new Error("Already seen");
     }
-
     seen.add(object);
     Object.keys(object).forEach(key => {
       if (key.charAt(0) == "$") {

package/dist/util/random.js

@@ -13,11 +13,8 @@ exports.getRandomString = getRandomString;
 exports.getRandomTrueExpression = getRandomTrueExpression;
 exports.shuffle = shuffle;
 exports.splitIntoChunks = splitIntoChunks;
-
 var _assert = require("assert");
-
 var _gen = require("./gen");
-
 /**
  * Returns a random element from the given array
  * @param choices Array of items
@@ -27,135 +24,107 @@ 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
  */
-
-
 function shuffle(array) {
   array.sort(() => Math.random() - 0.5);
   return array;
 }
+
 /**
  * Returns a random string.
  */
-
-
 function getRandomString(length) {
   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;
 }
-
 function getRandom(min, max) {
   return Math.random() * (max - min) + min;
 }
-
 function getRandomInteger(min, max) {
   return Math.floor(getRandom(min, max));
 }
-
 function splitIntoChunks(str, size) {
   (0, _assert.ok)(typeof str === "string", "str must be typeof string");
   (0, _assert.ok)(typeof size === "number", "size must be typeof number");
   (0, _assert.ok)(Math.floor(size) === size, "size must be integer");
   const numChunks = Math.ceil(str.length / size);
   const chunks = new Array(numChunks);
-
   for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
     chunks[i] = str.substr(o, size);
   }
-
   return chunks;
 }
+
 /**
  * Returns a random expression that will test to `false`.
  */
-
-
 function getRandomFalseExpression() {
   var type = choice(["0", "false", "null", "undefined", "NaN", "emptyString"]);
-
   switch (type) {
     case "0":
       return (0, _gen.Literal)(0);
-
     case "false":
       return (0, _gen.Literal)(false);
-
     case "null":
       return (0, _gen.Identifier)("null");
-
     case "undefined":
       return (0, _gen.Identifier)("undefined");
-
     case "NaN":
       return (0, _gen.Identifier)("NaN");
-
     default:
       // case "emptyString":
       return (0, _gen.Literal)("");
   }
 }
+
 /**
  * Returns a random expression that will test to `true`
  */
-
-
 function getRandomTrueExpression() {
   var type = choice(["number", "true", "Infinity", "nonEmptyString", "array", "object"]);
-
   switch (type) {
     case "number":
       return (0, _gen.Literal)(getRandomInteger(1, 100));
-
     case "true":
       return (0, _gen.Identifier)("true");
-
     case "Infinity":
       return (0, _gen.Identifier)("Infinity");
-
     case "nonEmptyString":
       return (0, _gen.Literal)(getRandomString(getRandomInteger(3, 9)));
-
     case "array":
       return (0, _gen.ArrayExpression)([]);
-
     default:
       //case "object":
       return (0, _gen.ObjectExpression)([]);
   }
 }
-
 function alphabeticalGenerator(index) {
   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;
 }

package/dist/util/scope.js

@@ -4,14 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getLexicalScope = getLexicalScope;
+exports.getLexicalScopeBody = getLexicalScopeBody;
 exports.isLexicalScope = isLexicalScope;
-
+var _assert = require("assert");
 var _traverse = require("../traverse");
-
 function isLexicalScope(object) {
   return (0, _traverse.isBlock)(object) || object.type == "SwitchCase";
 }
-
 function getLexicalScope(object, parents) {
   return [object, ...parents].find(node => isLexicalScope(node));
+}
+function getLexicalScopeBody(object) {
+  (0, _assert.ok)(isLexicalScope(object));
+  return (0, _traverse.isBlock)(object) ? object.body : object.type === "SwitchCase" ? object.consequent : (0, _assert.ok)("Unhandled case");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",
@@ -22,8 +22,8 @@
   "author": "MichaelXF",
   "license": "MIT",
   "dependencies": {
-    "acorn": "^8.10.0",
-    "escodegen": "^2.0.0"
+    "acorn": "^8.12.1",
+    "escodegen": "^2.1.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.17.6",

package/src/constants.ts

@@ -82,3 +82,15 @@ export const reservedIdentifiers = new Set([
 
 export const noRenameVariablePrefix = "__NO_JS_CONFUSER_RENAME__";
 export const placeholderVariablePrefix = "__p_";
+
+/**
+ * Tells the obfuscator this function is predictable:
+ * -  Never called with extraneous parameters
+ */
+export const predictableFunctionTag = "__JS_PREDICT__";
+
+/**
+ * Tells the obfuscator this function is critical for the Obfuscated code.
+ * -  Example: string decryption function
+ */
+export const criticalFunctionTag = "__JS_CRITICAL__";

package/src/options.ts

@@ -585,6 +585,15 @@ export interface ObfuscateOptions {
    * [See all settings here](https://github.com/MichaelXF/js-confuser/blob/master/README.md#options)
    */
   debugComments?: boolean;
+
+  /**
+   * ### `preserveFunctionLength`
+   *
+   * Modified functions will retain the correct `function.length` property. Enabled by default. (`true/false`)
+   *
+   * [See all settings here](https://github.com/MichaelXF/js-confuser/blob/master/README.md#options)
+   */
+  preserveFunctionLength?: boolean;
 }
 
 const validProperties = new Set([
@@ -619,6 +628,7 @@ const validProperties = new Set([
   "verbose",
   "globalVariables",
   "debugComments",
+  "preserveFunctionLength",
 ]);
 
 const validOses = new Set(["windows", "linux", "osx", "ios", "android"]);
@@ -764,6 +774,9 @@ export async function correctOptions(
   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.globalVariables && !(options.globalVariables instanceof Set)) {
     options.globalVariables = new Set(Object.keys(options.globalVariables));

package/src/order.ts

@@ -46,11 +46,11 @@ export enum ObfuscateOrder {
 
   Minify = 28,
 
+  AntiTooling = 29,
+
   RenameVariables = 30,
 
   ES5 = 31,
 
-  AntiTooling = 34,
-
   Finalizer = 35,
 }