js-confuser 2.0.0-alpha.2 → 2.0.0-alpha.3

package/src/transforms/functionOutlining.ts

@@ -1,225 +0,0 @@
-import { NodePath } from "@babel/traverse";
-import { PluginArg, PluginObject } from "./plugin";
-import { Order } from "../order";
-import { ensureComputedExpression, prepend } from "../utils/ast-utils";
-import * as t from "@babel/types";
-import { NameGen } from "../utils/NameGen";
-import { chance, getRandomInteger } from "../utils/random-utils";
-import { Binding, Visitor } from "@babel/traverse";
-import { computeProbabilityMap } from "../probability";
-
-function isSafeForOutlining(path: NodePath): {
-  isSafe: boolean;
-  bindings?: Binding[];
-} {
-  if (path.isIdentifier() || path.isLiteral()) return { isSafe: false };
-
-  // Skip direct invocations ('this' will be different)
-  if (path.key === "callee" && path.parentPath.isCallExpression()) {
-    return { isSafe: false };
-  }
-
-  // Skip typeof and delete expressions (identifier behavior is different)
-  if (path.key === "argument" && path.parentPath.isUnaryExpression()) {
-    return { isSafe: false };
-  }
-
-  if (
-    path.isReturnStatement() ||
-    path.isYieldExpression() ||
-    path.isAwaitExpression() ||
-    path.isContinueStatement() ||
-    path.isBreakStatement() ||
-    path.isThrowStatement() ||
-    path.isDebuggerStatement() ||
-    path.isImportDeclaration() ||
-    path.isExportDeclaration()
-  ) {
-    return { isSafe: false };
-  }
-
-  var isSafe = true;
-  var bindings: Binding[] = [];
-  var fnPath = path.getFunctionParent();
-
-  var visitor: Visitor = {
-    ThisExpression(path) {
-      isSafe = false;
-      path.stop();
-    },
-    Identifier(path) {
-      if (["arguments", "eval"].includes(path.node.name)) {
-        isSafe = false;
-        path.stop();
-      }
-    },
-    BindingIdentifier(path) {
-      var binding = path.scope.getBinding(path.node.name);
-      if (binding) {
-        bindings.push(binding);
-      }
-    },
-    // Function flow guard
-    "ReturnStatement|YieldExpression|AwaitExpression"(path) {
-      if (path.getFunctionParent() === fnPath) {
-        isSafe = false;
-        path.stop();
-      }
-    },
-  };
-
-  // Exclude 'ThisExpression' and semantic 'Identifier' nodes
-  if (visitor[path.type]) return { isSafe: false };
-
-  path.traverse(visitor);
-
-  return { isSafe, bindings };
-}
-
-export default ({ Plugin }: PluginArg): PluginObject => {
-  const me = Plugin(Order.FunctionOutlining, {
-    changeData: {
-      functionsMade: 0,
-    },
-  });
-
-  var changesMade = 0;
-
-  function checkProbability() {
-    if (!computeProbabilityMap(me.options.functionOutlining)) return false;
-
-    if (changesMade > 100 && chance(changesMade - 100)) return false;
-
-    return true;
-  }
-
-  return {
-    visitor: {
-      Block: {
-        exit(blockPath) {
-          if (blockPath.isProgram()) {
-            blockPath.scope.crawl();
-          }
-
-          if (blockPath.find((p) => me.isSkipped(p))) return;
-
-          if (!checkProbability()) return;
-
-          // Extract a random number of statements
-
-          var statements = blockPath.get("body");
-          // var startIndex = getRandomInteger(0, statements.length);
-          // var endIndex = getRandomInteger(startIndex, statements.length);
-
-          var startIndex = 0;
-          var endIndex = statements.length;
-
-          var extractedStatements = statements.slice(startIndex, endIndex);
-          if (!extractedStatements.length) return;
-
-          var bindings: Binding[] = [];
-
-          for (var statement of extractedStatements) {
-            // Don't override the control node
-            if (me.isSkipped(statement)) return;
-
-            var result = isSafeForOutlining(statement);
-            if (!result.isSafe) {
-              return;
-            }
-
-            bindings.push(...result.bindings);
-          }
-
-          const extractedStatementSet = new Set<NodePath>(extractedStatements);
-
-          for (var binding of bindings) {
-            for (var referencePath of binding.referencePaths) {
-              var found = referencePath.find((p) =>
-                extractedStatementSet.has(p)
-              );
-              if (!found) {
-                return;
-              }
-            }
-            for (var constantViolation of binding.constantViolations) {
-              var found = constantViolation.find((p) =>
-                extractedStatementSet.has(p)
-              );
-              if (!found) {
-                return;
-              }
-            }
-          }
-
-          changesMade++;
-
-          var isFirst = true;
-          for (var statement of extractedStatements) {
-            if (isFirst) {
-              isFirst = false;
-              var memberExpression = me
-                .getControlObject(blockPath)
-                .addProperty(
-                  t.functionExpression(
-                    null,
-                    [],
-                    t.blockStatement(extractedStatements.map((x) => x.node))
-                  )
-                );
-
-              me.changeData.functionsMade++;
-
-              var callExpression = t.callExpression(memberExpression, []);
-
-              statement.replaceWith(callExpression);
-              continue;
-            }
-            statement.remove();
-          }
-        },
-      },
-      Expression: {
-        exit(path) {
-          // Skip assignment left
-          if (
-            path.find(
-              (p) =>
-                p.key === "left" &&
-                p.parentPath?.type === "AssignmentExpression"
-            )
-          ) {
-            return;
-          }
-
-          if (!checkProbability()) return;
-
-          if (path.find((p) => me.isSkipped(p))) return;
-          if (!isSafeForOutlining(path).isSafe) return;
-
-          changesMade++;
-
-          var blockPath = path.find((p) => p.isBlock()) as NodePath<t.Block>;
-
-          var memberExpression = me
-            .getControlObject(blockPath)
-            .addProperty(
-              t.functionExpression(
-                null,
-                [],
-                t.blockStatement([t.returnStatement(t.cloneNode(path.node))])
-              )
-            );
-
-          me.changeData.functionsMade++;
-
-          var callExpression = t.callExpression(memberExpression, []);
-
-          ensureComputedExpression(path);
-          path.replaceWith(callExpression);
-          me.skip(path);
-        },
-      },
-    },
-  };
-};

package/src/utils/ControlObject.ts

@@ -1,141 +0,0 @@
-import { NodePath } from "@babel/traverse";
-import * as t from "@babel/types";
-import { PluginInstance } from "../transforms/plugin";
-import { NameGen } from "./NameGen";
-import { prepend } from "./ast-utils";
-import { chance, choice } from "./random-utils";
-
-/**
- * A Control Object is an object that is used to store properties that are used in multiple places.
- */
-export default class ControlObject {
-  propertyNames = new Set<string>();
-  nameGen: NameGen;
-  objectName: string | null = null;
-  objectPath: NodePath<t.Declaration> | null = null;
-  objectExpression: t.ObjectExpression | null = null;
-
-  constructor(public me: PluginInstance, public blockPath: NodePath<t.Block>) {
-    this.nameGen = new NameGen(me.options.identifierGenerator, {
-      avoidReserved: true,
-      avoidObjectPrototype: true,
-    });
-  }
-
-  createMemberExpression(propertyName: string): t.MemberExpression {
-    return t.memberExpression(
-      t.identifier(this.objectName),
-      t.stringLiteral(propertyName),
-      true
-    );
-  }
-
-  createPredicate() {
-    this.ensureCreated();
-
-    var propertyName = choice(Array.from(this.propertyNames));
-    if (!propertyName || chance(50)) {
-      propertyName = this.nameGen.generate();
-    }
-
-    return {
-      node: t.binaryExpression(
-        "in",
-        t.stringLiteral(propertyName),
-        t.identifier(this.objectName)
-      ),
-      value: this.propertyNames.has(propertyName),
-    };
-  }
-
-  createTruePredicate() {
-    var { node, value } = this.createPredicate();
-    if (value) {
-      return node;
-    }
-    return t.unaryExpression("!", node);
-  }
-
-  createFalsePredicate() {
-    var { node, value } = this.createPredicate();
-    if (!value) {
-      return node;
-    }
-    return t.unaryExpression("!", node);
-  }
-
-  private ensureCreated(node?: t.Node) {
-    if (!this.objectName) {
-      // Object hasn't been created yet
-      this.objectName = this.me.getPlaceholder() + "_controlObject";
-
-      if (node && t.isFunctionExpression(node) && !node.id) {
-        // Use function declaration as object
-
-        let newNode: t.FunctionDeclaration = node as any;
-        newNode.type = "FunctionDeclaration";
-        newNode.id = t.identifier(this.objectName);
-
-        let newPath = prepend(
-          this.blockPath,
-          newNode
-        )[0] as NodePath<t.FunctionDeclaration>;
-        this.me.skip(newPath);
-
-        this.objectPath = newPath;
-
-        return t.identifier(this.objectName);
-      } else {
-        // Create plain object
-        let newPath = prepend(
-          this.blockPath,
-          t.variableDeclaration("var", [
-            t.variableDeclarator(
-              t.identifier(this.objectName),
-              t.objectExpression([])
-            ),
-          ])
-        )[0] as NodePath<t.VariableDeclaration>;
-        this.me.skip(newPath);
-
-        this.objectPath = newPath;
-
-        var objectExpression = newPath.node.declarations[0]
-          .init as t.ObjectExpression;
-
-        this.objectExpression = objectExpression;
-        this.me.skip(this.objectExpression);
-      }
-    }
-  }
-
-  addProperty(node: t.Expression) {
-    var initialNode = this.ensureCreated(node);
-    if (initialNode) return initialNode;
-
-    const propertyName = this.nameGen.generate();
-    this.propertyNames.add(propertyName);
-
-    // Add an initial property
-    if (this.objectExpression) {
-      this.objectExpression.properties.push(
-        t.objectProperty(t.identifier(propertyName), node)
-      );
-    } else {
-      // Add as assignment expression
-
-      let assignment = t.assignmentExpression(
-        "=",
-        this.createMemberExpression(propertyName),
-        node
-      );
-
-      var newPath = this.objectPath.insertAfter(
-        t.expressionStatement(assignment)
-      )[0];
-      this.me.skip(newPath);
-    }
-
-    return this.createMemberExpression(propertyName);
-  }
-}