js-confuser 1.7.1 → 1.7.3

package/test/templates/template.test.ts

@@ -1,4 +1,7 @@
+import { compileJsSync } from "../../src/compiler";
+import { parseSnippet } from "../../src/parser";
 import Template from "../../src/templates/template";
+import { Literal } from "../../src/util/gen";
 
 describe("Template", () => {
   test("Variant #1: Error when invalid code passed in", () => {
@@ -6,9 +9,216 @@ describe("Template", () => {
     console.error = () => {};
 
     expect(() => {
-      Template(`#&!#Ylet{}class)--1]?|:!@#`).compile();
+      new Template(`#&!#Ylet{}class)--1]?|:!@#`).compile();
     }).toThrow();
 
     console.error = _consoleError;
   });
+
+  test("Variant #2: Error on missing variables", () => {
+    var _consoleError = console.error;
+    console.error = () => {};
+
+    expect(() => {
+      new Template(`
+        function {name}(){
+          {global}.property = true;
+        }
+        
+        `).compile({ name: "test" });
+    }).toThrow();
+
+    console.error = _consoleError;
+  });
+
+  test("Variant #3: Basic string interpolation", () => {
+    var Base64Template = new Template(`
+      function {name}(str){
+        return window.btoa(str)
+      }`);
+
+    var functionDeclaration = Base64Template.single({
+      name: "decodeBase64",
+    });
+
+    expect(functionDeclaration.type).toStrictEqual("FunctionDeclaration");
+    expect(functionDeclaration.id.name).toStrictEqual("decodeBase64");
+
+    // Generated code and check
+    var output = compileJsSync(functionDeclaration, {
+      target: "node",
+      compact: true,
+    });
+
+    // Ensure code has no syntax errors
+    eval(output);
+  });
+
+  test("Variant #4: AST subtree insertion", () => {
+    var Base64Template = new Template(`
+     function {name}(str){
+       {getWindow}
+      
+       return {getWindowName}.btoa(str)
+     }`);
+
+    var functionDeclaration = Base64Template.single({
+      name: "decodeBase64",
+      getWindowName: "newWindow",
+      getWindow: parseSnippet("var newWindow = {}").body,
+    });
+
+    expect(functionDeclaration.type).toStrictEqual("FunctionDeclaration");
+    expect(functionDeclaration.body.body[0].type).toStrictEqual(
+      "VariableDeclaration"
+    );
+
+    // Generated code and check
+    var output = compileJsSync(functionDeclaration, {
+      target: "node",
+      compact: true,
+    });
+
+    expect(output).toContain("var newWindow={}");
+    expect(output).toContain("return newWindow.btoa(str)");
+  });
+
+  test("Variant #5: AST subtree insertion (callback)", () => {
+    var Base64Template = new Template(`
+     function {name}(str){
+       {getWindow}
+      
+       return {getWindowName}.btoa(str)
+     }`);
+
+    var functionDeclaration = Base64Template.single({
+      name: "decodeBase64",
+      getWindowName: "newWindow",
+      getWindow: () => {
+        return parseSnippet("var newWindow = {}").body;
+      },
+    });
+
+    expect(functionDeclaration.type).toStrictEqual("FunctionDeclaration");
+    expect(functionDeclaration.body.body[0].type).toStrictEqual(
+      "VariableDeclaration"
+    );
+
+    // Generated code and check
+    var output = compileJsSync(functionDeclaration, {
+      target: "node",
+      compact: true,
+    });
+
+    expect(output).toContain("var newWindow={}");
+    expect(output).toContain("return newWindow.btoa(str)");
+  });
+
+  test("Variant #6: Template subtree insertion", async () => {
+    var NewWindowTemplate = new Template(`
+      var {NewWindowName} = {};
+    `);
+    var Base64Template = new Template(`
+    function {name}(str){
+      {NewWindowTemplate}
+
+      return {NewWindowName}.btoa(str)
+    }`);
+
+    var functionDeclaration = Base64Template.single({
+      name: "atob",
+      NewWindowTemplate: NewWindowTemplate,
+      NewWindowName: "newWindow",
+    });
+
+    expect(functionDeclaration.type).toStrictEqual("FunctionDeclaration");
+    expect(functionDeclaration.body.body[0].type).toStrictEqual(
+      "VariableDeclaration"
+    );
+
+    // Generated code and check
+    var output = compileJsSync(functionDeclaration, {
+      target: "node",
+      compact: true,
+    });
+
+    expect(output).toContain("var newWindow={}");
+    expect(output).toContain("return newWindow.btoa(str)");
+  });
+
+  test("Variant #7: Template subtree insertion (callback)", async () => {
+    var NewWindowTemplate = new Template(`
+      var {NewWindowName} = {};
+    `);
+    var Base64Template = new Template(`
+    function {name}(str){
+      {NewWindowTemplate}
+
+      return {NewWindowName}.btoa(str)
+    }`);
+
+    var functionDeclaration = Base64Template.single({
+      name: "atob",
+      NewWindowTemplate: () => NewWindowTemplate,
+      NewWindowName: "newWindow",
+    });
+
+    expect(functionDeclaration.type).toStrictEqual("FunctionDeclaration");
+    expect(functionDeclaration.body.body[0].type).toStrictEqual(
+      "VariableDeclaration"
+    );
+
+    // Generated code and check
+    var output = compileJsSync(functionDeclaration, {
+      target: "node",
+      compact: true,
+    });
+
+    expect(output).toContain("var newWindow={}");
+    expect(output).toContain("return newWindow.btoa(str)");
+  });
+
+  test("Variant #8: AST string replacement with Literal node", async () => {
+    var Base64Template = new Template(`
+      function {name}(str){
+        return window[{property}](str)
+      }`);
+
+    var functionDeclaration = Base64Template.single({
+      name: "decodeBase64",
+      property: Literal("atob"),
+    });
+
+    expect(functionDeclaration.type).toStrictEqual("FunctionDeclaration");
+
+    // Generated code and check
+    var output = compileJsSync(functionDeclaration, {
+      target: "node",
+      compact: true,
+    });
+
+    expect(output).toContain("return window['atob'](str)");
+  });
+
+  test("Variant #9: AST string replacement with Literal node (callback)", async () => {
+    var Base64Template = new Template(`
+      function {name}(str){
+        return window[{property}](str)
+      }`);
+
+    var functionDeclaration = Base64Template.single({
+      name: "decodeBase64",
+      property: () => Literal("atob"),
+    });
+
+    expect(functionDeclaration.type).toStrictEqual("FunctionDeclaration");
+
+    // Generated code and check
+    var output = compileJsSync(functionDeclaration, {
+      target: "node",
+      compact: true,
+    });
+
+    expect(output).toContain("return window['atob'](str)");
+  });
 });

package/test/transforms/controlFlowFlattening/expressionObfuscation.test.ts

@@ -1,15 +1,21 @@
+import { criticalFunctionTag } from "../../../src/constants";
 import JsConfuser from "../../../src/index";
 
+// Enable Control Flow Flattening's 'Expression Obfuscation' but skips all CFF switch transformations
+function fakeEnabled() {
+  return false;
+}
+
 test("Variant #1: Join expressions in a sequence expression", async () => {
   var output = await JsConfuser(
     `
   TEST_OUTPUT=0;
   TEST_OUTPUT++;
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("(TEST_OUTPUT=0,TEST_OUTPUT++");
+  expect(output).toContain("TEST_OUTPUT=0,TEST_OUTPUT++");
 
   var TEST_OUTPUT;
   eval(output);
@@ -25,10 +31,10 @@ test("Variant #2: If Statement", async () => {
     TEST_OUTPUT++;
   }
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("if(TEST_OUTPUT=0,true)");
+  expect(output).toContain("TEST_OUTPUT=0,true");
 
   var TEST_OUTPUT;
   eval(output);
@@ -44,10 +50,10 @@ test("Variant #3: ForStatement (Variable Declaration initializer)", async () =>
     TEST_OUTPUT++;
   }
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("for(var i=(TEST_OUTPUT=0,0)");
+  expect(output).toContain("TEST_OUTPUT=0,0");
 
   var TEST_OUTPUT;
   eval(output);
@@ -63,10 +69,10 @@ test("Variant #4: ForStatement (Assignment expression initializer)", async () =>
     TEST_OUTPUT++;
   }
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("for(i=(TEST_OUTPUT=0,0)");
+  expect(output).toContain("TEST_OUTPUT=0,0");
 
   var TEST_OUTPUT, i;
   eval(output);
@@ -83,10 +89,10 @@ test("Variant #5: Return statement", async () => {
   }
   fn();
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("return TEST_OUTPUT=10,'Value'}");
+  expect(output).toContain("TEST_OUTPUT=10,'Value'");
 
   var TEST_OUTPUT;
   eval(output);
@@ -103,10 +109,10 @@ test("Variant #6: Return statement (no argument)", async () => {
   }
   fn();
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("return TEST_OUTPUT=10,undefined}");
+  expect(output).toContain("TEST_OUTPUT=10,undefined");
 
   var TEST_OUTPUT;
   eval(output);
@@ -127,10 +133,10 @@ test("Variant #7: Throw statement", async () => {
 
   }
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("throw TEST_OUTPUT='Correct Value',new Error");
+  expect(output).toContain("TEST_OUTPUT='Correct Value',new Error");
 
   var TEST_OUTPUT;
   eval(output);
@@ -144,10 +150,10 @@ test("Variant #8: Variable declaration", async () => {
   TEST_OUTPUT = "Correct Value";
   var x = 1, y = 2;
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("var x=(TEST_OUTPUT='Correct Value',1)");
+  expect(output).toContain("(TEST_OUTPUT='Correct Value'");
 
   var TEST_OUTPUT;
   eval(output);
@@ -161,13 +167,26 @@ test("Variant #9: Variable declaration (no initializer)", async () => {
   TEST_OUTPUT = "Correct Value";
   var x,y;
   `,
-    { target: "node", controlFlowFlattening: true }
+    { target: "node", controlFlowFlattening: fakeEnabled }
   );
 
-  expect(output).toContain("var x=(TEST_OUTPUT='Correct Value',undefined)");
+  expect(output).toContain(`(TEST_OUTPUT='Correct Value',undefined)`);
 
   var TEST_OUTPUT;
   eval(output);
 
   expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
+
+test("Variant #10: Use function call", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT = "Correct Value";
+  var x,y;
+  `,
+    { target: "node", controlFlowFlattening: fakeEnabled }
+  );
+
+  expect(output).toContain("function");
+  expect(output).toContain(criticalFunctionTag);
+});

package/test/transforms/dispatcher.test.ts

@@ -400,3 +400,58 @@ printX();
 
   expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
+
+test("Variant #18: Preserve function.length property", async () => {
+  var output = await JsConfuser(
+    `
+  function myFunction1(){
+    // Function.length = 0
+  }
+  function myFunction2(a, b, c, d = "") {
+    // Function.length = 3
+  }
+  
+  myFunction1();
+  myFunction2();
+  TEST_OUTPUT_1 = myFunction1.length;
+  TEST_OUTPUT_2 = myFunction2.length;
+  
+  `,
+    { target: "node", dispatcher: true }
+  );
+
+  expect(output).toContain("dispatcher_0");
+
+  var TEST_OUTPUT_1, TEST_OUTPUT_2;
+  eval(output);
+
+  expect(TEST_OUTPUT_1).toStrictEqual(0);
+  expect(TEST_OUTPUT_2).toStrictEqual(3);
+});
+
+test("Variant #19: Lexically bound variables", async () => {
+  var output = await JsConfuser(
+    `
+  switch (true) {
+    case true:
+      let message = "Hello World";
+  
+      function logMessage() {
+        TEST_OUTPUT = message;
+      }
+  
+      logMessage();
+  }
+  `,
+    {
+      target: "node",
+      dispatcher: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Hello World");
+});

package/test/transforms/extraction/classExtraction.test.ts

@@ -0,0 +1,86 @@
+import JsConfuser from "../../../src/index";
+
+// TODO
+test.skip("Variant #1: Extract class methods", async () => {
+  var code = `
+  function nested() {
+    if (true) {
+      switch (true) {
+        case true:
+          let dimension2D = "2D";
+  
+          class Square {
+            constructor(size) {
+              this.size = size;
+            }
+  
+            static fromJSON(json) {
+              return new Square(json.size);
+            }
+  
+            getArea() {
+              return this.size * this.size;
+            }
+  
+            get dimensions() {
+              return dimension2D;
+            }
+  
+            set dimensions(value) {
+              if (value !== "2D") {
+                throw new Error("Only supports 2D");
+              }
+            }
+          }
+  
+          class Rectangle extends Square {
+            constructor(width, length) {
+              super(null);
+              this.width = width;
+              this.length = length;
+            }
+  
+            static fromJSON(json) {
+              return new Rectangle(json.width, json.height);
+            }
+  
+            getArea() {
+              return this.width * this.length;
+            }
+  
+            myMethod(dim = super.dimensions) {
+              console.log(dim);
+            }
+          }
+  
+          var rectangle = Rectangle.fromJSON({ width: 10, height: 5 });
+  
+          console.log(rectangle.getArea());
+          rectangle.myMethod();
+  
+          rectangle.dimensions = "2D"; // Allowed
+  
+          try {
+            rectangle.dimensions = "3D"; // Not allowed
+          } catch (e) {
+            if (e.message.includes("Only supports 2D")) {
+              // console.log("Failed to set dimensions");
+              TEST_OUTPUT = true;
+            }
+          }
+
+      }
+    }
+  }
+  
+  nested();
+  
+  `;
+
+  var output = await JsConfuser(code, { target: "node" });
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});

package/test/transforms/extraction/duplicateLiteralsRemoval.test.ts

@@ -184,9 +184,17 @@ test("Variant #9: Undefined as variable name", async () => {
     `
   var undefined = 0;
   var undefined = 1;
+
+  try {
+    (undefined = 0);
+    undefined = 1;
+  } catch (e) {
+  }
   `,
     { target: "node", duplicateLiteralsRemoval: true }
   );
 
+  expect(output).toContain("(undefined=");
+
   eval(output);
 });

package/test/transforms/extraction/objectExtraction.test.ts

@@ -482,6 +482,8 @@ test("Variant #16: Handle const declarations", async () => {
     }
   );
 
+  expect(output).toContain("let");
+
   var TEST_OUTPUT;
   eval(output);
 

package/test/transforms/identifier/globalConcealing.test.ts

@@ -51,3 +51,92 @@ test("Variant #3: Properly hide in default parameter, function expression", asyn
 
   expect(TEST_OUTPUT).toStrictEqual(true);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/131
+test("Variant #4: Don't change __dirname", async function () {
+  var code = `
+  TEST_OUTPUT = __dirname;
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    globalConcealing: true,
+  });
+
+  expect(output).toContain("__dirname");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(typeof TEST_OUTPUT).toStrictEqual("string");
+});
+
+test("Variant #5: Hide 'global' var, even if properties are modified", async () => {
+  var output = await JsConfuser(
+    `
+    TEST_GLOBAL_VARIANT_5_OUTPUT = global.TEST_GLOBAL_VARIANT_5_INPUT * 2;
+    `,
+    { target: "node", globalConcealing: true }
+  );
+
+  // Input should get transformed
+  expect(output).not.toContain("global['TEST_GLOBAL_VARIANT_5_INPUT");
+
+  // TEST_GLOBAL_VARIANT_5_OUTPUT should stay the same
+  expect(output).not.toContain("global['TEST_GLOBAL_VARIANT_5_OUTPUT");
+
+  (global as any).TEST_GLOBAL_VARIANT_5_INPUT = 50;
+  (global as any).TEST_GLOBAL_VARIANT_5_OUTPUT = 100;
+
+  eval(output);
+
+  expect((global as any).TEST_GLOBAL_VARIANT_5_OUTPUT).toStrictEqual(100);
+});
+
+test("Variant #6: Preserve __JS_CONFUSER_VAR__", async () => {
+  // Covers both defined and undefined case
+  var output = await JsConfuser(
+    `
+    var TEST_VARIABLE
+    TEST_OUTPUT = [__JS_CONFUSER_VAR__(TEST_OUTER_VARIABLE), __JS_CONFUSER_VAR__(TEST_VARIABLE)];
+    `,
+    {
+      target: "node",
+      globalConcealing: true,
+    }
+  );
+
+  expect(output).not.toContain("__JS_CONFUSER_VAR__");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(["TEST_OUTER_VARIABLE", "TEST_VARIABLE"]);
+});
+
+test("Variant #7: Custom callback option", async () => {
+  var namesCollected: string[] = [];
+
+  var output = await JsConfuser(
+    `
+    expect(true).toStrictEqual(true);
+
+    TEST_OUTPUT = true;
+    `,
+    {
+      target: "node",
+      globalConcealing: (name) => {
+        namesCollected.push(name);
+        return false;
+      },
+    }
+  );
+
+  expect(namesCollected).toContain("expect");
+  expect(namesCollected).not.toContain("TEST_OUTPUT");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});

package/test/transforms/identifier/movedDeclarations.test.ts

@@ -1,3 +1,4 @@
+import { predictableFunctionTag } from "../../../src/constants";
 import JsConfuser from "../../../src/index";
 
 test("Variant #1: Move variable 'y' to top", async () => {
@@ -212,3 +213,63 @@ test("Variant #9: Defined variable without an initializer", async () => {
   eval(output2);
   expect(TEST_OUTPUT).toStrictEqual(3);
 });
+
+test("Variant #10: Move parameters to predictable function", async () => {
+  var code = `
+  function testFunction${predictableFunctionTag}_FN(){
+    var values = [10,20,35,"40", null]
+    var parseIntKey = "parseInt"
+    var output = 0
+    var utils = {
+      get parser${predictableFunctionTag}(){
+        var fn = (value)=>{
+          return global[parseIntKey](value)
+        }
+        return fn
+      },
+
+      set setter_fn${predictableFunctionTag}(newValue){
+        var fakeVar
+      }
+    }
+    
+    class FakeClass {
+      constructor(){
+      }
+
+      get fakeGet${predictableFunctionTag}(){
+        var fakeVar
+      }
+    }
+
+    for(var value of values) {
+      switch(value){
+        case null:
+          break;
+
+        default:
+          var stringifiedValue = "" + value
+          var parsedValue = utils.parser${predictableFunctionTag}(stringifiedValue)
+          output += parsedValue;
+          break;
+      }
+    }
+
+    return output
+  }
+
+  TEST_OUTPUT = testFunction${predictableFunctionTag}_FN()
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    movedDeclarations: true,
+  });
+
+  expect(output).toContain("_FN(values");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(105);
+});