js-confuser 1.5.8 → 1.5.9

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);
+  });
+});