js-confuser 1.5.9 → 1.7.0

package/test/code/Dynamic.test.ts

@@ -1,10 +1,11 @@
 import { readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import JsConfuser from "../../src/index";
+import { ObfuscateOptions } from "../../src/options";
 
 var SOURCE_JS = readFileSync(join(__dirname, "./Dynamic.src.js"), "utf-8");
 
-it("works on High Preset", async () => {
+test.concurrent("Variant #1: Dynamic.src.js on High Preset", async () => {
   // `input` is an embedded variable, therefore globalConcealing must be turned off
   var output = await JsConfuser(SOURCE_JS, {
     target: "browser",
@@ -22,19 +23,20 @@ it("works on High Preset", async () => {
   expect(value).toStrictEqual(1738.1738);
 });
 
-it("work when doubly obfuscated with High Preset", async () => {
-  // `input` is an embedded variable, therefore globalConcealing must be turned off
-  var output = await JsConfuser(SOURCE_JS, {
+test.concurrent("Variant #2: Dynamic.src.js on 2x High Preset", async () => {
+  var options: ObfuscateOptions = {
     target: "node",
     preset: "high",
     globalConcealing: false,
-  });
+  };
 
-  var doublyObfuscated = await JsConfuser(output, {
-    target: "node",
-    preset: "high",
-    globalConcealing: false,
-  });
+  var output = await JsConfuser(SOURCE_JS, options);
+
+  // writeFileSync("./dev.error.1.js", output, "utf-8");
+
+  var doublyObfuscated = await JsConfuser(output, options);
+
+  // writeFileSync("./dev.error.2.js", doublyObfuscated, "utf-8");
 
   var value = "never_called";
   function input(x) {

package/test/code/ES6.src.js

@@ -1,3 +1,5 @@
+"use strict";
+
 // Variant #1 Using `let`
 let myVariable = 1;
 
@@ -87,3 +89,147 @@ for (
 var TEST_OUTPUT = myFunction();
 
 expect(TEST_OUTPUT).toStrictEqual(12);
+
+function noLexicalVariables() {
+  // Variant #13 For-in statement
+  var object = { 100: true, "-87": true, 1000: false };
+  var sumOfKeys = 0;
+  for (var propertyName in object) {
+    if (object[propertyName] === true) {
+      sumOfKeys += parseInt(propertyName);
+    }
+  }
+
+  expect(sumOfKeys).toStrictEqual(13);
+
+  // Variant #14 For-of statement
+  var values = [10, 20, 30, 40, -86];
+  var sumOfValues = 0;
+  for (var value of values) {
+    sumOfValues += value;
+  }
+
+  expect(sumOfValues).toStrictEqual(14);
+}
+
+noLexicalVariables();
+
+function useStrictFunction() {
+  "use strict";
+
+  function testThis() {
+    // Ensure 'this' behaves like strict mode
+    function fun() {
+      return this;
+    }
+
+    expect(fun() === undefined).toStrictEqual(true);
+    expect(fun.call(2) === 2).toStrictEqual(true);
+    expect(fun.apply(null) === null).toStrictEqual(true);
+    expect(fun.call(undefined) === undefined).toStrictEqual(true);
+    expect(fun.bind(true)() === true).toStrictEqual(true);
+  }
+
+  testThis();
+
+  function testArguments() {
+    // Ensure arguments behaves like strict-mode
+    expect(() => useStrictFunction.arguments).toThrow();
+    expect(() => useStrictFunction.caller).toThrow();
+    expect(() => arguments.callee).toThrow();
+  }
+
+  testArguments();
+
+  function testEval() {
+    var __NO_JS_CONFUSER_RENAME__myOuterVariable = "Initial Value";
+
+    // Eval will not leak names
+    eval("var __NO_JS_CONFUSER_RENAME__myOuterVariable = 'Incorrect Value';");
+
+    expect(__NO_JS_CONFUSER_RENAME__myOuterVariable).toStrictEqual(
+      "Initial Value"
+    );
+  }
+
+  testEval();
+}
+
+useStrictFunction();
+
+function labeledBreaksAndContinues() {
+  var flag = true;
+
+  label_1: for (var i = 0; i < 20; i++) {
+    b: switch (i) {
+      case 15:
+        c: do {
+          if (i !== 15) {
+            break c;
+          }
+          flag = true;
+
+          break label_1;
+
+          var fillerVar1;
+          var fillerVar2;
+          var fillerVar3;
+        } while (i == 15);
+
+        break;
+
+      case 10:
+        continue label_1;
+
+      default:
+        flag = false;
+        break b;
+    }
+
+    var fillerVar1;
+    var fillerVar2;
+    var fillerVar3;
+  }
+
+  var fillerVar1;
+  var fillerVar2;
+  var fillerVar3;
+
+  if (flag) {
+    return i;
+  }
+}
+
+var variant15 = labeledBreaksAndContinues();
+expect(variant15).toStrictEqual(15);
+
+// Variant #16: Function.length property
+var variant16 = function (
+  n1,
+  n2,
+  n3,
+  n4,
+  n5,
+  n6,
+  n7,
+  n8,
+  n9,
+  n10,
+  n11,
+  n12,
+  n13,
+  n14,
+  n15,
+  n16
+) {
+  var _ = true;
+};
+
+expect(variant16.length).toStrictEqual(16);
+
+// Set 'ranAllTest' to TRUE
+ranAllTest = true;
+
+function countermeasures() {
+  throw new Error("Countermeasures function called.");
+}

package/test/code/ES6.test.ts

@@ -4,13 +4,39 @@ import JsConfuser from "../../src/index";
 
 var ES6_JS = readFileSync(join(__dirname, "./ES6.src.js"), "utf-8");
 
-it("works with ES6 code on High Preset", async () => {
+test.concurrent("Variant #1: ES6 code on High Preset", async () => {
   var output = await JsConfuser(ES6_JS, {
     target: "node",
     preset: "high",
   });
 
-  (global as any).expect = expect;
+  // Ensure 'use strict' directive is preserved
+  expect(output.startsWith("'use strict'")).toStrictEqual(true);
 
+  var ranAllTest = false;
   eval(output);
+
+  // 'ranAllTest' is set to TRUE by the evaluated code
+  expect(ranAllTest).toStrictEqual(true);
 });
+
+test.concurrent(
+  "Variant #2: ES6 code on High Preset + RGF + Self Defending",
+  async () => {
+    var output = await JsConfuser(ES6_JS, {
+      target: "node",
+      preset: "high",
+      rgf: true,
+      lock: {
+        selfDefending: true,
+        countermeasures: "countermeasures",
+      },
+    });
+
+    var ranAllTest = false;
+    eval(output);
+
+    // 'ranAllTest' is set to TRUE by the evaluated code
+    expect(ranAllTest).toStrictEqual(true);
+  }
+);

package/test/index.test.ts

@@ -227,7 +227,8 @@ describe("debugObfuscation", () => {
     var output = await debugObfuscation(
       `console.log(1)`,
       { target: "node", preset: "low" },
-      callback
+      callback,
+      require("perf_hooks").performance
     );
 
     expect(typeof output).toStrictEqual("object");

package/test/probability.test.ts

@@ -0,0 +1,44 @@
+import { isProbabilityMapProbable } from "../src/probability";
+
+describe("isProbabilityMapProbable", function () {
+  test("Variant #1: True examples", function () {
+    expect(isProbabilityMapProbable(true)).toStrictEqual(true);
+    expect(isProbabilityMapProbable(1)).toStrictEqual(true);
+    expect(isProbabilityMapProbable(0.1)).toStrictEqual(true);
+
+    expect(
+      isProbabilityMapProbable({
+        mode: 1,
+      })
+    ).toStrictEqual(true);
+
+    expect(isProbabilityMapProbable(["mode"])).toStrictEqual(true);
+
+    // Function are always true
+    expect(isProbabilityMapProbable(() => true)).toStrictEqual(true);
+    expect(isProbabilityMapProbable(() => false)).toStrictEqual(true);
+  });
+
+  test("Variant #2: False examples", function () {
+    expect(isProbabilityMapProbable(false)).toStrictEqual(false);
+    expect(isProbabilityMapProbable(0)).toStrictEqual(false);
+    expect(isProbabilityMapProbable(undefined)).toStrictEqual(false);
+    expect(isProbabilityMapProbable(null)).toStrictEqual(false);
+
+    expect(isProbabilityMapProbable([false])).toStrictEqual(false);
+  });
+
+  test("Variant #3: Invalid examples", function () {
+    // Invalid percentage
+    expect(() => isProbabilityMapProbable(1.1)).toThrow();
+    expect(() => isProbabilityMapProbable(50)).toThrow();
+    expect(() => isProbabilityMapProbable(-0.1)).toThrow();
+    expect(() => isProbabilityMapProbable(NaN)).toThrow();
+
+    // Empty object
+    expect(() => isProbabilityMapProbable({})).toThrow();
+
+    // Empty array
+    expect(() => isProbabilityMapProbable([])).toThrow();
+  });
+});

package/test/templates/template.test.ts

@@ -3,7 +3,7 @@ import Template from "../../src/templates/template";
 describe("Template", () => {
   test("Variant #1: Error when invalid code passed in", () => {
     var _consoleError = console.error;
-    console.error = null;
+    console.error = () => {};
 
     expect(() => {
       Template(`#&!#Ylet{}class)--1]?|:!@#`).compile();

package/test/transforms/antiTooling.test.ts

@@ -28,3 +28,25 @@ test("Variant #1: Don't break Symbols", async () => {
     }
   }
 });
+
+test("Variant #2: Join expressions into sequence expressions", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT = 0;
+  TEST_OUTPUT++;
+  TEST_OUTPUT++;
+  TEST_OUTPUT++;
+  if(TEST_OUTPUT > 0) {
+    TEST_OUTPUT *= 2;
+  }
+  `,
+    { target: "node", renameVariables: true }
+  );
+
+  expect(output).toContain("(TEST_OUTPUT=0,TEST_OUTPUT++");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(6);
+});

package/test/transforms/calculator.test.ts

@@ -36,3 +36,43 @@ it("should execute property with complex operations", async () => {
 
   expect(value).toStrictEqual(5618);
 });
+
+it("should apply to unary operators", async () => {
+  var code = `
+  var one = +1;
+  var negativeOne = -one;
+
+  var trueValue = true;
+  var falseValue = !trueValue;
+
+  TEST_OUTPUT = typeof (1, falseValue) === "boolean" && negativeOne === ~~-1 && void 0 === undefined;
+  `;
+
+  var output = await JsConfuser(code, { target: "node", calculator: true });
+
+  expect(output).toContain("_calc");
+  expect(output).not.toContain("+1");
+  expect(output).not.toContain("-one");
+  expect(output).not.toContain("typeof(1,falseValue)");
+  expect(output).not.toContain("void 0");
+
+  var TEST_OUTPUT = true;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});
+
+it("should not break typeof expressions", async () => {
+  var code = `
+    TEST_OUTPUT = typeof nonExistentVariable === "undefined";
+    `;
+
+  var output = await JsConfuser(code, { target: "node", calculator: true });
+
+  expect(output).not.toContain("_calc");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});