js-confuser 1.5.7 → 1.5.9

package/test/transforms/dispatcher.test.ts

@@ -330,3 +330,27 @@ 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");
+});

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/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,144 @@ 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");
+});

package/test/transforms/identifier/nameRecycling.test.ts

@@ -164,3 +164,42 @@ it("should convert variable declarations in for loop initializers properly", asy
   expect(TEST_VAR_1).toStrictEqual("Hello World");
   expect(TEST_VAR_2).toStrictEqual("Number: 0");
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/68
+it("should work on Function Declarations that are defined later in the code", async () => {
+  var output = await JsConfuser(
+    `
+  var result = MyFunction();
+  TEST_VAR = result;
+  
+  function MyFunction(b) {
+    return "Hello World";
+  }
+  `,
+    { target: "node", nameRecycling: true }
+  );
+
+  var TEST_VAR;
+  eval(output);
+
+  expect(TEST_VAR).toStrictEqual("Hello World");
+});
+
+// https://github.com/MichaelXF/js-confuser/issues/71
+it("should work on Import Declarations", async () => {
+  var output = await JsConfuser(
+    `
+  import crypto from 'node:crypto'
+
+  var x = 1;
+  
+  console.log(x);
+  `,
+    {
+      target: "node",
+      nameRecycling: true,
+    }
+  );
+
+  expect(output).not.toContain("crypto=");
+});

package/test/transforms/identifier/renameVariables.test.ts

@@ -436,3 +436,67 @@ test("Variant #18: Catch parameter and lexical variable clash", async () => {
 
   eval(output);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/69
+test("Variant #19: Don't break Import Declarations", async () => {
+  var output = await JsConfuser(
+    `
+  import { createHash } from 'node:crypto'
+
+  function sha256(content) {  
+    return createHash('sha256').update(content).digest('hex')
+  }
+
+  TEST_OUTPUT = sha256("Hash this string");
+  `,
+    {
+      target: "node",
+      renameVariables: true,
+    }
+  );
+
+  // Ensure the createHash got renamed
+  expect(output).toContain("createHash as ");
+
+  // Convert to runnable code
+  // This smartly changes the `import` statement to a require call, keeping the new variable name intact
+  var newVarName = output.split("createHash as ")[1].split("}")[0];
+  output = output
+    .split(";")
+    .filter((s) => !s.startsWith("import"))
+    .join(";");
+  output = `var {createHash: ${newVarName}}=require('crypto');` + output;
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(
+    "1cac63f39fd68d8c531f27b807610fb3d50f0fc3f186995767fb6316e7200a3e"
+  );
+});
+
+// https://github.com/MichaelXF/js-confuser/issues/80
+test("Variant #20: Don't break code with var and let variables in same scope", async () => {
+  var output = await JsConfuser(
+    `
+  function log(param) {
+    let message = param;
+    var isWarning = false;
+    var isError = false;
+  
+    TEST_OUTPUT = message;
+  };
+
+  log("Correct Value");
+  `,
+    {
+      target: "node",
+      renameVariables: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

package/test/transforms/minify.test.ts

@@ -269,6 +269,7 @@ test("Variant #15: Removing implied 'return'", async () => {
   function MyFunction(){ 
     var output = "Hello World";
     console.log(output);
+    this; // Stop arrow function conversion
     return;
   } 
   
@@ -366,3 +367,68 @@ test("Variant #19: Remove unreachable code following a throw statement", async (
 
   expect(output).not.toContain("unreachableStmt");
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/76
+test("Variant #20: Properly handle objects with `, ^, [, ] as keys", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OBJECT = {
+    "\`": true,
+    "^": true,
+    "]": true,
+    "[": true
+  };
+  `,
+    {
+      target: "node",
+      minify: true,
+    }
+  );
+
+  var TEST_OBJECT;
+  eval(output);
+
+  expect(TEST_OBJECT).toStrictEqual({
+    "`": true,
+    "^": true,
+    "]": true,
+    "[": true,
+  });
+});
+
+// https://github.com/MichaelXF/js-confuser/issues/75
+test("Variant #21: Properly handle Object constructor (Function Declaration)", async () => {
+  var output = await JsConfuser(
+    `
+  function MyClass() {};
+
+  var myObject = new MyClass();
+
+  TEST_OUTPUT = myObject instanceof MyClass;
+  `,
+    { target: "node", minify: true }
+  );
+
+  var TEST_OUTPUT = false;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});
+
+test("Variant #22: Properly handle Object constructor (Function Expression)", async () => {
+  var output = await JsConfuser(
+    `
+  var MyClass = function() {};
+
+  var myObject = new MyClass();
+
+  TEST_OUTPUT = myObject instanceof MyClass;
+  `,
+    { target: "node", minify: true }
+  );
+
+  var TEST_OUTPUT = false;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});

package/test/transforms/rgf.test.ts

@@ -288,6 +288,62 @@ input(console.log, result)
 
     expect(output).not.toContain("new Function");
   });
+
+  it("should work with Control Flow Flattening and Duplicate Literals Removal enabled", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var x = [1,1,1,1,1,1,1,1,1,1];
+
+      function myFunction(){
+        return 1;
+      };
+
+      input( myFunction() ); // 1
+    `,
+      {
+        target: "node",
+        controlFlowFlattening: true,
+        duplicateLiteralsRemoval: true,
+        rgf: true,
+      }
+    );
+
+    var value = "never_called";
+    function input(valueIn) {
+      value = valueIn;
+    }
+
+    eval(output);
+
+    expect(value).toStrictEqual(1);
+  });
+
+  it("should work with String Encoding enabled", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      function myFunction(){
+        var val1 = "\\x43\\x6F\\x72\\x72\\x65\\x63\\x74\\x20\\x56\\x61\\x6C\\x75\\x65"; // "Correct Value"
+        var val2 = "Correct Value";
+        return val1 === val2;
+      }
+
+      TEST_OUTPUT = myFunction(); // true
+    `,
+      {
+        target: "node",
+        rgf: true,
+        stringEncoding: true,
+      }
+    );
+
+    // Ensure RGF applied
+    expect(output).toContain("new Function");
+
+    var TEST_OUTPUT;
+    eval(output);
+
+    expect(TEST_OUTPUT).toStrictEqual(true);
+  });
 });
 
 describe("RGF with the 'all' mode", () => {

package/test/transforms/string/stringConcealing.test.ts

@@ -182,3 +182,36 @@ it("should not encode constructor key", async () => {
 
   expect(TEST_VAR).toStrictEqual(100);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/82
+it("should work inside the Class Constructor function", async () => {
+  var code = `
+  class MyClass1 {}
+  class MyClass2 extends MyClass1 {
+    constructor(){
+      super();
+      this["myString1"] = true;
+      this["myString2"] = true;
+      this["myString3"] = true;
+    }
+  }
+
+  var instance = new MyClass2();
+
+  TEST_OUTPUT = instance.myString1 === true; // true
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    stringConcealing: true,
+  });
+
+  // Ensure the strings got encrypted properly
+  expect(output).not.toContain("myString");
+
+  // Ensure the code works
+  var TEST_OUTPUT = false;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});

package/test/util/compare.test.ts

@@ -1,4 +1,4 @@
-import { isEquivalent } from "../../src/util/compare";
+import { isEquivalent, isValidIdentifier } from "../../src/util/compare";
 import { Identifier } from "../../src/util/gen";
 
 it("should compare nodes correctly", () => {
@@ -10,3 +10,25 @@ it("should compare nodes correctly", () => {
     isEquivalent(Identifier("name"), Identifier("different_name"))
   ).toStrictEqual(false);
 });
+
+describe("isValidIdentifier", () => {
+  test("Variant #1: Basic examples", () => {
+    // true examples
+    expect(isValidIdentifier("myClass")).toStrictEqual(true);
+    expect(isValidIdentifier("MyClass")).toStrictEqual(true);
+    expect(isValidIdentifier("$myObject")).toStrictEqual(true);
+    expect(isValidIdentifier("_myObject")).toStrictEqual(true);
+    expect(isValidIdentifier("myObject2")).toStrictEqual(true);
+    expect(isValidIdentifier("_0")).toStrictEqual(true);
+
+    // false examples
+    expect(isValidIdentifier("0")).toStrictEqual(false);
+    expect(isValidIdentifier("0myInvalidVar")).toStrictEqual(false);
+    expect(isValidIdentifier("^")).toStrictEqual(false);
+    expect(isValidIdentifier("%")).toStrictEqual(false);
+    expect(isValidIdentifier("invalid*Var")).toStrictEqual(false);
+    expect(isValidIdentifier("invalid!")).toStrictEqual(false);
+    expect(isValidIdentifier("my invalid var")).toStrictEqual(false);
+    expect(isValidIdentifier("my-invalid-var")).toStrictEqual(false);
+  });
+});