js-confuser 1.5.8 → 1.6.0

package/test/code/ES6.src.js

@@ -1,3 +1,5 @@
+"use strict";
+
 // Variant #1 Using `let`
 let myVariable = 1;
 
@@ -73,3 +75,137 @@ for (var x of [3, 3, 5]) {
   sum += x;
 }
 expect(sum).toStrictEqual(11);
+
+// Variant #12 More complex for-loop initializer
+var outside = 12;
+for (
+  var myFunction = function () {
+    return outside;
+  };
+  false;
+
+) {}
+
+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);
+
+// 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/code/NewFeatures.test.ts

@@ -0,0 +1,19 @@
+import JsConfuser from "../../src/index";
+
+// https://github.com/MichaelXF/js-confuser/issues/79
+test("Variant #1: Support BigInt Literals (1n)", async () => {
+  var code = `
+  TEST_OUTPUT = 1n;
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    renameVariables: true,
+  });
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(typeof TEST_OUTPUT).toStrictEqual("bigint");
+  expect(TEST_OUTPUT).toStrictEqual(1n);
+});

package/test/index.test.ts

@@ -227,10 +227,23 @@ describe("debugObfuscation", () => {
     var output = await debugObfuscation(
       `console.log(1)`,
       { target: "node", preset: "low" },
-      callback
+      callback,
+      require("perf_hooks").performance
     );
 
-    expect(typeof output).toStrictEqual("string");
+    expect(typeof output).toStrictEqual("object");
+    expect(typeof output.obfuscated).toStrictEqual("string");
+    expect(typeof output.obfuscationTime).toStrictEqual("number");
+    expect(typeof output.compileTime).toStrictEqual("number");
+    expect(typeof output.parseTime).toStrictEqual("number");
+    expect(typeof output.totalPossibleTransforms).toStrictEqual("number");
+    expect(typeof output.totalTransforms).toStrictEqual("number");
+    expect(typeof output.transformationTimes).toStrictEqual("object");
+    expect(typeof output.transformationTimes.RenameVariables).toStrictEqual(
+      "number"
+    );
+
+    eval(output.obfuscated);
     expect(called).toStrictEqual(true);
   });
 });

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

@@ -0,0 +1,52 @@
+import JsConfuser from "../../src/index";
+
+// https://github.com/MichaelXF/js-confuser/issues/74
+test("Variant #1: Don't break Symbols", async () => {
+  if (typeof Symbol !== "undefined") {
+    for (var i = 0; i < 6; i++) {
+      var output = await JsConfuser(
+        `
+  
+      var sym1 = Symbol();
+    
+      if (true) {
+        sym1;
+        sym1;
+        sym1;
+      }
+  
+      TEST_OUTPUT = sym1;
+    
+      `,
+        { target: "node", renameVariables: true }
+      );
+
+      var TEST_OUTPUT;
+
+      eval(output);
+      expect(typeof TEST_OUTPUT).toStrictEqual("symbol");
+    }
+  }
+});
+
+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);
+});