js-confuser 1.7.2 → 2.0.0-alpha.0

package/src/transforms/stack.ts

@@ -1,551 +0,0 @@
-import { ok } from "assert";
-import { ObfuscateOrder } from "../order";
-import { ComputeProbabilityMap } from "../probability";
-import Template, { ITemplate } from "../templates/template";
-import { walk } from "../traverse";
-import {
-  AssignmentExpression,
-  BinaryExpression,
-  CallExpression,
-  ExpressionStatement,
-  Identifier,
-  IfStatement,
-  Literal,
-  MemberExpression,
-  Node,
-  RestElement,
-  ReturnStatement,
-  SequenceExpression,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../util/gen";
-import { getIdentifierInfo } from "../util/identifiers";
-import {
-  computeFunctionLength,
-  getBlockBody,
-  getDefiningContext,
-  getReferencingContexts,
-  isForInitialize,
-  isFunction,
-  isVarContext,
-  prepend,
-} from "../util/insert";
-import { chance, choice, getRandomInteger } from "../util/random";
-import Transform from "./transform";
-import { noRenameVariablePrefix } from "../constants";
-import { FunctionLengthTemplate } from "../templates/functionLength";
-import { ObjectDefineProperty } from "../templates/globals";
-
-export default class Stack extends Transform {
-  mangledExpressionsMade: number;
-
-  functionLengthName: string;
-
-  constructor(o) {
-    super(o, ObfuscateOrder.Stack);
-
-    this.mangledExpressionsMade = 0;
-  }
-
-  match(object: Node, parents: Node[]) {
-    return (
-      isFunction(object) &&
-      !object.params.find((x) => x.type !== "Identifier") &&
-      object.body.type === "BlockStatement" &&
-      !parents.find((x) => x.$dispatcherSkip) &&
-      !object.$requiresEval
-    );
-  }
-
-  transform(object: Node, parents: Node[]) {
-    return () => {
-      // Uncaught SyntaxError: Getter must not have any formal parameters.
-      // Uncaught SyntaxError: Setter must have exactly one formal parameter
-      var propIndex = parents.findIndex(
-        (x) => x.type === "Property" || x.type === "MethodDefinition"
-      );
-      if (propIndex !== -1) {
-        if (parents[propIndex].value === (parents[propIndex - 1] || object)) {
-          if (parents[propIndex].kind !== "init" || parents[propIndex].method) {
-            return;
-          }
-        }
-      }
-
-      // Don't apply to functions with 'use strict' directive
-      if (getBlockBody(object.body)[0]?.directive) {
-        return;
-      }
-
-      if (!ComputeProbabilityMap(this.options.stack)) {
-        return;
-      }
-
-      var defined = new Set<string>();
-      var referenced = new Set<string>();
-      var illegal = new Set<string>();
-
-      /**
-       * Maps old names to new indices
-       */
-      var subscripts = new Map<string, string>();
-      var deadValues = Object.create(null);
-
-      var propertyGen = this.getGenerator();
-
-      function isTransformableFunction(functionNode: Node) {
-        if (functionNode.$requiresEval) return false;
-
-        // Check for 'this'
-        var isIllegal = false;
-        walk(functionNode.body, [], (o, p) => {
-          if (o.type === "ThisExpression") {
-            isIllegal = true;
-            return "EXIT";
-          }
-        });
-
-        return !isIllegal;
-      }
-
-      function setSubscript(string, index) {
-        subscripts.set(string, index + "");
-      }
-
-      object.params.forEach((param) => {
-        ok(param.name);
-        defined.add(param.name);
-
-        setSubscript(param.name, subscripts.size);
-      });
-
-      var startingSize = subscripts.size;
-      var isIllegal = false;
-
-      walk(object.body, [object, ...parents], (o, p) => {
-        if (o.type === "Identifier" && o.name === "arguments") {
-          isIllegal = true;
-          return "EXIT";
-        }
-
-        if (o.type == "Identifier") {
-          var info = getIdentifierInfo(o, p);
-          if (!info.spec.isReferenced || info.spec.isExported) {
-            return;
-          }
-
-          var c = info.spec.isDefined
-            ? getDefiningContext(o, p)
-            : getReferencingContexts(o, p).find((x) => isVarContext(x));
-
-          if (c !== object) {
-            // this.log(o.name + " is illegal due to different context");
-            illegal.add(o.name);
-          }
-
-          if (o.name.startsWith(noRenameVariablePrefix)) {
-            illegal.add(o.name);
-          }
-
-          if (
-            info.isClauseParameter ||
-            info.isFunctionParameter ||
-            isForInitialize(o, p)
-          ) {
-            // this.log(
-            //   o.name + " is illegal due to clause parameter/function parameter"
-            // );
-            illegal.add(o.name);
-          }
-          if (o.hidden) {
-            illegal.add(o.name);
-          }
-
-          if (info.spec.isDefined) {
-            if (defined.has(o.name)) {
-              illegal.add(o.name);
-            }
-
-            if (info.isFunctionDeclaration) {
-              ok(p[0].type === "FunctionDeclaration");
-              if (
-                p[0] !== object.body.body[0] ||
-                !isTransformableFunction(p[0])
-              ) {
-                illegal.add(o.name);
-              }
-            }
-
-            // The new accessors will either be numbered: [index] or as a string .string
-            var newSubscript = choice([
-              subscripts.size,
-              propertyGen.generate(),
-            ]);
-
-            setSubscript(o.name, newSubscript);
-            defined.add(o.name);
-
-            // Stack can only process single VariableDeclarations
-            var varIndex = p.findIndex((x) => x.type == "VariableDeclaration");
-
-            if (varIndex !== -1) {
-              // Invalid 'id' property (must be Identifier)
-              if (varIndex !== 2) {
-                illegal.add(o.name);
-              } else if (p[varIndex].declarations.length > 1) {
-                illegal.add(o.name);
-              } else {
-                var value = p[varIndex].declarations[0].init;
-                if (value && !isTransformableFunction(value)) {
-                  illegal.add(o.name);
-                }
-              }
-            }
-          } else if (info.spec.isReferenced) {
-            if (info.spec.isModified) {
-              var assignmentIndex = p.findIndex(
-                (x) => x.type === "AssignmentExpression"
-              );
-              if (assignmentIndex !== -1) {
-                var value = p[assignmentIndex].right;
-                if (value && !isTransformableFunction(value)) {
-                  illegal.add(o.name);
-                }
-              }
-            }
-
-            referenced.add(o.name);
-          }
-        }
-      });
-
-      if (isIllegal) return;
-
-      illegal.forEach((name) => {
-        defined.delete(name);
-        referenced.delete(name);
-        subscripts.delete(name);
-      });
-
-      referenced.forEach((name) => {
-        if (!defined.has(name)) {
-          subscripts.delete(name);
-        }
-      });
-
-      if (object.params.find((x) => illegal.has(x.name))) {
-        return;
-      }
-
-      if (!subscripts.size) {
-        return;
-      }
-
-      const numberLiteral = (number: number | string, depth = 0): Node => {
-        ok(number === number);
-        if (
-          typeof number !== "number" ||
-          !Object.keys(deadValues).length ||
-          depth > 4 ||
-          chance(75 + depth * 15 + this.mangledExpressionsMade / 25)
-        ) {
-          return Literal(number);
-        }
-        this.mangledExpressionsMade++;
-
-        var opposingIndex = choice(Object.keys(deadValues));
-        if (typeof opposingIndex === "undefined") {
-          return Literal(number);
-        }
-        var actualValue = deadValues[opposingIndex];
-
-        ok(typeof actualValue === "number");
-
-        return BinaryExpression(
-          "-",
-          MemberExpression(
-            Identifier(stackName),
-            numberLiteral(
-              isNaN(parseFloat(opposingIndex))
-                ? opposingIndex
-                : parseFloat(opposingIndex),
-              depth + 1
-            ),
-            true
-          ),
-          numberLiteral(actualValue - number, depth + 1)
-        );
-      };
-
-      function getMemberExpression(index) {
-        ok(typeof index === "string", typeof index);
-        return MemberExpression(
-          Identifier(stackName),
-          numberLiteral(isNaN(parseFloat(index)) ? index : parseFloat(index)),
-          true
-        );
-      }
-
-      var stackName = this.getPlaceholder() + "_stack";
-
-      const scan = (o, p) => {
-        if (o.type == "Identifier") {
-          var index = subscripts.get(o.name);
-          if (typeof index !== "undefined") {
-            var info = getIdentifierInfo(o, p);
-            if (!info.spec.isReferenced) {
-              return;
-            }
-
-            var member = getMemberExpression(index);
-
-            if (info.spec.isDefined) {
-              if (info.isVariableDeclaration) {
-                walk(p[2], p.slice(3), (oo, pp) => {
-                  if (oo != o) {
-                    return scan(oo, pp);
-                  }
-                });
-
-                this.replace(
-                  p[2],
-                  ExpressionStatement(
-                    AssignmentExpression(
-                      "=",
-                      member,
-                      p[0].init || Identifier("undefined")
-                    )
-                  )
-                );
-                return;
-              } else if (info.isFunctionDeclaration) {
-                walk(p[0], p.slice(1), (oo, pp) => {
-                  if (oo != o) {
-                    return scan(oo, pp);
-                  }
-                });
-
-                this.replace(
-                  p[0],
-                  ExpressionStatement(
-                    AssignmentExpression("=", member, {
-                      ...p[0],
-                      type: "FunctionExpression",
-                      id: null,
-                      expression: false,
-                    })
-                  )
-                );
-                return;
-              } else if (info.isClassDeclaration) {
-                walk(p[0], p.slice(1), (oo, pp) => {
-                  if (oo != o) {
-                    return scan(oo, pp);
-                  }
-                });
-
-                this.replace(
-                  p[0],
-                  ExpressionStatement(
-                    AssignmentExpression("=", member, {
-                      ...p[0],
-                      type: "ClassExpression",
-                    })
-                  )
-                );
-                return;
-              }
-            }
-
-            if (info.spec.isReferenced) {
-              this.replace(o, member);
-            }
-          }
-        }
-
-        if (
-          o.type == "Literal" &&
-          typeof o.value === "number" &&
-          Math.floor(o.value) === o.value &&
-          Math.abs(o.value) < 100_000 &&
-          p.find((x) => isFunction(x)) === object &&
-          chance(50)
-        ) {
-          return () => {
-            this.replaceIdentifierOrLiteral(o, numberLiteral(o.value, 0), p);
-          };
-        }
-      };
-
-      var rotateNodes: { [index: number]: Node } = Object.create(null);
-
-      object.body.body.forEach((stmt, index) => {
-        var isFirst = index == 0;
-
-        if (isFirst || chance(50 - index * 10)) {
-          var exprs = [];
-
-          var changes = getRandomInteger(1, 3);
-
-          for (var i = 0; i < changes; i++) {
-            var expr;
-            var type = choice(["set", "deadValue"]);
-
-            var valueSet = new Set([
-              ...Array.from(subscripts.values()),
-              ...Object.keys(deadValues),
-            ]);
-            var newIndex;
-            var i = 0;
-            do {
-              newIndex = choice([
-                propertyGen.generate(),
-                getRandomInteger(0, 250 + subscripts.size + i * 1000) + "",
-              ]);
-              i++;
-            } while (valueSet.has(newIndex));
-
-            switch (type) {
-              case "set":
-                var randomName = choice(Array.from(subscripts.keys()));
-                var currentIndex = subscripts.get(randomName);
-
-                expr = AssignmentExpression(
-                  "=",
-                  getMemberExpression(newIndex),
-                  getMemberExpression(currentIndex)
-                );
-
-                ok(
-                  typeof deadValues[newIndex] === "undefined",
-                  deadValues[newIndex]
-                );
-                setSubscript(randomName, newIndex);
-                break;
-
-              case "deadValue":
-                var rand = getRandomInteger(-150, 150);
-
-                // modify an already existing dead value index
-                if (chance(50)) {
-                  var alreadyExisting = choice(Object.keys(deadValues));
-
-                  if (typeof alreadyExisting === "string") {
-                    newIndex = alreadyExisting;
-                  }
-                }
-
-                expr = AssignmentExpression(
-                  "=",
-                  getMemberExpression(newIndex),
-                  numberLiteral(rand)
-                );
-
-                deadValues[newIndex] = rand;
-                break;
-            }
-
-            exprs.push(expr);
-          }
-          rotateNodes[index] = ExpressionStatement(SequenceExpression(exprs));
-        }
-
-        walk(
-          stmt,
-          [object.body.body, object.body, object, ...parents],
-          (o, p) => {
-            return scan(o, p);
-          }
-        );
-
-        if (stmt.type == "ReturnStatement") {
-          var opposing = choice(Object.keys(deadValues));
-          if (typeof opposing === "string") {
-            this.replace(
-              stmt,
-              IfStatement(
-                BinaryExpression(
-                  ">",
-                  getMemberExpression(opposing),
-                  numberLiteral(
-                    deadValues[opposing] + getRandomInteger(40, 140)
-                  )
-                ),
-                [
-                  ReturnStatement(
-                    getMemberExpression(getRandomInteger(-250, 250) + "")
-                  ),
-                ],
-                [ReturnStatement(stmt.argument)]
-              )
-            );
-          }
-        }
-      });
-
-      // Add in the rotation nodes
-      Object.keys(rotateNodes).forEach((index, i) => {
-        object.body.body.splice(parseInt(index) + i, 0, rotateNodes[index]);
-      });
-
-      // Preserve function.length property
-      var originalFunctionLength = computeFunctionLength(object.params);
-
-      // Set the params for this function to be the stack array
-      object.params = [RestElement(Identifier(stackName))];
-
-      // Ensure the array is correct length
-      prepend(
-        object.body,
-        Template(`${stackName}["length"] = ${startingSize}`).single()
-      );
-
-      if (this.options.preserveFunctionLength && originalFunctionLength !== 0) {
-        if (!this.functionLengthName) {
-          this.functionLengthName = this.getPlaceholder();
-          prepend(
-            parents[parents.length - 1] || object,
-            FunctionLengthTemplate.single({
-              name: this.functionLengthName,
-              ObjectDefineProperty: this.createInitVariable(
-                ObjectDefineProperty,
-                parents
-              ),
-            })
-          );
-        }
-
-        if (object.type === "FunctionDeclaration") {
-          var body = parents[0];
-          if (Array.isArray(body)) {
-            var index = body.indexOf(object);
-
-            body.splice(
-              index,
-              0,
-              ExpressionStatement(
-                CallExpression(Identifier(this.functionLengthName), [
-                  Identifier(object.id.name),
-                  Literal(originalFunctionLength),
-                ])
-              )
-            );
-          }
-        } else {
-          ok(
-            object.type === "FunctionExpression" ||
-              object.type === "ArrowFunctionExpression"
-          );
-
-          this.replace(
-            object,
-            CallExpression(Identifier(this.functionLengthName), [
-              { ...object },
-              Literal(originalFunctionLength),
-            ])
-          );
-        }
-      }
-    };
-  }
-}