js-confuser 1.7.1 → 1.7.2

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,22 @@ 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");
+});

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);
+});

package/test/transforms/minify.test.ts

@@ -211,6 +211,16 @@ test("Variant #11: Shorten 'undefined' to 'void 0'", async () => {
   });
 
   expect(output2).toContain("var x={[void 0]:1}");
+
+  var output3 = await JsConfuser(
+    `try { var undefined; (undefined) = true } catch(e) {}`,
+    {
+      target: "node",
+      minify: true,
+    }
+  );
+
+  eval(output3);
 });
 
 test("Variant #11: Shorten 'Infinity' to 1/0", async () => {
@@ -536,3 +546,30 @@ test("Variant #27: Preserve function.length property", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual(6);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/125
+test("Variant #28: Don't break destructuring assignment", async () => {
+  var output = await JsConfuser(
+    `
+    let objectSlice = [];
+    objectSlice.push({
+      a: 1,
+      b: 2,
+      c: 3,
+    })
+    for (let {
+      a,
+      b,
+      c
+    } of objectSlice) {
+      TEST_OUTPUT = a + b + c;
+    }
+  `,
+    { target: "node", minify: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(6);
+});

package/test/transforms/rgf.test.ts

@@ -326,3 +326,53 @@ test("Variant #10: Configurable by custom function option", async () => {
   expect(TEST_OUTPUT_1).toStrictEqual(false);
   expect(TEST_OUTPUT_2).toStrictEqual(true);
 });
+
+test("Variant #11: Function containing function should both be changed", async function () {
+  var output = await JsConfuser(
+    `
+    function FunctionA(){
+      function FunctionB(){
+        var bVar = 10;
+        return bVar
+      }
+
+      var bFn = FunctionB;
+      var aVar = bFn();
+      return aVar + 1
+    }
+
+    TEST_OUTPUT = FunctionA();
+  `,
+    { target: "node", rgf: true }
+  );
+
+  // 2 means one Function changed, 3 means two Functions changed
+  expect(output.split("new Function").length).toStrictEqual(3);
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(11);
+});
+
+test("Variant #12: Preserve Function.length", async function () {
+  var output = await JsConfuser(
+    `
+  function myFunction(a,b,c,d = ""){ // Function.length = 3
+
+  }
+
+  myFunction()
+  TEST_OUTPUT = myFunction.length
+  `,
+    {
+      target: "node",
+      rgf: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(3);
+});

package/dist/transforms/controlFlowFlattening/choiceFlowObfuscation.js

@@ -1,62 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _gen = require("../../util/gen");
-
-var _transform = _interopRequireDefault(require("../transform"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class ChoiceFlowObfuscation extends _transform.default {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return object.type == "IfStatement";
-  }
-
-  transform(object, parents) {
-    return () => {
-      var body = parents[0];
-      var element = object;
-
-      if (parents[0].type == "LabeledStatement") {
-        body = parents[1];
-        element = parents[0];
-      }
-
-      var before = [];
-      var isNested = parents[0].type == "IfStatement" && parents[0].alternate === object;
-
-      if (!isNested && (!Array.isArray(body) || body.indexOf(element) === -1)) {
-        return;
-      }
-
-      var result = this.getPlaceholder();
-      before.push((0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(result)));
-      var yesBody = object.consequent ? object.consequent.type == "BlockStatement" ? [...object.consequent.body] : [object.consequent] : [];
-      yesBody.unshift((0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(result), (0, _gen.Literal)(1))));
-      var noBody = object.alternate ? object.alternate.type == "BlockStatement" ? [...object.alternate.body] : [object.alternate] : [];
-      noBody.unshift((0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(result), (0, _gen.Literal)(1))));
-      var elseTest = (0, _gen.UnaryExpression)("!", (0, _gen.Identifier)(result));
-      var newObject = (0, _gen.TryStatement)([(0, _gen.IfStatement)({ ...object.test
-      }, [(0, _gen.ThrowStatement)((0, _gen.Identifier)(result))])], (0, _gen.CatchClause)((0, _gen.Identifier)(this.getPlaceholder()), yesBody), [(0, _gen.IfStatement)(elseTest, noBody)]);
-
-      if (isNested) {
-        this.replace(object, (0, _gen.BlockStatement)([...before, { ...newObject
-        }]));
-      } else {
-        body.splice(body.indexOf(element), 0, ...before);
-        this.replace(object, newObject);
-      }
-    };
-  }
-
-}
-
-exports.default = ChoiceFlowObfuscation;