js-confuser 1.6.0 → 1.7.0

package/test/transforms/flatten.test.ts

@@ -1,15 +1,13 @@
 import JsConfuser from "../../src/index";
 
-it("should bring independent to the global level", async () => {
+test("Variant #1: Function Declaration", async () => {
   var output = await JsConfuser.obfuscate(
     `
-    function container(){
-      function nested(param){
-
-      }
-
-      nested();
+    function myFunction(){
+      return 10;
     }
+
+    TEST_OUTPUT = myFunction();
     `,
     {
       target: "node",
@@ -17,18 +15,24 @@ it("should bring independent to the global level", async () => {
     }
   );
 
-  // Ensure flatten was applied
-  expect(output).toContain("[param]");
+  expect(output).toContain("_flat_myFunction");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
 });
 
-it("should have correct return values", async () => {
+test("Variant #2: Function Expression", async () => {
   var output = await JsConfuser.obfuscate(
     `
-    function TEST_FUNCTION(){
-      return 10;
+    var outsideVar = "Correct Value";
+
+    var myFunction = function(){
+      return outsideVar;
     }
 
-    input(TEST_FUNCTION());
+    TEST_OUTPUT = myFunction();
     `,
     {
       target: "node",
@@ -36,21 +40,22 @@ it("should have correct return values", async () => {
     }
   );
 
-  var value = "never_called",
-    input = (x) => (value = x);
+  expect(output).toContain("_flat_myFunction");
 
+  var TEST_OUTPUT;
   eval(output);
-  expect(value).toStrictEqual(10);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
 
-it("should have correct parameters", async () => {
+test("Variant #3: Simple parameters", async () => {
   var output = await JsConfuser.obfuscate(
     `
-    function TEST_FUNCTION(x, y){
-      input(x + y);
+    function myFunction(x, y){
+      TEST_OUTPUT = x + y;
     }
 
-    TEST_FUNCTION(10, 15);
+    myFunction(10, 15);
     `,
     {
       target: "node",
@@ -58,14 +63,15 @@ it("should have correct parameters", async () => {
     }
   );
 
-  var value = "never_called",
-    input = (x) => (value = x);
+  expect(output).toContain("_flat_myFunction");
+
+  var TEST_OUTPUT;
 
   eval(output);
-  expect(value).toStrictEqual(25);
+  expect(TEST_OUTPUT).toStrictEqual(25);
 });
 
-it("should have correct parameters when nested", async () => {
+test("Variant #4: Simple parameters nested", async () => {
   var output = await JsConfuser.obfuscate(
     `
     function TEST_FUNCTION(x){
@@ -91,7 +97,7 @@ it("should have correct parameters when nested", async () => {
   expect(value).toStrictEqual(10);
 });
 
-it("should have correct return values when nested", async () => {
+test("Variant #5: Correct return values when nested", async () => {
   var output = await JsConfuser.obfuscate(
     `
     function TEST_FUNCTION(){
@@ -117,7 +123,7 @@ it("should have correct return values when nested", async () => {
   expect(value).toStrictEqual(10);
 });
 
-it("should have correct values when deeply nested", async () => {
+test("Variant #6: Correct values when deeply nested", async () => {
   var output = await JsConfuser.obfuscate(
     `
     function TEST_FUNCTION(x, y){
@@ -148,7 +154,7 @@ it("should have correct values when deeply nested", async () => {
   expect(value).toStrictEqual(15);
 });
 
-it("should have correct values when modifying local variables", async () => {
+test("Variant #7: Correct values when modifying local variables", async () => {
   var output = await JsConfuser.obfuscate(
     `
     function TEST_FUNCTION(x, y){
@@ -182,7 +188,7 @@ it("should have correct values when modifying local variables", async () => {
   expect(value).toStrictEqual(17);
 });
 
-it("should work with dispatcher", async () => {
+test("Variant #8: Work with dispatcher", async () => {
   var output = await JsConfuser.obfuscate(
     `
     function container(x){
@@ -211,34 +217,8 @@ it("should work with dispatcher", async () => {
   expect(value).toStrictEqual(100);
 });
 
-it("should not change functions with const", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    function TEST_FUNCTION(x, y){
-      const CONSTANT = 20;
-
-      return CONSTANT + x + y;
-    }
-
-    input(TEST_FUNCTION(10, 5));
-    `,
-    {
-      target: "node",
-      flatten: true,
-    }
-  );
-
-  expect(output).not.toContain("set");
-
-  var value = "never_called",
-    input = (x) => (value = x);
-
-  eval(output);
-  expect(value).toStrictEqual(35);
-});
-
 // https://github.com/MichaelXF/js-confuser/issues/25
-it("should work when pattern-based assignment expressions are involved", async () => {
+test("Variant #9: Work with pattern-based assignment expressions", async () => {
   var output = await JsConfuser.obfuscate(
     `
     var i = 0;
@@ -257,7 +237,7 @@ it("should work when pattern-based assignment expressions are involved", async (
   );
 
   // Ensure flatten was applied
-  expect(output).toContain("[i],[]");
+  expect(output).toContain("_flat_");
 
   var value = "never_called",
     input = (x) => (value = x);
@@ -266,7 +246,7 @@ it("should work when pattern-based assignment expressions are involved", async (
   expect(value).toStrictEqual(1);
 });
 
-it("should work on async functions", async () => {
+test("Variant #10: Async function", async () => {
   var output = await JsConfuser.obfuscate(
     `
     async function timeout(ms){
@@ -310,33 +290,7 @@ it("should work on async functions", async () => {
   }, 2000);
 });
 
-it("should work on Function Expressions", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    var outsideVar = "Correct Value";
-
-    var myFunctionExpression = function(){
-      return outsideVar;
-    }
-
-    TEST_OUTPUT = myFunctionExpression();
-    `,
-    {
-      target: "node",
-      flatten: true,
-    }
-  );
-
-  // Ensure flatten applied
-  expect(output).toContain("_flat_myFunctionExpression");
-
-  var TEST_OUTPUT;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
-});
-
-it("should work on Properties", async () => {
+test("Variant #11: Work with properties", async () => {
   var output = await JsConfuser.obfuscate(
     `
     var outsideVar = "Incorrect Value";
@@ -369,7 +323,7 @@ it("should work on Properties", async () => {
   );
 
   // Ensure flatten applied
-  expect(output).toContain("_flat_myInitProperty");
+  expect(output).toContain("_flat_");
 
   var TEST_OUTPUT;
   eval(output);
@@ -377,7 +331,7 @@ it("should work on Properties", async () => {
   expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
 
-it("should work with RGF enabled", async () => {
+test("Variant #12: Work with RGF enabled", async () => {
   var output = await JsConfuser.obfuscate(
     `
   var outsideVar = "Correct Value";
@@ -407,7 +361,7 @@ it("should work with RGF enabled", async () => {
   expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
 
-it("should work with assignment expressions in the return statement", async () => {
+test("Variant #13: Work with assignment expression in the return statement", async () => {
   var output = await JsConfuser(
     `
   var outside;
@@ -433,7 +387,7 @@ it("should work with assignment expressions in the return statement", async () =
   expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
 
-it("should work with 'use strict' directive", async () => {
+test("Variant #14: Work with 'use strict' directive", async () => {
   var output = await JsConfuser(
     `
   function myFunction(){
@@ -455,3 +409,313 @@ it("should work with 'use strict' directive", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/89
+test("Variant #15: Work with functions with invalid identifier names", async () => {
+  var output = await JsConfuser(
+    `
+  // Input
+  var object = {
+    "my-function": function () {
+      TEST_OUTPUT = "Success";
+    },
+  };
+
+  object["my-function"](); // "Success"
+  `,
+    { target: "node", flatten: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Success");
+});
+
+test("Variant #16: Multiple test", async () => {
+  var output = await JsConfuser(
+    `
+  "use strict";
+
+  function assertLegalInvocation(){
+    if(this !== undefined) throw new Error("Illegal Invocation");
+  }
+
+  (function (){
+    var requiredValue = {};
+    var value;
+    var counter = 0;
+
+    function getCorrectValueObject(requiredParameter){
+      function nestedFunction(){
+        var requiredCounterValue = 1;
+        if(requiredParameter === requiredValue) {
+          if(counter === requiredCounterValue) {
+            return {value: "Correct Value"};
+          }
+        }
+
+        return {value: "Incorrect Value"};
+      }
+
+      return nestedFunction();
+    }
+
+    function setValue(){
+      // Test update-expression
+      counter++;
+      
+      // Test call-expression
+      assertLegalInvocation();
+
+      function nestedSetValue(){
+        // Test destructuring
+        ({value} = getCorrectValueObject(requiredValue));
+      }
+
+      nestedSetValue()
+    }
+
+    function myFunction(myParameter1, myParameter2, myParameter3){
+      setValue();
+
+      myParameter1 = TEST_OUTPUT = value;
+    }
+
+    myFunction();
+  })();
+  `,
+    { target: "node", flatten: true }
+  );
+
+  expect(output).toContain("_flat_getCorrectValue");
+  expect(output).toContain("_flat_setValue");
+  expect(output).toContain("_flat_myFunction");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #17: Don't apply to generator functions", async () => {
+  var output = await JsConfuser(
+    `
+  function* myGeneratorFunction(){
+    yield "Correct Value";
+  }
+
+  TEST_OUTPUT = (myGeneratorFunction()).next().value;
+  `,
+    { target: "node", flatten: true }
+  );
+
+  expect(output).not.toContain("_flat_myGeneratorFunction");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #18: Redefined variable in nested scope", async () => {
+  var output = await JsConfuser(
+    `
+  (function (){
+    var outsideVar = "Incorrect Value 1";
+    function myFunction1(){
+      (()=>{
+        var outsideVar = "Correct Value 1";
+        TEST_OUTPUT_1 = outsideVar;
+      })();
+    };
+  
+    myFunction1();
+  
+    outsideVar = "Correct Value 2";
+  
+    function myFunction2(){
+      (()=>{
+        var outsideVar = "Incorrect Value 2";
+      })();
+      TEST_OUTPUT_2 = outsideVar;
+    };
+  
+    myFunction2();
+  })();
+  `,
+    {
+      target: "node",
+      flatten: true,
+      renameVariables: (x) => !x.includes("_flat_"),
+    }
+  );
+
+  expect(output).toContain("_flat_myFunction1");
+  expect(output).toContain("_flat_myFunction2");
+
+  var TEST_OUTPUT_1, TEST_OUTPUT_2;
+  eval(output);
+
+  expect(TEST_OUTPUT_1).toStrictEqual("Correct Value 1");
+  expect(TEST_OUTPUT_2).toStrictEqual("Correct Value 2");
+});
+
+test("Variant #19: Nested function declaration", async () => {
+  var output = await JsConfuser(
+    `
+  function myFunction(){
+    TEST_OUTPUT = nestedFunctionDeclaration();
+
+    function nestedFunctionDeclaration(){
+      return "Correct Value";
+    }
+  }
+
+  myFunction();
+  `,
+    {
+      target: "node",
+      flatten: true,
+    }
+  );
+
+  expect(output).toContain("_flat_myFunction");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #20: Don't apply to functions that use 'this' 'arguments' or 'eval'", async () => {
+  var output = await JsConfuser(
+    `
+  function myFunction(){
+    usesEval();
+  }
+
+  function usesThis(){
+    return this;
+  }
+  function usesArguments(){
+    return arguments;
+  }
+  function usesEval(){
+    eval("TEST_OUTPUT = 'Correct Value'");
+  }
+
+  myFunction();
+  `,
+    {
+      target: "node",
+      flatten: true,
+    }
+  );
+
+  expect(output).toContain("_flat_myFunction");
+  expect(output).not.toContain("_flat_usesThis");
+  expect(output).not.toContain("_flat_usesArguments");
+  expect(output).not.toContain("_flat_usesEval");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #21: Preserve function.length property", async () => {
+  var output = await JsConfuser(
+    `
+  function oneParameter(a){};
+  var twoParameters = function({a},{b,c},...d){};
+  function threeParameters(a,b,c,d = 1,{e},...f){};
+
+  TEST_OUTPUT = oneParameter.length + twoParameters.length + threeParameters.length;
+  `,
+    {
+      target: "node",
+      flatten: true,
+    }
+  );
+
+  expect(output).toContain("_flat_oneParameter");
+  expect(output).not.toContain("_flat_twoParameters");
+  expect(output).not.toContain("_flat_threeParameters");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(6);
+});
+
+test("Variant #22: Modify object properties", async () => {
+  var output = await JsConfuser(
+    `
+    var myObject = {};
+
+    function setProperty(property, value){
+      myObject[property] = value;
+    }
+
+    function getProperty(property){
+      return myObject[property];
+    }
+
+    setProperty("TEST_PROPERTY", "Correct Value");
+    TEST_OUTPUT = getProperty("TEST_PROPERTY");
+  `,
+    { target: "node", flatten: true }
+  );
+
+  expect(output).toContain("_flat_setProperty");
+  expect(output).toContain("_flat_getProperty");
+
+  var TEST_OUTPUT;
+
+  eval(output);
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #23: Reference original function name", async () => {
+  var output = await JsConfuser(
+    `
+    (function (){
+      function myFunction(){
+        var valueToCheck = myFunction;
+        TEST_OUTPUT = typeof valueToCheck === "function";
+      }
+
+      myFunction();
+    })();
+  `,
+    { target: "node", flatten: true }
+  );
+
+  expect(output).toContain("_flat_myFunction");
+
+  var TEST_OUTPUT;
+
+  eval(output);
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});
+
+test("Variant #24: Typeof expression", async () => {
+  var output = await JsConfuser(
+    `
+    function myFunction(){
+      TEST_OUTPUT = typeof nonExistentVariable === "undefined";
+    }
+
+    myFunction();
+  `,
+    { target: "node", flatten: true }
+  );
+
+  expect(output).toContain("_flat_myFunction");
+
+  var TEST_OUTPUT;
+
+  eval(output);
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});

package/test/transforms/identifier/movedDeclarations.test.ts

@@ -12,7 +12,7 @@ test("Variant #1: Move variable 'y' to top", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y;");
+  expect(output).toContain("var x=10,y;");
   expect(output).toContain("y=15");
 
   var TEST_VARIABLE;
@@ -34,7 +34,7 @@ test("Variant #2: Move variable 'y' and 'z' to top", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y,z");
+  expect(output).toContain("var x=10,y,z;");
   expect(output).toContain("y=15");
   expect(output).toContain("z=5");
 
@@ -44,7 +44,7 @@ test("Variant #2: Move variable 'y' and 'z' to top", async () => {
   expect(TEST_VARIABLE).toStrictEqual(30);
 });
 
-test("Variant #2: Don't move 'y' (destructuring)", async () => {
+test("Variant #3: Don't move 'y' (destructuring)", async () => {
   var code = `
     var x = 10;
     var [y] = [15];
@@ -64,7 +64,7 @@ test("Variant #2: Don't move 'y' (destructuring)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
+test("Variant #4: Move 'y' (nested lexical scope)", async () => {
   var code = `
     var x = 10;
     var y = 15;
@@ -81,7 +81,7 @@ test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y=15");
+  expect(output).toContain("var x=10,y;");
 
   var TEST_VARIABLE;
   eval(output);
@@ -89,7 +89,7 @@ test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(20);
 });
 
-test("Variant #4: Move 'y' (for statement initializer)", async () => {
+test("Variant #5: Move 'y' (for statement initializer)", async () => {
   var code = `
     var x = 10;
     for ( var y = 0; y < 15; y++ ) {
@@ -111,7 +111,7 @@ test("Variant #4: Move 'y' (for statement initializer)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #5: Move 'y' (for-in left-hand initializer)", async () => {
+test("Variant #6: Move 'y' (for-in left-hand initializer)", async () => {
   var code = `
     var x = 10;
     for ( var y in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15] ) {
@@ -134,7 +134,7 @@ test("Variant #5: Move 'y' (for-in left-hand initializer)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #6: Don't move const or let variables", async () => {
+test("Variant #7: Don't move const or let variables", async () => {
   var code = `
     var fillerExpr;
 
@@ -158,7 +158,7 @@ test("Variant #6: Don't move const or let variables", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #7: Work with 'use strict'", async () => {
+test("Variant #8: Work with 'use strict'", async () => {
   var code = `
   function myFunction(){
     'use strict';
@@ -184,3 +184,31 @@ test("Variant #7: Work with 'use strict'", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual(true);
 });
+
+test("Variant #9: Defined variable without an initializer", async () => {
+  var code = `
+  var x;
+  x = 1;
+  var y;
+  y = 2;
+  TEST_OUTPUT = x + y;
+  `;
+
+  var output1 = await JsConfuser(code, {
+    target: "node",
+    movedDeclarations: true,
+    controlFlowFlattening: true,
+    duplicateLiteralsRemoval: true,
+  });
+
+  var output2 = await JsConfuser(output1, {
+    target: "node",
+    movedDeclarations: true,
+    controlFlowFlattening: true,
+    duplicateLiteralsRemoval: true,
+  });
+
+  var TEST_OUTPUT;
+  eval(output2);
+  expect(TEST_OUTPUT).toStrictEqual(3);
+});