js-confuser 1.2.1 → 1.4.1

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

@@ -1,134 +1,159 @@
 import JsConfuser from "../../../src/index";
 
-it("should move variable declarations to the top of the lexical block", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    console.log("...")
-    var a = 1, b = 2;
-    console.log(a)
-    `,
-    {
-      target: "node",
-      movedDeclarations: true,
-    }
-  );
-
-  expect(output).toContain("var a,b;");
-  expect(output).toContain("a=1,b=2");
+test("Variant #1: Move variable 'y' to top", async () => {
+  var code = `
+    var x = 10;
+    var y = 15;
+    TEST_VARIABLE = x + y;
+  `;
+
+  var output = await JsConfuser.obfuscate(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
+
+  expect(output).toContain("var y;");
+  expect(output).toContain("y=15");
+
+  var TEST_VARIABLE;
+  eval(output);
+
+  expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-it("should still execute properly", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
+test("Variant #2: Move variable 'y' and 'z' to top", async () => {
+  var code = `
+    var x = 10;
+    var y = 15;
+    var z = 5;
+    TEST_VARIABLE = x + y + z;
+  `;
 
-    function add(n1, n2){
-      return n1 + n2;
-    }
+  var output = await JsConfuser.obfuscate(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
 
-    var a = 6, b = 4;
+  expect(output).toContain("var y,z");
+  expect(output).toContain("y=15");
+  expect(output).toContain("z=5");
 
-    input( add(a, b) );
-    `,
-    {
-      target: "node",
-      movedDeclarations: true,
-    }
-  );
+  var TEST_VARIABLE;
+  eval(output);
+
+  expect(TEST_VARIABLE).toStrictEqual(30);
+});
 
-  expect(output).toContain("var a,b;");
+test("Variant #2: Don't move 'y' (destructuring)", async () => {
+  var code = `
+    var x = 10;
+    var [y] = [15];
+    TEST_VARIABLE = x + y;
+  `;
 
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
+  var output = await JsConfuser.obfuscate(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
 
+  expect(output).toContain("var [y]=[15];");
+
+  var TEST_VARIABLE;
   eval(output);
 
-  expect(value).toStrictEqual(10);
+  expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-it("should not move declarations in for statements", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    for ( var i = 0; i < 10; i++ ) {
-      
-    }
-    `,
-    {
-      target: "node",
-      movedDeclarations: true,
-    }
-  );
-
-  expect(output).toContain("for(var i=0;");
-});
+test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
+  var code = `
+    var x = 10;
+    var y = 15;
 
-it("should not move redefined names", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    var a;
-    var output;
     (function(){
-      var a;
-      var output;
+      y = 10;
     })();
-    `,
-    {
-      target: "node",
-      movedDeclarations: true,
-    }
-  );
-
-  expect(output).toContain("var a;var output;");
+
+    TEST_VARIABLE = x + y;
+  `;
+
+  var output = await JsConfuser.obfuscate(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
+
+  expect(output).toContain("var y=15");
+
+  var TEST_VARIABLE;
+  eval(output);
+
+  expect(TEST_VARIABLE).toStrictEqual(20);
+});
+
+test("Variant #4: Move 'y' (for statement initializer)", async () => {
+  var code = `
+    var x = 10;
+    for ( var y = 0; y < 15; y++ ) {
+
+    } // y ends as 15
+    TEST_VARIABLE = x + y;
+  `;
+
+  var output = await JsConfuser.obfuscate(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
+
+  expect(output).not.toContain("var y=0;");
+
+  var TEST_VARIABLE;
+  eval(output);
+
+  expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-it("should not move declarations in switch cases", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    var b = 0;
-    switch(b){
-      case 0:
-        var a = 0;
-        break;
-      case 1:
-        a = 1;
-        break;
-    }
-    `,
-    {
-      target: "node",
-      movedDeclarations: true,
-    }
-  );
-
-  expect(output).toContain("var a=0;");
+test("Variant #5: 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] ) {
+
+    } // y ends as "15"
+    TEST_VARIABLE = x + parseInt(y);
+  `;
+
+  var output = await JsConfuser.obfuscate(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
+
+  expect(output).not.toContain("var y in");
+  expect(output).toContain("y in");
+
+  var TEST_VARIABLE;
+  eval(output);
+
+  expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-it("should not move declarations in nested switch cases", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    var i = 1;
-    while(i > 0){
-      var b = 0;
-      switch(b){
-        case 0:
-          var a = 0;
-          break;
-        case 1:
-          a = 1;
-          break;
-      }
-
-      i--;
-    }
-
-    
-    `,
-    {
-      target: "node",
-      movedDeclarations: true,
-    }
-  );
-
-  expect(output).toContain("var a=0;");
+test("Variant #6: Don't move const or let variables", async () => {
+  var code = `
+    var fillerExpr;
+
+    let x = 10;
+    const y = 15;
+
+    TEST_VARIABLE = x + y;
+  `;
+
+  var output = await JsConfuser.obfuscate(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
+
+  expect(output).toContain("let x=10");
+  expect(output).toContain("const y=15");
+
+  var TEST_VARIABLE;
+  eval(output);
+
+  expect(TEST_VARIABLE).toStrictEqual(25);
 });

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

@@ -1,6 +1,6 @@
 import JsConfuser from "../../../src/index";
 
-it("should rename variables properly", async () => {
+test("Variant #1: Rename variables properly", async () => {
   var code = "var TEST_VARIABLE = 1;";
   var output = await JsConfuser(code, {
     target: "browser",
@@ -13,7 +13,7 @@ it("should rename variables properly", async () => {
   expect(output).not.toContain("TEST_VARIABLE");
 });
 
-it("should not rename global accessors", async () => {
+test("Variant #2: Don't rename global accessors", async () => {
   var code = `
   var TEST_VARIABLE = 1;
   success(TEST_VARIABLE); // success should not be renamed
@@ -38,7 +38,7 @@ it("should not rename global accessors", async () => {
   expect(passed).toStrictEqual(true);
 });
 
-it("should rename shadowed variables properly", async () => {
+test("Variant #3: Rename shadowed variables properly", async () => {
   var code = `
   var TEST_VARIABLE = 1;
   
@@ -66,7 +66,7 @@ it("should rename shadowed variables properly", async () => {
   expect(value).toStrictEqual(10);
 });
 
-it("should not rename member properties", async () => {
+test("Variant #4: Don't rename member properties", async () => {
   var code = `
 
     var TEST_OBJECT = { TEST_PROPERTY: 100 }
@@ -92,7 +92,7 @@ it("should not rename member properties", async () => {
   expect(value).toStrictEqual(100);
 });
 
-it("should handle variable defined with let (1)", async () => {
+test("Variant #5: Handle variable defined with let (1)", async () => {
   var code = `
 
     // lexically bound
@@ -117,7 +117,7 @@ it("should handle variable defined with let (1)", async () => {
   expect(value).toStrictEqual(100);
 });
 
-it("should handle variable defined with let (2)", async () => {
+test("Variant #6: Handle variable defined with let (2)", async () => {
   var code = `
 
     // lexically bound
@@ -145,7 +145,7 @@ it("should handle variable defined with let (2)", async () => {
   expect(value).toStrictEqual(100);
 });
 
-it("should handle variable defined with let (3)", async () => {
+test("Variant #7: Handle variable defined with let (3)", async () => {
   var code = `
 
     // lexically bound
@@ -179,7 +179,7 @@ it("should handle variable defined with let (3)", async () => {
   expect(value).toStrictEqual(100);
 });
 
-it("should not rename null (reservedIdentifiers)", async () => {
+test("Variant #8: Don't rename null (reservedIdentifiers)", async () => {
   var code = `
     input(null)
   `;
@@ -199,7 +199,7 @@ it("should not rename null (reservedIdentifiers)", async () => {
   expect(value).toStrictEqual(null);
 });
 
-it("should not rename exported names", async () => {
+test("Variant #9: Don't rename exported names", async () => {
   var code = `
     export function abc(){
 
@@ -215,7 +215,7 @@ it("should not rename exported names", async () => {
   expect(output).toContain("abc");
 });
 
-it("should call renameVariables callback properly (variables)", async () => {
+test("Variant #10: Call renameVariables callback properly (variables)", async () => {
   var code = `
     var myVariable = 1;
   `;
@@ -233,7 +233,7 @@ it("should call renameVariables callback properly (variables)", async () => {
   expect(input).toEqual(["myVariable", true]);
 });
 
-it("should call renameVariables callback properly (variables, nested)", async () => {
+test("Variant #11: Call renameVariables callback properly (variables, nested)", async () => {
   var code = `
     (function(){
       var myVariable = 1;
@@ -253,7 +253,7 @@ it("should call renameVariables callback properly (variables, nested)", async ()
   expect(input).toEqual(["myVariable", false]);
 });
 
-it("should call renameVariables callback properly (function declaration)", async () => {
+test("Variant #12: Call renameVariables callback properly (function declaration)", async () => {
   var code = `
     function myFunction(){
 
@@ -273,7 +273,7 @@ it("should call renameVariables callback properly (function declaration)", async
   expect(input).toEqual(["myFunction", true]);
 });
 
-it("should allow excluding custom variables from being renamed", async () => {
+test("Variant #13: Allow excluding custom variables from being renamed", async () => {
   var code = `
     var myVariable1 = 1;
     var myVariable2 = 1;
@@ -290,3 +290,114 @@ it("should allow excluding custom variables from being renamed", async () => {
   expect(output).toContain("myVariable1");
   expect(output).not.toContain("myVariable2");
 });
+
+test("Variant #14: should not break global variable references", async () => {
+  /**
+   * In this case `b` is a global variable,
+   *
+   * "mangled" names are a,b,c,d...
+   *
+   * therefore make sure `b` is NOT used as it breaks program
+   */
+  var code = `
+  var a = "";
+
+  function myFunction(param1, param2){
+      b(param1);
+  }
+
+  myFunction("Hello World");
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    renameVariables: true,
+    renameGlobals: true,
+    identifierGenerator: "mangled",
+  });
+
+  expect(output).not.toContain("b(b)");
+
+  var value;
+  function b(valueIn) {
+    value = valueIn;
+  }
+
+  eval(output);
+
+  expect(value).toStrictEqual("Hello World");
+});
+
+test("Variant #15: Function parameter default value", async () => {
+  /**
+   * In this case `b` is a global variable,
+   *
+   * "mangled" names are a,b,c,d...
+   *
+   * therefore make sure `b` is NOT used as it breaks program
+   */
+  var code = `
+   var a = "Filler Variables";
+   var b = "Hello World";
+   var c = "Another incorrect string";
+ 
+   function myFunction(param1 = ()=>{
+     return b;
+   }){
+    var b = param1();
+    if(false){
+      a,c;
+    }
+    input(b);
+   }
+ 
+   myFunction();
+   `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    renameVariables: true,
+    renameGlobals: true,
+    identifierGenerator: "mangled",
+  });
+
+  var value;
+  function input(valueIn) {
+    value = valueIn;
+  }
+
+  eval(output);
+
+  expect(value).toStrictEqual("Hello World");
+});
+
+// https://github.com/MichaelXF/js-confuser/issues/24
+test("Variant #16: Function with multiple parameters and a default value", async () => {
+  var code = `
+  function FuncA(param1, param2 = FuncB){
+    param2()
+  }
+  
+  function FuncB(){
+    input("Success!");
+  }
+  
+  FuncA();
+   `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    renameVariables: true,
+    renameGlobals: true,
+    identifierGenerator: "mangled",
+  });
+
+  var value;
+  function input(valueIn) {
+    value = valueIn;
+  }
+
+  eval(output);
+
+  expect(value).toStrictEqual("Success!");
+});

package/test/transforms/lock/antiDebug.test.ts

@@ -21,3 +21,46 @@ it("add a background interval", async () => {
 
   expect(output).toContain("setInterval");
 });
+
+it("should place syntax-correct code", async () => {
+  for (var i = 0; i < 50; i++) {
+    var output = await JsConfuser.obfuscate(
+      `
+    /**
+    * GitHub: https://github.com/MichaelXF/js-confuser
+    * NPM: https://www.npmjs.com/package/js-confuser
+    *
+    * Welcome to Js Confuser
+    * 
+    * You can obfuscate the code with the top right button 'Obfuscate'.
+    * 
+    * You can customize the obfuscator with the button 'Options'.
+    * (Set the target to 'node' for NodeJS apps)
+    *
+    * Happy Hacking!
+    */
+    
+    function greet(name){
+        var output = "Hello " + name + "!";
+    }
+    
+    greet("Internet User");
+    
+    `,
+      {
+        compact: true,
+        controlFlowFlattening: 0.25,
+        identifierGenerator: "randomized",
+        lock: { antiDebug: true },
+        minify: true,
+        target: "node",
+      }
+    );
+
+    try {
+      eval(output);
+    } catch (e) {
+      expect(e).toStrictEqual(undefined);
+    }
+  }
+});

package/test/transforms/lock/selfDefending.test.ts

@@ -0,0 +1,68 @@
+import JsConfuser from "../../../src/index";
+
+test("Variant #1: SelfDefending should forcibly enable `compact`", async () => {
+  var output = await JsConfuser.obfuscate(`console.log(1)`, {
+    target: "node",
+    compact: false,
+    lock: {
+      selfDefending: true,
+    },
+  });
+
+  expect(output).not.toContain("\n");
+});
+
+test("Variant #2: SelfDefending should not crash when unchanged", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  function caught(){
+    TEST_CAUGHT = true;
+  }
+  TEST_VAR = 100;
+  `,
+    {
+      target: "node",
+      lock: {
+        selfDefending: true,
+        countermeasures: "caught",
+      },
+    }
+  );
+
+  var TEST_VAR, TEST_CAUGHT;
+
+  eval(output);
+
+  expect(TEST_VAR).toStrictEqual(100);
+  expect(TEST_CAUGHT).toStrictEqual(undefined);
+});
+
+test("Variant #2: SelfDefending should crash when changed", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  function caught(){
+    TEST_CAUGHT = true;
+  }
+  TEST_VAR = 100;
+  `,
+    {
+      target: "node",
+      lock: {
+        selfDefending: true,
+        countermeasures: "caught",
+      },
+    }
+  );
+
+  // Re-run through obfuscator without compact = new lines = crash should occur
+  var output2 = await JsConfuser.obfuscate(output, {
+    target: "node",
+    compact: false,
+  });
+
+  var TEST_VAR, TEST_CAUGHT;
+
+  eval(output2);
+
+  expect(TEST_CAUGHT).toStrictEqual(true);
+});