js-confuser 1.5.8 → 1.6.0

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/hexadecimalNumbers.ts

@@ -1,31 +0,0 @@
-import Transform from "./transform";
-import { ObfuscateOrder } from "../order";
-import { ExitCallback } from "../traverse";
-import { Identifier, Node } from "../util/gen";
-
-export default class HexadecimalNumbers extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.HexadecimalNumbers);
-  }
-
-  match(object: Node, parents: Node[]): boolean {
-    return (
-      object.type === "Literal" &&
-      typeof object.value === "number" &&
-      Math.floor(object.value) === object.value
-    );
-  }
-
-  transform(object: Node, parents: Node[]): void | ExitCallback {
-    return () => {
-      // Technically, a Literal will never be negative because it's supposed to be inside a UnaryExpression with a "-" operator.
-      // This code handles it regardless
-      var isNegative = object.value < 0;
-      var hex = Math.abs(object.value).toString(16);
-
-      var newStr = (isNegative ? "-" : "") + "0x" + hex;
-
-      this.replace(object, Identifier(newStr));
-    };
-  }
-}