js-confuser 1.5.9 → 1.7.0

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

@@ -12,7 +12,7 @@ test("Variant #1: Move variable 'y' to top", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y;");
+  expect(output).toContain("var x=10,y;");
   expect(output).toContain("y=15");
 
   var TEST_VARIABLE;
@@ -34,7 +34,7 @@ test("Variant #2: Move variable 'y' and 'z' to top", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y,z");
+  expect(output).toContain("var x=10,y,z;");
   expect(output).toContain("y=15");
   expect(output).toContain("z=5");
 
@@ -44,7 +44,7 @@ test("Variant #2: Move variable 'y' and 'z' to top", async () => {
   expect(TEST_VARIABLE).toStrictEqual(30);
 });
 
-test("Variant #2: Don't move 'y' (destructuring)", async () => {
+test("Variant #3: Don't move 'y' (destructuring)", async () => {
   var code = `
     var x = 10;
     var [y] = [15];
@@ -64,7 +64,7 @@ test("Variant #2: Don't move 'y' (destructuring)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
+test("Variant #4: Move 'y' (nested lexical scope)", async () => {
   var code = `
     var x = 10;
     var y = 15;
@@ -81,7 +81,7 @@ test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y=15");
+  expect(output).toContain("var x=10,y;");
 
   var TEST_VARIABLE;
   eval(output);
@@ -89,7 +89,7 @@ test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(20);
 });
 
-test("Variant #4: Move 'y' (for statement initializer)", async () => {
+test("Variant #5: Move 'y' (for statement initializer)", async () => {
   var code = `
     var x = 10;
     for ( var y = 0; y < 15; y++ ) {
@@ -111,7 +111,7 @@ test("Variant #4: Move 'y' (for statement initializer)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #5: Move 'y' (for-in left-hand initializer)", async () => {
+test("Variant #6: 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] ) {
@@ -134,7 +134,7 @@ test("Variant #5: Move 'y' (for-in left-hand initializer)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #6: Don't move const or let variables", async () => {
+test("Variant #7: Don't move const or let variables", async () => {
   var code = `
     var fillerExpr;
 
@@ -157,3 +157,58 @@ test("Variant #6: Don't move const or let variables", async () => {
 
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
+
+test("Variant #8: 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);
+});
+
+test("Variant #9: Defined variable without an initializer", async () => {
+  var code = `
+  var x;
+  x = 1;
+  var y;
+  y = 2;
+  TEST_OUTPUT = x + y;
+  `;
+
+  var output1 = await JsConfuser(code, {
+    target: "node",
+    movedDeclarations: true,
+    controlFlowFlattening: true,
+    duplicateLiteralsRemoval: true,
+  });
+
+  var output2 = await JsConfuser(output1, {
+    target: "node",
+    movedDeclarations: true,
+    controlFlowFlattening: true,
+    duplicateLiteralsRemoval: true,
+  });
+
+  var TEST_OUTPUT;
+  eval(output2);
+  expect(TEST_OUTPUT).toStrictEqual(3);
+});

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

@@ -1,4 +1,5 @@
 import JsConfuser from "../../../src/index";
+import { ObfuscateOptions } from "../../../src/options";
 
 test("Variant #1: Rename variables properly", async () => {
   var code = "var TEST_VARIABLE = 1;";
@@ -500,3 +501,121 @@ test("Variant #20: Don't break code with var and let variables in same scope", a
 
   expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
+
+test.each(["hexadecimal", "mangled", "number", "zeroWidth"])(
+  "Variant #21: Work with custom identifierGenerator mode",
+  async (identifierGeneratorMode) => {
+    var output = await JsConfuser(
+      `
+  var myVar1 = "Correct Value";
+
+  TEST_OUTPUT = myVar1;
+  `,
+      {
+        target: "node",
+        renameVariables: true,
+        identifierGenerator:
+          identifierGeneratorMode as ObfuscateOptions["identifierGenerator"],
+      }
+    );
+
+    // Ensure 'myVar1' got renamed
+    expect(output).not.toContain("myVar1");
+
+    var TEST_OUTPUT;
+
+    eval(output);
+    expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+  }
+);
+
+test("Variant #22: Don't rename variables prefixed with '__NO_JS_CONFUSER_RENAME__'", async () => {
+  var output = await JsConfuser(
+    `
+    var myValue = "Correct Value";
+
+    var __NO_JS_CONFUSER_RENAME__myVar4 = "Incorrect Value";
+
+    __NO_JS_CONFUSER_RENAME__myVar4 = myValue;
+
+    eval( "TEST_OUTPUT = __NO_JS_CONFUSER_RENAME__myVar4" );
+    `,
+    {
+      target: "node",
+      renameVariables: true,
+    }
+  );
+
+  // Ensure 'myValue' got renamed
+  expect(output).not.toContain("myValue");
+  // Ensure '__NO_JS_CONFUSER_RENAME__myVar4' was not renamed
+  expect(output).toContain("__NO_JS_CONFUSER_RENAME__myVar4");
+
+  // Test the code
+  var TEST_OUTPUT;
+
+  eval(output);
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #23: Re-use previously generated names", async () => {
+  var output = await JsConfuser(
+    `
+  function log(message){
+    TEST_OUTPUT = message;
+  }
+
+  log("Correct Value");
+  `,
+    {
+      target: "node",
+      renameVariables: true,
+      identifierGenerator: "mangled",
+    }
+  );
+
+  expect(output).not.toContain("log");
+  expect(output).toContain("function a(a)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #24: Reference function name with parameter", async () => {
+  var output = await JsConfuser(
+    `
+  function myFunction(myFunction){
+    myFunction.property = "Correct Value";
+  }
+
+  myFunction(myFunction);
+  TEST_OUTPUT = myFunction.property;
+  `,
+    { target: "node", renameVariables: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #25: Reference catch parameter", async () => {
+  var output = await JsConfuser(
+    `
+  try {
+    throw "Correct Value";
+  } catch ( e ) {
+    TEST_OUTPUT = e;
+  }
+  `,
+    { target: "node", renameVariables: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

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

@@ -23,7 +23,7 @@ it("add a background interval", async () => {
 });
 
 it("should place syntax-correct code", async () => {
-  for (var i = 0; i < 50; i++) {
+  for (var i = 0; i < 25; i++) {
     var output = await JsConfuser.obfuscate(
       `
     /**
@@ -49,7 +49,7 @@ it("should place syntax-correct code", async () => {
     `,
       {
         compact: true,
-        controlFlowFlattening: 0.25,
+        controlFlowFlattening: true,
         identifierGenerator: "randomized",
         lock: { antiDebug: true },
         minify: true,

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

@@ -64,6 +64,7 @@ it("should work with endDate and call countermeasures function", async () => {
   expect(value).toStrictEqual(true);
 });
 
+// REMOVED FEATURE:
 // it("strings should be encoded when startDate and endDate are given", async () => {
 //   var startDate = await JsConfuser.obfuscate(` input("ENCODED_STRING") `, {
 //     target: "node",
@@ -82,54 +83,6 @@ it("should work with endDate and call countermeasures function", async () => {
 //   expect(value).toStrictEqual("ENCODED_STRING");
 // });
 
-it("should work with nativeFunctions and call countermeasures function", async () => {
-  var output = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "node",
-      lock: {
-        nativeFunctions: ["fetch"],
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  // custom function, not "native"
-  var fetch = () => {};
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-  expect(value).toStrictEqual(true);
-});
-
-it("should work with nativeFunctions and not call countermeasures function when correct", async () => {
-  var output = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "node",
-      lock: {
-        nativeFunctions: ["fetch"],
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  // bound functions return the "[native code]" string
-  var fetch = (() => {}).bind(this);
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-  expect(value).toStrictEqual("never_called");
-});
-
 it("countermeasures function should still work even with renameVariables enabled", async () => {
   var output = await JsConfuser.obfuscate(
     ` function countermeasures(){ input(true) } `,

package/test/transforms/minify.test.ts

@@ -432,3 +432,107 @@ test("Variant #22: Properly handle Object constructor (Function Expression)", as
 
   expect(TEST_OUTPUT).toStrictEqual(true);
 });
+
+test("Variant #23: Shorten property names and method names", async () => {
+  var output = await JsConfuser(
+    `
+  var myObject = { "myKey": "Correct Value" };
+  var myClass = class { ["myMethod"](){ return "Correct Value" } }
+
+  TEST_OUTPUT = myObject.myKey === (new myClass()).myMethod();
+  `,
+    { target: "node", minify: true }
+  );
+
+  expect(output).not.toContain("'myKey'");
+  expect(output).not.toContain("'myMethod'");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});
+
+test("Variant #24: Variable grouping in switch case", async () => {
+  var output = await JsConfuser(
+    `
+  switch(true){
+    case true:
+      var myVar1;
+      var myVar2;
+      var myVar3 = "Correct Value";
+      var myVar4;
+
+      TEST_OUTPUT = myVar3;
+    break;
+  }
+  `,
+    { target: "node", minify: true }
+  );
+
+  // Ensure the variable declarations were grouped
+  expect(output).toContain("var myVar1,myVar2,myVar3");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #25: Don't break redefined function declaration", async () => {
+  var output = await JsConfuser(
+    `
+  function a(){ TEST_OUTPUT = 1 };
+  function a(){ TEST_OUTPUT = 2 };
+  function a(){ TEST_OUTPUT = 3 };
+
+  a();
+  `,
+    { target: "node", minify: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(3);
+});
+
+test("Variant #26: Don't break nested redefined function declaration", async () => {
+  var output = await JsConfuser(
+    `
+  var a = 0;
+  if(true){
+    function a(){
+      TEST_OUTPUT = 1;
+    }
+  }
+
+  a();
+  `,
+    { target: "node", minify: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(1);
+});
+
+// https://github.com/MichaelXF/js-confuser/issues/91
+test("Variant #27: Preserve function.length property", async () => {
+  var output = await JsConfuser(
+    `
+    function oneParameter(a){};
+    var twoParameters = function({a},{b,c},...d){};
+    function threeParameters(a,b,c,d = 1,{e},...f){};
+
+    TEST_OUTPUT = oneParameter.length + twoParameters.length + threeParameters.length;
+  `,
+    { target: "node", minify: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(6);
+});

package/test/transforms/preparation.test.ts

@@ -0,0 +1,157 @@
+import JsConfuser from "../../src/index";
+
+test("Variant #1: Force Block Statements on If statements", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  if ( a ) b();
+
+  if ( a ) {} else c()
+  `,
+    {
+      target: "node",
+      compact: true, // <- Something needs to be enabled
+    }
+  );
+
+  // Ensure parenthesis were added
+  expect(output).toContain("{b()}");
+  expect(output).toContain("{c()}");
+});
+
+test("Variant #2: Force Block Statements on Arrow functions", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  TEST_OUTPUT = ()=>true;
+  `,
+    {
+      target: "node",
+      compact: true, // <- Something needs to be enabled
+    }
+  );
+
+  // Ensure parenthesis were added
+  expect(output).toContain("return");
+  expect(output).toContain("{");
+  expect(output).toContain("}");
+
+  // Ensure code still works
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(typeof TEST_OUTPUT).toStrictEqual("function");
+  expect(TEST_OUTPUT()).toStrictEqual(true);
+});
+
+test("Variant #3: Force Block Statements on For loops", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  for(;;) forStatement();
+  for(a in b) forInStatement();
+  for(a of b) forOfStatement();
+  `,
+    {
+      target: "node",
+      compact: true, // <- Something needs to be enabled
+    }
+  );
+
+  // Ensure parenthesis were added
+  expect(output).toContain("{forStatement()}");
+  expect(output).toContain("{forInStatement()}");
+  expect(output).toContain("{forOfStatement()}");
+});
+
+test("Variant #4: Force Block Statements on While loops/With statement", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  while(1) whileStatement();
+  with(a) withStatement();
+  `,
+    {
+      target: "node",
+      compact: true, // <- Something needs to be enabled
+    }
+  );
+
+  // Ensure parenthesis were added
+  expect(output).toContain("{whileStatement()}");
+  expect(output).toContain("{withStatement()}");
+});
+
+test("Variant #5: Force object accessors to use strings instead", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  console.log("Hello World")
+  `,
+    {
+      target: "node",
+      compact: true, // <- Something needs to be enabled
+    }
+  );
+
+  // Ensure the member expression got changed to a string
+  expect(output).toContain("console['log']");
+});
+
+test("Variant #6: Force object property keys to use strings instead", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  var myObject = {
+    myKey: 1
+  }
+  `,
+    {
+      target: "node",
+      compact: true, // <- Something needs to be enabled
+    }
+  );
+
+  // Ensure key got changed to a string
+  expect(output).toContain("'myKey'");
+});
+
+test("Variant #7: Force Variable declarations to be expanded", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  var myVar1, myVar2, myVar3;
+
+  switch(true){
+    case true:
+      var mySwitchVar1, mySwitchVar2, mySwitchVar3;
+    break;
+  }
+
+  {
+    var myBlockVar1;
+    var myBlockVar2;
+    var myBlockVar3;
+  }
+
+  if(true) var myIfVar1, myIfVar2, myIfVar3;
+  `,
+    {
+      target: "node",
+      compact: true, // <- Something needs to be enabled
+    }
+  );
+
+  // Ensure the variable declarations got changed
+  expect(output).toContain("var myVar1;");
+  expect(output).toContain("var myVar2;");
+  expect(output).toContain("var myVar3;");
+
+  // Ensure the switch declarations got changed
+  expect(output).toContain("var mySwitchVar1;");
+  expect(output).toContain("var mySwitchVar2;");
+  expect(output).toContain("var mySwitchVar3;");
+
+  // Ensure the block declarations got changed
+  expect(output).toContain("var myBlockVar1;");
+  expect(output).toContain("var myBlockVar2;");
+  expect(output).toContain("var myBlockVar3");
+
+  // Ensure the if-statement declarations got changed
+  expect(output).toContain("var myIfVar1;");
+  expect(output).toContain("var myIfVar2;");
+  expect(output).toContain("var myIfVar3");
+});