js-confuser 1.5.8 → 1.6.0

package/src/transforms/identifier/globalConcealing.ts

@@ -16,88 +16,15 @@ import {
   VariableDeclarator,
   FunctionExpression,
   ExpressionStatement,
-  SequenceExpression,
   AssignmentExpression,
   VariableDeclaration,
   BreakStatement,
 } from "../../util/gen";
 import { append, prepend } from "../../util/insert";
-import { getIdentifierInfo } from "../../util/identifiers";
-import { getRandomInteger } from "../../util/random";
-import { reservedIdentifiers, reservedKeywords } from "../../constants";
+import { chance, getRandomInteger } from "../../util/random";
+import { reservedIdentifiers } from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
-
-class GlobalAnalysis extends Transform {
-  notGlobals: Set<string>;
-  globals: { [name: string]: Location[] };
-
-  constructor(o) {
-    super(o);
-
-    this.globals = Object.create(null);
-    this.notGlobals = new Set();
-  }
-
-  match(object: Node, parents: Node[]) {
-    return object.type == "Identifier" && !reservedKeywords.has(object.name);
-  }
-
-  transform(object: Node, parents: Node[]) {
-    // 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 = 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);
-      }
-    }
-  }
-}
+import GlobalAnalysis from "./globalAnalysis";
 
 /**
  * Global Concealing hides global variables being accessed.
@@ -141,12 +68,10 @@ export default class GlobalConcealing extends Transform {
         }
       });
 
-      // this.log(Object.keys(globals).join(', '))
-
       if (Object.keys(globals).length > 0) {
         var used = new Set();
 
-        // 1. Make getter function
+        // Make getter function
 
         // holds "window" or "global"
         var globalVar = this.getPlaceholder();
@@ -157,6 +82,8 @@ export default class GlobalConcealing extends Transform {
         // "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();
 
@@ -164,7 +91,7 @@ export default class GlobalConcealing extends Transform {
         var getGlobalVariableFn = Template(`
         var ${getGlobalVariableFnName} = function(){
           try {
-            return ${global};
+            return ${global} || ${alternateGlobal} || (new Function("return this"))();
           } catch (e){
             return ${getThisVariableFnName}["call"](this);
           }
@@ -182,7 +109,7 @@ export default class GlobalConcealing extends Transform {
         // 2. Replace old accessors
         var globalFn = this.getPlaceholder();
 
-        var newNames = Object.create(null);
+        var newNames: { [globalVarName: string]: number } = Object.create(null);
 
         Object.keys(globals).forEach((name) => {
           var locations: Location[] = globals[name];
@@ -195,26 +122,10 @@ export default class GlobalConcealing extends Transform {
           newNames[name] = state;
 
           locations.forEach(([node, parents]) => {
-            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,
-                CallExpression(Identifier(globalFn), [Literal(state)])
-              );
-            }
+            this.replace(
+              node,
+              CallExpression(Identifier(globalFn), [Literal(state)])
+            );
           });
         });
 
@@ -224,7 +135,7 @@ export default class GlobalConcealing extends Transform {
             var state;
             do {
               state = getRandomInteger(
-                -1000,
+                0,
                 1000 + used.size + this.options.globalVariables.size * 100
               );
             } while (used.has(state));
@@ -259,7 +170,7 @@ export default class GlobalConcealing extends Transform {
                     )
                   ),
                 ];
-                if (Math.random() > 0.5 && name) {
+                if (chance(50)) {
                   body = [
                     ExpressionStatement(
                       AssignmentExpression(

package/src/transforms/identifier/movedDeclarations.ts

@@ -1,21 +1,18 @@
 import Transform from "../transform";
-import { isBlock, getBlock, walk } from "../../traverse";
+import { isBlock, walk } from "../../traverse";
 import {
   Location,
   ExpressionStatement,
-  SequenceExpression,
   AssignmentExpression,
   Identifier,
   Node,
   VariableDeclarator,
   VariableDeclaration,
 } from "../../util/gen";
-import { clone, isForInitialize, isFunction, prepend } from "../../util/insert";
+import { isForInitialize, prepend } from "../../util/insert";
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
 import { getIdentifierInfo } from "../../util/identifiers";
-import { isLoop } from "../../util/compare";
-import { reservedIdentifiers } from "../../constants";
 import { isLexicalScope, getLexicalScope } from "../../util/scope";
 
 /**
@@ -46,7 +43,7 @@ export default class MovedDeclarations extends Transform {
 
       walk(object, parents, (o, p) => {
         if (o.type == "Identifier") {
-          if (getLexicalScope(o, p) !== object) {
+          if (o.hidden || getLexicalScope(o, p) !== object) {
             illegal.add(o.name);
           } else {
             var info = getIdentifierInfo(o, p);
@@ -125,11 +122,7 @@ export default class MovedDeclarations extends Transform {
         })
       );
 
-      if (object.type == "Program") {
-        prepend(object, variableDeclaration);
-      } else {
-        body.unshift(variableDeclaration);
-      }
+      prepend(object, variableDeclaration);
 
       movingNames.forEach((name) => {
         var { location, replace } = variableDeclarations[name];

package/src/transforms/identifier/renameVariables.ts

@@ -1,18 +1,14 @@
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
 import { walk } from "../../traverse";
-import { Location, Node } from "../../util/gen";
+import { Node } from "../../util/gen";
 import { getIdentifierInfo } from "../../util/identifiers";
 import {
-  getVarContext,
   isVarContext,
-  getLexContext,
   isContext,
   isLexContext,
-  getDefiningContext,
   clone,
 } from "../../util/insert";
-import { isValidIdentifier } from "../../util/compare";
 import Transform from "../transform";
 import { reservedIdentifiers } from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
@@ -21,12 +17,13 @@ import VariableAnalysis from "./variableAnalysis";
 /**
  * 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
  */
 export default class RenameVariables extends Transform {
-  // Generator object
-  gen: any;
-
   // Names already used
   generated: string[];
 
@@ -41,17 +38,18 @@ export default class RenameVariables extends Transform {
 
     this.changed = new Map();
 
+    // 1.
     this.variableAnalysis = new VariableAnalysis(o);
     this.before.push(this.variableAnalysis);
-    this.gen = this.getGenerator();
     this.generated = [];
   }
 
-  match(object, parents) {
+  match(object: Node, parents: Node[]) {
     return isContext(object);
   }
 
-  transform(object, parents) {
+  transform(object: Node, parents: Node[]) {
+    // 2. Notice this is on 'onEnter' (top-down)
     var isGlobal = object.type == "Program";
     var type = isGlobal
       ? "root"
@@ -68,15 +66,18 @@ export default class RenameVariables extends Transform {
     var defined = this.variableAnalysis.defined.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;
     }
 
-    var possible = new Set();
+    // Names possible to be re-used here
+    var possible = new Set<string>();
 
+    // 3. Try to re-use names when possible
     if (this.generated.length && !isGlobal) {
-      var allReferences = new Set(references || []);
+      var allReferences = new Set<string>();
       var nope = new Set(defined);
       walk(object, [], (o, p) => {
         var ref = this.variableAnalysis.references.get(o);
@@ -90,14 +91,14 @@ export default class RenameVariables extends Transform {
         }
       });
 
-      var passed = new Set();
+      var passed = new Set<string>();
       parents.forEach((p) => {
         var changes = this.changed.get(p);
         if (changes) {
           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);
@@ -111,42 +112,48 @@ export default class RenameVariables extends Transform {
       possible = passed;
     }
 
-    defined.forEach((name) => {
+    // 4. Defined names to new names
+    for (var name of defined) {
       if (
-        (isGlobal && !name.startsWith("__p_")
+        !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
           ? ComputeProbabilityMap(this.options.renameGlobals, (x) => x, name)
           : true) &&
         ComputeProbabilityMap(
+          // Check the user's option for renaming variables
           this.options.renameVariables,
           (x) => x,
           name,
           isGlobal
         )
       ) {
-        // Fix 2. Ensure global names aren't overridden
-        var newName;
+        // Create a new name from (1) or (2) methods
+        var newName: string;
         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();
+            // (2) Create a new name with `generateIdentifier` function
+            var generatedName = this.generateIdentifier();
 
-            newName = g;
-            this.generated.push(g);
+            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);
 
+    // 5. Update Identifier node's 'name' property
     walk(object, parents, (o, p) => {
       if (o.type == "Identifier") {
         if (
@@ -156,6 +163,10 @@ export default class RenameVariables extends Transform {
           return;
         }
 
+        if (o.$renamed) {
+          return;
+        }
+
         var info = getIdentifierInfo(o, p);
 
         if (info.spec.isExported) {
@@ -182,10 +193,6 @@ export default class RenameVariables extends Transform {
         }
 
         if (newName && typeof newName === "string") {
-          if (o.$renamed) {
-            return;
-          }
-
           // Strange behavior where the `local` and `imported` objects are the same
           if (info.isImportSpecifier) {
             var importSpecifierIndex = p.findIndex(

package/src/transforms/identifier/variableAnalysis.ts

@@ -1,14 +1,9 @@
 import { ok } from "assert";
 import { reservedIdentifiers } from "../../constants";
-import { walk } from "../../traverse";
 import { isValidIdentifier } from "../../util/compare";
 import { Node } from "../../util/gen";
 import { getIdentifierInfo } from "../../util/identifiers";
 import {
-  getDefiningContext,
-  getVarContext,
-  getLexContext,
-  isContext,
   getReferencingContexts,
   getAllDefiningContexts,
 } from "../../util/insert";
@@ -30,11 +25,13 @@ export default class VariableAnalysis extends Transform {
 
   /**
    * Set of global identifiers to never be redefined
+   *
+   * - Used to not accidentally block access to a global variable
    */
   globals: Set<string>;
 
   /**
-   * Set of identifers that are defined within the program
+   * Set of identifiers that are defined within the program
    */
   notGlobals: Set<string>;
 
@@ -48,77 +45,73 @@ export default class VariableAnalysis extends Transform {
   }
 
   match(object, parents) {
-    return isContext(object);
+    return object.type === "Identifier";
   }
 
-  transform(object, parents) {
-    walk(object, parents, (o, p) => {
-      if (o.type == "Identifier") {
-        var name = o.name;
-        ok(typeof name === "string");
-        if (!isValidIdentifier(name)) {
-          return;
+  transform(object: Node, parents: Node[]) {
+    var name = object.name;
+    ok(typeof name === "string");
+    if (!isValidIdentifier(name)) {
+      return;
+    }
+
+    if (reservedIdentifiers.has(name)) {
+      return;
+    }
+    if (this.options.globalVariables.has(name)) {
+      return;
+    }
+
+    var info = 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
+      ? getAllDefiningContexts(object, parents)
+      : getReferencingContexts(object, parents, info);
+
+    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());
         }
-
-        if (reservedIdentifiers.has(name)) {
-          return;
-        }
-        if (this.options.globalVariables.has(name)) {
-          return;
-        }
-
-        var info = getIdentifierInfo(o, p);
-        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(o.name);
-          this.globals.delete(o.name);
-        } else if (!this.notGlobals.has(o.name)) {
-          this.globals.add(o.name);
-        }
-
-        var definingContexts = info.spec.isDefined
-          ? getAllDefiningContexts(o, p)
-          : getReferencingContexts(o, p, info);
-
-        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);
-            }
+        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);
+        }
       }
     });
   }