js-confuser 1.5.9 → 1.7.0

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

@@ -0,0 +1,173 @@
+import JsConfuser from "../../../src/index";
+
+test("Variant #1: Join expressions in a sequence expression", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT=0;
+  TEST_OUTPUT++;
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("(TEST_OUTPUT=0,TEST_OUTPUT++");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(1);
+});
+
+test("Variant #2: If Statement", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT=0;
+  if(true){
+    TEST_OUTPUT++;
+  }
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("if(TEST_OUTPUT=0,true)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(1);
+});
+
+test("Variant #3: ForStatement (Variable Declaration initializer)", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT=0;
+  for(var i =0; i < 10; i++){
+    TEST_OUTPUT++;
+  }
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("for(var i=(TEST_OUTPUT=0,0)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
+});
+
+test("Variant #4: ForStatement (Assignment expression initializer)", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT=0;
+  for(i = 0; i < 10; i++){
+    TEST_OUTPUT++;
+  }
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("for(i=(TEST_OUTPUT=0,0)");
+
+  var TEST_OUTPUT, i;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
+});
+
+test("Variant #5: Return statement", async () => {
+  var output = await JsConfuser(
+    `
+  function fn(){
+    TEST_OUTPUT = 10;
+    return "Value";
+  }
+  fn();
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("return TEST_OUTPUT=10,'Value'}");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
+});
+
+test("Variant #6: Return statement (no argument)", async () => {
+  var output = await JsConfuser(
+    `
+  function fn(){
+    TEST_OUTPUT = 10;
+    return;
+  }
+  fn();
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("return TEST_OUTPUT=10,undefined}");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(10);
+});
+
+test("Variant #7: Throw statement", async () => {
+  var output = await JsConfuser(
+    `
+  function fn(){
+    TEST_OUTPUT = "Correct Value";
+    throw new Error("My Error")
+  }
+  try {
+    fn();
+  } catch(e){
+
+  }
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("throw TEST_OUTPUT='Correct Value',new Error");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #8: Variable declaration", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT = "Correct Value";
+  var x = 1, y = 2;
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("var x=(TEST_OUTPUT='Correct Value',1)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #9: Variable declaration (no initializer)", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OUTPUT = "Correct Value";
+  var x,y;
+  `,
+    { target: "node", controlFlowFlattening: true }
+  );
+
+  expect(output).toContain("var x=(TEST_OUTPUT='Correct Value',undefined)");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

package/test/transforms/deadCode.test.ts

@@ -1,21 +1,25 @@
 import JsConfuser from "../../src/index";
 
-it("should execute properly", async () => {
+test("Variant #1: Execute properly", async () => {
   var code = `
-    var array = [];
-
-    array.push(1);
-    array.push(2);
-    array.push(3);
-    array.push(4);
-    array.push(5);
-    array.push(6);
-    array.push(7);
-    array.push(8);
-    array.push(9);
-    array.push(10);
-
-    input(array);
+    function myFunction(){
+      var array = [];
+
+      array.push(1);
+      array.push(2);
+      array.push(3);
+      array.push(4);
+      array.push(5);
+      array.push(6);
+      array.push(7);
+      array.push(8);
+      array.push(9);
+      array.push(10);
+
+      input(array);
+    }
+
+    myFunction();
   `;
 
   var output = await JsConfuser(code, {
@@ -23,6 +27,53 @@ it("should execute properly", async () => {
     deadCode: true,
   });
 
+  // Ensure Dead code was added
+  expect(output).toContain("if");
+
+  var value = "never_called";
+  function input(valueIn) {
+    value = valueIn;
+  }
+
+  eval(output);
+
+  expect(value).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+});
+
+test("Variant #2: Preserve 'use strict' directive", async () => {
+  var code = `
+    'use strict';
+    function myFunction(){
+      var array = [];
+
+      array.push(1);
+      array.push(2);
+      array.push(3);
+      array.push(4);
+      array.push(5);
+      array.push(6);
+      array.push(7);
+      array.push(8);
+      array.push(9);
+      array.push(10);
+
+      input(array);
+    }
+
+    myFunction();
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "browser",
+    deadCode: true,
+  });
+
+  // Ensure 'use strict' was preversed
+  expect(output.startsWith("'use strict'")).toStrictEqual(true);
+
+  // Ensure Dead code was added
+  expect(output).toContain("if");
+
   var value = "never_called";
   function input(valueIn) {
     value = valueIn;

package/test/transforms/dispatcher.test.ts

@@ -1,4 +1,3 @@
-import { isObject } from "util";
 import JsConfuser from "../../src/index";
 
 it("should middleman function calls", async () => {
@@ -354,3 +353,23 @@ it("should work with code that uses toString() function", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual("Correct Value");
 });
+
+test("Variant #16: Don't change functions that use 'eval'", async () => {
+  var output = await JsConfuser(
+    `
+  function myEvalFunction(){
+    return eval("1+1");
+  }
+
+  TEST_OUTPUT = myEvalFunction();
+  `,
+    { target: "node", dispatcher: true }
+  );
+
+  expect(output).not.toContain("dispatcher");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(2);
+});

package/test/transforms/es5/antiDestructuring.test.ts

@@ -139,3 +139,19 @@ it("should fix destructuring inside the try...catch clause", async () => {
 
   expect(TEST_VARIABLE).toStrictEqual(100);
 });
+
+it("should fix destructuring member expressions", async () => {
+  var code = `
+  var myObject = { nested: {} };
+  [myObject.key1, myObject["key2"], myObject.nested.key3] = [1, 2, 3];
+
+  TEST_VARIABLE = [myObject.key1, myObject.key2, myObject.nested.key3];
+  `;
+
+  var output = await JsConfuser(code, { target: "node", es5: true });
+
+  var TEST_VARIABLE;
+  eval(output);
+
+  expect(TEST_VARIABLE).toStrictEqual([1, 2, 3]);
+});