js-confuser 1.5.8 → 1.6.0

package/test/transforms/controlFlowFlattening/expressionObfuscation.test.ts

@@ -0,0 +1,173 @@
+import JsConfuser from "../../../src/index";
+
+test("Variant #1: Join expressions in a sequence expression", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT=0;
+  TEST_OUTPUT++;
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("(TEST_OUTPUT=0,TEST_OUTPUT++");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(1);
+});
+
+test("Variant #2: If Statement", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT=0;
+  if(true){
+    TEST_OUTPUT++;
+  }
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("if(TEST_OUTPUT=0,true)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(1);
+});
+
+test("Variant #3: ForStatement (Variable Declaration initializer)", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT=0;
+  for(var i =0; i < 10; i++){
+    TEST_OUTPUT++;
+  }
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("for(var i=(TEST_OUTPUT=0,0)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
+});
+
+test("Variant #4: ForStatement (Assignment expression initializer)", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT=0;
+  for(i = 0; i < 10; i++){
+    TEST_OUTPUT++;
+  }
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("for(i=(TEST_OUTPUT=0,0)");
+
+  var TEST_OUTPUT, i;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
+});
+
+test("Variant #5: Return statement", async () => {
+  var output = await JsConfuser(
+    `
+  function fn(){
+    TEST_OUTPUT = 10;
+    return "Value";
+  }
+  fn();
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("return TEST_OUTPUT=10,'Value'}");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
+});
+
+test("Variant #6: Return statement (no argument)", async () => {
+  var output = await JsConfuser(
+    `
+  function fn(){
+    TEST_OUTPUT = 10;
+    return;
+  }
+  fn();
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("return TEST_OUTPUT=10,undefined}");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
+});
+
+test("Variant #7: Throw statement", async () => {
+  var output = await JsConfuser(
+    `
+  function fn(){
+    TEST_OUTPUT = "Correct Value";
+    throw new Error("My Error")
+  }
+  try {
+    fn();
+  } catch(e){
+
+  }
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("throw TEST_OUTPUT='Correct Value',new Error");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #8: Variable declaration", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT = "Correct Value";
+  var x = 1, y = 2;
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("var x=(TEST_OUTPUT='Correct Value',1)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #9: Variable declaration (no initializer)", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT = "Correct Value";
+  var x,y;
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("var x=(TEST_OUTPUT='Correct Value',undefined)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

package/test/transforms/deadCode.test.ts

@@ -1,21 +1,25 @@
 import JsConfuser from "../../src/index";
 
-it("should execute properly", async () => {
+test("Variant #1: Execute properly", async () => {
   var code = `
-    var array = [];
-
-    array.push(1);
-    array.push(2);
-    array.push(3);
-    array.push(4);
-    array.push(5);
-    array.push(6);
-    array.push(7);
-    array.push(8);
-    array.push(9);
-    array.push(10);
-
-    input(array);
+    function myFunction(){
+      var array = [];
+
+      array.push(1);
+      array.push(2);
+      array.push(3);
+      array.push(4);
+      array.push(5);
+      array.push(6);
+      array.push(7);
+      array.push(8);
+      array.push(9);
+      array.push(10);
+
+      input(array);
+    }
+
+    myFunction();
   `;
 
   var output = await JsConfuser(code, {
@@ -23,6 +27,53 @@ it("should execute properly", async () => {
     deadCode: true,
   });
 
+  // Ensure Dead code was added
+  expect(output).toContain("if");
+
+  var value = "never_called";
+  function input(valueIn) {
+    value = valueIn;
+  }
+
+  eval(output);
+
+  expect(value).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+});
+
+test("Variant #2: Preserve 'use strict' directive", async () => {
+  var code = `
+    'use strict';
+    function myFunction(){
+      var array = [];
+
+      array.push(1);
+      array.push(2);
+      array.push(3);
+      array.push(4);
+      array.push(5);
+      array.push(6);
+      array.push(7);
+      array.push(8);
+      array.push(9);
+      array.push(10);
+
+      input(array);
+    }
+
+    myFunction();
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "browser",
+    deadCode: true,
+  });
+
+  // Ensure 'use strict' was preversed
+  expect(output.startsWith("'use strict'")).toStrictEqual(true);
+
+  // Ensure Dead code was added
+  expect(output).toContain("if");
+
   var value = "never_called";
   function input(valueIn) {
     value = valueIn;

package/test/transforms/dispatcher.test.ts

@@ -1,4 +1,3 @@
-import { isObject } from "util";
 import JsConfuser from "../../src/index";
 
 it("should middleman function calls", async () => {
@@ -330,3 +329,47 @@ it("should apply to every level of the code", async () => {
 
   expect(value).toStrictEqual(100);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/77
+it("should work with code that uses toString() function", async () => {
+  var output = await JsConfuser(
+    `
+  function myFunction(){
+    
+  }
+  
+  TEST_OUTPUT = toString();
+  `,
+    {
+      target: "node",
+      dispatcher: true,
+    }
+  );
+
+  var toString = () => "Correct Value";
+  var TEST_OUTPUT;
+
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #16: Don't change functions that use 'eval'", async () => {
+  var output = await JsConfuser(
+    `
+  function myEvalFunction(){
+    return eval("1+1");
+  }
+
+  TEST_OUTPUT = myEvalFunction();
+  `,
+    { target: "node", dispatcher: true }
+  );
+
+  expect(output).not.toContain("dispatcher");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(2);
+});

package/test/transforms/es5/antiClass.test.ts

@@ -392,3 +392,36 @@ it("should work with stringConcealing and hide method names", async () => {
 
   expect(TEST_VALUE).toStrictEqual(100);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/72
+it("should support class fields", async () => {
+  var output = await JsConfuser(
+    `
+  class MyClass {
+    myField = 1;
+    ["myComputedField"] = 2;
+    
+    static myStaticField = 3;
+    static ["myComputedStaticField"] = 4;
+  }
+
+  var myObject = new MyClass();
+  TEST_OUTPUT_1 = myObject.myField;
+  TEST_OUTPUT_2 = myObject.myComputedField;
+  TEST_OUTPUT_3 = MyClass.myStaticField;
+  TEST_OUTPUT_4 = MyClass.myComputedStaticField;
+  `,
+    {
+      target: "node",
+      es5: true,
+    }
+  );
+
+  var TEST_OUTPUT_1, TEST_OUTPUT_2, TEST_OUTPUT_3, TEST_OUTPUT_4;
+
+  eval(output);
+  expect(TEST_OUTPUT_1).toStrictEqual(1);
+  expect(TEST_OUTPUT_2).toStrictEqual(2);
+  expect(TEST_OUTPUT_3).toStrictEqual(3);
+  expect(TEST_OUTPUT_4).toStrictEqual(4);
+});

package/test/transforms/es5/antiDestructuring.test.ts

@@ -139,3 +139,19 @@ it("should fix destructuring inside the try...catch clause", async () => {
 
   expect(TEST_VARIABLE).toStrictEqual(100);
 });
+
+it("should fix destructuring member expressions", async () => {
+  var code = `
+  var myObject = { nested: {} };
+  [myObject.key1, myObject["key2"], myObject.nested.key3] = [1, 2, 3];
+
+  TEST_VARIABLE = [myObject.key1, myObject.key2, myObject.nested.key3];
+  `;
+
+  var output = await JsConfuser(code, { target: "node", es5: true });
+
+  var TEST_VARIABLE;
+  eval(output);
+
+  expect(TEST_VARIABLE).toStrictEqual([1, 2, 3]);
+});

package/test/transforms/eval.test.ts

@@ -76,3 +76,56 @@ it("should work with Integrity also enabled", async () => {
 
   expect(value).toStrictEqual("Hello World");
 });
+
+it("should work on async functions", async () => {
+  var output = await JsConfuser(
+    `
+  async function myFunction(){
+    return "Correct Value";
+  }
+
+  (async ()=>{
+    TEST_FUNCTION( await myFunction() );
+  })();
+  `,
+    { target: "node", eval: true }
+  );
+
+  expect(output).toContain("eval");
+
+  var wasCalled = false;
+
+  function TEST_FUNCTION(value) {
+    wasCalled = true;
+    expect(value).toStrictEqual("Correct Value");
+  }
+
+  eval(output);
+
+  setTimeout(() => {
+    expect(wasCalled).toStrictEqual(true);
+  }, 1000);
+});
+
+it("should work on generator functions", async () => {
+  var output = await JsConfuser(
+    `
+  function* myFunction(){
+    yield "Correct Value";
+  }
+  
+  const gen = myFunction();
+
+  TEST_OUTPUT = gen.next().value;
+  `,
+    { target: "node", eval: true }
+  );
+
+  expect(output).toContain("eval");
+
+  var TEST_OUTPUT;
+
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

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

@@ -446,3 +446,24 @@ it("should not apply to objects with non-init properties (method, set, get)", as
   expect(output).toContain("TEST_OBJECT");
   expect(output).toContain("set ");
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/78
+it("should handle objects with spread elements", async () => {
+  var output = await JsConfuser(
+    `
+    var x = { firstName: "John", lastName: "Doe" }
+    var y = { ...x };
+
+    TEST_OUTPUT = y;
+`,
+    {
+      target: "node",
+      objectExtraction: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual({ firstName: "John", lastName: "Doe" });
+});

package/test/transforms/flatten.test.ts

@@ -4,7 +4,7 @@ it("should bring independent to the global level", async () => {
   var output = await JsConfuser.obfuscate(
     `
     function container(){
-      function nested(){
+      function nested(param){
 
       }
 
@@ -17,7 +17,8 @@ it("should bring independent to the global level", async () => {
     }
   );
 
-  expect(output).toContain("set");
+  // Ensure flatten was applied
+  expect(output).toContain("[param]");
 });
 
 it("should have correct return values", async () => {
@@ -255,7 +256,8 @@ it("should work when pattern-based assignment expressions are involved", async (
     }
   );
 
-  expect(output).toContain("set");
+  // Ensure flatten was applied
+  expect(output).toContain("[i],[]");
 
   var value = "never_called",
     input = (x) => (value = x);
@@ -263,3 +265,193 @@ it("should work when pattern-based assignment expressions are involved", async (
   eval(output);
   expect(value).toStrictEqual(1);
 });
+
+it("should work on async functions", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+    async function timeout(ms){
+      return await new Promise((resolve, reject)=>{
+        setTimeout(()=>{
+          resolve();
+        }, ms);
+      });
+    }
+
+    (async ()=>{
+      var startTime = Date.now();
+
+      await timeout(1000);
+
+      var endTime = Date.now();
+
+      var duration = endTime - startTime;
+
+      TEST_CALLBACK(duration);
+    })();
+    `,
+    {
+      target: "node",
+      flatten: true,
+    }
+  );
+
+  expect(output).toContain("_flat_timeout");
+
+  var wasCalled = false;
+  var TEST_CALLBACK = (time) => {
+    expect(time).toBeGreaterThan(500);
+    wasCalled = true;
+  };
+
+  eval(output);
+
+  setTimeout(() => {
+    expect(wasCalled).toStrictEqual(true);
+  }, 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 () => {
+  var output = await JsConfuser.obfuscate(
+    `
+    var outsideVar = "Incorrect Value";
+
+    var myObject = {
+      myInitProperty: function(){
+        return outsideVar;
+      },
+
+      myMethodProperty(){
+        return;
+      },
+
+      get myGetProperty(){
+        return;  
+      },
+
+      set mySetProperty(val){
+        outsideVar = val;
+      }
+    }
+
+    myObject.mySetProperty = "Correct Value";
+    TEST_OUTPUT = myObject.myInitProperty();
+    `,
+    {
+      target: "node",
+      flatten: true,
+    }
+  );
+
+  // Ensure flatten applied
+  expect(output).toContain("_flat_myInitProperty");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+it("should work with RGF enabled", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  var outsideVar = "Correct Value";
+
+  function myFunction(){
+    return outsideVar;
+  }
+
+  TEST_OUTPUT = myFunction();
+  `,
+    {
+      target: "node",
+      flatten: true,
+      rgf: true,
+    }
+  );
+
+  // Ensure flatten applied
+  expect(output).toContain("_flat_myFunction");
+
+  // Ensure RGF applied
+  expect(output).toContain("new Function");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+it("should work with assignment expressions in the return statement", async () => {
+  var output = await JsConfuser(
+    `
+  var outside;
+
+  function myFunction(){
+    return outside = "Correct Value"
+  }
+
+  myFunction(outside);
+
+  TEST_OUTPUT = outside;
+  
+  `,
+    { target: "node", flatten: true }
+  );
+
+  // Ensure flat was applied
+  expect(output).toContain("_flat_myFunction");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+it("should work with 'use strict' directive", async () => {
+  var output = await JsConfuser(
+    `
+  function myFunction(){
+    "use strict";
+
+    return "Correct Value";
+  }
+
+  TEST_OUTPUT = myFunction();
+  `,
+    { target: "node", flatten: true }
+  );
+
+  // Ensure flat was applied
+  expect(output).toContain("_flat_myFunction");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

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

@@ -157,3 +157,30 @@ test("Variant #6: Don't move const or let variables", async () => {
 
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
+
+test("Variant #7: Work with 'use strict'", async () => {
+  var code = `
+  function myFunction(){
+    'use strict';
+
+    var x = 1;
+
+    return this === undefined;
+  }
+
+  TEST_OUTPUT = myFunction();
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
+
+  // Ensure movedDeclarations applied and 'use strict' is still first
+  expect(output).toContain("function myFunction(){'use strict';var x;");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});