js-confuser 1.7.1 → 1.7.3

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.alphabeticalGenerator = alphabeticalGenerator;
 exports.chance = chance;
 exports.choice = choice;
+exports.createZeroWidthGenerator = createZeroWidthGenerator;
 exports.getRandom = getRandom;
 exports.getRandomFalseExpression = getRandomFalseExpression;
 exports.getRandomInteger = getRandomInteger;
@@ -13,11 +14,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 +25,132 @@ 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;
+}
+function createZeroWidthGenerator() {
+  var keywords = ["if", "in", "for", "let", "new", "try", "var", "case", "else", "null", "break", "catch", "class", "const", "super", "throw", "while", "yield", "delete", "export", "import", "public", "return", "switch", "default", "finally", "private", "continue", "debugger", "function", "arguments", "protected", "instanceof", "await", "async",
+  // new key words and other fun stuff :P
+  "NaN", "undefined", "true", "false", "typeof", "this", "static", "void", "of"];
+  var maxSize = 0;
+  var currentKeyWordsArray = [];
+  function generateArray() {
+    var result = keywords.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() {
+    if (!currentKeyWordsArray.length) {
+      ++maxSize;
+      currentKeyWordsArray = generateArray();
+    }
+    return currentKeyWordsArray.pop();
+  }
+  return {
+    generate: getNextVariable
+  };
 }

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/docs/Countermeasures.md

@@ -1,6 +1,6 @@
 ## `Countermeasures`
 
-[Countermeasures](https://docs.jscrambler.com/code-integrity/documentation/client-side-countermeasures) is a property on the `lock` object, determining the response to a triggered lock.
+Countermeasures is a property on the `lock` object, determining the response to a triggered lock.
 
 For instance, the `domainLock` determines the current domain is invalid.
 
@@ -21,12 +21,13 @@ For instance, the `domainLock` determines the current domain is invalid.
 
 ## Crash Process
 
-The default behavior is to crash the process. This depends on the `target` property.
+The default behavior is to crash the process This is done by an infinite loop to ensure the process becomes useless.
 
-- `node` -> `process.exit();`
-- `browser` -> `document.documentElement.innerHTML = '';`
-
-This is followed by an infinite loop as a fallback measure to ensure the process becomes useless.
+```js
+while(true) {
+  // ...
+}
+```
 
 ## Custom Callback
 
@@ -61,3 +62,9 @@ Try setting your machine time to the past or before the allowed range.
 #### Integrity:
 
 Try changing a string within your code.
+
+### See also
+
+- [Integrity](Integrity.md)
+- [Tamper Protection](TamperProtection.md)
+