js-confuser 1.6.0 → 1.7.0

package/src/transforms/identifier/movedDeclarations.ts

@@ -1,19 +1,15 @@
 import Transform from "../transform";
-import { isBlock, walk } from "../../traverse";
+import { isBlock } from "../../traverse";
 import {
-  Location,
   ExpressionStatement,
   AssignmentExpression,
   Identifier,
   Node,
   VariableDeclarator,
-  VariableDeclaration,
 } from "../../util/gen";
 import { isForInitialize, prepend } from "../../util/insert";
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
-import { getIdentifierInfo } from "../../util/identifiers";
-import { isLexicalScope, getLexicalScope } from "../../util/scope";
 
 /**
  * Defines all the names at the top of every lexical block.
@@ -24,110 +20,68 @@ export default class MovedDeclarations extends Transform {
   }
 
   match(object, parents) {
-    return isLexicalScope(object);
+    return (
+      object.type === "VariableDeclaration" &&
+      object.kind === "var" &&
+      object.declarations.length === 1 &&
+      object.declarations[0].id.type === "Identifier"
+    );
   }
 
   transform(object: Node, parents: Node[]) {
     return () => {
-      var body = isBlock(object) ? object.body : object.consequent;
-      ok(Array.isArray(body));
-
-      var illegal = new Set<string>();
-      var defined = new Set<string>();
-      var variableDeclarations: {
-        [name: string]: {
-          location: Location;
-          replace: Node;
+      var forInitializeType = isForInitialize(object, parents);
+
+      // Get the block statement or Program node
+      var blockIndex = parents.findIndex((x) => 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 index = body.indexOf(bodyObject);
+      if (index === -1 || index === 0) return;
+
+      var topVariableDeclaration;
+      if (body[0].type === "VariableDeclaration" && body[0].kind === "var") {
+        topVariableDeclaration = body[0];
+      } else {
+        topVariableDeclaration = {
+          type: "VariableDeclaration",
+          declarations: [],
+          kind: "var",
         };
-      } = Object.create(null);
-
-      walk(object, parents, (o, p) => {
-        if (o.type == "Identifier") {
-          if (o.hidden || getLexicalScope(o, p) !== object) {
-            illegal.add(o.name);
-          } else {
-            var info = 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);
-                }
-              }
-            }
-          }
-        }
+        prepend(block, topVariableDeclaration);
+      }
 
-        if (o.type == "VariableDeclaration") {
-          return () => {
-            if (
-              o.declarations.length === 1 &&
-              o.declarations[0].id.type === "Identifier"
-            ) {
-              var name = o.declarations[0].id.name;
+      var varName = object.declarations[0].id.name;
+      ok(typeof varName === "string");
 
-              // Check if duplicate
-              if (variableDeclarations[name] || o.kind !== "var") {
-                illegal.add(name);
-                return;
-              }
+      // Add `var x` at the top of the block
+      topVariableDeclaration.declarations.push(
+        VariableDeclarator(Identifier(varName))
+      );
 
-              // Check if already at top
-              if (body[0] === o) {
-                illegal.add(name);
-                return;
-              }
+      var assignmentExpression = AssignmentExpression(
+        "=",
+        Identifier(varName),
+        object.declarations[0].init || Identifier(varName)
+      );
 
-              var replace: Node = AssignmentExpression(
-                "=",
-                Identifier(name),
-                o.declarations[0].init || Identifier("undefined")
-              );
+      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 ...)`
 
-              var forType = isForInitialize(o, p);
-              if (forType === "left-hand") {
-                replace = Identifier(name);
-              } else if (!forType) {
-                replace = ExpressionStatement(replace);
-              }
-              variableDeclarations[name] = {
-                location: [o, p],
-                replace: replace,
-              };
-            }
-          };
+          this.replace(object, Identifier(varName));
         }
-      });
-
-      illegal.forEach((name) => {
-        delete variableDeclarations[name];
-      });
-
-      var movingNames = Object.keys(variableDeclarations);
-
-      if (movingNames.length === 0) {
-        return;
+      } else {
+        // Replace `var x = value` to `x = value`
+        this.replace(object, ExpressionStatement(assignmentExpression));
       }
-
-      var variableDeclaration = VariableDeclaration(
-        movingNames.map((name) => {
-          return VariableDeclarator(name);
-        })
-      );
-
-      prepend(object, variableDeclaration);
-
-      movingNames.forEach((name) => {
-        var { location, replace } = variableDeclarations[name];
-        this.replace(location[0], replace);
-      });
     };
   }
 }

package/src/transforms/identifier/renameVariables.ts

@@ -8,9 +8,14 @@ import {
   isContext,
   isLexContext,
   clone,
+  isFunction,
 } from "../../util/insert";
 import Transform from "../transform";
-import { reservedIdentifiers } from "../../constants";
+import {
+  noRenameVariablePrefix,
+  placeholderVariablePrefix,
+  reservedIdentifiers,
+} from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
 import VariableAnalysis from "./variableAnalysis";
 
@@ -33,6 +38,9 @@ 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);
 
@@ -45,10 +53,10 @@ export default class RenameVariables extends Transform {
   }
 
   match(object: Node, parents: Node[]) {
-    return isContext(object);
+    return isContext(object) || object.type === "Identifier";
   }
 
-  transform(object: Node, parents: Node[]) {
+  transformContext(object: Node, parents: Node[]) {
     // 2. Notice this is on 'onEnter' (top-down)
     var isGlobal = object.type == "Program";
     var type = isGlobal
@@ -76,7 +84,7 @@ export default class RenameVariables extends Transform {
     var possible = new Set<string>();
 
     // 3. Try to re-use names when possible
-    if (this.generated.length && !isGlobal) {
+    if (this.reusePreviousNames && this.generated.length && !isGlobal) {
       var allReferences = new Set<string>();
       var nope = new Set(defined);
       walk(object, [], (o, p) => {
@@ -115,8 +123,8 @@ export default class RenameVariables extends Transform {
     // 4. Defined names to new names
     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
+        !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(
@@ -151,71 +159,127 @@ export default class RenameVariables extends Transform {
       }
     }
 
+    // console.log(object.type, newNames);
     this.changed.set(object, newNames);
+  }
 
-    // 5. Update Identifier node's 'name' property
-    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 (o.$renamed) {
-          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);
+      }
+    }
+
+    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 contexts = [o, ...p].filter((x) => isContext(x));
-        var newName = null;
+        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") {
-          // 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
-              );
-            }
-          }
+        if (!isReferencedHere) {
+          // This context is not referenced, so remove it
+          contexts = contexts.filter(
+            (context) => context != parents[functionIndex]
+          );
+        }
+      }
+    }
 
-          // console.log(o.name, "->", newName);
-          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 = 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/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(
             "<",

package/src/transforms/minify.ts

@@ -22,6 +22,7 @@ import {
   isForInitialize,
   append,
   isVarContext,
+  computeFunctionLength,
 } from "../util/insert";
 import { isValidIdentifier, isEquivalent } from "../util/compare";
 import { walk, isBlock } from "../traverse";
@@ -258,8 +259,15 @@ export default class Minify extends Transform {
             append(
               parents[parents.length - 1] || object,
               Template(`
-            function ${this.arrowFunctionName}(arrowFn){
-              return function(){ return arrowFn(...arguments) }
+            function ${this.arrowFunctionName}(arrowFn, functionLength){
+              var functionObject = function(){ return arrowFn(...arguments) };
+
+              Object["defineProperty"](functionObject, "length", {
+                "value": functionLength,
+                "configurable": true
+              });
+
+              return functionObject;
             }
             `).single()
             );
@@ -268,6 +276,7 @@ export default class Minify extends Transform {
           const wrap = (object: Node) => {
             return CallExpression(Identifier(this.arrowFunctionName), [
               clone(object),
+              Literal(computeFunctionLength(object.params)),
             ]);
           };