js-confuser 1.5.9 → 1.7.0

package/test/transforms/stack.test.ts

@@ -1,6 +1,6 @@
 import JsConfuser from "../../src/index";
 
-it("should replace all variables with array indexes (single variable)", async () => {
+test("Variant #1: Replace all variables with array indexes (single variable)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -26,7 +26,7 @@ it("should replace all variables with array indexes (single variable)", async ()
   expect(value).toStrictEqual(1);
 });
 
-it("should replace all variables with array indexes (multiple variables)", async () => {
+test("Variant #2: Replace all variables with array indexes (multiple variables)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -53,7 +53,7 @@ it("should replace all variables with array indexes (multiple variables)", async
   expect(value).toStrictEqual(15);
 });
 
-it("should replace all variables with array indexes (uninitialized variable are made undefined)", async () => {
+test("Variant #3: Replace all variables with array indexes (uninitialized variable are made undefined)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -79,7 +79,7 @@ it("should replace all variables with array indexes (uninitialized variable are
   expect(value).toStrictEqual(undefined);
 });
 
-it("should replace all variables with array indexes (parameters)", async () => {
+test("Variant #4: Replace all variables with array indexes (parameters)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(TEST_VARIABLE_1, TEST_VARIABLE_2){
@@ -105,7 +105,7 @@ it("should replace all variables with array indexes (parameters)", async () => {
   expect(value).toStrictEqual(75);
 });
 
-it("should replace all variables with array indexes (nested function)", async () => {
+test("Variant #5: Replace all variables with array indexes (nested function)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -135,7 +135,7 @@ it("should replace all variables with array indexes (nested function)", async ()
   expect(value).toStrictEqual(65);
 });
 
-it("should replace all variables with array indexes (nested class)", async () => {
+test("Variant #6: Replace all variables with array indexes (nested class)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -173,7 +173,7 @@ it("should replace all variables with array indexes (nested class)", async () =>
   expect(value).toStrictEqual("Value");
 });
 
-it("should only replace variables defined within the function, and not run if any changes can be made", async () => {
+test("Variant #7: Replace variables defined within the function, and not run if any changes can be made", async () => {
   var output = await JsConfuser(
     `
       var TEST_VARIABLE = 0;
@@ -192,11 +192,11 @@ it("should only replace variables defined within the function, and not run if an
   expect(output).not.toContain("...");
 });
 
-it("should work even when differing amount of arguments passed in", async () => {
+test("Variant #8: Work even when differing amount of arguments passed in", async () => {
   var output = await JsConfuser(
     `
-      function add3(x, y, z){
-        return x + y;
+      function add3(var_x, var_y, var_z){
+        return var_x + var_y;
       }
       
       input(add3(10, 15), add3(10, 15, 30))
@@ -207,7 +207,7 @@ it("should work even when differing amount of arguments passed in", async () =>
     }
   );
 
-  expect(output).not.toContain("x");
+  expect(output).not.toContain("var_x");
 
   var value = "never_called",
     input = (x) => (value = x);
@@ -216,7 +216,7 @@ it("should work even when differing amount of arguments passed in", async () =>
   expect(value).toStrictEqual(25);
 });
 
-it("should replace all variables with array indexes (middle indexes use array[index] syntax)", async () => {
+test("Variant #9: Replace all variables with array indexes (middle indexes use array[index] syntax)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -249,7 +249,7 @@ it("should replace all variables with array indexes (middle indexes use array[in
   expect(value).toStrictEqual("Updated");
 });
 
-it("should guess execution order correctly (CallExpression, arguments run before callee)", async () => {
+test("Variant #10: Guess execution order correctly (CallExpression, arguments run before callee)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(a,b){
@@ -277,14 +277,14 @@ it("should guess execution order correctly (CallExpression, arguments run before
   expect(value).toStrictEqual(25);
 });
 
-it("should guess execution order correctly (AssignmentExpression, right side executes first)", async () => {
+test("Variant #11: Guess execution order correctly (AssignmentExpression, right side executes first)", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(a,b){
         
-        var C;
-        C = a + b;
-        input(C)
+        var _C;
+        _C = a + b;
+        input(_C)
         
       }
       
@@ -296,7 +296,7 @@ it("should guess execution order correctly (AssignmentExpression, right side exe
     }
   );
 
-  expect(output).not.toContain("C=");
+  expect(output).not.toContain("_C=");
 
   var value = "never_called",
     input = (x) => (value = x);
@@ -305,7 +305,7 @@ it("should guess execution order correctly (AssignmentExpression, right side exe
   expect(value).toStrictEqual(25);
 });
 
-it("should not entangle floats or NaN", async () => {
+test("Variant #12: Should not entangle floats or NaN", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -335,7 +335,7 @@ it("should not entangle floats or NaN", async () => {
   expect(value).toStrictEqual(25.02);
 });
 
-it("should correctly entangle property keys", async () => {
+test("Variant #13: Correctly entangle property keys", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -382,7 +382,7 @@ it("should correctly entangle property keys", async () => {
   expect(value).toStrictEqual(10);
 });
 
-it("should correctly entangle method definition keys", async () => {
+test("Variant #14: Correctly entangle method definition keys", async () => {
   var output = await JsConfuser(
     `
       function TEST_FUNCTION(){
@@ -449,3 +449,125 @@ it("should correctly entangle method definition keys", async () => {
   eval(output);
   expect(value).toStrictEqual(10);
 });
+
+test("Variant #15: Function with 'use strict' directive", async () => {
+  var output = await JsConfuser(
+    `
+  function useStrictFunction(){
+    'use strict';
+
+    function fun(){
+      return this;
+    }
+
+    var necessaryDeclarationForStackToApply;
+
+    TEST_OUTPUT = fun() === undefined; // true
+  }
+
+  useStrictFunction();
+  `,
+    { target: "node", stack: true }
+  );
+
+  // Stack will not apply to functions with 'use strict' directive
+  expect(output).not.toContain("_stack");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});
+
+test("Variant #16: Function with 'this'", async () => {
+  var output = await JsConfuser(
+    `
+  'use strict';
+  function stackFunction(){
+    var necessaryDeclarationForStackToApply;
+
+    function thisFunctionDeclaration(){
+      return this;
+    }
+
+    var thisFunctionExpression1 = function(){
+      return this;
+    }
+
+    var thisFunctionExpression2;
+
+    thisFunctionExpression2 = function(){
+      return this;
+    }
+
+    return thisFunctionDeclaration() || thisFunctionExpression1() || thisFunctionExpression2();
+  }
+
+  TEST_OUTPUT = stackFunction() === undefined;
+  `,
+    { target: "node", stack: true }
+  );
+
+  // Ensure stack applied
+  expect(output).toContain("_stack");
+
+  // Ensure 'thisFunction' was not changed by stack due to using 'this' keyword
+  expect(output).toContain("function thisFunction");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});
+
+// https://github.com/MichaelXF/js-confuser/issues/88
+test("Variant #17: Syncing arguments parameter", async () => {
+  var output = await JsConfuser(
+    `
+    var TEST_OUTPUT;
+
+    function syncingArguments(parameter) {
+      arguments[0] = "Correct Value";
+      TEST_OUTPUT = parameter;
+    }
+    
+    syncingArguments("Incorrect Value");
+  `,
+    { target: "node", stack: true }
+  );
+
+  function evalNoStrictMode(evalCode) {
+    var fn = new Function(evalCode + ";return TEST_OUTPUT");
+    return fn();
+  }
+
+  var TEST_OUTPUT = evalNoStrictMode(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #18: Preserve function.length property", async () => {
+  var output = await JsConfuser(
+    `
+    function oneParameter(a){
+      var _ = 1;
+    };
+    var twoParameters = function(a,b){
+      var _ = 1;
+    };
+    var myObject = {
+      threeParameters(a,b,c){
+        var _ = 1;
+      }
+    }
+
+    TEST_OUTPUT = oneParameter.length + twoParameters.length + myObject.threeParameters.length;
+  `,
+    { target: "node", stack: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(6);
+});

package/test/transforms/string/stringCompression.test.ts

@@ -79,3 +79,42 @@ it("should not encode constructor key", async () => {
 
   expect(TEST_VAR).toStrictEqual(100);
 });
+
+it("should be configurable by custom function option", async () => {
+  var code = `
+  TEST_OUTPUT_1 = "My String 1";
+  TEST_OUTPUT_2 = "My String 2";
+  TEST_OUTPUT_3 = "My String 3";
+  `;
+
+  var stringsFound = [];
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    stringCompression: (strValue) => {
+      stringsFound.push(strValue);
+
+      // Change all strings but "My String 2"
+      return strValue !== "My String 2";
+    },
+  });
+
+  // Ensure all strings were found
+  expect(stringsFound).toContain("My String 1");
+  expect(stringsFound).toContain("My String 2");
+  expect(stringsFound).toContain("My String 3");
+
+  // Ensure the strings got changed (except for "My String 2")
+  expect(output).not.toContain("TEST_OUTPUT_1='My String 1'");
+  expect(output).toContain("TEST_OUTPUT_2='My String 2'");
+  expect(output).not.toContain("TEST_OUTPUT_3='My String 3'");
+
+  // Make sure the code still works!
+  var TEST_OUTPUT_1, TEST_OUTPUT_2, TEST_OUTPUT_3;
+
+  eval(output);
+
+  expect(TEST_OUTPUT_1).toStrictEqual("My String 1");
+  expect(TEST_OUTPUT_2).toStrictEqual("My String 2");
+  expect(TEST_OUTPUT_3).toStrictEqual("My String 3");
+});

package/test/transforms/string/stringConcealing.test.ts

@@ -215,3 +215,85 @@ it("should work inside the Class Constructor function", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual(true);
 });
+
+it("should be configurable by custom function option", async () => {
+  var code = `
+  var myVar1 = "My First String";
+  var myVar2 = "My Second String";
+  var myVar3 = "My Third String";
+
+  TEST_RESULT = [myVar1, myVar2, myVar3];
+  `;
+
+  var strings = [];
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    stringConcealing: (str) => {
+      strings.push(str);
+
+      return str !== "My Second String";
+    },
+  });
+
+  // Ensure stringConcealing found all the strings
+  expect(strings).toContain("My First String");
+  expect(strings).toContain("My Second String");
+  expect(strings).toContain("My Third String");
+
+  // These strings should be encoded
+  expect(output).not.toContain("My First String");
+  expect(output).not.toContain("My Third String");
+
+  // This string should NOT be encoded
+  expect(output).toContain("My Second String");
+
+  // Ensure strings get properly decoded
+  var TEST_RESULT;
+
+  eval(output);
+  expect(TEST_RESULT).toStrictEqual([
+    "My First String",
+    "My Second String",
+    "My Third String",
+  ]);
+});
+
+test("Variant #13: Work without TextEncoder or Buffer being defined", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT = [];
+  TEST_OUTPUT.push("My First String");
+  TEST_OUTPUT.push("My Second String");
+  TEST_OUTPUT.push("My Third String");
+  TEST_OUTPUT.push("My Fourth String");
+  TEST_OUTPUT.push("My Fifth String");
+  `,
+    { target: "node", stringConcealing: true }
+  );
+
+  // Ensure the strings got changed
+  expect(output).not.toContain("My First String");
+  expect(output).not.toContain("My Second String");
+  expect(output).not.toContain("My Third String");
+  expect(output).not.toContain("My Fourth String");
+  expect(output).not.toContain("My Fifth String");
+
+  // Disable TextEncoder and Buffer
+  var global = {};
+  var window = {};
+  var Buffer = undefined;
+  var TextEncoder = undefined;
+
+  // Test the code
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual([
+    "My First String",
+    "My Second String",
+    "My Third String",
+    "My Fourth String",
+    "My Fifth String",
+  ]);
+});

package/test/transforms/string/stringEncoding.test.ts

@@ -1,6 +1,6 @@
 import JsConfuser from "../../../src/index";
 
-it("should encode strings", async () => {
+test("Variant #1: Encode strings", async () => {
   var code = `var TEST_STRING = "encoded."`;
 
   var output = await JsConfuser(code, {
@@ -17,7 +17,7 @@ it("should encode strings", async () => {
   ).toStrictEqual(true);
 });
 
-it("should encode strings but still have same result", async () => {
+test("Variant #2: Encode strings AND still have same result", async () => {
   var code = `input("encoded.")`;
 
   var output = await JsConfuser(code, {
@@ -42,3 +42,54 @@ it("should encode strings but still have same result", async () => {
 
   expect(value).toStrictEqual("encoded.");
 });
+
+test("Variant #3: Encode object property keys", async () => {
+  var code = `TEST_OUTPUT = { myProperty1: true, "myProperty2": true }`;
+
+  var output = await JsConfuser(code, { target: "node", stringEncoding: true });
+
+  // Ensure the strings got changed
+  expect(output).not.toContain("myProperty1");
+  expect(output).not.toContain("myProperty2");
+
+  // Ensure output is exactly the same
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual({ myProperty1: true, myProperty2: true });
+});
+
+test("Variant #4: Encode object destructuring property keys", async () => {
+  var code = `({ ["myDestructedKey"]: TEST_OUTPUT } = { myDestructedKey: true })`;
+
+  var output = await JsConfuser(code, { target: "node", stringEncoding: true });
+
+  // Ensure the string(s) got changed
+  expect(output).not.toContain("myDestructedKey");
+
+  // Ensure output is exactly the same
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});
+
+// This test multiple transformations
+test("Variant #5: Preserve 'use strict' directive", async () => {
+  var code = `
+  "use strict";
+
+  var filler1;
+  var filler2;
+  var filler3;
+
+  var anotherVar = "use strict";
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    preset: "high",
+  });
+
+  expect(output.startsWith("'use strict'")).toStrictEqual(true);
+});

package/test/transforms/transform.test.ts

@@ -0,0 +1,66 @@
+import Obfuscator from "../../src/obfuscator";
+import Transform from "../../src/transforms/transform";
+
+describe("Transform class", () => {
+  class MyTransformClass extends Transform {
+    constructor(o) {
+      super(o);
+    }
+  }
+
+  const myObfuscator = new Obfuscator({
+    target: "node",
+    identifierGenerator: "mangled",
+  });
+  const myTransform = new MyTransformClass(myObfuscator);
+
+  const tree = {
+    type: "Program",
+    body: [],
+  };
+
+  test("Variant #1: Not implemented match()", () => {
+    expect(() => myTransform.match(tree, [])).toThrow();
+  });
+
+  test("Variant #2: Not implemented transform()", () => {
+    expect(() => myTransform.transform(tree, [])).toThrow();
+  });
+
+  test("Variant #3: getGenerator()", () => {
+    const generator = myTransform.getGenerator();
+
+    const generated = new Set<string>();
+
+    const count = 50;
+
+    for (var i = 0; i < count; i++) {
+      const newName = generator.generate();
+      generated.add(newName);
+    }
+
+    // This ensures all generated names are unique!
+    expect(generated.size).toStrictEqual(count);
+  });
+
+  test("Variant #4: getGenerator() with overrideMode parameter", () => {
+    // number generator
+    const generator = myTransform.getGenerator("number");
+
+    expect(generator.generate()).toStrictEqual("var_1");
+    expect(generator.generate()).toStrictEqual("var_2");
+    expect(generator.generate()).toStrictEqual("var_3");
+
+    // hexadecimal generator
+    const anotherGenerator = myTransform.getGenerator("hexadecimal");
+
+    expect(anotherGenerator.generate()).toContain("_0x");
+
+    // mangled generator
+    const yetAnotherGenerator = myTransform.getGenerator("mangled");
+
+    expect(yetAnotherGenerator.generate()).toStrictEqual("a");
+    expect(yetAnotherGenerator.generate()).toStrictEqual("b");
+    expect(yetAnotherGenerator.generate()).toStrictEqual("c");
+  });
+});

package/test/traverse.test.ts

@@ -0,0 +1,139 @@
+import traverse, { assertNoCircular } from "../src/traverse";
+import { Node } from "../src/util/gen";
+
+describe("traverse", function () {
+  test("Variant #1: Traverse tree", function () {
+    var executionOrder = [];
+
+    var tree: Node = {
+      type: "Program",
+      start: 0,
+      end: 27,
+      body: [
+        {
+          type: "ExpressionStatement",
+          start: 0,
+          end: 27,
+          expression: {
+            type: "CallExpression",
+            start: 0,
+            end: 26,
+            callee: {
+              type: "MemberExpression",
+              start: 0,
+              end: 11,
+              object: {
+                type: "Identifier",
+                start: 0,
+                end: 7,
+                name: "console",
+              },
+              property: {
+                type: "Identifier",
+                start: 8,
+                end: 11,
+                name: "log",
+              },
+              computed: false,
+              optional: false,
+            },
+            arguments: [
+              {
+                type: "Literal",
+                start: 12,
+                end: 25,
+                value: "Hello World",
+                raw: '"Hello World"',
+              },
+            ],
+            optional: false,
+          },
+        },
+      ],
+      sourceType: "module",
+    };
+
+    var literalParents;
+
+    traverse(tree, (object, parents) => {
+      if (object.type) {
+        if (object.type === "Literal") {
+          literalParents = parents;
+        }
+
+        executionOrder.push("ENTER:" + object.type);
+
+        return () => {
+          executionOrder.push("EXIT:" + object.type);
+        };
+      }
+    });
+
+    var displayString = executionOrder.join(",");
+
+    expect(displayString).toStrictEqual(
+      "ENTER:Program,ENTER:ExpressionStatement,ENTER:CallExpression,ENTER:MemberExpression,ENTER:Identifier,EXIT:Identifier,ENTER:Identifier,EXIT:Identifier,EXIT:MemberExpression,ENTER:Literal,EXIT:Literal,EXIT:CallExpression,EXIT:ExpressionStatement,EXIT:Program"
+    );
+
+    var displayLiteralParents = literalParents
+      .map((x) => (Array.isArray(x) ? "(array)" : x.type))
+      .join(",");
+    expect(displayLiteralParents).toStrictEqual(
+      "(array),CallExpression,ExpressionStatement,(array),Program"
+    );
+  });
+});
+
+describe("assertNoCircular", function () {
+  test("Variant #1: Valid tree", function () {
+    var tree = {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: {
+        a: 1,
+        b: 2,
+        c: 3,
+      },
+      e: [
+        {
+          a: 1,
+          b: 2,
+          c: 3,
+          f: {
+            a: 1,
+          },
+        },
+      ],
+    };
+
+    expect(() => assertNoCircular(tree)).not.toThrow();
+  });
+
+  test("Variant #2: Invalid tree", function () {
+    var circularRef = {};
+
+    var tree = {
+      a: 1,
+      b: 2,
+      c: circularRef,
+      d: {
+        a: 1,
+        b: 2,
+        c: 3,
+      },
+      e: [
+        {
+          a: 1,
+          b: 2,
+          c: 3,
+          f: {
+            a: circularRef,
+          },
+        },
+      ],
+    };
+
+    expect(() => assertNoCircular(tree)).toThrow();
+  });
+});