js-confuser 1.5.9 → 1.7.0

package/test/util/identifiers.test.ts

@@ -1,4 +1,7 @@
-import parseJS from "../../src/parser";
+import { ok } from "assert";
+import parseJS, { parseSync } from "../../src/parser";
+import traverse from "../../src/traverse";
+import { Location, Node } from "../../src/util/gen";
 import {
   getFunctionParameters,
   getIdentifierInfo,
@@ -41,6 +44,115 @@ describe("getIdentifierInfo", () => {
       getIdentifierInfo({ type: "Literal", value: true }, []);
     }).toThrow();
   });
+
+  function findIdentifier(tree: Node, identifierName: string) {
+    var searchLocation: Location;
+
+    traverse(tree, (o, p) => {
+      if (o.type === "Identifier" && o.name === identifierName) {
+        ok(!searchLocation);
+        searchLocation = [o, p];
+      }
+    });
+
+    ok(searchLocation);
+    return searchLocation;
+  }
+
+  test("Variant #4: Variable declaration assignment pattern", async () => {
+    var tree = parseSync(`
+      var [ definedIdentifier = nonDefinedIdentifier ] = [];
+    `);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(true);
+  });
+
+  test("Variant #5: Function parameter assignment pattern", async () => {
+    var tree = parseSync(`
+      function myFunction(definedIdentifier = nonDefinedIdentifier) {
+
+      }
+    `);
+
+    var myFunction = findIdentifier(tree, "myFunction");
+    var myFunctionInfo = getIdentifierInfo(myFunction[0], myFunction[1]);
+
+    expect(myFunctionInfo.isFunctionDeclaration).toStrictEqual(true);
+    expect(myFunctionInfo.spec.isDefined).toStrictEqual(true);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(true);
+  });
+
+  test("Variant #6: Object pattern", async () => {
+    var tree = parseSync(`
+      var { nonDefinedIdentifier: definedIdentifier } = {};
+
+      ( { nonModifiedIdentifier: modifiedIdentifier } = {} );
+    `);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(false);
+
+    var modifiedIdentifier = findIdentifier(tree, "modifiedIdentifier");
+    var modifiedInfo = getIdentifierInfo(
+      modifiedIdentifier[0],
+      modifiedIdentifier[1]
+    );
+    expect(modifiedInfo.spec.isDefined).toStrictEqual(false);
+    expect(modifiedInfo.spec.isModified).toStrictEqual(true);
+    expect(modifiedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonModifiedIdentifier = findIdentifier(tree, "nonModifiedIdentifier");
+    var nonModifiedInfo = getIdentifierInfo(
+      nonModifiedIdentifier[0],
+      nonModifiedIdentifier[1]
+    );
+
+    expect(nonModifiedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonModifiedInfo.spec.isModified).toStrictEqual(false);
+    expect(nonModifiedInfo.spec.isReferenced).toStrictEqual(false);
+  });
 });
 
 describe("validateChain", () => {

package/test/util/insert.test.ts

@@ -1,7 +1,8 @@
+import { ok } from "assert";
 import { compileJsSync } from "../../src/compiler";
-import parseJS from "../../src/parser";
-import { isBlock } from "../../src/traverse";
-import { Identifier } from "../../src/util/gen";
+import parseJS, { parseSync } from "../../src/parser";
+import traverse, { isBlock } from "../../src/traverse";
+import { Identifier, Location } from "../../src/util/gen";
 import {
   deleteDeclaration,
   isVarContext,
@@ -10,6 +11,7 @@ import {
   getContexts,
   getLexContext,
   getVarContext,
+  computeFunctionLength,
 } from "../../src/util/insert";
 
 it("isBlock() should be true for block statements and program", async () => {
@@ -86,3 +88,55 @@ it("should throw when missing parameters", () => {
   expect(() => getLexContext(Identifier("test"), [])).toThrow();
   expect(() => getVarContext(Identifier("test"), [])).toThrow();
 });
+
+test("computeFunctionLength", () => {
+  var tree = parseSync(`
+  function zeroParameters(){}; // 0
+  function oneParameter(a){}; // 1
+  function twoParameter(a,b){}; // 2
+  function restParameter1(...a){}; // 0
+  function restParameter2(a,b,...c){}; // 2
+  function defaultValue(a,b,c=1,d){}; // 2
+  function arrayPattern([a],[b = 2],[[c]]){}; // 3
+  function objectPattern({a},{b = 2},{c, d}){}; // 3
+  function mixed(a,{b},[c = 3],d,e=5,f,...g){}; // 4
+  `);
+
+  function getFunction(searchName: string): Location {
+    var searchLocation: Location;
+    traverse(tree, (o, p) => {
+      if (o.type === "FunctionDeclaration" && o.id.name === searchName) {
+        ok(!searchLocation);
+        searchLocation = [o, p];
+      }
+    });
+
+    ok(searchLocation);
+    return searchLocation;
+  }
+
+  expect(
+    computeFunctionLength(getFunction("zeroParameters")[0].params)
+  ).toStrictEqual(0);
+  expect(
+    computeFunctionLength(getFunction("oneParameter")[0].params)
+  ).toStrictEqual(1);
+  expect(
+    computeFunctionLength(getFunction("twoParameter")[0].params)
+  ).toStrictEqual(2);
+  expect(
+    computeFunctionLength(getFunction("restParameter1")[0].params)
+  ).toStrictEqual(0);
+  expect(
+    computeFunctionLength(getFunction("restParameter2")[0].params)
+  ).toStrictEqual(2);
+  expect(
+    computeFunctionLength(getFunction("arrayPattern")[0].params)
+  ).toStrictEqual(3);
+  expect(
+    computeFunctionLength(getFunction("objectPattern")[0].params)
+  ).toStrictEqual(3);
+  expect(computeFunctionLength(getFunction("mixed")[0].params)).toStrictEqual(
+    4
+  );
+});

package/src/transforms/controlFlowFlattening/choiceFlowObfuscation.ts

@@ -1,87 +0,0 @@
-import {
-  AssignmentExpression,
-  BlockStatement,
-  CatchClause,
-  ExpressionStatement,
-  Identifier,
-  IfStatement,
-  Literal,
-  ThrowStatement,
-  TryStatement,
-  UnaryExpression,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../../util/gen";
-import Transform from "../transform";
-
-export default class ChoiceFlowObfuscation extends Transform {
-  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(VariableDeclaration(VariableDeclarator(result)));
-
-      var yesBody = object.consequent
-        ? object.consequent.type == "BlockStatement"
-          ? [...object.consequent.body]
-          : [object.consequent]
-        : [];
-
-      yesBody.unshift(
-        ExpressionStatement(
-          AssignmentExpression("=", Identifier(result), Literal(1))
-        )
-      );
-
-      var noBody = object.alternate
-        ? object.alternate.type == "BlockStatement"
-          ? [...object.alternate.body]
-          : [object.alternate]
-        : [];
-
-      noBody.unshift(
-        ExpressionStatement(
-          AssignmentExpression("=", Identifier(result), Literal(1))
-        )
-      );
-
-      var elseTest = UnaryExpression("!", Identifier(result));
-
-      var newObject = TryStatement(
-        [IfStatement({ ...object.test }, [ThrowStatement(Identifier(result))])],
-        CatchClause(Identifier(this.getPlaceholder()), yesBody),
-        [IfStatement(elseTest, noBody)]
-      );
-
-      if (isNested) {
-        this.replace(object, BlockStatement([...before, { ...newObject }]));
-      } else {
-        body.splice(body.indexOf(element), 0, ...before);
-        this.replace(object, newObject);
-      }
-    };
-  }
-}

package/src/transforms/controlFlowFlattening/controlFlowObfuscation.ts

@@ -1,203 +0,0 @@
-import { ok } from "assert";
-import { ComputeProbabilityMap } from "../../probability";
-import { walk } from "../../traverse";
-import {
-  AssignmentExpression,
-  BinaryExpression,
-  BreakStatement,
-  ExpressionStatement,
-  Identifier,
-  IfStatement,
-  Literal,
-  Node,
-  SwitchCase,
-  SwitchStatement,
-  VariableDeclaration,
-  VariableDeclarator,
-  WhileStatement,
-} from "../../util/gen";
-import { containsLexicallyBoundVariables } from "../../util/identifiers";
-import { clone, getBlockBody } from "../../util/insert";
-import { getRandomInteger, shuffle } from "../../util/random";
-import Transform from "../transform";
-
-/**
- * Obfuscates For and While statements.
- */
-export default class ControlFlowObfuscation extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object: Node, parents: Node[]) {
-    return object.type === "ForStatement" || object.type === "WhileStatement";
-  }
-
-  transform(object: Node, parents: Node[]) {
-    return () => {
-      if (object.$controlFlowObfuscation) {
-        // avoid infinite loop
-        return;
-      }
-
-      if (containsLexicallyBoundVariables(object, parents)) {
-        return;
-      }
-
-      var illegal = false;
-      walk(object, parents, (o, p) => {
-        if (o.type == "FunctionDeclaration" || o.type == "BreakStatement") {
-          illegal = true;
-          return "EXIT";
-        }
-      });
-
-      if (illegal) {
-        return;
-      }
-
-      var body =
-        parents[0].type == "LabeledStatement" ? parents[1] : parents[0];
-      var element = parents[0].type == "LabeledStatement" ? parents[0] : object;
-
-      // No place to insert more statements
-      if (!Array.isArray(body)) {
-        return;
-      }
-
-      // No place to insert variable declaration
-      if (body.indexOf(element) === -1) {
-        return;
-      }
-
-      if (
-        !ComputeProbabilityMap(this.options.controlFlowFlattening, (x) => x)
-      ) {
-        return;
-      }
-
-      var init = [];
-      var update = [];
-      var test: Node = null;
-      var consequent = [];
-
-      if (object.type === "ForStatement") {
-        if (object.init) {
-          init.push(object.init);
-        }
-        if (object.update) {
-          update.push(ExpressionStatement(object.update));
-        }
-        if (object.test) {
-          test = object.test || Literal(true);
-        }
-      } else if (object.type === "WhileStatement") {
-        if (object.test) {
-          test = object.test;
-        }
-      } else {
-        throw new Error("Unknown type: " + object.type);
-      }
-
-      if (object.body.type == "BlockStatement") {
-        consequent.push(...getBlockBody(object.body));
-      } else {
-        consequent.push(object.body);
-      }
-
-      if (!test) {
-        test = Literal(true);
-      }
-
-      ok(test);
-
-      init.forEach((o) => {
-        if (
-          o.type !== "VariableDeclaration" &&
-          o.type !== "ExpressionStatement"
-        ) {
-          this.replace(o, ExpressionStatement(clone(o)));
-        }
-      });
-
-      var stateVar = this.getPlaceholder();
-
-      var selection = new Set();
-
-      //            init 0  test 1  run 2  update 3  end 4
-      var states: number[] = [];
-
-      // Create 5 random unique number
-      while (states.length < 5) {
-        var newState;
-        do {
-          newState = getRandomInteger(0, 1000 + states.length);
-        } while (selection.has(newState));
-
-        ok(!isNaN(newState));
-
-        states.push(newState);
-        selection.add(newState);
-      }
-      ok(selection.size === states.length);
-      ok(states.length === 5);
-
-      var startState = states[0];
-      var testState = states[1];
-      var bodyState = states[2];
-      var updateState = states[3];
-      var endState = states[4];
-
-      body.splice(
-        body.indexOf(element),
-        0,
-        VariableDeclaration(VariableDeclarator(stateVar, Literal(startState)))
-      );
-
-      function goto(from: number, to: number) {
-        var diff = to - from;
-        ok(!isNaN(diff));
-        return ExpressionStatement(
-          AssignmentExpression("+=", Identifier(stateVar), Literal(diff))
-        );
-      }
-
-      var cases = [
-        SwitchCase(Literal(startState), [
-          ...init,
-          goto(startState, testState),
-          BreakStatement(),
-        ]),
-        SwitchCase(Literal(testState), [
-          IfStatement(
-            test,
-            [goto(testState, bodyState)],
-            [goto(testState, endState)]
-          ),
-          BreakStatement(),
-        ]),
-        SwitchCase(Literal(bodyState), [
-          ...consequent,
-          goto(bodyState, updateState),
-          BreakStatement(),
-        ]),
-        SwitchCase(Literal(updateState), [
-          ...update,
-          goto(updateState, testState),
-          BreakStatement(),
-        ]),
-      ];
-
-      this.replace(
-        object,
-        WhileStatement(
-          BinaryExpression("!=", Identifier(stateVar), Literal(endState)),
-          [SwitchStatement(Identifier(stateVar), cases)]
-        )
-      );
-
-      // Marked to not be infinite
-      object.$controlFlowObfuscation = 1;
-    };
-  }
-}

package/src/transforms/controlFlowFlattening/switchCaseObfuscation.ts

@@ -1,130 +0,0 @@
-import Template from "../../templates/template";
-import { walk } from "../../traverse";
-import {
-  BinaryExpression,
-  Identifier,
-  Literal,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../../util/gen";
-import { clone } from "../../util/insert";
-import { getRandomInteger } from "../../util/random";
-import Transform from "../transform";
-
-/**
- * Does complex math to the state variable, after both CFF and CFO have run.
- *
- * The switch statements are ones with numbered cases and a simple discriminant.
- */
-export default class SwitchCaseObfuscation extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return (
-      object.type == "SwitchStatement" &&
-      !object.cases.find(
-        (x) =>
-          !(
-            x.test &&
-            typeof x.test === "object" &&
-            x.test.type == "Literal" &&
-            typeof x.test.value === "number" &&
-            Math.abs(x.test.value) < 100_000
-          )
-      )
-    );
-  }
-
-  transform(object, parents) {
-    var types = new Set();
-    walk(object.discriminant, [object, ...parents], (o, p) => {
-      if (o.type) {
-        if (
-          object.$controlFlowFlattening &&
-          o.type == "BinaryExpression" &&
-          o.operator === "+"
-        ) {
-        } else {
-          types.add(o.type);
-        }
-      }
-    });
-
-    types.delete("Identifier");
-    if (types.size) {
-      return;
-    }
-
-    var body = parents[0];
-    var element = object;
-
-    if (parents[0].type == "LabeledStatement") {
-      body = parents[1];
-      element = parents[0];
-    }
-
-    if (!Array.isArray(body)) {
-      return;
-    }
-
-    var index = body.indexOf(element);
-    if (index === -1) {
-      return;
-    }
-
-    var factor = getRandomInteger(-150, 150);
-    if (factor == 0) {
-      factor = 2;
-    }
-    var offset = getRandomInteger(-250, 250);
-
-    var newVar = this.getPlaceholder();
-
-    var newStates = [];
-    var max;
-    object.cases.forEach((x) => {
-      var current = x.test.value;
-      var value = current * factor + offset;
-
-      newStates.push(value);
-      if (!max || Math.abs(value) > max) {
-        max = Math.abs(value);
-      }
-    });
-
-    if (max > 100_000) {
-      return;
-    }
-
-    if (new Set(newStates).size !== newStates.length) {
-      // not possible because of clashing case test
-      return;
-    }
-
-    // State variable declaration
-    body.splice(
-      index,
-      0,
-      VariableDeclaration(
-        VariableDeclarator(
-          newVar,
-
-          BinaryExpression(
-            "+",
-            BinaryExpression("*", clone(object.discriminant), Literal(factor)),
-            Literal(offset)
-          )
-        )
-      )
-    );
-
-    object.discriminant = Identifier(newVar);
-
-    // possible so override
-    object.cases.forEach((x, i) => {
-      x.test = Literal(newStates[i]);
-    });
-  }
-}

package/src/transforms/eval.ts

@@ -1,89 +0,0 @@
-import { compileJsSync } from "../compiler";
-import { ObfuscateOrder } from "../order";
-import { ComputeProbabilityMap } from "../probability";
-import { isBlock } from "../traverse";
-import {
-  CallExpression,
-  Identifier,
-  Literal,
-  Node,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../util/gen";
-import { isFunction, prepend } from "../util/insert";
-import Transform from "./transform";
-
-export default class Eval extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.Eval);
-  }
-
-  match(object, parents) {
-    return (
-      isFunction(object) &&
-      object.type != "ArrowFunctionExpression" &&
-      !object.$eval &&
-      !object.$dispatcherSkip
-    );
-  }
-
-  transform(object, parents) {
-    // Don't apply to getter/setters or class methods
-    if (parents[0]) {
-      if (
-        parents[0].type === "MethodDefinition" &&
-        parents[0].value === object
-      ) {
-        return;
-      }
-
-      if (
-        parents[0].type === "Property" &&
-        parents[0].value === object &&
-        (parents[0].kind !== "init" || parents[0].method)
-      ) {
-        return;
-      }
-    }
-
-    if (
-      !ComputeProbabilityMap(
-        this.options.eval,
-        (x) => x,
-        object.id && object.id.name
-      )
-    ) {
-      return;
-    }
-
-    object.$eval = (o, p) => {
-      var name;
-      var requiresMove = false;
-      if (object.type == "FunctionDeclaration") {
-        name = object.id.name;
-        object.type = "FunctionExpression";
-        object.id = null;
-        requiresMove = Array.isArray(p[0]) && isBlock(p[1]);
-      }
-
-      var code = compileJsSync(object, this.options);
-      if (object.type == "FunctionExpression") {
-        code = "(" + code + ")";
-      }
-
-      var literal = Literal(code);
-
-      var expr: Node = CallExpression(Identifier("eval"), [literal]);
-      if (name) {
-        expr = VariableDeclaration(VariableDeclarator(name, expr));
-      }
-
-      if (requiresMove) {
-        prepend(p[1], expr);
-        p[0].splice(p[0].indexOf(object), 1);
-      } else {
-        this.replace(object, expr);
-      }
-    };
-  }
-}