js-confuser 1.5.9 → 1.7.0

package/dist/transforms/identifier/globalConcealing.js

@@ -15,92 +15,30 @@ var _gen = require("../../util/gen");
 
 var _insert = require("../../util/insert");
 
-var _identifiers = require("../../util/identifiers");
-
 var _random = require("../../util/random");
 
 var _constants = require("../../constants");
 
 var _probability = require("../../probability");
 
+var _globalAnalysis = _interopRequireDefault(require("./globalAnalysis"));
+
 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; }
 
-class GlobalAnalysis extends _transform.default {
-  constructor(o) {
-    super(o);
-
-    _defineProperty(this, "notGlobals", void 0);
-
-    _defineProperty(this, "globals", void 0);
-
-    this.globals = Object.create(null);
-    this.notGlobals = new Set();
-  }
-
-  match(object, parents) {
-    return object.type == "Identifier" && !_constants.reservedKeywords.has(object.name);
-  }
-
-  transform(object, parents) {
-    // no touching `import()` or `import x from ...`
-    var importIndex = parents.findIndex(x => x.type == "ImportExpression" || x.type == "ImportDeclaration");
-
-    if (importIndex !== -1) {
-      if (parents[importIndex].source === (parents[importIndex - 1] || object)) {
-        return;
-      }
-    }
-
-    var info = (0, _identifiers.getIdentifierInfo)(object, parents);
-
-    if (!info.spec.isReferenced) {
-      return;
-    } // Add to globals
-
-
-    if (!this.notGlobals.has(object.name)) {
-      if (!this.globals[object.name]) {
-        this.globals[object.name] = [];
-      }
-
-      this.globals[object.name].push([object, parents]);
-    }
-
-    if (info.spec.isDefined || info.spec.isModified) {
-      delete this.globals[object.name];
-      this.notGlobals.add(object.name);
-    }
-
-    var assignmentIndex = parents.findIndex(x => x.type == "AssignmentExpression");
-    var updateIndex = parents.findIndex(x => x.type == "UpdateExpression");
-
-    if (assignmentIndex != -1 && parents[assignmentIndex].left === (parents[assignmentIndex - 1] || object) || updateIndex != -1) {
-      var memberIndex = parents.findIndex(x => x.type == "MemberExpression");
-
-      if (memberIndex == -1 || memberIndex > (assignmentIndex == -1 ? assignmentIndex : updateIndex)) {
-        delete this.globals[object.name];
-        this.notGlobals.add(object.name);
-      }
-    }
-  }
-
-}
 /**
  * Global Concealing hides global variables being accessed.
  *
  * - Any variable that is not defined is considered "global"
  */
-
-
 class GlobalConcealing extends _transform.default {
   constructor(o) {
     super(o, _order.ObfuscateOrder.GlobalConcealing);
 
     _defineProperty(this, "globalAnalysis", void 0);
 
-    this.globalAnalysis = new GlobalAnalysis(o);
+    this.globalAnalysis = new _globalAnalysis.default(o);
     this.before.push(this.globalAnalysis);
   }
 
@@ -126,10 +64,10 @@ class GlobalConcealing extends _transform.default {
         } else if (!(0, _probability.ComputeProbabilityMap)(this.options.globalConcealing, x => x, x)) {
           delete globals[x];
         }
-      }); // this.log(Object.keys(globals).join(', '))
+      });
 
       if (Object.keys(globals).length > 0) {
-        var used = new Set(); // 1. Make getter function
+        var used = new Set(); // Make getter function
         // holds "window" or "global"
 
         var globalVar = this.getPlaceholder(); // holds outermost "this"
@@ -137,10 +75,11 @@ class GlobalConcealing extends _transform.default {
         var thisVar = this.getPlaceholder(); // "window" or "global" in node
 
         var global = this.options.globalVariables.values().next().value || "window";
+        var alternateGlobal = global === "window" ? "global" : "window";
         var getGlobalVariableFnName = this.getPlaceholder();
         var getThisVariableFnName = this.getPlaceholder(); // Returns global variable or fall backs to `this`
 
-        var getGlobalVariableFn = (0, _template.default)("\n        var ".concat(getGlobalVariableFnName, " = function(){\n          try {\n            return ").concat(global, ";\n          } catch (e){\n            return ").concat(getThisVariableFnName, "[\"call\"](this);\n          }\n        }")).single();
+        var getGlobalVariableFn = (0, _template.default)("\n        var ".concat(getGlobalVariableFnName, " = function(){\n          try {\n            return ").concat(global, " || ").concat(alternateGlobal, " || (new Function(\"return this\"))();\n          } catch (e){\n            return ").concat(getThisVariableFnName, "[\"call\"](this);\n          }\n        }")).single();
         var getThisVariableFn = (0, _template.default)("\n        var ".concat(getThisVariableFnName, " = function(){\n          try {\n            return this;\n          } catch (e){\n            return null;\n          }\n        }")).single(); // 2. Replace old accessors
 
         var globalFn = this.getPlaceholder();
@@ -157,19 +96,7 @@ class GlobalConcealing extends _transform.default {
           newNames[name] = state;
           locations.forEach(_ref => {
             let [node, parents] = _ref;
-
-            if (!parents.find(x => x.$dispatcherSkip)) {
-              // Do not replace
-              if (parents[0]) {
-                if (parents[0].type == "ClassDeclaration" || parents[0].type == "ClassExpression" || parents[0].type == "FunctionExpression" || parents[0].type == "FunctionDeclaration") {
-                  if (parents[0].id === node) {
-                    return;
-                  }
-                }
-              }
-
-              this.replace(node, (0, _gen.CallExpression)((0, _gen.Identifier)(globalFn), [(0, _gen.Literal)(state)]));
-            }
+            this.replace(node, (0, _gen.CallExpression)((0, _gen.Identifier)(globalFn), [(0, _gen.Literal)(state)]));
           });
         }); // Adds all global variables to the switch statement
 
@@ -178,7 +105,7 @@ class GlobalConcealing extends _transform.default {
             var state;
 
             do {
-              state = (0, _random.getRandomInteger)(-1000, 1000 + used.size + this.options.globalVariables.size * 100);
+              state = (0, _random.getRandomInteger)(0, 1000 + used.size + this.options.globalVariables.size * 100);
             } while (used.has(state));
 
             used.add(state);
@@ -191,7 +118,7 @@ class GlobalConcealing extends _transform.default {
           var code = newNames[name];
           var body = [(0, _gen.ReturnStatement)((0, _gen.LogicalExpression)("||", (0, _gen.MemberExpression)((0, _gen.Identifier)(globalVar), (0, _gen.Literal)(name), true), (0, _gen.MemberExpression)((0, _gen.Identifier)(thisVar), (0, _gen.Literal)(name), true)))];
 
-          if (Math.random() > 0.5 && name) {
+          if ((0, _random.chance)(50)) {
             body = [(0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(returnName), (0, _gen.LogicalExpression)("||", (0, _gen.Literal)(name), (0, _gen.MemberExpression)((0, _gen.Identifier)(thisVar), (0, _gen.Literal)(name), true)))), (0, _gen.BreakStatement)()];
           }
 

package/dist/transforms/identifier/movedDeclarations.js

@@ -17,10 +17,6 @@ var _assert = require("assert");
 
 var _order = require("../../order");
 
-var _identifiers = require("../../util/identifiers");
-
-var _scope = require("../../util/scope");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -32,100 +28,51 @@ class MovedDeclarations extends _transform.default {
   }
 
   match(object, parents) {
-    return (0, _scope.isLexicalScope)(object);
+    return object.type === "VariableDeclaration" && object.kind === "var" && object.declarations.length === 1 && object.declarations[0].id.type === "Identifier";
   }
 
   transform(object, parents) {
     return () => {
-      var body = (0, _traverse.isBlock)(object) ? object.body : object.consequent;
-      (0, _assert.ok)(Array.isArray(body));
-      var illegal = new Set();
-      var defined = new Set();
-      var variableDeclarations = Object.create(null);
-      (0, _traverse.walk)(object, parents, (o, p) => {
-        if (o.type == "Identifier") {
-          if (o.hidden || (0, _scope.getLexicalScope)(o, p) !== object) {
-            illegal.add(o.name);
-          } else {
-            var info = (0, _identifiers.getIdentifierInfo)(o, p);
-
-            if (!info.spec.isReferenced) {
-              return;
-            }
-
-            if (info.spec.isDefined) {
-              if (info.isFunctionDeclaration || info.isClassDeclaration) {
-                illegal.add(o.name);
-              } else {
-                if (defined.has(o.name)) {
-                  illegal.add(o.name);
-                } else {
-                  defined.add(o.name);
-                }
-              }
-            }
-          }
-        }
+      var forInitializeType = (0, _insert.isForInitialize)(object, parents); // Get the block statement or Program node
 
-        if (o.type == "VariableDeclaration") {
-          return () => {
-            if (o.declarations.length === 1 && o.declarations[0].id.type === "Identifier") {
-              var name = o.declarations[0].id.name; // Check if duplicate
-
-              if (variableDeclarations[name] || o.kind !== "var") {
-                illegal.add(name);
-                return;
-              } // Check if already at top
-
-
-              if (body[0] === o) {
-                illegal.add(name);
-                return;
-              }
-
-              var replace = (0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(name), o.declarations[0].init || (0, _gen.Identifier)("undefined"));
-              var forType = (0, _insert.isForInitialize)(o, p);
-
-              if (forType === "left-hand") {
-                replace = (0, _gen.Identifier)(name);
-              } else if (!forType) {
-                replace = (0, _gen.ExpressionStatement)(replace);
-              }
-
-              variableDeclarations[name] = {
-                location: [o, p],
-                replace: replace
-              };
-            }
-          };
-        }
-      });
-      illegal.forEach(name => {
-        delete variableDeclarations[name];
-      });
-      var movingNames = Object.keys(variableDeclarations);
-
-      if (movingNames.length === 0) {
-        return;
-      }
+      var blockIndex = parents.findIndex(x => (0, _traverse.isBlock)(x));
+      var block = parents[blockIndex];
+      var body = block.body;
+      var bodyObject = parents[blockIndex - 2] || object; // Make sure in the block statement, and not already at the top of it
 
-      var variableDeclaration = (0, _gen.VariableDeclaration)(movingNames.map(name => {
-        return (0, _gen.VariableDeclarator)(name);
-      }));
+      var index = body.indexOf(bodyObject);
+      if (index === -1 || index === 0) return;
+      var topVariableDeclaration;
 
-      if (object.type == "Program") {
-        (0, _insert.prepend)(object, variableDeclaration);
+      if (body[0].type === "VariableDeclaration" && body[0].kind === "var") {
+        topVariableDeclaration = body[0];
       } else {
-        body.unshift(variableDeclaration);
+        topVariableDeclaration = {
+          type: "VariableDeclaration",
+          declarations: [],
+          kind: "var"
+        };
+        (0, _insert.prepend)(block, topVariableDeclaration);
       }
 
-      movingNames.forEach(name => {
-        var {
-          location,
-          replace
-        } = variableDeclarations[name];
-        this.replace(location[0], replace);
-      });
+      var varName = object.declarations[0].id.name;
+      (0, _assert.ok)(typeof varName === "string"); // Add `var x` at the top of the block
+
+      topVariableDeclaration.declarations.push((0, _gen.VariableDeclarator)((0, _gen.Identifier)(varName)));
+      var assignmentExpression = (0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(varName), object.declarations[0].init || (0, _gen.Identifier)(varName));
+
+      if (forInitializeType) {
+        if (forInitializeType === "initializer") {
+          // Replace `for (var i = 0...)` to `for (i = 0...)`
+          this.replace(object, assignmentExpression);
+        } else if (forInitializeType === "left-hand") {
+          // Replace `for (var k in...)` to `for (k in ...)`
+          this.replace(object, (0, _gen.Identifier)(varName));
+        }
+      } else {
+        // Replace `var x = value` to `x = value`
+        this.replace(object, (0, _gen.ExpressionStatement)(assignmentExpression));
+      }
     };
   }
 

package/dist/transforms/identifier/renameVariables.js

@@ -30,52 +30,58 @@ 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
+  // Option to re-use previously generated names
   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();
+    _defineProperty(this, "reusePreviousNames", true);
+
+    this.changed = new Map(); // 1.
+
     this.variableAnalysis = new _variableAnalysis.default(o);
     this.before.push(this.variableAnalysis);
-    this.gen = this.getGenerator();
     this.generated = [];
   }
 
   match(object, parents) {
-    return (0, _insert.isContext)(object);
+    return (0, _insert.isContext)(object) || object.type === "Identifier";
   }
 
-  transform(object, parents) {
+  transformContext(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 || []);
+    if (this.reusePreviousNames && this.generated.length && !isGlobal) {
+      var allReferences = new Set();
       var nope = new Set(defined);
       (0, _traverse.walk)(object, [], (o, p) => {
         var ref = this.variableAnalysis.references.get(o);
@@ -98,7 +104,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,80 +114,139 @@ 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(_constants.noRenameVariablePrefix) && ( // Variables prefixed with '__NO_JS_CONFUSER_RENAME__' are never renamed
+      isGlobal && !name.startsWith(_constants.placeholderVariablePrefix) // 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;
       }
-    });
+    } // console.log(object.type, newNames);
+
+
     this.changed.set(object, newNames);
-    (0, _traverse.walk)(object, parents, (o, p) => {
-      if (o.type == "Identifier") {
-        if (_constants.reservedIdentifiers.has(o.name) || this.options.globalVariables.has(o.name)) {
-          return;
-        }
+  }
 
-        var info = (0, _identifiers.getIdentifierInfo)(o, p);
+  transformIdentifier(object, parents) {
+    const identifierName = object.name;
 
-        if (info.spec.isExported) {
-          return;
-        }
+    if (_constants.reservedIdentifiers.has(identifierName) || this.options.globalVariables.has(identifierName)) {
+      return;
+    }
 
-        if (!info.spec.isReferenced) {
-          return;
-        }
+    if (object.$renamed) {
+      return;
+    }
 
-        var contexts = [o, ...p].filter(x => (0, _insert.isContext)(x));
-        var newName = null;
+    var info = (0, _identifiers.getIdentifierInfo)(object, parents);
 
-        for (var check of contexts) {
-          if (this.variableAnalysis.defined.has(check) && this.variableAnalysis.defined.get(check).has(o.name)) {
-            if (this.changed.has(check) && this.changed.get(check)[o.name]) {
-              newName = this.changed.get(check)[o.name];
-              break;
-            }
-          }
-        }
+    if (info.spec.isExported) {
+      return;
+    }
+
+    if (!info.spec.isReferenced) {
+      return;
+    }
 
-        if (newName && typeof newName === "string") {
-          if (o.$renamed) {
-            return;
-          } // Strange behavior where the `local` and `imported` objects are the same
+    var contexts = [object, ...parents].filter(x => (0, _insert.isContext)(x));
+    var newName = null; // Function default parameter check!
 
+    var functionIndices = [];
 
-          if (info.isImportSpecifier) {
-            var importSpecifierIndex = p.findIndex(x => x.type === "ImportSpecifier");
+    for (var i in parents) {
+      if ((0, _insert.isFunction)(parents[i])) {
+        functionIndices.push(i);
+      }
+    }
 
-            if (importSpecifierIndex != -1 && p[importSpecifierIndex].imported === (p[importSpecifierIndex - 1] || o) && p[importSpecifierIndex].imported && p[importSpecifierIndex].imported.type === "Identifier") {
-              p[importSpecifierIndex].imported = (0, _insert.clone)(p[importSpecifierIndex - 1] || o);
-            }
-          } // console.log(o.name, "->", newName);
+    for (var functionIndex of functionIndices) {
+      if (parents[functionIndex].id === object) {
+        // This context is not referenced, so remove it
+        contexts = contexts.filter(context => context != parents[functionIndex]);
+        continue;
+      }
+
+      if (parents[functionIndex].params === parents[functionIndex - 1]) {
+        var isReferencedHere = true;
+        var slicedParents = parents.slice(0, functionIndex);
+        var forIndex = 0;
+
+        for (var parent of slicedParents) {
+          var childNode = slicedParents[forIndex - 1] || object;
 
+          if (parent.type === "AssignmentPattern" && parent.right === childNode) {
+            isReferencedHere = false;
+            break;
+          }
+
+          forIndex++;
+        }
+
+        if (!isReferencedHere) {
+          // This context is not referenced, so remove it
+          contexts = contexts.filter(context => context != parents[functionIndex]);
+        }
+      }
+    }
 
-          o.name = newName;
-          o.$renamed = true;
+    for (var check of contexts) {
+      if (this.variableAnalysis.defined.has(check) && this.variableAnalysis.defined.get(check).has(identifierName)) {
+        if (this.changed.has(check) && this.changed.get(check)[identifierName]) {
+          newName = this.changed.get(check)[identifierName];
+          break;
         }
       }
-    });
+    }
+
+    if (newName && typeof newName === "string") {
+      // Strange behavior where the `local` and `imported` objects are the same
+      if (info.isImportSpecifier) {
+        var importSpecifierIndex = parents.findIndex(x => x.type === "ImportSpecifier");
+
+        if (importSpecifierIndex != -1 && parents[importSpecifierIndex].imported === (parents[importSpecifierIndex - 1] || object) && parents[importSpecifierIndex].imported && parents[importSpecifierIndex].imported.type === "Identifier") {
+          parents[importSpecifierIndex].imported = (0, _insert.clone)(parents[importSpecifierIndex - 1] || object);
+        }
+      } // console.log(o.name, "->", newName);
+      // 5. Update Identifier node's 'name' property
+
+
+      object.name = newName;
+      object.$renamed = true;
+    }
+  }
+
+  transform(object, parents) {
+    var matchType = object.type === "Identifier" ? "Identifier" : "Context";
+
+    if (matchType === "Identifier") {
+      this.transformIdentifier(object, parents);
+    } else {
+      this.transformContext(object, parents);
+    }
   }
 
 }