js-confuser 1.5.9 → 1.7.0

package/src/transforms/identifier/renameVariables.ts

@@ -1,32 +1,34 @@
 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,
+  isFunction,
 } from "../../util/insert";
-import { isValidIdentifier } from "../../util/compare";
 import Transform from "../transform";
-import { reservedIdentifiers } from "../../constants";
+import {
+  noRenameVariablePrefix,
+  placeholderVariablePrefix,
+  reservedIdentifiers,
+} from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
 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[];
 
@@ -36,22 +38,26 @@ export default class RenameVariables extends Transform {
   // Ref to VariableAnalysis data
   variableAnalysis: VariableAnalysis;
 
+  // Option to re-use previously generated names
+  reusePreviousNames = true;
+
   constructor(o) {
     super(o, ObfuscateOrder.RenameVariables);
 
     this.changed = new Map();
 
+    // 1.
     this.variableAnalysis = new VariableAnalysis(o);
     this.before.push(this.variableAnalysis);
-    this.gen = this.getGenerator();
     this.generated = [];
   }
 
-  match(object, parents) {
-    return isContext(object);
+  match(object: Node, parents: Node[]) {
+    return isContext(object) || object.type === "Identifier";
   }
 
-  transform(object, parents) {
+  transformContext(object: Node, parents: Node[]) {
+    // 2. Notice this is on 'onEnter' (top-down)
     var isGlobal = object.type == "Program";
     var type = isGlobal
       ? "root"
@@ -68,15 +74,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>();
 
-    if (this.generated.length && !isGlobal) {
-      var allReferences = new Set(references || []);
+    // 3. Try to re-use names when possible
+    if (this.reusePreviousNames && this.generated.length && !isGlobal) {
+      var allReferences = new Set<string>();
       var nope = new Set(defined);
       walk(object, [], (o, p) => {
         var ref = this.variableAnalysis.references.get(o);
@@ -90,14 +99,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,104 +120,166 @@ 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(noRenameVariablePrefix) && // Variables prefixed with '__NO_JS_CONFUSER_RENAME__' are never renamed
+        (isGlobal && !name.startsWith(placeholderVariablePrefix) // 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;
       }
-    });
+    }
 
+    // console.log(object.type, newNames);
     this.changed.set(object, newNames);
+  }
 
-    walk(object, parents, (o, p) => {
-      if (o.type == "Identifier") {
-        if (
-          reservedIdentifiers.has(o.name) ||
-          this.options.globalVariables.has(o.name)
-        ) {
-          return;
-        }
+  transformIdentifier(object: Node, parents: Node[]) {
+    const identifierName = object.name;
+    if (
+      reservedIdentifiers.has(identifierName) ||
+      this.options.globalVariables.has(identifierName)
+    ) {
+      return;
+    }
+
+    if (object.$renamed) {
+      return;
+    }
 
-        var info = getIdentifierInfo(o, p);
+    var info = getIdentifierInfo(object, parents);
 
-        if (info.spec.isExported) {
-          return;
-        }
+    if (info.spec.isExported) {
+      return;
+    }
 
-        if (!info.spec.isReferenced) {
-          return;
-        }
+    if (!info.spec.isReferenced) {
+      return;
+    }
+
+    var contexts = [object, ...parents].filter((x) => isContext(x));
+    var newName = null;
+
+    // Function default parameter check!
+    var functionIndices = [];
+    for (var i in parents) {
+      if (isFunction(parents[i])) {
+        functionIndices.push(i);
+      }
+    }
 
-        var contexts = [o, ...p].filter((x) => isContext(x));
-        var newName = null;
+    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;
 
-        for (var check of contexts) {
           if (
-            this.variableAnalysis.defined.has(check) &&
-            this.variableAnalysis.defined.get(check).has(o.name)
+            parent.type === "AssignmentPattern" &&
+            parent.right === childNode
           ) {
-            if (this.changed.has(check) && this.changed.get(check)[o.name]) {
-              newName = this.changed.get(check)[o.name];
-              break;
-            }
+            isReferencedHere = false;
+            break;
           }
+
+          forIndex++;
         }
 
-        if (newName && typeof newName === "string") {
-          if (o.$renamed) {
-            return;
-          }
+        if (!isReferencedHere) {
+          // This context is not referenced, so remove it
+          contexts = contexts.filter(
+            (context) => context != parents[functionIndex]
+          );
+        }
+      }
+    }
 
-          // Strange behavior where the `local` and `imported` objects are the same
-          if (info.isImportSpecifier) {
-            var importSpecifierIndex = p.findIndex(
-              (x) => x.type === "ImportSpecifier"
-            );
-            if (
-              importSpecifierIndex != -1 &&
-              p[importSpecifierIndex].imported ===
-                (p[importSpecifierIndex - 1] || o) &&
-              p[importSpecifierIndex].imported &&
-              p[importSpecifierIndex].imported.type === "Identifier"
-            ) {
-              p[importSpecifierIndex].imported = clone(
-                p[importSpecifierIndex - 1] || o
-              );
-            }
-          }
+    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;
+        }
+      }
+    }
 
-          // console.log(o.name, "->", newName);
-          o.name = newName;
-          o.$renamed = true;
+    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 = 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: Node, parents: Node[]) {
+    var matchType = object.type === "Identifier" ? "Identifier" : "Context";
+    if (matchType === "Identifier") {
+      this.transformIdentifier(object, parents);
+    } else {
+      this.transformContext(object, parents);
+    }
   }
 }

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);
+        }
       }
     });
   }

package/src/transforms/lock/lock.ts

@@ -219,9 +219,7 @@ export default class Lock extends Transform {
     if (this.options.lock.domainLock && this.options.lock.domainLock.length) {
       choices.push("domainLock");
     }
-    if (this.options.lock.nativeFunctions) {
-      choices.push("nativeFunction");
-    }
+
     if (this.options.lock.context && this.options.lock.context.length) {
       choices.push("context");
     }
@@ -312,45 +310,6 @@ export default class Lock extends Transform {
 
           break;
 
-        case "nativeFunction":
-          var set = this.options.lock.nativeFunctions;
-          if (set === true) {
-            if (this.options.target == "node") {
-              set = new Set(["Function", "String"]);
-            } else {
-              set = new Set(["Function", "String", "fetch"]);
-            }
-          }
-          if (Array.isArray(set)) {
-            set = new Set(set);
-          }
-          if (!set) {
-            set = new Set();
-          }
-
-          var fn = choice(Array.from(set));
-          if (fn) {
-            test = Template(
-              `(${fn}+"").indexOf("[native code]") == -1`
-            ).single().expression;
-
-            if (Math.random() > 0.5) {
-              test = Template(
-                `${fn}.toString().split("{ [native code] }").length <= 1`
-              ).single().expression;
-            }
-
-            nodes.push(
-              IfStatement(
-                test,
-                this.getCounterMeasuresCode(object, parents) || [],
-                null
-              )
-            );
-          }
-
-          break;
-
         case "startDate":
           test = BinaryExpression(
             "<",