js-confuser 1.7.2 → 2.0.0-alpha.0

package/test/code/Cash.test.ts

@@ -1,49 +0,0 @@
-import { readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import JsConfuser from "../../src/index";
-
-var CASH_JS = readFileSync(join(__dirname, "./Cash.src.js"), "utf-8");
-
-test("Variant #1: Cash.js on High Preset (Strict Mode)", async () => {
-  var output = await JsConfuser(CASH_JS, {
-    target: "browser",
-    preset: "high",
-  });
-
-  // Make the required document variables for initialization
-  var document = {
-    documentElement: {},
-    createElement: () => {
-      return { style: {} };
-    },
-  } as any as Document;
-  var window = {
-    document,
-    Array,
-    Object,
-    Symbol,
-    Number,
-    parseInt,
-    JSON,
-    setTimeout,
-    encodeURIComponent,
-    RegExp,
-    String,
-    $: false,
-  } as any;
-  window.window = window;
-  global.window = window;
-
-  try {
-    eval(output);
-  } catch (e) {
-    console.error(e);
-    writeFileSync("dev.output.js", output, {
-      encoding: "utf-8",
-    });
-
-    expect(true).toStrictEqual(false);
-  }
-
-  expect(window).toHaveProperty("cash");
-});

package/test/code/Dynamic.src.js

@@ -1,118 +0,0 @@
-function MyFunction() {
-  var fillerVar1;
-  var fillerVar2;
-  var fillerVar3;
-  var fillerVar4;
-  var fillerVar5;
-
-  // Filler keys for testing for syntax errors
-  class TEST_CLASS {
-    // Tests Stack
-    10() {
-      return 10;
-    }
-    9() {
-      return 9;
-    }
-    8() {
-      return 8;
-    }
-    7() {
-      return 7;
-    }
-    6() {
-      return 6;
-    }
-    5() {
-      return 5;
-    }
-    4() {
-      return 4;
-    }
-    3() {
-      return 3;
-    }
-    2() {
-      return 2;
-    }
-    1() {
-      return 2;
-    }
-
-    // Tests String Concealing
-    MyMethod1() {
-      return 1;
-    }
-    MyMethod2() {
-      return 2;
-    }
-    MyMethod3() {
-      return 3;
-    }
-    MyMethod4() {
-      return 4;
-    }
-    MyMethod5() {
-      return 5;
-    }
-    MyMethod6() {
-      return 6;
-    }
-    MyMethod7() {
-      return 7;
-    }
-    MyMethod8() {
-      return 8;
-    }
-    MyMethod9() {
-      return 9;
-    }
-    MyMethod10() {
-      return 10;
-    }
-  }
-
-  var a = (function (cbRunner, obj) {
-    var num1;
-    var num2 = get30();
-    var num3 = 8;
-
-    num1 = obj["1700"];
-
-    var _num4 = 1000;
-    var _num5 = 1001;
-    var _num6 = 1002;
-
-    var decimal = 0.1738;
-
-    cbRunner(() => {
-      return num1 + num2 + num3 + decimal;
-    });
-    var _num7 = 1003;
-
-    function get30() {
-      return 30;
-    }
-  })(
-    function (cb) {
-      input(cb());
-    },
-    {
-      1700: 1700,
-
-      // Filler keys for testing for syntax errors
-      10: 10,
-      9: 9,
-      8: 8,
-      7: 7,
-      6: 6,
-      5: 5,
-      4: 4,
-      3: 3,
-      2: 2,
-      1: 1,
-    }
-  );
-}
-
-MyFunction();

package/test/code/Dynamic.test.ts

@@ -1,49 +0,0 @@
-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");
-
-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",
-    preset: "high",
-    globalConcealing: false,
-  });
-
-  var value = "never_called";
-  function input(x) {
-    value = x;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(1738.1738);
-});
-
-test.concurrent("Variant #2: Dynamic.src.js on 2x High Preset", async () => {
-  var options: ObfuscateOptions = {
-    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) {
-    value = x;
-  }
-
-  eval(doublyObfuscated);
-
-  expect(value).toStrictEqual(1738.1738);
-});

package/test/code/ES6.src.js

@@ -1,235 +0,0 @@
-"use strict";
-
-// Variant #1 Using `let`
-let myVariable = 1;
-
-expect(myVariable).toStrictEqual(1);
-
-// Variant #2 Destructing variable from object (ObjectPattern)
-let { key } = { key: 2 };
-
-expect(key).toStrictEqual(2);
-
-// Variant #3 Destructing variable and using differing output name (ObjectPattern)
-let { key: customName } = { key: 3 };
-
-expect(customName).toStrictEqual(3);
-
-// Variant #4 Destructing variable from array (ArrayPattern)
-let [element] = [4];
-
-expect(element).toStrictEqual(4);
-
-// Variant #5 Destructing computed property from nested pattern
-let [{ ["key"]: deeplyNestedKey }] = [{ key: 5 }];
-
-expect(deeplyNestedKey).toStrictEqual(5);
-
-// Variant #6 Make sure arrow functions work
-const arrowFn = () => 6;
-
-expect(arrowFn()).toStrictEqual(6);
-
-// Variant #7 Make sure inline methods on object work
-let es6Object = {
-  method() {
-    return 7;
-  },
-};
-
-expect(es6Object.method()).toStrictEqual(7);
-
-// Variant #8 Make sure getters on object work
-es6Object = {
-  get getter() {
-    return 8;
-  },
-};
-
-expect(es6Object.getter).toStrictEqual(8);
-
-// Variant #9 Make sure getters with computed properties work
-let customKey = "myGetter";
-es6Object = {
-  get [customKey]() {
-    return 9;
-  },
-};
-
-expect(es6Object.myGetter).toStrictEqual(9);
-
-// Variant #10 Make sure constructor method works
-var value;
-class MyClass {
-  constructor(x) {
-    value = x;
-  }
-}
-
-var myInstance = new MyClass(10);
-expect(value).toStrictEqual(10);
-
-// Variant #11 Make sure for-loop initializers work
-var sum = 0;
-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);
-
-// 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

@@ -1,42 +0,0 @@
-import { readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import JsConfuser from "../../src/index";
-
-var ES6_JS = readFileSync(join(__dirname, "./ES6.src.js"), "utf-8");
-
-test.concurrent("Variant #1: ES6 code on High Preset", async () => {
-  var output = await JsConfuser(ES6_JS, {
-    target: "node",
-    preset: "high",
-  });
-
-  // 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

@@ -1,19 +0,0 @@
-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/code/StrictMode.src.js

@@ -1,65 +0,0 @@
-"use strict";
-
-function TestStrictMode() {
-  "use strict";
-
-  var isStrictMode = () => {
-    try {
-      undefined = true;
-    } catch (E) {
-      return true;
-    }
-    return false;
-  };
-
-  // filler code to make transformations more likely to affect this function
-  var x, y, z;
-  var string1 = "Hello World";
-  var string2 = "use strict";
-
-  var chars = string2.split("");
-  var count = 0;
-  for (var char of chars) {
-    count++;
-  }
-
-  expect(count).toStrictEqual(10);
-
-  // This function should be in strict mode
-  expect(isStrictMode()).toStrictEqual(true);
-}
-
-var isStrictMode = () => {
-  try {
-    undefined = true;
-  } catch (E) {
-    return true;
-  }
-  return false;
-};
-
-// Global level should be in strict mode
-expect(isStrictMode()).toStrictEqual(true);
-TestStrictMode();
-
-// Direct vs. Indirect eval usage
-var evalString = `
-var isStrictMode = () => {
-  try {
-    undefined = true;
-  } catch (E) {
-    return true;
-  }
-  return false;
-};
-
-isStrictMode();`;
-
-// Direct eval -> Preserve global strict-mode
-var directEvalResult = eval(evalString);
-expect(directEvalResult).toStrictEqual(true);
-
-// Indirect eval -> Does not inherit context strict-mode
-var _eval_ = eval;
-var indirectEvalResult = _eval_(evalString);
-expect(indirectEvalResult).toStrictEqual(false);

package/test/code/StrictMode.test.js

@@ -1,37 +0,0 @@
-import { readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import JsConfuser from "../../src/index";
-
-var StrictMode_JS = readFileSync(
-  join(__dirname, "./StrictMode.src.js"),
-  "utf-8"
-);
-
-test("Variant #1: StrictMode on High Preset", async () => {
-  var output = await JsConfuser(StrictMode_JS, {
-    target: "node",
-    preset: "high",
-  });
-
-  //writeFileSync("./dev.output.js", output);
-
-  eval(output);
-});
-
-test("Variant #2: StrictMode on 2x High Preset", async () => {
-  var output = await JsConfuser(StrictMode_JS, {
-    target: "node",
-    preset: "high",
-  });
-
-  //writeFileSync("./dev.output1.js", output);
-
-  var output2 = await JsConfuser(output, {
-    target: "node",
-    preset: "high",
-  });
-
-  //writeFileSync("./dev.output2.js", output2);
-
-  eval(output2);
-});

package/test/compare.test.ts

@@ -1,104 +0,0 @@
-import Template from "../src/templates/template";
-import { isIndependent } from "../src/util/compare";
-import {
-  ArrayExpression,
-  FunctionExpression,
-  Identifier,
-  Literal,
-} from "../src/util/gen";
-
-describe("isIndependent", () => {
-  it("should return true for literals", () => {
-    expect(isIndependent(Literal("String"), [])).toStrictEqual(true);
-  });
-
-  it("should return false for identifiers", () => {
-    expect(
-      isIndependent(Identifier("variable"), [{ type: "Program" }])
-    ).toStrictEqual(false);
-  });
-
-  it("should return true for reserved identifiers (undefined, NaN, etc)", () => {
-    expect(
-      isIndependent(Identifier("undefined"), [{ type: "Program" }])
-    ).toStrictEqual(true);
-  });
-
-  it("should return true for arrays of literals", () => {
-    expect(
-      isIndependent(ArrayExpression([Literal("String")]), [])
-    ).toStrictEqual(true);
-  });
-
-  it("should return false for arrays with identifiers", () => {
-    expect(
-      isIndependent(
-        ArrayExpression([Literal("String"), Identifier("variable")]),
-        []
-      )
-    ).toStrictEqual(false);
-  });
-
-  it("should return false for everything else", () => {
-    expect(isIndependent(FunctionExpression([], []), [])).toStrictEqual(false);
-  });
-
-  it("various cases", () => {
-    expect(
-      isIndependent(
-        Template(`({
-      x: 1,
-      y: 2,
-      z: 3,
-    })`).single().expression,
-        []
-      )
-    ).toStrictEqual(true);
-
-    expect(
-      isIndependent(
-        Template(`({
-      x: 1,
-      y: 2,
-      z: [3,4,5,6,7,"My String",undefined,null,NaN],
-    })`).single().expression,
-        []
-      )
-    ).toStrictEqual(true);
-
-    expect(
-      isIndependent(
-        Template(`({
-      x: 1,
-      y: 2,
-      z: 3,
-      _: function(){return value}
-    })`).single().expression,
-        []
-      )
-    ).toStrictEqual(false);
-
-    expect(
-      isIndependent(
-        Template(`({
-      x: 1,
-      y: 2,
-      z: 3,
-      _: [value]
-    })`).single().expression,
-        []
-      )
-    ).toStrictEqual(false);
-
-    expect(
-      isIndependent(
-        Template(`([
-          {
-            x: value
-          }
-        ])`).single().expression,
-        []
-      )
-    ).toStrictEqual(false);
-  });
-});