js-confuser 1.6.0 → 1.7.0

package/dist/transforms/identifier/renameVariables.js

@@ -40,6 +40,7 @@ class RenameVariables extends _transform.default {
   // 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);
 
@@ -49,6 +50,8 @@ class RenameVariables extends _transform.default {
 
     _defineProperty(this, "variableAnalysis", void 0);
 
+    _defineProperty(this, "reusePreviousNames", true);
+
     this.changed = new Map(); // 1.
 
     this.variableAnalysis = new _variableAnalysis.default(o);
@@ -57,10 +60,10 @@ class RenameVariables extends _transform.default {
   }
 
   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;
@@ -77,7 +80,7 @@ class RenameVariables extends _transform.default {
 
     var possible = new Set(); // 3. Try to re-use names when possible
 
-    if (this.generated.length && !isGlobal) {
+    if (this.reusePreviousNames && this.generated.length && !isGlobal) {
       var allReferences = new Set();
       var nope = new Set(defined);
       (0, _traverse.walk)(object, [], (o, p) => {
@@ -115,8 +118,8 @@ class RenameVariables extends _transform.default {
 
 
     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
+      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
@@ -142,58 +145,108 @@ class RenameVariables extends _transform.default {
         // This variable name was deemed not to be renamed.
         newNames[name] = name;
       }
+    } // console.log(object.type, newNames);
+
+
+    this.changed.set(object, newNames);
+  }
+
+  transformIdentifier(object, parents) {
+    const identifierName = object.name;
+
+    if (_constants.reservedIdentifiers.has(identifierName) || this.options.globalVariables.has(identifierName)) {
+      return;
     }
 
-    this.changed.set(object, newNames); // 5. Update Identifier node's 'name' property
+    if (object.$renamed) {
+      return;
+    }
 
-    (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)(object, parents);
 
-        if (o.$renamed) {
-          return;
-        }
+    if (info.spec.isExported) {
+      return;
+    }
 
-        var info = (0, _identifiers.getIdentifierInfo)(o, p);
+    if (!info.spec.isReferenced) {
+      return;
+    }
 
-        if (info.spec.isExported) {
-          return;
-        }
+    var contexts = [object, ...parents].filter(x => (0, _insert.isContext)(x));
+    var newName = null; // Function default parameter check!
 
-        if (!info.spec.isReferenced) {
-          return;
-        }
+    var functionIndices = [];
 
-        var contexts = [o, ...p].filter(x => (0, _insert.isContext)(x));
-        var newName = null;
+    for (var i in parents) {
+      if ((0, _insert.isFunction)(parents[i])) {
+        functionIndices.push(i);
+      }
+    }
 
-        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;
-            }
+    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 (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 (!isReferencedHere) {
+          // This context is not referenced, so remove it
+          contexts = contexts.filter(context => context != parents[functionIndex]);
+        }
+      }
+    }
 
-            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 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");
 
-          o.name = newName;
-          o.$renamed = true;
+        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);
+    }
   }
 
 }

package/dist/transforms/lock/lock.js

@@ -194,10 +194,6 @@ class Lock extends _transform.default {
       choices.push("domainLock");
     }
 
-    if (this.options.lock.nativeFunctions) {
-      choices.push("nativeFunction");
-    }
-
     if (this.options.lock.context && this.options.lock.context.length) {
       choices.push("context");
     }
@@ -248,39 +244,6 @@ class Lock extends _transform.default {
           nodes.push((0, _gen.IfStatement)(callExpression, this.getCounterMeasuresCode(object, parents) || [], null));
           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 = (0, _random.choice)(Array.from(set));
-
-          if (fn) {
-            test = (0, _template.default)("(".concat(fn, "+\"\").indexOf(\"[native code]\") == -1")).single().expression;
-
-            if (Math.random() > 0.5) {
-              test = (0, _template.default)("".concat(fn, ".toString().split(\"{ [native code] }\").length <= 1")).single().expression;
-            }
-
-            nodes.push((0, _gen.IfStatement)(test, this.getCounterMeasuresCode(object, parents) || [], null));
-          }
-
-          break;
-
         case "startDate":
           test = (0, _gen.BinaryExpression)("<", dateNow, (0, _gen.Literal)(this.getTime(this.options.lock.startDate)));
           nodes.push((0, _gen.IfStatement)(test, this.getCounterMeasuresCode(object, parents) || [], null));

package/dist/transforms/minify.js

@@ -214,11 +214,11 @@ 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());
+            (0, _insert.append)(parents[parents.length - 1] || object, (0, _template.default)("\n            function ".concat(this.arrowFunctionName, "(arrowFn, functionLength){\n              var functionObject = function(){ return arrowFn(...arguments) };\n\n              Object[\"defineProperty\"](functionObject, \"length\", {\n                \"value\": functionLength,\n                \"configurable\": true\n              });\n\n              return functionObject;\n            }\n            ")).single());
           }
 
           const wrap = object => {
-            return (0, _gen.CallExpression)((0, _gen.Identifier)(this.arrowFunctionName), [(0, _insert.clone)(object)]);
+            return (0, _gen.CallExpression)((0, _gen.Identifier)(this.arrowFunctionName), [(0, _insert.clone)(object), (0, _gen.Literal)((0, _insert.computeFunctionLength)(object.params))]);
           };
 
           if (object.type == "FunctionExpression") {