js-confuser 1.5.8 → 1.6.0

package/dist/transforms/identifier/renameVariables.js

@@ -30,28 +30,29 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 /**
  * Rename variables to randomly generated names.
  *
- * - Attempts to re-use already generated names in nested scopes.
+ * - 1. First collect data on identifiers in all scope using 'VariableAnalysis'
+ * - 2. After 'VariableAnalysis' is finished start applying to each scope (top-down)
+ * - 3. Each scope, find the all names used here and exclude those names from being re-named
+ * - 4. Now loop through all the defined names in this scope and set it to a random name (or re-use previously generated name)
+ * - 5. Update all the Identifiers node's 'name' property to reflect this change
  */
 class RenameVariables extends _transform.default {
-  // Generator object
   // Names already used
   // Map of Context->Object of changes
   // Ref to VariableAnalysis data
   constructor(o) {
     super(o, _order.ObfuscateOrder.RenameVariables);
 
-    _defineProperty(this, "gen", void 0);
-
     _defineProperty(this, "generated", void 0);
 
     _defineProperty(this, "changed", void 0);
 
     _defineProperty(this, "variableAnalysis", void 0);
 
-    this.changed = new Map();
+    this.changed = new Map(); // 1.
+
     this.variableAnalysis = new _variableAnalysis.default(o);
     this.before.push(this.variableAnalysis);
-    this.gen = this.getGenerator();
     this.generated = [];
   }
 
@@ -60,22 +61,24 @@ class RenameVariables extends _transform.default {
   }
 
   transform(object, parents) {
+    // 2. Notice this is on 'onEnter' (top-down)
     var isGlobal = object.type == "Program";
     var type = isGlobal ? "root" : (0, _insert.isVarContext)(object) ? "var" : (0, _insert.isLexContext)(object) ? "lex" : undefined;
     (0, _assert.ok)(type);
     var newNames = Object.create(null);
     var defined = this.variableAnalysis.defined.get(object) || new Set();
-    var references = this.variableAnalysis.references.get(object) || new Set();
+    var references = this.variableAnalysis.references.get(object) || new Set(); // No changes needed here
 
     if (!defined && !this.changed.has(object)) {
       this.changed.set(object, Object.create(null));
       return;
-    }
+    } // Names possible to be re-used here
+
 
-    var possible = new Set();
+    var possible = new Set(); // 3. Try to re-use names when possible
 
     if (this.generated.length && !isGlobal) {
-      var allReferences = new Set(references || []);
+      var allReferences = new Set();
       var nope = new Set(defined);
       (0, _traverse.walk)(object, [], (o, p) => {
         var ref = this.variableAnalysis.references.get(o);
@@ -98,7 +101,7 @@ class RenameVariables extends _transform.default {
           Object.keys(changes).forEach(x => {
             var name = changes[x];
 
-            if (!allReferences.has(x)) {
+            if (!allReferences.has(x) && !references.has(x)) {
               passed.add(name);
             } else {
               nope.add(name);
@@ -108,38 +111,51 @@ class RenameVariables extends _transform.default {
       });
       nope.forEach(x => passed.delete(x));
       possible = passed;
-    }
+    } // 4. Defined names to new names
+
 
-    defined.forEach(name => {
-      if ((isGlobal && !name.startsWith("__p_") ? (0, _probability.ComputeProbabilityMap)(this.options.renameGlobals, x => x, name) : true) && (0, _probability.ComputeProbabilityMap)(this.options.renameVariables, x => x, name, isGlobal)) {
-        // Fix 2. Ensure global names aren't overridden
+    for (var name of defined) {
+      if (!name.startsWith("__NO_JS_CONFUSER_RENAME__") && ( // Variables prefixed with '__NO_JS_CONFUSER_RENAME__' are never renamed
+      isGlobal && !name.startsWith("__p_") // Variables prefixed with '__p_' are created by the obfuscator, always renamed
+      ? (0, _probability.ComputeProbabilityMap)(this.options.renameGlobals, x => x, name) : true) && (0, _probability.ComputeProbabilityMap)( // Check the user's option for renaming variables
+      this.options.renameVariables, x => x, name, isGlobal)) {
+        // Create a new name from (1) or (2) methods
         var newName;
 
         do {
           if (possible.size) {
+            // (1) Re-use previously generated name
             var first = possible.values().next().value;
             possible.delete(first);
             newName = first;
           } else {
-            // Fix 1. Use `generateIdentifier` over `gen.generate()` so Integrity can get unique variable names
-            var g = this.generateIdentifier();
-            newName = g;
-            this.generated.push(g);
+            // (2) Create a new name with `generateIdentifier` function
+            var generatedName = this.generateIdentifier();
+            newName = generatedName;
+            this.generated.push(generatedName);
           }
-        } while (this.variableAnalysis.globals.has(newName));
+        } while (this.variableAnalysis.globals.has(newName)); // Ensure global names aren't overridden
+
 
         newNames[name] = newName;
       } else {
+        // This variable name was deemed not to be renamed.
         newNames[name] = name;
       }
-    });
-    this.changed.set(object, newNames);
+    }
+
+    this.changed.set(object, newNames); // 5. Update Identifier node's 'name' property
+
     (0, _traverse.walk)(object, parents, (o, p) => {
       if (o.type == "Identifier") {
         if (_constants.reservedIdentifiers.has(o.name) || this.options.globalVariables.has(o.name)) {
           return;
         }
 
+        if (o.$renamed) {
+          return;
+        }
+
         var info = (0, _identifiers.getIdentifierInfo)(o, p);
 
         if (info.spec.isExported) {
@@ -163,11 +179,7 @@ class RenameVariables extends _transform.default {
         }
 
         if (newName && typeof newName === "string") {
-          if (o.$renamed) {
-            return;
-          } // Strange behavior where the `local` and `imported` objects are the same
-
-
+          // Strange behavior where the `local` and `imported` objects are the same
           if (info.isImportSpecifier) {
             var importSpecifierIndex = p.findIndex(x => x.type === "ImportSpecifier");
 

package/dist/transforms/identifier/variableAnalysis.js

@@ -9,8 +9,6 @@ var _assert = require("assert");
 
 var _constants = require("../../constants");
 
-var _traverse = require("../../traverse");
-
 var _compare = require("../../util/compare");
 
 var _identifiers = require("../../util/identifiers");
@@ -37,10 +35,12 @@ class VariableAnalysis extends _transform.default {
 
   /**
    * Set of global identifiers to never be redefined
+   *
+   * - Used to not accidentally block access to a global variable
    */
 
   /**
-   * Set of identifers that are defined within the program
+   * Set of identifiers that are defined within the program
    */
   constructor(o) {
     super(o);
@@ -60,72 +60,68 @@ class VariableAnalysis extends _transform.default {
   }
 
   match(object, parents) {
-    return (0, _insert.isContext)(object);
+    return object.type === "Identifier";
   }
 
   transform(object, parents) {
-    (0, _traverse.walk)(object, parents, (o, p) => {
-      if (o.type == "Identifier") {
-        var name = o.name;
-        (0, _assert.ok)(typeof name === "string");
-
-        if (!(0, _compare.isValidIdentifier)(name)) {
-          return;
-        }
-
-        if (_constants.reservedIdentifiers.has(name)) {
-          return;
-        }
-
-        if (this.options.globalVariables.has(name)) {
-          return;
-        }
-
-        var info = (0, _identifiers.getIdentifierInfo)(o, p);
-
-        if (!info.spec.isReferenced) {
-          return;
-        }
-
-        if (info.spec.isExported) {
-          return;
+    var name = object.name;
+    (0, _assert.ok)(typeof name === "string");
+
+    if (!(0, _compare.isValidIdentifier)(name)) {
+      return;
+    }
+
+    if (_constants.reservedIdentifiers.has(name)) {
+      return;
+    }
+
+    if (this.options.globalVariables.has(name)) {
+      return;
+    }
+
+    var info = (0, _identifiers.getIdentifierInfo)(object, parents);
+
+    if (!info.spec.isReferenced) {
+      return;
+    }
+
+    if (info.spec.isExported) {
+      return;
+    }
+
+    var isDefined = info.spec.isDefined; // Keep track of defined names within the program
+
+    if (isDefined) {
+      this.notGlobals.add(object.name);
+      this.globals.delete(object.name);
+    } else if (!this.notGlobals.has(object.name)) {
+      this.globals.add(object.name);
+    }
+
+    var definingContexts = info.spec.isDefined ? (0, _insert.getAllDefiningContexts)(object, parents) : (0, _insert.getReferencingContexts)(object, parents, info);
+    (0, _assert.ok)(definingContexts.length);
+    definingContexts.forEach(definingContext => {
+      // ok(
+      //   isContext(definingContext),
+      //   `${definingContext.type} is not a context`
+      // );
+      if (isDefined) {
+        // Add to defined Map
+        if (!this.defined.has(definingContext)) {
+          this.defined.set(definingContext, new Set());
         }
 
-        var isDefined = info.spec.isDefined; // Keep track of defined names within the program
+        this.defined.get(definingContext).add(name);
+        this.references.has(definingContext) && this.references.get(definingContext).delete(name);
+      } else {
+        // Add to references Map
+        if (!this.defined.has(definingContext) || !this.defined.get(definingContext).has(name)) {
+          if (!this.references.has(definingContext)) {
+            this.references.set(definingContext, new Set());
+          }
 
-        if (isDefined) {
-          this.notGlobals.add(o.name);
-          this.globals.delete(o.name);
-        } else if (!this.notGlobals.has(o.name)) {
-          this.globals.add(o.name);
+          this.references.get(definingContext).add(name);
         }
-
-        var definingContexts = info.spec.isDefined ? (0, _insert.getAllDefiningContexts)(o, p) : (0, _insert.getReferencingContexts)(o, p, info);
-        (0, _assert.ok)(definingContexts.length);
-        definingContexts.forEach(definingContext => {
-          // ok(
-          //   isContext(definingContext),
-          //   `${definingContext.type} is not a context`
-          // );
-          if (isDefined) {
-            // Add to defined Map
-            if (!this.defined.has(definingContext)) {
-              this.defined.set(definingContext, new Set());
-            }
-
-            this.defined.get(definingContext).add(name);
-            this.references.has(definingContext) && this.references.get(definingContext).delete(name);
-          } else {
-            // Add to references Map
-            if (!this.defined.has(definingContext) || !this.defined.get(definingContext).has(name)) {
-              if (!this.references.has(definingContext)) {
-                this.references.set(definingContext, new Set());
-              }
-
-              this.references.get(definingContext).add(name);
-            }
-          }
-        });
       }
     });
   }

package/dist/transforms/minify.js

@@ -21,6 +21,8 @@ var _assert = require("assert");
 
 var _scope = require("../util/scope");
 
+var _template = _interopRequireDefault(require("../templates/template"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
@@ -34,12 +36,13 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  * - `x['y']` **->** `x.y`
  */
 class Minify extends _transform.default {
+  /**
+   * A helper function that is introduced preserve function semantics
+   */
   constructor(o) {
     super(o, _order.ObfuscateOrder.Minify);
 
-    _defineProperty(this, "variables", void 0);
-
-    this.variables = new Map();
+    _defineProperty(this, "arrowFunctionName", void 0);
   }
 
   match(object, parents) {
@@ -75,7 +78,7 @@ class Minify extends _transform.default {
           var startIndex = -1;
           var sequences = [];
           body.forEach((stmt, i) => {
-            if (stmt.type == "ExpressionStatement") {
+            if (stmt.type == "ExpressionStatement" && !stmt.directive) {
               exprs.push(stmt.expression);
 
               if (startIndex == -1) {
@@ -105,48 +108,44 @@ class Minify extends _transform.default {
             (0, _assert.ok)(seq.index != -1);
             body.splice(seq.index, seq.exprs.length, (0, _gen.ExpressionStatement)(seq.exprs.length == 1 ? seq.exprs[0] : (0, _gen.SequenceExpression)(seq.exprs)));
           });
-        }
+        } // Unnecessary return
 
-        if (object.type != "SwitchCase") {
-          // Unnecessary return
-          if (body.length && body[body.length - 1]) {
-            var last = body[body.length - 1];
 
-            if (last.type == "ReturnStatement") {
-              var isUndefined = last.argument == null;
+        if (parents[0] && (0, _insert.isVarContext)(parents[0]) && body.length && body[body.length - 1]) {
+          var last = body[body.length - 1];
 
-              if (isUndefined) {
-                if ((0, _insert.getFunction)(object, parents).body == object) {
-                  body.pop();
-                }
-              }
+          if (last.type == "ReturnStatement") {
+            var isUndefined = last.argument == null;
+
+            if (isUndefined) {
+              body.pop();
             }
-          } // Variable declaration grouping
-          // var a = 1;
-          // var b = 1;
-          // var c = 1;
-          //
-          // var a=1,b=1,c=1;
-
-
-          var lastDec = null;
-          var remove = [];
-          body.forEach((x, i) => {
-            if (x.type === "VariableDeclaration") {
-              if (!lastDec || lastDec.kind !== x.kind || !lastDec.declarations.length) {
-                lastDec = x;
-              } else {
-                lastDec.declarations.push(...(0, _insert.clone)(x.declarations));
-                remove.unshift(i);
-              }
+          }
+        } // Variable declaration grouping
+        // var a = 1;
+        // var b = 1;
+        // var c = 1;
+        //
+        // var a=1,b=1,c=1;
+
+
+        var lastDec = null;
+        var remove = [];
+        body.forEach((x, i) => {
+          if (x.type === "VariableDeclaration") {
+            if (!lastDec || lastDec.kind !== x.kind || !lastDec.declarations.length) {
+              lastDec = x;
             } else {
-              lastDec = null;
+              lastDec.declarations.push(...(0, _insert.clone)(x.declarations));
+              remove.unshift(i);
             }
-          });
-          remove.forEach(x => {
-            body.splice(x, 1);
-          });
-        }
+          } else {
+            lastDec = null;
+          }
+        });
+        remove.forEach(x => {
+          body.splice(x, 1);
+        });
       };
     }
     /**
@@ -169,29 +168,30 @@ class Minify extends _transform.default {
           }
         }
 
-        var blockIndex = parents.findIndex(x => (0, _insert.isLexContext)(x));
-
-        if (blockIndex !== -1) {
-          var block = parents[blockIndex];
-          var body = block.body;
+        if (object.type === "FunctionDeclaration") {
+          var body = parents[0];
 
           if (!Array.isArray(body)) {
             return;
           }
 
-          var stmt = parents[blockIndex - 2] || object;
-          var index = body.indexOf(stmt);
+          var index = body.indexOf(object);
 
           if (index == -1) {
             return;
           }
 
           var before = body.slice(0, index);
-          (0, _assert.ok)(!before.includes(stmt));
-          var set = new Set(before.map(x => x.type));
-          set.delete("FunctionDeclaration");
+          (0, _assert.ok)(!before.includes(object));
+          var beforeTypes = new Set(before.map(x => x.type));
+          beforeTypes.delete("FunctionDeclaration");
+
+          if (beforeTypes.size > 0) {
+            return;
+          } // Test Variant #25: Don't break redefined function declaration
 
-          if (set.size) {
+
+          if (object.id && body.find(x => x.type === "FunctionDeclaration" && x !== object && x.id && x.id.name === object.id.name)) {
             return;
           }
         }
@@ -212,15 +212,28 @@ class Minify extends _transform.default {
         });
 
         if (canTransform) {
+          if (!this.arrowFunctionName) {
+            this.arrowFunctionName = this.getPlaceholder();
+            (0, _insert.append)(parents[parents.length - 1] || object, (0, _template.default)("\n            function ".concat(this.arrowFunctionName, "(arrowFn){\n              return function(){ return arrowFn(...arguments) }\n            }\n            ")).single());
+          }
+
+          const wrap = object => {
+            return (0, _gen.CallExpression)((0, _gen.Identifier)(this.arrowFunctionName), [(0, _insert.clone)(object)]);
+          };
+
           if (object.type == "FunctionExpression") {
             object.type = "ArrowFunctionExpression";
+            this.replace(object, wrap((0, _insert.clone)(object)));
           } else {
             var arrow = { ...(0, _insert.clone)(object),
               type: "ArrowFunctionExpression"
             };
-            this.replace(object, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(object.id.name, arrow)));
+            this.replace(object, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(object.id.name, wrap(arrow))));
             var x = this.transform(arrow, []);
-            x();
+
+            if (typeof x === "function") {
+              x();
+            }
           }
         }
       };
@@ -237,7 +250,7 @@ class Minify extends _transform.default {
 
         if (body.length == 1 && stmt1.type == "ReturnStatement") {
           // x=>{a: 1} // Invalid syntax
-          if (stmt1.argument.type != "ObjectExpression") {
+          if (stmt1.argument && stmt1.argument.type != "ObjectExpression") {
             object.body = stmt1.argument;
             object.expression = true;
           }
@@ -372,7 +385,7 @@ class Minify extends _transform.default {
           object.alternate = null;
         }
 
-        if (object.consequent.body.length == 1 && object.alternate && object.alternate.body.length == 1) {
+        if (object.consequent && object.consequent.body && object.consequent.body.length == 1 && object.alternate && object.alternate.body.length == 1) {
           var stmt1 = (0, _insert.clone)(object.consequent.body[0]);
           var stmt2 = (0, _insert.clone)(object.alternate.body[0]); // if (a) {return b;} else {return c;} -> return a ? b : c;
 
@@ -405,8 +418,16 @@ class Minify extends _transform.default {
       if (property.type == "Literal" && (0, _compare.isValidIdentifier)(property.value)) {
         object.computed = false;
         object.property.type = "Identifier";
-        object.property.name = (0, _insert.clone)(object.property.value);
-        obj.name && this.log(obj.name + "['" + object.property.name + "'] -> " + obj.name + "." + object.property.name);
+        object.property.name = (0, _insert.clone)(object.property.value); // obj.name &&
+        //   this.log(
+        //     obj.name +
+        //       "['" +
+        //       object.property.name +
+        //       "'] -> " +
+        //       obj.name +
+        //       "." +
+        //       object.property.name
+        //   );
       }
     }
 
@@ -421,18 +442,16 @@ class Minify extends _transform.default {
     } // { "x": 1 } -> {x: 1}
 
 
-    if (object.type == "Property") {
+    if (object.type === "Property" || object.type === "MethodDefinition") {
       if (object.key.type == "SequenceExpression" && object.key.expressions.length == 1) {
         object.key = object.key.expressions[0];
         object.computed = true;
       }
 
-      if (object.key.type == "Literal" && (0, _compare.isValidIdentifier)(object.key.value)) {
+      if (object.key.type == "Literal" && typeof object.key.value === "string" && (0, _compare.isValidIdentifier)(object.key.value)) {
         object.key.type = "Identifier";
         object.key.name = object.key.value;
         object.computed = false;
-      } else if (object.key.type == "Identifier" && !(0, _compare.isValidIdentifier)(object.key.name)) {
-        object.key = (0, _gen.Literal)(object.key.name);
       }
     }
 

package/dist/transforms/opaquePredicates.js

@@ -66,7 +66,7 @@ class OpaquePredicates extends _transform.default {
     _defineProperty(this, "made", void 0);
 
     this.predicates = Object.create(null);
-    this.gen = this.getGenerator((0, _random.getRandomInteger)(0, 20));
+    this.gen = this.getGenerator();
     this.made = 0;
   }
 

package/dist/transforms/preparation/preparation.js

@@ -103,9 +103,9 @@ class ExplicitIdentifiers extends _transform.default {
         if (parents[propIndex].type == "MethodDefinition" && parents[propIndex].kind == "constructor") {
           return;
         }
-      }
+      } // this.log(object.name, "->", `'${object.name}'`);
+
 
-      this.log(object.name, "->", "'".concat(object.name, "'"));
       this.replace(object, (0, _gen.Literal)(object.name));
       parents[0].computed = true;
       parents[0].shorthand = false;