js-confuser 1.7.3 → 2.0.0-alpha.0

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

@@ -1,66 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-it("add debugger statements", async () => {
-  var output = await JsConfuser.obfuscate("input(true)", {
-    target: "node",
-    lock: {
-      antiDebug: true,
-    },
-  });
-
-  expect(output).toContain("debugger");
-});
-
-it("add a background interval", async () => {
-  var output = await JsConfuser.obfuscate("input(true)", {
-    target: "node",
-    lock: {
-      antiDebug: true,
-    },
-  });
-
-  expect(output).toContain("setInterval");
-});
-
-it("should place syntax-correct code", async () => {
-  for (var i = 0; i < 25; 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: true,
-        identifierGenerator: "randomized",
-        lock: { antiDebug: true },
-        minify: true,
-        target: "node",
-      }
-    );
-
-    try {
-      eval(output);
-    } catch (e) {
-      expect(e).toStrictEqual(undefined);
-    }
-  }
-});

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

@@ -1,129 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-test("Variant #1: Chrome", async () => {
-  // Chrome user-agent
-  var window = {
-    navigator: {
-      userAgent:
-        "Mozilla/5.0 (X11; CrOS x86_64 8172.45.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.64 Safari/537.36",
-    },
-  };
-
-  var output = await JsConfuser.obfuscate(
-    `
-  function caught(){
-    TEST_VARIABLE = "caught"
-  }
-  `,
-    {
-      target: "browser",
-      lock: {
-        browserLock: ["chrome"],
-        countermeasures: "caught",
-      },
-    }
-  );
-
-  var TEST_VARIABLE;
-
-  eval(output);
-  expect(TEST_VARIABLE).toStrictEqual(undefined);
-});
-
-test(
-  "Variant #2: Chrome on Firefox browser",
-  async () => {
-    // Firefox user-agent
-    var window = {
-      navigator: {
-        userAgent:
-          "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0.1",
-      },
-    };
-
-    var output = await JsConfuser.obfuscate(
-      `
-  function caught(){
-    TEST_VARIABLE = "caught"
-  }
-  `,
-      {
-        target: "browser",
-        lock: {
-          browserLock: ["chrome"],
-          countermeasures: "caught",
-        },
-      }
-    );
-
-    var TEST_VARIABLE;
-
-    eval(output);
-    expect(TEST_VARIABLE).toStrictEqual("caught");
-  },
-  30 * 1000
-);
-
-test("Variant #2: Firefox", async () => {
-  // Firefox user-agent
-  var window = {
-    navigator: {
-      userAgent:
-        "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0.1",
-    },
-  };
-
-  var output = await JsConfuser.obfuscate(
-    `
-  function caught(){
-    TEST_VARIABLE = "caught"
-  }
-  `,
-    {
-      target: "browser",
-      lock: {
-        browserLock: ["firefox"],
-        countermeasures: "caught",
-      },
-    }
-  );
-
-  var TEST_VARIABLE;
-
-  eval(output);
-  expect(TEST_VARIABLE).toStrictEqual(undefined);
-});
-
-test(
-  "Variant #4: Firefox on Chrome browser",
-  async () => {
-    // Chrome user-agent
-    var window = {
-      navigator: {
-        userAgent:
-          "Mozilla/5.0 (X11; CrOS x86_64 8172.45.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.64 Safari/537.36",
-      },
-    };
-
-    var output = await JsConfuser.obfuscate(
-      `
-  function caught(){
-    TEST_VARIABLE = "caught"
-  }
-  `,
-      {
-        target: "browser",
-        lock: {
-          browserLock: ["firefox"],
-          countermeasures: "caught",
-        },
-      }
-    );
-
-    var TEST_VARIABLE;
-
-    eval(output);
-    expect(TEST_VARIABLE).toStrictEqual("caught");
-  },
-  30 * 1000
-);

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

@@ -1,100 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-test("Variant #1: Error when countermeasures function can't be found", async () => {
-  var err;
-  try {
-    await JsConfuser.obfuscate(`5+5`, {
-      target: "node",
-      lock: {
-        countermeasures: "myMissingFunction",
-      },
-    });
-  } catch (_err) {
-    err = _err;
-  }
-
-  expect(err).toBeTruthy();
-  expect(err instanceof Error).toStrictEqual(true);
-  expect(err.message).toContain(
-    "Countermeasures function named 'myMissingFunction' was not found"
-  );
-});
-
-test("Variant #2: Error when countermeasures function isn't top-level", async () => {
-  await expect(async () => {
-    await JsConfuser.obfuscate(
-      `
-    (function(){
-      function myNonTopLevelFunction(){
-
-      }
-    })();
-    `,
-      {
-        target: "node",
-        lock: {
-          countermeasures: "myNonTopLevelFunction",
-        },
-      }
-    );
-  }).rejects.toThrow(
-    "Countermeasures function must be defined at the global level"
-  );
-});
-
-test("Variant #3: Error when countermeasures function is redefined", async () => {
-  await expect(async () => {
-    await JsConfuser.obfuscate(
-      `
-    function myFunction(){
-
-    }
-    var myFunction = function(){
-
-    }
-    `,
-      {
-        target: "node",
-        lock: {
-          countermeasures: "myFunction",
-        },
-      }
-    );
-  }).rejects.toThrow(
-    "Countermeasures function was already defined, it must have a unique name from the rest of your code"
-  );
-});
-
-test("Variant #4: Should work when countermeasures is variable declaration", async () => {
-  await JsConfuser.obfuscate(
-    `
-  var myFunction = function(){
-
-  }
-  `,
-    {
-      target: "node",
-      lock: {
-        countermeasures: "myFunction",
-      },
-    }
-  );
-});
-
-// https://github.com/MichaelXF/js-confuser/issues/66
-test("Variant #5: Should work with RGF enabled", async () => {
-  await JsConfuser.obfuscate(
-    `
-  function myCountermeasuresFunction(){
-
-  }
-  `,
-    {
-      target: "node",
-      lock: {
-        countermeasures: "myCountermeasuresFunction",
-      },
-      rgf: true,
-    }
-  );
-});

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

@@ -1,161 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-it("should run correctly", async () => {
-  var code = `
-  function TEST_FUNCTION(){
-    input_test1(true) 
-  }
-
-  TEST_FUNCTION();
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    lock: { integrity: true, countermeasures: false },
-  });
-
-  expect(output).toContain("function");
-
-  var value = "never_called";
-  function input_test1(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(true);
-});
-
-it("should not run when source code is modified", async () => {
-  var code = `
-  function TEST_FUNCTION(){
-    input("Hello World") 
-  }
-
-  TEST_FUNCTION();
-  
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    lock: { integrity: true, countermeasures: false },
-  });
-
-  expect(output).toContain("function");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  // Change the "Hello World" to "Goodnight"
-  output = output.replace("Hello World", "Goodnight");
-
-  eval(output);
-
-  expect(value).not.toEqual("Goodnight");
-
-  expect(value).toStrictEqual("never_called");
-});
-
-it("should run countermeasures function when changed", async () => {
-  var code = `
-  function TEST_FUNCTION(){
-    input("The code was never changed") 
-  }
-
-  function TEST_COUNTERMEASURES(){
-    input("countermeasures")
-  }
-
-  TEST_FUNCTION();
-  
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    lock: { integrity: true, countermeasures: "TEST_COUNTERMEASURES" },
-  });
-
-  expect(output).toContain("function");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  // Change the "Hello World" to "Goodnight"
-  output = output.replace(
-    "The code was never changed",
-    "The modified code was executed"
-  );
-
-  eval(output);
-
-  expect(value).toStrictEqual("countermeasures");
-});
-
-it("should error when countermeasures function doesn't exist", async () => {
-  var code = `
-  function TEST_FUNCTION(){
-    input("The code was never changed") 
-  }
-
-  TEST_FUNCTION();
-  `;
-
-  var errorCaught;
-  try {
-    var output = await JsConfuser(code, {
-      target: "node",
-      lock: { integrity: true, countermeasures: "TEST_COUNTERMEASURES" },
-    });
-  } catch (e) {
-    errorCaught = e;
-  }
-
-  expect(errorCaught).toBeTruthy();
-  expect(errorCaught.toString()).toContain(
-    "Countermeasures function named 'TEST_COUNTERMEASURES' was not found."
-  );
-  expect(errorCaught.toString()).toContain("TEST_COUNTERMEASURES");
-});
-
-it("should work on High Preset", async () => {
-  var output = await JsConfuser(`TEST_OUTPUT = ("Hello World")`, {
-    target: "node",
-    preset: "high",
-    lock: {
-      integrity: true,
-    },
-  });
-
-  var TEST_OUTPUT;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual("Hello World");
-});
-
-it("should work with RGF enabled", async () => {
-  var output = await JsConfuser(
-    `
-  function getTestOutput(){
-    return "Hello World";
-  }
-
-  TEST_OUTPUT = getTestOutput();
-  `,
-    {
-      target: "node",
-      rgf: true,
-      lock: {
-        integrity: true,
-      },
-    }
-  );
-
-  var TEST_OUTPUT;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual("Hello World");
-});

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

@@ -1,204 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-it("should work with startDate and call countermeasures function", async () => {
-  var startDate = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "node",
-      lock: {
-        startDate: Date.now() + 1000 * 60 * 60 * 24, // one day in the future
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(startDate);
-  expect(value).toStrictEqual(true);
-});
-
-it("should not call countermeasures if the time is correct", async () => {
-  var startDate = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "node",
-      lock: {
-        startDate: Date.now() - 1000 * 60 * 60 * 24, // one day in the past
-        endDate: Date.now() + 1000 * 60 * 60 * 24, // one day in the future (2-day window to run this code)
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(startDate);
-  expect(value).toStrictEqual("never_called");
-});
-
-it("should work with endDate and call countermeasures function", async () => {
-  var endDate = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "node",
-      lock: {
-        endDate: Date.now() - 1000 * 60 * 60 * 24, // one day in the past
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(endDate);
-  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",
-//     lock: {
-//       startDate: Date.now() - 1000 * 60 * 60 * 24, // one day in the past
-//       endDate: Date.now() + 1000 * 60 * 60 * 24, // one day in the future (2-day window to run this code)
-//     },
-//   });
-
-//   var value = "never_called";
-//   function input(valueIn) {
-//     value = valueIn;
-//   }
-
-//   eval(startDate);
-//   expect(value).toStrictEqual("ENCODED_STRING");
-// });
-
-it("countermeasures function should still work even with renameVariables enabled", async () => {
-  var output = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "node",
-      renameVariables: true,
-      renameGlobals: true, // <- `countermeasures` is top level name
-      lock: {
-        endDate: Date.now() - 1000 * 60 * 60 * 24, // always in the past, therefore countermeasures will always be called
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  // ensure function was renamed
-  expect(output).not.toContain("countermeasures");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-  expect(value).toStrictEqual(true);
-});
-
-it("should not call countermeasures when domainLock is correct", async () => {
-  var output = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "browser",
-      lock: {
-        domainLock: ["mywebsite.com"],
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  var location = {
-    href: "mywebsite.com",
-  };
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-  expect(value).toStrictEqual("never_called");
-});
-
-it("should call countermeasures when domain is different", async () => {
-  var output = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "browser",
-      lock: {
-        domainLock: ["mywebsite.com"],
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  var location = {
-    href: "anotherwebsite.com",
-  };
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-  expect(value).toStrictEqual(true);
-});
-
-it("should not call countermeasures when context is correct", async () => {
-  var output = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "node",
-      lock: {
-        context: ["authenticated"],
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  (global as any).authenticated = true;
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-  expect(value).toStrictEqual("never_called");
-});
-
-it("should call countermeasures when context is different", async () => {
-  var output = await JsConfuser.obfuscate(
-    ` function countermeasures(){ input(true) } `,
-    {
-      target: "node",
-      lock: {
-        context: ["missingProperty"],
-        countermeasures: "countermeasures",
-      },
-    }
-  );
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-  expect(value).toStrictEqual(true);
-});