js-confuser 1.2.1 → 1.4.1

package/test/transforms/minify.test.ts

@@ -124,3 +124,140 @@ it("should work when shortening nested if-statements", async () => {
 
   expect(value).toStrictEqual(10);
 });
+
+test("Variant #8: Shorten simple array destructuring", async () => {
+  // Valid
+  var output = await JsConfuser(`var [x] = [1]`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output).toContain("var x=1");
+
+  // Invalid
+  var output2 = await JsConfuser(`var [x, y] = [1]`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output2).toContain("var [x,y]");
+});
+
+test("Variant #9: Shorten simple object destructuring", async () => {
+  // Valid
+  var output = await JsConfuser(`var {x} = {x: 1}`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output).toContain("var x=1");
+
+  // Valid
+  var output2 = await JsConfuser(`var {['x']: y} = {x: 1}`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output2).toContain("var y=1");
+
+  // Invalid
+  var output3 = await JsConfuser(`var {x,y} = {x:1}`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output3).toContain("var {x:x,y:y}");
+
+  // Invalid
+  var output4 = await JsConfuser(`var {y} = {x:1}`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output4).toContain("var {y:y}");
+});
+
+test("Variant #10: Shorten booleans", async () => {
+  // Valid
+  var output = await JsConfuser(`var x = true;`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output).toContain("var x=!0");
+
+  // Valid
+  var output2 = await JsConfuser(`var x = false`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output2).toContain("var x=!1");
+});
+
+test("Variant #11: Shorten 'undefined' to 'void 0'", async () => {
+  // Valid
+  var output = await JsConfuser(`x = undefined;`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output).toContain("x=void 0");
+
+  // Valid
+  var output2 = await JsConfuser(`var x = {undefined: 1}`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output2).toContain("var x={[void 0]:1}");
+});
+
+test("Variant #11: Shorten 'Infinity' to 1/0", async () => {
+  // Valid
+  var output = await JsConfuser(`var x = Infinity;`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output).toContain("var x=1/0");
+
+  // Valid
+  var output2 = await JsConfuser(`var x = {Infinity: 1}`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output2).toContain("var x={[1/0]:1}");
+});
+
+test("Variant #12: Shorten '!false' to 'true'", async () => {
+  // Valid
+  var output = await JsConfuser(`var x = !false;`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output).toContain("var x=true");
+});
+
+test("Variant #13: Shorten 'false ? a : b' to 'b'", async () => {
+  // Valid
+  var output = await JsConfuser(`var x = false ? 10 : 15;`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output).toContain("var x=15");
+});
+
+test("Variant #14: Shorten 'var x = undefined' to 'var x'", async () => {
+  // Valid
+  var output = await JsConfuser(`var x = undefined`, {
+    target: "node",
+    minify: true,
+  });
+
+  expect(output).toContain("var x");
+  expect(output).not.toContain("var x=");
+});

package/test/transforms/renameLabels.test.ts

@@ -60,3 +60,36 @@ it("should not rename nested labels", async () => {
   expect(output).not.toContain("TEST_LABEL");
   expect(output).toContain(":for");
 });
+
+it("should not remove labels on block statements", async () => {
+  var code = `
+    TEST_LABEL: {
+      break TEST_LABEL;
+    }
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "browser",
+    objectExtraction: true,
+  });
+
+  expect(output).not.toContain("TEST_LABEL");
+  expect(output).toContain(":{");
+});
+
+it("should remove labels on block statements when the label was never used", async () => {
+  var code = `
+    TEST_LABEL: {
+      "";
+    }
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "browser",
+    objectExtraction: true,
+  });
+
+  expect(output).not.toContain("TEST_LABEL");
+  expect(output).not.toContain(":{");
+  expect(output).toContain("{");
+});

package/test/transforms/rgf.test.ts

@@ -125,6 +125,35 @@ describe("RGF", () => {
 
     expect(value).toStrictEqual("Hello World");
   });
+
+  it("should work with hideInitializingCode enabled", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+function abc(x, y){
+  return x + y;
+}
+
+var result = abc(10, 50);
+input(console.log, result) 
+`,
+      {
+        target: "node",
+        identifierGenerator: "randomized",
+        hideInitializingCode: true,
+        rgf: true,
+        compact: false,
+        renameVariables: true,
+      }
+    );
+
+    var value = "never_called";
+    function input(_, valueIn) {
+      value = valueIn;
+    }
+
+    eval(output);
+    expect(value).toStrictEqual(60);
+  });
 });
 
 describe("RGF with the 'all' mode", () => {

package/test/transforms/string/stringSplitting.test.ts

@@ -100,3 +100,36 @@ it("should not encode constructor key", async () => {
 
   expect(TEST_VAR).toStrictEqual(100);
 });
+
+it("should allow custom callback to exclude strings", async () => {
+  var code = `
+  var str1 = "-- Hello World --";
+  var str2 = "-- This String Will Not Be Split --";
+  var str3 = "-- This string Will Be Split --";
+  `;
+
+  var strings = [];
+  var output = await JsConfuser(code, {
+    target: "node",
+    stringSplitting: (str) => {
+      strings.push(str);
+
+      if (str == "-- This String Will Not Be Split --") {
+        return false;
+      }
+
+      return true;
+    },
+  });
+
+  expect(strings).toEqual([
+    "-- Hello World --",
+    "-- This String Will Not Be Split --",
+    "-- This string Will Be Split --",
+  ]);
+
+  expect(output).toContain("-- This String Will Not Be Split --");
+
+  expect(output).not.toContain("-- Hello World --");
+  expect(output).not.toContain("-- This string Will Be Split --");
+});

package/test/util/identifiers.test.ts

@@ -1,32 +1,120 @@
 import parseJS from "../../src/parser";
-import { getIdentifierInfo } from "../../src/util/identifiers";
+import {
+  getFunctionParameters,
+  getIdentifierInfo,
+  validateChain,
+} from "../../src/util/identifiers";
 
-it("getIdentifierInfo() should determine function declarations", async () => {
-  var tree = await parseJS(`function abc(){}`);
+describe("getIdentifierInfo", () => {
+  test("Variant #1: Determine function declarations", async () => {
+    var tree = await parseJS(`function abc(){}`);
 
-  var object = tree.body[0].id;
+    var object = tree.body[0].id;
 
-  expect(object.type).toStrictEqual("Identifier");
+    expect(object.type).toStrictEqual("Identifier");
 
-  var parents = [tree.body[0], tree.body, tree];
+    var parents = [tree.body[0], tree.body, tree];
 
-  var info = getIdentifierInfo(object, parents as any);
+    var info = getIdentifierInfo(object, parents as any);
 
-  expect(info.isFunctionDeclaration).toStrictEqual(true);
-  expect(info.spec.isDefined).toStrictEqual(true);
+    expect(info.isFunctionDeclaration).toStrictEqual(true);
+    expect(info.spec.isDefined).toStrictEqual(true);
+  });
+
+  test("Variant #2: Determine labels", async () => {
+    var tree = await parseJS(`label: for (var i = 0; i < 0; i++ ) {}`);
+
+    var object = tree.body[0].label;
+
+    expect(object.type).toStrictEqual("Identifier");
+
+    var parents = [tree.body[0], tree.body, tree];
+
+    var info = getIdentifierInfo(object, parents as any);
+
+    expect(info.isLabel).toStrictEqual(true);
+    expect(info.spec.isReferenced).toStrictEqual(false);
+  });
+
+  test("Variant #3: Error when a non-identifier node is given", async () => {
+    expect(() => {
+      getIdentifierInfo({ type: "Literal", value: true }, []);
+    }).toThrow();
+  });
+});
+
+describe("validateChain", () => {
+  test("Variant #1: Error when parents is not an array", () => {
+    expect(() => {
+      validateChain({ type: "Identifier", name: "name" }, {} as any);
+    }).toThrow();
+  });
+
+  test("Variant #2: Error when object is undefined", () => {
+    expect(() => {
+      validateChain(undefined, []);
+    }).toThrow();
+  });
+
+  test("Variant #3: Error when object is not connected to direct parent", () => {
+    expect(() => {
+      validateChain({ type: "Identifier", name: "name" }, [
+        { type: "Program", body: [] },
+      ]);
+    }).toThrow();
+  });
 });
 
-it("getIdentifierInfo() should determine labels", async () => {
-  var tree = await parseJS(`label: for (var i = 0; i < 0; i++ ) {}`);
+describe("getFunctionParameters", () => {
+  test("Variant #1: Work with default values and destructuring", async () => {
+    var code = `function a(A=_b,{B,[_c]:C},[D]){}`;
+    var tree = await parseJS(code);
+
+    var object = tree.body[0];
+    var parents: any = [tree.body, tree];
+
+    var locations = getFunctionParameters(object, parents);
+    var names = locations.map((x) => x[0].name);
+
+    expect(names).toStrictEqual(["A", "B", "C", "D"]);
+  });
+
+  test("Variant #2: Work with spread element", async () => {
+    var code = `function a(...A){}`;
+    var tree = await parseJS(code);
+
+    var object = tree.body[0];
+    var parents: any = [tree.body, tree];
+
+    var locations = getFunctionParameters(object, parents);
+    var names = locations.map((x) => x[0].name);
+
+    expect(names).toStrictEqual(["A"]);
+  });
+
+  test("Variant #3: Normal parameters", async () => {
+    var code = `function a(A,B,C,D){}`;
+    var tree = await parseJS(code);
+
+    var object = tree.body[0];
+    var parents: any = [tree.body, tree];
+
+    var locations = getFunctionParameters(object, parents);
+    var names = locations.map((x) => x[0].name);
 
-  var object = tree.body[0].label;
+    expect(names).toStrictEqual(["A", "B", "C", "D"]);
+  });
 
-  expect(object.type).toStrictEqual("Identifier");
+  test("Variant #4: Default values as functions", async () => {
+    var code = `function a(A = function(_a){ return _a; },B = function(_a, _b = function(){return this;}){return _a + _b();},C,D){}`;
+    var tree = await parseJS(code);
 
-  var parents = [tree.body[0], tree.body, tree];
+    var object = tree.body[0];
+    var parents: any = [tree.body, tree];
 
-  var info = getIdentifierInfo(object, parents as any);
+    var locations = getFunctionParameters(object, parents);
+    var names = locations.map((x) => x[0].name);
 
-  expect(info.isLabel).toStrictEqual(true);
-  expect(info.spec.isReferenced).toStrictEqual(false);
+    expect(names).toStrictEqual(["A", "B", "C", "D"]);
+  });
 });

package/dist/util/expr.js

@@ -1,60 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.inverseExpression = inverseExpression;
-
-var _gen = require("./gen");
-
-var _traverse = require("../traverse");
-
-function inverseExpression(expr) {
-  /**
-   * !x -> x
-   */
-  if (expr.type == "UnaryExpression" && expr.operator == "!" && expr.prefix) {
-    return expr.argument;
-  }
-
-  var inverseMapping = {
-    BinaryExpression: {
-      "<": ">=",
-      ">": "<=",
-      "<=": ">",
-      ">=": "<",
-      "==": "!=",
-      "===": "!=",
-      "!=": "==",
-      "!==": "==="
-    }
-  };
-
-  if (!inverseMapping[expr.type]) {
-    return (0, _gen.UnaryExpression)("!", expr);
-  }
-
-  var safe = new Set(["Literal", "Identifier", "MemberExpression"]);
-  var canInvert = true;
-  (0, _traverse.walk)(expr, [], (object, parents) => {
-    if (object.type) {
-      var hasInverse = inverseMapping[object.type] && inverseMapping[object.type][object.operator];
-
-      if (!safe.has(object.type) && !hasInverse) {
-        // console.log(object.type);
-        canInvert = false;
-      }
-    }
-  });
-
-  if (canInvert) {
-    (0, _traverse.walk)(expr, [], (object, parents) => {
-      if (object.operator) {
-        object.operator = inverseMapping[object.type][object.operator];
-      }
-    });
-    return expr;
-  } else {
-    return (0, _gen.UnaryExpression)("!", expr);
-  }
-}

package/src/util/expr.ts

@@ -1,56 +0,0 @@
-import { Node, UnaryExpression } from "./gen";
-import { walk } from "../traverse";
-
-export function inverseExpression(expr: Node) {
-  /**
-   * !x -> x
-   */
-  if (expr.type == "UnaryExpression" && expr.operator == "!" && expr.prefix) {
-    return expr.argument;
-  }
-
-  var inverseMapping = {
-    BinaryExpression: {
-      "<": ">=",
-      ">": "<=",
-      "<=": ">",
-      ">=": "<",
-      "==": "!=",
-      "===": "!=",
-      "!=": "==",
-      "!==": "===",
-    },
-  };
-
-  if (!inverseMapping[expr.type]) {
-    return UnaryExpression("!", expr);
-  }
-
-  var safe = new Set(["Literal", "Identifier", "MemberExpression"]);
-
-  var canInvert = true;
-  walk(expr, [], (object: Node, parents: Node[]) => {
-    if (object.type) {
-      var hasInverse =
-        inverseMapping[object.type] &&
-        inverseMapping[object.type][object.operator];
-
-      if (!safe.has(object.type) && !hasInverse) {
-        // console.log(object.type);
-        canInvert = false;
-      }
-    }
-  });
-
-  if (canInvert) {
-    walk(expr, [], (object: Node, parents: Node[]) => {
-      if (object.operator) {
-        object.operator = inverseMapping[object.type][object.operator];
-      }
-    });
-
-    return expr;
-  } else {
-    return UnaryExpression("!", expr);
-  }
-}