js-confuser 1.5.8 → 1.6.0

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;";
@@ -474,3 +475,110 @@ test("Variant #19: Don't break Import Declarations", async () => {
     "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");
+});
+
+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");
+});

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

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

package/test/transforms/rgf.test.ts

@@ -126,35 +126,6 @@ describe("RGF", () => {
     expect(value).toStrictEqual("Hello World");
   });
 
-  it("should work with hideInitializingCode enabled", async () => {
-    var output = await JsConfuser.obfuscate(
-      `
-function abc(x, y){
-  return x + y;
-}
-
-var result = abc(10, 50);
-input(console.log, result) 
-`,
-      {
-        target: "node",
-        identifierGenerator: "randomized",
-        hideInitializingCode: true,
-        rgf: true,
-        compact: false,
-        renameVariables: true,
-      }
-    );
-
-    var value = "never_called";
-    function input(_, valueIn) {
-      value = valueIn;
-    }
-
-    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(
@@ -288,6 +259,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", () => {