js-confuser 1.5.5 → 1.5.7

package/test/transforms/minify.test.ts

@@ -301,9 +301,9 @@ test("Variant #15: Removing implied 'return'", async () => {
 });
 
 // https://github.com/MichaelXF/js-confuser/issues/43
-test("Variant #16: Handle deconstructuring in for loop", async ()=>{
-// Valid
-var output = await JsConfuser(
+test("Variant #16: Handle deconstructuring in for loop", async () => {
+  // Valid
+  var output = await JsConfuser(
     `
     for(const [a] of [[1]]) {
         input(a);
@@ -313,11 +313,56 @@ var output = await JsConfuser(
   );
 
   var value;
-  function input(valueIn){
+  function input(valueIn) {
     value = valueIn;
   }
 
   eval(output);
 
   expect(value).toStrictEqual(1);
-})
+});
+
+test("Variant #17: Remove unreachable code following a return statement", async () => {
+  var output = await JsConfuser(
+    `
+    function myFunction(){
+      return;
+      unreachableStmt;
+    }
+  `,
+    { target: "node", minify: true }
+  );
+
+  expect(output).not.toContain("unreachableStmt");
+});
+
+test("Variant #18: Remove unreachable code following a continue or break statement", async () => {
+  var output = await JsConfuser(
+    `
+    for(var i =0; i < 10; i++){
+      continue;
+      unreachableStmt
+    }
+
+    while(true){
+      break;
+      unreachableStmt
+    }
+  `,
+    { target: "node", minify: true }
+  );
+
+  expect(output).not.toContain("unreachableStmt");
+});
+
+test("Variant #19: Remove unreachable code following a throw statement", async () => {
+  var output = await JsConfuser(
+    `
+    throw new Error("No more code to run");
+    unreachableStmt;
+  `,
+    { target: "node", minify: true }
+  );
+
+  expect(output).not.toContain("unreachableStmt");
+});

package/test/transforms/rgf.test.ts

@@ -154,6 +154,140 @@ input(console.log, result)
     eval(output);
     expect(value).toStrictEqual(60);
   });
+
+  // https://github.com/MichaelXF/js-confuser/issues/64
+  it("should work on Arrow Functions", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var double = (num)=>num*2;
+      TEST_VALUE = double(10);
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).toContain("new Function");
+
+    var TEST_VALUE;
+
+    eval(output);
+    expect(TEST_VALUE).toStrictEqual(20);
+  });
+
+  it("should work on Function Expressions", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var double = function(num){
+        return num * 2
+      };
+      TEST_VALUE = double(10);
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).toContain("new Function");
+
+    var TEST_VALUE;
+
+    eval(output);
+    expect(TEST_VALUE).toStrictEqual(20);
+  });
+
+  it("should work on re-assigned functions", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var fn1 = ()=>{
+        return "FN1";
+      }
+      var fn2 = ()=>{
+        fn1 = ()=>{
+          return "FN1 - Modified"
+        }
+      }
+      fn2();
+      TEST_VALUE = fn1();
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).toContain("new Function");
+
+    var TEST_VALUE;
+
+    eval(output);
+    expect(TEST_VALUE).toStrictEqual("FN1 - Modified");
+  });
+
+  it("should work on re-assigned functions to non-function values", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var fn1 = ()=>{
+        return "FN1";
+      }
+      var fn2 = ()=>{
+        fn1 = undefined;
+      }
+      fn2();
+      TEST_VALUE = typeof fn1;
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).toContain("new Function");
+
+    var TEST_VALUE;
+
+    eval(output);
+    expect(TEST_VALUE).toStrictEqual("undefined");
+  });
+
+  it("should not apply to functions that reference their parent scope in the parameters", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var outsideVar = 0;
+      function myFunction(insideVar = outsideVar){
+      }
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).not.toContain("new Function");
+  });
+
+  it("should not apply to functions that reference their parent scope in previously defined names", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var outsideVar = 0;
+      function myFunction(){
+        (function (){
+          var outsideVar;
+        })();
+
+        console.log(outsideVar);
+      }
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).not.toContain("new Function");
+  });
 });
 
 describe("RGF with the 'all' mode", () => {