js-confuser 1.6.0 → 1.7.0

package/src/transforms/stack.ts

@@ -6,6 +6,7 @@ import { walk } from "../traverse";
 import {
   AssignmentExpression,
   BinaryExpression,
+  CallExpression,
   ExpressionStatement,
   Identifier,
   IfStatement,
@@ -18,6 +19,7 @@ import {
 } from "../util/gen";
 import { getIdentifierInfo } from "../util/identifiers";
 import {
+  computeFunctionLength,
   getBlockBody,
   getDefiningContext,
   getReferencingContexts,
@@ -28,10 +30,14 @@ import {
 } from "../util/insert";
 import { chance, choice, getRandomInteger } from "../util/random";
 import Transform from "./transform";
+import { noRenameVariablePrefix } from "../constants";
+import { FunctionLengthTemplate } from "../templates/functionLength";
 
 export default class Stack extends Transform {
   mangledExpressionsMade: number;
 
+  functionLengthName: string;
+
   constructor(o) {
     super(o, ObfuscateOrder.Stack);
 
@@ -111,8 +117,14 @@ export default class Stack extends Transform {
       });
 
       var startingSize = subscripts.size;
+      var isIllegal = false;
 
       walk(object.body, [object, ...parents], (o, p) => {
+        if (o.type === "Identifier" && o.name === "arguments") {
+          isIllegal = true;
+          return "EXIT";
+        }
+
         if (o.type == "Identifier") {
           var info = getIdentifierInfo(o, p);
           if (!info.spec.isReferenced || info.spec.isExported) {
@@ -128,6 +140,10 @@ export default class Stack extends Transform {
             illegal.add(o.name);
           }
 
+          if (o.name.startsWith(noRenameVariablePrefix)) {
+            illegal.add(o.name);
+          }
+
           if (
             info.isClauseParameter ||
             info.isFunctionParameter ||
@@ -200,6 +216,8 @@ export default class Stack extends Transform {
         }
       });
 
+      if (isIllegal) return;
+
       illegal.forEach((name) => {
         defined.delete(name);
         referenced.delete(name);
@@ -467,6 +485,9 @@ export default class Stack extends Transform {
         object.body.body.splice(parseInt(index) + i, 0, rotateNodes[index]);
       });
 
+      // Preserve function.length property
+      var originalFunctionLength = computeFunctionLength(object.params);
+
       // Set the params for this function to be the stack array
       object.params = [RestElement(Identifier(stackName))];
 
@@ -475,6 +496,47 @@ export default class Stack extends Transform {
         object.body,
         Template(`${stackName}["length"] = ${startingSize}`).single()
       );
+
+      if (originalFunctionLength !== 0) {
+        if (!this.functionLengthName) {
+          this.functionLengthName = this.getPlaceholder();
+          prepend(
+            parents[parents.length - 1] || object,
+            FunctionLengthTemplate.single({ name: this.functionLengthName })
+          );
+        }
+
+        if (object.type === "FunctionDeclaration") {
+          var body = parents[0];
+          if (Array.isArray(body)) {
+            var index = body.indexOf(object);
+
+            body.splice(
+              index,
+              0,
+              ExpressionStatement(
+                CallExpression(Identifier(this.functionLengthName), [
+                  Identifier(object.id.name),
+                  Literal(originalFunctionLength),
+                ])
+              )
+            );
+          }
+        } else {
+          ok(
+            object.type === "FunctionExpression" ||
+              object.type === "ArrowFunctionExpression"
+          );
+
+          this.replace(
+            object,
+            CallExpression(Identifier(this.functionLengthName), [
+              { ...object },
+              Literal(originalFunctionLength),
+            ])
+          );
+        }
+      }
     };
   }
 }

package/src/transforms/transform.ts

@@ -9,7 +9,11 @@ import { ok } from "assert";
 import Obfuscator from "../obfuscator";
 import { ObfuscateOptions } from "../options";
 import { ComputeProbabilityMap } from "../probability";
-import { reservedIdentifiers, reservedKeywords } from "../constants";
+import {
+  placeholderVariablePrefix,
+  reservedIdentifiers,
+  reservedKeywords,
+} from "../constants";
 import { ObfuscateOrder } from "../order";
 
 /**
@@ -176,7 +180,7 @@ export default class Transform {
       [...Array(size)]
         .map(() => Math.floor(Math.random() * 10).toString(10))
         .join("");
-    return "__p_" + genRanHex(10);
+    return placeholderVariablePrefix + genRanHex(10);
   }
 
   /**

package/src/util/gen.ts

@@ -171,7 +171,12 @@ export function BreakStatement(label?: string) {
   };
 }
 
-export function Property(key: Node, value: Node, computed = false) {
+export function Property(
+  key: Node,
+  value: Node,
+  computed = false,
+  kind: "init" | "set" | "get" = "init"
+) {
   if (!key) {
     throw new Error("key is undefined");
   }
@@ -183,7 +188,7 @@ export function Property(key: Node, value: Node, computed = false) {
     key: key,
     computed: computed,
     value: value,
-    kind: "init",
+    kind: kind,
     method: false,
     shorthand: false,
   };

package/src/util/identifiers.ts

@@ -30,6 +30,23 @@ export function validateChain(object: Node, parents: Node[]) {
   }
 }
 
+function objectPatternCheck(object: Node, parents: Node[]) {
+  var objectPatternIndex = parents.findIndex((x) => x.type === "ObjectPattern");
+  if (objectPatternIndex == -1) {
+    return true;
+  }
+
+  var property = parents[objectPatternIndex].properties.find(
+    (property) => parents[objectPatternIndex - 2] === property
+  );
+
+  if (property.key === (parents[objectPatternIndex - 3] || object)) {
+    return false;
+  }
+
+  return true;
+}
+
 /**
  * Returns detailed information about the given Identifier node.
  * @param object
@@ -74,7 +91,22 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
   var isVariableDeclaration =
     varIndex != -1 &&
     parents[varIndex].id == (parents[varIndex - 1] || object) &&
-    parents.find((x) => x.type == "VariableDeclaration");
+    parents.find((x) => x.type == "VariableDeclaration") &&
+    objectPatternCheck(object, parents);
+
+  // Assignment pattern check!
+  if (isVariableDeclaration) {
+    var slicedParents = parents.slice(0, varIndex - 1);
+    var i = 0;
+    for (var parent of slicedParents) {
+      var childNode = slicedParents[i - 1] || object;
+      if (parent.type === "AssignmentPattern" && parent.right === childNode) {
+        isVariableDeclaration = false;
+        break;
+      }
+      i++;
+    }
+  }
 
   var forIndex = parents.findIndex((x) => x.type == "ForStatement");
   var isForInitializer =
@@ -87,6 +119,12 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
     functionIndex != -1 &&
     parents[functionIndex].type == "FunctionDeclaration" &&
     parents[functionIndex].id == object;
+
+  var isNamedFunctionExpression =
+    functionIndex != -1 &&
+    parents[functionIndex].type === "FunctionExpression" &&
+    parents[functionIndex].id === object;
+
   var isAFunctionParameter = isFunctionParameter(object, parents);
 
   var isClauseParameter = false;
@@ -112,7 +150,9 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
 
   var isAssignmentLeft =
     assignmentIndex !== -1 &&
-    parents[assignmentIndex].left === (parents[assignmentIndex - 1] || object);
+    parents[assignmentIndex].left ===
+      (parents[assignmentIndex - 1] || object) &&
+    objectPatternCheck(object, parents);
   var isAssignmentValue =
     assignmentIndex !== -1 &&
     parents[assignmentIndex].right === (parents[assignmentIndex - 1] || object);
@@ -272,6 +312,7 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
       isDefined:
         isVariableDeclaration ||
         isFunctionDeclaration ||
+        isNamedFunctionExpression ||
         isAFunctionParameter ||
         isClassDeclaration ||
         isClauseParameter ||

package/src/util/insert.ts

@@ -145,13 +145,13 @@ export function getAllDefiningContexts(o: Node, p: Node[]): Node[] {
     // Get Function
     var fn = getFunction(o, p);
 
-    contexts.push(fn.body);
+    // contexts.push(fn.body);
   }
 
   if (info.isClauseParameter) {
     var catchClause = p.find((x) => x.type === "CatchClause");
     if (catchClause) {
-      contexts.push(catchClause.body);
+      return [catchClause];
     }
   }
 
@@ -376,3 +376,27 @@ export function isForInitialize(
 
   return false;
 }
+
+/**
+ * Computes the `function.length` property given the parameter nodes.
+ *
+ * @param params
+ * @returns
+ */
+export function computeFunctionLength(params: Node[]): number {
+  var count = 0;
+
+  for (var parameterNode of params) {
+    if (
+      parameterNode.type === "Identifier" ||
+      parameterNode.type === "ObjectPattern" ||
+      parameterNode.type === "ArrayPattern"
+    ) {
+      count++;
+    } else {
+      break;
+    }
+  }
+
+  return count;
+}

package/test/code/ES6.src.js

@@ -203,6 +203,30 @@ function labeledBreaksAndContinues() {
 var variant15 = labeledBreaksAndContinues();
 expect(variant15).toStrictEqual(15);
 
+// Variant #16: Function.length property
+var variant16 = function (
+  n1,
+  n2,
+  n3,
+  n4,
+  n5,
+  n6,
+  n7,
+  n8,
+  n9,
+  n10,
+  n11,
+  n12,
+  n13,
+  n14,
+  n15,
+  n16
+) {
+  var _ = true;
+};
+
+expect(variant16.length).toStrictEqual(16);
+
 // Set 'ranAllTest' to TRUE
 ranAllTest = true;