js-confuser 1.6.0 → 1.7.1

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,19 +91,43 @@ 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);
+
+  var functionIndex = parents.findIndex((x) => isFunction(x));
+
+  // Assignment pattern check!
+  if (isVariableDeclaration) {
+    var slicedParents = parents.slice(
+      0,
+      functionIndex != -1 ? Math.min(varIndex, functionIndex) : varIndex
+    );
+    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 =
     forIndex != -1 &&
     parents[forIndex].init == (parents[forIndex - 1] || object);
 
-  var functionIndex = parents.findIndex((x) => isFunction(x));
-
   var isFunctionDeclaration =
     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 +153,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 +315,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;
 

package/test/transforms/dispatcher.test.ts

@@ -373,3 +373,30 @@ test("Variant #16: Don't change functions that use 'eval'", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual(2);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/103
+test("Variant #17: Don't break default parameter, function expression", async () => {
+  var output = await JsConfuser(
+    `
+  var X = "Correct Value";
+
+function printX(
+  getX = function () {
+    return X;
+  }
+) {
+  var X = "Incorrect Value";
+
+  TEST_OUTPUT = getX();
+}
+
+printX();
+  `,
+    { target: "node", dispatcher: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

package/test/transforms/extraction/duplicateLiteralsRemoval.test.ts

@@ -1,6 +1,6 @@
 import JsConfuser from "../../../src/index";
 
-it("should remove duplicate literals", async () => {
+test("Variant #1: Remove duplicate literals", async () => {
   var code = `
   
   var TEST_ARRAY = [5,5];
@@ -15,7 +15,7 @@ it("should remove duplicate literals", async () => {
   expect(output).toContain("5");
 });
 
-it("should remove duplicate literals and execute correctly", async () => {
+test("Variant #2: Remove duplicate literals and execute correctly", async () => {
   var code = `
   
   TEST_ARRAY = [5,5];
@@ -36,7 +36,7 @@ it("should remove duplicate literals and execute correctly", async () => {
   expect(TEST_ARRAY).toEqual([5, 5]);
 });
 
-it("should remove 'undefined' and 'null' values", async () => {
+test("Variant #3: Remove 'undefined' and 'null' values", async () => {
   var code = `
   
   TEST_ARRAY = [undefined,undefined,null,null];
@@ -60,7 +60,7 @@ it("should remove 'undefined' and 'null' values", async () => {
   expect(TEST_ARRAY).toEqual([undefined, undefined, null, null]);
 });
 
-it("should not remove empty strings", async () => {
+test("Variant #4: Do not remove empty strings", async () => {
   var code = `
   
   TEST_ARRAY = ['','','',''];
@@ -80,7 +80,7 @@ it("should not remove empty strings", async () => {
   expect(TEST_ARRAY).toEqual(["", "", "", ""]);
 });
 
-it("should work with NaN values", async () => {
+test("Variant #5: Work with NaN values", async () => {
   var code = `
   
   TEST_ARRAY = [NaN];
@@ -98,7 +98,7 @@ it("should work with NaN values", async () => {
   expect(TEST_ARRAY[0] === TEST_ARRAY[0]).toStrictEqual(false);
 });
 
-it("should work on property keys", async () => {
+test("Variant #6: Work on property keys", async () => {
   var code = `
   var myObject = {
     myKey: 100
@@ -124,7 +124,7 @@ it("should work on property keys", async () => {
   expect(TEST_VAR).toStrictEqual(100);
 });
 
-it("should work on class keys", async () => {
+test("Variant #7: Work on class keys", async () => {
   var code = `
   class MyClass {
     myMethod(){
@@ -150,7 +150,7 @@ it("should work on class keys", async () => {
   expect(TEST_VAR).toStrictEqual(100);
 });
 
-it("should not encode constructor key", async () => {
+test("Variant #8: Do not encode constructor key", async () => {
   var code = `
   class MyClass {
     constructor(){
@@ -177,3 +177,16 @@ it("should not encode constructor key", async () => {
 
   expect(TEST_VAR).toStrictEqual(100);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/105
+test("Variant #9: Undefined as variable name", async () => {
+  var output = await JsConfuser(
+    `
+  var undefined = 0;
+  var undefined = 1;
+  `,
+    { target: "node", duplicateLiteralsRemoval: true }
+  );
+
+  eval(output);
+});

package/test/transforms/extraction/objectExtraction.test.ts

@@ -1,6 +1,6 @@
 import JsConfuser from "../../../src/index";
 
-it("should extract properties", async () => {
+test("Variant #1: Extract properties", async () => {
   var code = `
     var TEST_OBJECT = {
       TEST_1: "Hello World",
@@ -34,7 +34,7 @@ it("should extract properties", async () => {
   eval(output);
 });
 
-it("should extract function properties correctly", async () => {
+test("Variant #2: Extract function properties correctly", async () => {
   var code = `
     var TEST_OBJECT = {
       isBoolean: x=>typeof x === "boolean",
@@ -68,7 +68,7 @@ it("should extract function properties correctly", async () => {
   eval(output);
 });
 
-it("should not extract properties on with dynamically added keys", async () => {
+test("Variant #3: Not extract properties on with dynamically added keys", async () => {
   var code = `
     var TEST_OBJECT = {
       first_key: 1
@@ -100,7 +100,7 @@ it("should not extract properties on with dynamically added keys", async () => {
   eval(output);
 });
 
-it("should not extract properties on with dynamically added keys even when in nested contexts", async () => {
+test("Variant #4: Not extract properties on with dynamically added keys even when in nested contexts", async () => {
   var code = `
     var TEST_OBJECT = {
       first_key: 1
@@ -135,7 +135,7 @@ it("should not extract properties on with dynamically added keys even when in ne
   eval(output);
 });
 
-it("should not extract properties on objects with computed properties", async () => {
+test("Variant #5: Not extract properties on objects with computed properties", async () => {
   var code = `
     
     var key = "111"
@@ -166,7 +166,7 @@ it("should not extract properties on objects with computed properties", async ()
   eval(output);
 });
 
-it("should not extract properties on objects with computed properties (string)", async () => {
+test("Variant #6: Not extract properties on objects with computed properties (string)", async () => {
   var code = `
     
     var v = "key";
@@ -197,7 +197,7 @@ it("should not extract properties on objects with computed properties (string)",
   eval(output);
 });
 
-it("should not extract properties on objects when the object is referenced independently", async () => {
+test("Variant #7: Not extract properties on objects when the object is referenced independently", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -229,7 +229,7 @@ it("should not extract properties on objects when the object is referenced indep
   eval(output);
 });
 
-it("should not extract properties on objects when the variable gets redefined", async () => {
+test("Variant #8: Not extract properties on objects when the variable gets redefined", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -260,7 +260,7 @@ it("should not extract properties on objects when the variable gets redefined",
   eval(output);
 });
 
-it("should not extract properties on objects when the variable gets reassigned", async () => {
+test("Variant #9: Not extract properties on objects when the variable gets reassigned", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -292,7 +292,7 @@ it("should not extract properties on objects when the variable gets reassigned",
   eval(output);
 });
 
-it("should not extract properties on objects with methods referencing 'this'", async () => {
+test("Variant #10: Not extract properties on objects with methods referencing 'this'", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -325,7 +325,7 @@ it("should not extract properties on objects with methods referencing 'this'", a
   eval(output);
 });
 
-it("should not extract properties on objects when properties are dynamically deleted", async () => {
+test("Variant #11: Not extract properties on objects when properties are dynamically deleted", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -356,7 +356,7 @@ it("should not extract properties on objects when properties are dynamically del
   eval(output);
 });
 
-it("should not extract properties on objects with computed accessors", async () => {
+test("Variant #12: Not extract properties on objects with computed accessors", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -388,7 +388,7 @@ it("should not extract properties on objects with computed accessors", async ()
   eval(output);
 });
 
-it("should properly use custom callback to exclude certain names from being changed", async () => {
+test("Variant #13: Properly use custom callback to exclude certain names from being changed", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -424,7 +424,7 @@ it("should properly use custom callback to exclude certain names from being chan
   eval(output);
 });
 
-it("should not apply to objects with non-init properties (method, set, get)", async () => {
+test("Variant #14: Not apply to objects with non-init properties (method, set, get)", async () => {
   var code = `
     
     var realValue = 0;
@@ -448,7 +448,7 @@ it("should not apply to objects with non-init properties (method, set, get)", as
 });
 
 // https://github.com/MichaelXF/js-confuser/issues/78
-it("should handle objects with spread elements", async () => {
+test("Variant #15: Handle objects with spread elements", async () => {
   var output = await JsConfuser(
     `
     var x = { firstName: "John", lastName: "Doe" }
@@ -467,3 +467,23 @@ it("should handle objects with spread elements", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual({ firstName: "John", lastName: "Doe" });
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/106
+test("Variant #16: Handle const declarations", async () => {
+  var output = await JsConfuser(
+    `
+    const obj = {prop: 0};
+    obj.prop = 1;
+    TEST_OUTPUT = obj.prop;
+`,
+    {
+      target: "node",
+      objectExtraction: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(1);
+});