js-confuser 1.7.1 → 1.7.3

package/src/util/insert.ts

@@ -3,6 +3,12 @@ import { getBlock, isBlock } from "../traverse";
 import { Node } from "./gen";
 import { getIdentifierInfo, validateChain } from "./identifiers";
 
+export function isClass(object: Node): boolean {
+  return (
+    object.type === "ClassDeclaration" || object.type === "ClassExpression"
+  );
+}
+
 /**
  * - `FunctionDeclaration`
  * - `FunctionExpression`
@@ -18,6 +24,17 @@ export function isFunction(object: Node): boolean {
   ].includes(object && object.type);
 }
 
+export function isStrictModeFunction(object: Node): boolean {
+  ok(isFunction(object));
+
+  return (
+    object.body.type === "BlockStatement" &&
+    object.body.body[0] &&
+    object.body.body[0].type === "ExpressionStatement" &&
+    object.body.body[0].directive === "use strict"
+  );
+}
+
 /**
  * The function context where the object is.
  *

package/src/util/random.ts

@@ -63,7 +63,7 @@ export function splitIntoChunks(str: string, size: number) {
   ok(Math.floor(size) === size, "size must be integer");
 
   const numChunks = Math.ceil(str.length / size);
-  const chunks = new Array(numChunks);
+  const chunks: string[] = new Array(numChunks);
 
   for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
     chunks[i] = str.substr(o, size);
@@ -139,3 +139,83 @@ export function alphabeticalGenerator(index: number) {
   }
   return name;
 }
+
+export function createZeroWidthGenerator() {
+  var keywords = [
+    "if",
+    "in",
+    "for",
+    "let",
+    "new",
+    "try",
+    "var",
+    "case",
+    "else",
+    "null",
+    "break",
+    "catch",
+    "class",
+    "const",
+    "super",
+    "throw",
+    "while",
+    "yield",
+    "delete",
+    "export",
+    "import",
+    "public",
+    "return",
+    "switch",
+    "default",
+    "finally",
+    "private",
+    "continue",
+    "debugger",
+    "function",
+    "arguments",
+    "protected",
+    "instanceof",
+    "await",
+    "async",
+
+    // new key words and other fun stuff :P
+    "NaN",
+    "undefined",
+    "true",
+    "false",
+    "typeof",
+    "this",
+    "static",
+    "void",
+    "of",
+  ];
+
+  var maxSize = 0;
+  var currentKeyWordsArray: string[] = [];
+
+  function generateArray() {
+    var result = keywords
+      .map(
+        (keyWord) =>
+          keyWord + "\u200C".repeat(Math.max(maxSize - keyWord.length, 1))
+      )
+      .filter((craftedVariableName) => craftedVariableName.length == maxSize);
+
+    if (!result.length) {
+      ++maxSize;
+      return generateArray();
+    }
+
+    return shuffle(result);
+  }
+
+  function getNextVariable(): string {
+    if (!currentKeyWordsArray.length) {
+      ++maxSize;
+      currentKeyWordsArray = generateArray();
+    }
+    return currentKeyWordsArray.pop();
+  }
+
+  return { generate: getNextVariable };
+}

package/src/util/scope.ts

@@ -1,9 +1,21 @@
+import { ok } from "assert";
 import { isBlock } from "../traverse";
+import { Node } from "./gen";
 
-export function isLexicalScope(object) {
+export function isLexicalScope(object: Node) {
   return isBlock(object) || object.type == "SwitchCase";
 }
 
-export function getLexicalScope(object, parents) {
+export function getLexicalScope(object: Node, parents: Node[]): Node {
   return [object, ...parents].find((node) => isLexicalScope(node));
 }
+
+export function getLexicalScopeBody(object: Node): Node[] {
+  ok(isLexicalScope(object));
+
+  return isBlock(object)
+    ? object.body
+    : object.type === "SwitchCase"
+    ? object.consequent
+    : ok("Unhandled case");
+}

package/test/code/Cash.test.ts

@@ -6,7 +6,7 @@ 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",
+    target: "node",
     preset: "high",
   });
 
@@ -32,12 +32,101 @@ test("Variant #1: Cash.js on High Preset (Strict Mode)", async () => {
     $: false,
   } as any;
   window.window = window;
+  global.window = window;
+  for (var key in window) {
+    global[key] = window[key];
+  }
 
-  // writeFileSync(join(__dirname, "Cash.output.js"), output, {
-  //   encoding: "utf-8",
-  // });
+  try {
+    eval(output);
+  } catch (e) {
+    console.error(e);
+    writeFileSync("dev.output.js", output, {
+      encoding: "utf-8",
+    });
 
-  eval(output);
+    expect(true).toStrictEqual(false);
+  }
+
+  expect(window).toHaveProperty("cash");
+});
+
+test("Variant #2: Cash.js on High Preset + Integrity + Self Defending + RGF + Tamper Protection", async () => {
+  // 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;
+  for (var key in window) {
+    global[key] = window[key];
+  }
+
+  var output = await JsConfuser(CASH_JS, {
+    target: "node",
+    preset: "high",
+    rgf: true,
+    lock: {
+      integrity: true,
+      selfDefending: true,
+      tamperProtection: true,
+    },
+  });
+
+  try {
+    // new Function() runs in non-strict mode
+    new Function(output)();
+  } catch (e) {
+    var helperCode = `var document = {
+    documentElement: {},
+    createElement: () => {
+      return { style: {} };
+    },
+  };
+  var window = {
+    document,
+    Array,
+    Object,
+    Symbol,
+    Number,
+    parseInt,
+    JSON,
+    setTimeout,
+    encodeURIComponent,
+    RegExp,
+    String,
+    $: false,
+  };
+  window.window = window;
+  global.window = window;
+  for (var key in window) {
+    global[key] = window[key];
+  }`;
+
+    console.error(e);
+    writeFileSync("dev.output.js", helperCode + "\n" + output, {
+      encoding: "utf-8",
+    });
+
+    expect(true).toStrictEqual(false);
+  }
 
   expect(window).toHaveProperty("cash");
 });

package/test/code/StrictMode.src.js

@@ -0,0 +1,65 @@
+"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

@@ -0,0 +1,37 @@
+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,3 +1,4 @@
+import Template from "../src/templates/template";
 import { isIndependent } from "../src/util/compare";
 import {
   ArrayExpression,
@@ -17,9 +18,9 @@ describe("isIndependent", () => {
     ).toStrictEqual(false);
   });
 
-  it("should return true for reserved identifiers (null, undefined, etc)", () => {
+  it("should return true for reserved identifiers (undefined, NaN, etc)", () => {
     expect(
-      isIndependent(Identifier("null"), [{ type: "Program" }])
+      isIndependent(Identifier("undefined"), [{ type: "Program" }])
     ).toStrictEqual(true);
   });
 
@@ -41,4 +42,63 @@ describe("isIndependent", () => {
   it("should return false for everything else", () => {
     expect(isIndependent(FunctionExpression([], []), [])).toStrictEqual(false);
   });
+
+  it("various cases", () => {
+    expect(
+      isIndependent(
+        new Template(`({
+      x: 1,
+      y: 2,
+      z: 3,
+    })`).single().expression,
+        []
+      )
+    ).toStrictEqual(true);
+
+    expect(
+      isIndependent(
+        new Template(`({
+      x: 1,
+      y: 2,
+      z: [3,4,5,6,7,"My String",undefined,null,NaN],
+    })`).single().expression,
+        []
+      )
+    ).toStrictEqual(true);
+
+    expect(
+      isIndependent(
+        new Template(`({
+      x: 1,
+      y: 2,
+      z: 3,
+      _: function(){return value}
+    })`).single().expression,
+        []
+      )
+    ).toStrictEqual(false);
+
+    expect(
+      isIndependent(
+        new Template(`({
+      x: 1,
+      y: 2,
+      z: 3,
+      _: [value]
+    })`).single().expression,
+        []
+      )
+    ).toStrictEqual(false);
+
+    expect(
+      isIndependent(
+        new Template(`([
+          {
+            x: value
+          }
+        ])`).single().expression,
+        []
+      )
+    ).toStrictEqual(false);
+  });
 });

package/test/options.test.ts

@@ -1,76 +1,150 @@
 import JsConfuser from "../src/index";
 
-it("should accept percentages", async () => {
-  var output = await JsConfuser(`var TEST_VARIABLE;`, {
-    target: "node",
-    renameGlobals: true,
-    renameVariables: true,
-    stringConcealing: 0.5,
+describe("options", () => {
+  test("Variant #1: Accept percentages", async () => {
+    var output = await JsConfuser(`var TEST_VARIABLE;`, {
+      target: "node",
+      renameGlobals: true,
+      renameVariables: true,
+      stringConcealing: 0.5,
+    });
+
+    expect(output).not.toContain("TEST_VARIABLE");
   });
 
-  expect(output).not.toContain("TEST_VARIABLE");
-});
+  test("Variant #2: Accept probability arrays", async () => {
+    var output = await JsConfuser(`var TEST_VARIABLE;`, {
+      target: "node",
+      renameVariables: true,
+      renameGlobals: true,
+      identifierGenerator: ["hexadecimal", "mangled"], // half hexadecimal, half randomized
+    });
 
-it("should accept probability arrays", async () => {
-  var output = await JsConfuser(`var TEST_VARIABLE;`, {
-    target: "node",
-    renameVariables: true,
-    renameGlobals: true,
-    identifierGenerator: ["hexadecimal", "mangled"], // half hexadecimal, half randomized
+    expect(output).not.toContain("TEST_VARIABLE");
   });
 
-  expect(output).not.toContain("TEST_VARIABLE");
-});
+  test("Variant #3: Accept probability maps", async () => {
+    var output = await JsConfuser(`var TEST_VARIABLE;`, {
+      target: "node",
+      renameVariables: true,
+      renameGlobals: true,
+      identifierGenerator: {
+        // 25% each
+        hexadecimal: 0.25,
+        randomized: 0.25,
+        mangled: 0.25,
+        number: 0.25,
+      },
+    });
 
-it("should accept probability maps", async () => {
-  var output = await JsConfuser(`var TEST_VARIABLE;`, {
-    target: "node",
-    renameVariables: true,
-    renameGlobals: true,
-    identifierGenerator: {
-      // 25% each
-      hexadecimal: 0.25,
-      randomized: 0.25,
-      mangled: 0.25,
-      number: 0.25,
-    },
+    expect(output).not.toContain("TEST_VARIABLE");
   });
 
-  expect(output).not.toContain("TEST_VARIABLE");
-});
+  test("Variant #4: Work with compact false", async () => {
+    var output = await JsConfuser(`var TEST_VARIABLE;`, {
+      target: "node",
+      renameGlobals: true,
+      renameVariables: true,
+      compact: false,
+    });
 
-it("should work with compact false", async () => {
-  var output = await JsConfuser(`var TEST_VARIABLE;`, {
-    target: "node",
-    renameGlobals: true,
-    renameVariables: true,
-    compact: false,
+    expect(output).not.toContain("TEST_VARIABLE");
   });
 
-  expect(output).not.toContain("TEST_VARIABLE");
-});
+  test("Variant #5: Work with indent set to 2 spaces", async () => {
+    var output = await JsConfuser(`var TEST_VARIABLE;`, {
+      target: "node",
+      renameGlobals: true,
+      renameVariables: true,
+      compact: false,
+      indent: 2,
+    });
 
-it("should work with indent set to 2 spaces", async () => {
-  var output = await JsConfuser(`var TEST_VARIABLE;`, {
-    target: "node",
-    renameGlobals: true,
-    renameVariables: true,
-    compact: false,
-    indent: 2,
+    expect(output).not.toContain("TEST_VARIABLE");
   });
 
-  expect(output).not.toContain("TEST_VARIABLE");
+  test("Variant #6: Work with debugComments enabled", async () => {
+    var output = await JsConfuser(`var TEST_VARIABLE;`, {
+      target: "node",
+      renameGlobals: true,
+      renameVariables: true,
+      compact: false,
+      indent: 2,
+      debugComments: true,
+    });
+
+    expect(output).not.toContain("TEST_VARIABLE");
+  });
+
+  test("Variant #7: Error on invalid lock option", async () => {
+    expect(
+      JsConfuser(`var TEST_VARIABLE;`, {
+        target: "node",
+        lock: "invalid",
+      } as any)
+    ).rejects.toThrow();
+
+    expect(
+      JsConfuser(`var TEST_VARIABLE;`, {
+        target: "node",
+        lock: {
+          invalidProperty: true,
+        },
+      } as any)
+    ).rejects.toThrow();
+  });
 });
 
-it("should work with debugComments enabled", async () => {
-  var output = await JsConfuser(`var TEST_VARIABLE;`, {
-    target: "node",
-    renameGlobals: true,
-    renameVariables: true,
-    compact: false,
-    indent: 2,
-    debugComments: true,
+describe("options.preserveFunctionLength", () => {
+  test("Variant #1: Enabled by default", async () => {
+    var output = await JsConfuser(
+      `
+    function myFunction(a, b, c, d = "") {
+      // Function.length = 3
+    }
+
+    TEST_OUTPUT = myFunction.length; // 3
+    `,
+      {
+        target: "node",
+        preset: "high",
+      }
+    );
+
+    var TEST_OUTPUT;
+    eval(output);
+    expect(TEST_OUTPUT).toStrictEqual(3);
   });
 
-  expect(output).not.toContain("TEST_VARIABLE");
+  test("Variant #2: Disabled", async () => {
+    var output = await JsConfuser(
+      `
+    function myFunction(a, b, c, d = "") {
+      // Function.length = 3
+    }
+
+    TEST_OUTPUT = myFunction.length; // 3
+    `,
+      {
+        target: "node",
+        preset: "high",
+        preserveFunctionLength: false,
+
+        stringEncoding: false,
+        stringCompression: false,
+        stringConcealing: false,
+        stringSplitting: false,
+        deadCode: false,
+        duplicateLiteralsRemoval: false,
+
+        rgf: true,
+      }
+    );
+
+    expect(output).not.toContain("defineProperty");
+
+    var TEST_OUTPUT;
+    eval(output);
+    expect(TEST_OUTPUT).not.toStrictEqual(3);
+  });
 });