js-confuser 1.5.8 → 1.6.0

package/src/transforms/hideInitializingCode.ts

@@ -1,432 +0,0 @@
-import { reservedIdentifiers } from "../constants";
-import { ObfuscateOrder } from "../order";
-import { walk } from "../traverse";
-import {
-  AssignmentExpression,
-  BinaryExpression,
-  BreakStatement,
-  CallExpression,
-  ConditionalExpression,
-  ExpressionStatement,
-  FunctionDeclaration,
-  FunctionExpression,
-  Identifier,
-  Literal,
-  MemberExpression,
-  ReturnStatement,
-  SequenceExpression,
-  SwitchCase,
-  SwitchStatement,
-  ThisExpression,
-  UnaryExpression,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../util/gen";
-import { getIdentifierInfo, validateChain } from "../util/identifiers";
-import { getVarContext, isForInitialize, isFunction } from "../util/insert";
-import { choice, getRandomInteger, shuffle } from "../util/random";
-import Transform from "./transform";
-
-export default class HideInitializingCode extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.HideInitializingCode);
-  }
-
-  match(object, parents) {
-    return object.type == "Program";
-  }
-
-  transform(object, parents) {
-    return () => {
-      var body = object.body;
-      var hasExport = false;
-
-      var stmts = [];
-      var functions = [];
-      var exportTypes = new Set([
-        "ExportNamedDeclaration",
-        "ExportSpecifier",
-        "ExportDefaultDeclaration",
-        "ExportAllDeclaration",
-      ]);
-
-      var sampledNames = new Set<string>();
-
-      body.forEach((stmt) => {
-        if (stmt.type == "FunctionDeclaration") {
-          functions.push(stmt);
-          if (stmt.id) {
-            sampledNames.add(stmt.id.name);
-          }
-        } else if (exportTypes.has(stmt.type)) {
-          hasExport = true;
-        } else {
-          stmts.push(stmt);
-        }
-      });
-
-      if (hasExport) {
-        return;
-      }
-
-      var definedNames = new Set<string>();
-
-      const findNames = (o, p) => {
-        validateChain(o, p);
-        var context = getVarContext(o, p);
-        walk(o, p, (oo, pp) => {
-          if (
-            oo.type == "Identifier" &&
-            !reservedIdentifiers.has(oo.name) &&
-            !this.options.globalVariables.has(oo.name)
-          ) {
-            var info = getIdentifierInfo(oo, pp);
-            if (
-              info.spec.isReferenced &&
-              info.spec.isDefined &&
-              getVarContext(oo, pp) === context
-            ) {
-              definedNames.add(oo.name);
-            }
-          }
-        });
-      };
-
-      walk(object, [], (o, p) => {
-        if (o.type == "VariableDeclaration" || o.type == "ClassDeclaration") {
-          if (p.find((x) => isFunction(x))) {
-            return;
-          }
-          if (o.type == "VariableDeclaration") {
-            return () => {
-              var exprs = [];
-              var fi = isForInitialize(o, p);
-              o.declarations.forEach((declarator) => {
-                findNames(declarator.id, [declarator, o.declarations, o, ...p]);
-                if (fi === "left-hand") {
-                  exprs.push({ ...declarator.id });
-                } else {
-                  exprs.push(
-                    AssignmentExpression(
-                      "=",
-                      declarator.id,
-                      declarator.init || Identifier("undefined")
-                    )
-                  );
-                }
-              });
-
-              if (fi) {
-                this.replace(
-                  o,
-                  exprs.length > 1 ? SequenceExpression(exprs) : exprs[0]
-                );
-              } else {
-                this.replace(o, ExpressionStatement(SequenceExpression(exprs)));
-              }
-            };
-          } else if (o.type == "ClassDeclaration") {
-            if (o.id.name) {
-              definedNames.add(o.id.name);
-
-              this.replace(
-                o,
-                ExpressionStatement(
-                  AssignmentExpression("=", Identifier(o.id.name), {
-                    ...o,
-                    type: "ClassExpression",
-                  })
-                )
-              );
-            }
-          }
-        }
-      });
-
-      var addNodes = [];
-      if (definedNames.size) {
-        addNodes.push(
-          VariableDeclaration(
-            Array.from(definedNames).map((name) => {
-              return VariableDeclarator(name);
-            })
-          )
-        );
-      }
-
-      var deadValues: { [name: string]: number } = Object.create(null);
-      Array(getRandomInteger(1, 20))
-        .fill(0)
-        .forEach(() => {
-          var name = this.getPlaceholder();
-          var value = getRandomInteger(-250, 250);
-          addNodes.push(
-            VariableDeclaration(VariableDeclarator(name, Literal(value)))
-          );
-
-          deadValues[name] = value;
-          sampledNames.add(name);
-        });
-
-      var map = new Map<string, { [input: number]: number }>();
-      var fnsToMake = getRandomInteger(1, 5);
-
-      var numberLiteralsMade = 1;
-      function numberLiteral(num: number, depth = 1) {
-        if (
-          depth > 6 ||
-          Math.random() > 0.8 / depth ||
-          Math.random() > 80 / numberLiteralsMade
-        ) {
-          return Literal(num);
-        }
-
-        numberLiteralsMade++;
-
-        function ternaryCall(
-          name: string,
-          param: number = getRandomInteger(-250, 250)
-        ) {
-          return ConditionalExpression(
-            BinaryExpression(
-              "==",
-              UnaryExpression("typeof", Identifier(name)),
-              Literal("function")
-            ),
-            CallExpression(Identifier(name), [numberLiteral(param, depth + 1)]),
-            Identifier(name)
-          );
-        }
-
-        if (Math.random() > 0.5) {
-          var fnName = choice(Array.from(map.keys()));
-          if (fnName) {
-            var inputOutputs = map.get(fnName);
-            var randomInput = choice(Object.keys(inputOutputs));
-            var outputValue = inputOutputs[randomInput];
-            var parsed = parseFloat(randomInput);
-
-            return BinaryExpression(
-              "-",
-
-              ternaryCall(fnName, parsed),
-              numberLiteral(outputValue - num, depth + 1)
-            );
-          }
-        }
-
-        var deadValueName = choice(Object.keys(deadValues));
-        var actualValue = deadValues[deadValueName];
-
-        if (Math.random() > 0.5) {
-          return BinaryExpression(
-            "+",
-            numberLiteral(num - actualValue, depth + 1),
-            ternaryCall(deadValueName)
-          );
-        }
-
-        return BinaryExpression(
-          "-",
-          ternaryCall(deadValueName),
-          numberLiteral(actualValue - num, depth + 1)
-        );
-      }
-
-      for (var i = 0; i < fnsToMake; i++) {
-        var name = this.getPlaceholder();
-        var testShift = getRandomInteger(-250, 250);
-        var returnShift = getRandomInteger(-250, 250);
-
-        var inputs = getRandomInteger(2, 5);
-        var used = new Set<number>();
-        var uniqueNumbersNeeded = inputs * 2;
-        for (var j = 0; j < uniqueNumbersNeeded; j++) {
-          var num;
-          var k = 0;
-          do {
-            num = getRandomInteger(-250, 250 + k * 100);
-            k++;
-          } while (used.has(num));
-
-          used.add(num);
-        }
-
-        var inputOutput = Object.create(null);
-        var array: number[] = Array.from(used);
-        for (var j = 0; j < array.length; j += 2) {
-          inputOutput[array[j]] = array[j + 1];
-        }
-
-        var cases = Object.keys(inputOutput).map((input) => {
-          var parsed = parseFloat(input);
-
-          return SwitchCase(numberLiteral(parsed + testShift), [
-            ExpressionStatement(
-              AssignmentExpression(
-                "=",
-                Identifier("input"),
-                numberLiteral(inputOutput[input] - returnShift)
-              )
-            ),
-            BreakStatement(),
-          ]);
-        });
-
-        var functionExpression = FunctionExpression(
-          [Identifier("testShift"), Identifier("returnShift")],
-          [
-            ReturnStatement(
-              FunctionExpression(
-                [Identifier("input")],
-                [
-                  SwitchStatement(
-                    BinaryExpression(
-                      "+",
-                      Identifier("input"),
-                      Identifier("testShift")
-                    ),
-                    cases
-                  ),
-
-                  ReturnStatement(
-                    BinaryExpression(
-                      "+",
-                      Identifier("input"),
-                      Identifier("returnShift")
-                    )
-                  ),
-                ]
-              )
-            ),
-          ]
-        );
-
-        var variableDeclaration = VariableDeclaration(
-          VariableDeclarator(
-            name,
-            CallExpression(functionExpression, [
-              numberLiteral(testShift),
-              numberLiteral(returnShift),
-            ])
-          )
-        );
-        addNodes.push(variableDeclaration);
-
-        map.set(name, inputOutput);
-        sampledNames.add(name);
-      }
-
-      var deadNameArray = Object.keys(deadValues);
-      var sampledArray = Array.from(sampledNames);
-
-      var check = getRandomInteger(-250, 250);
-
-      var initName = "init" + this.getPlaceholder();
-
-      // Entangle number literals
-      var made = 1; // Limit frequency
-      walk(stmts, [], (o, p) => {
-        if (
-          o.type == "Literal" &&
-          typeof o.value === "number" &&
-          Math.floor(o.value) === o.value &&
-          Math.abs(o.value) < 100_000 &&
-          Math.random() < 4 / made
-        ) {
-          made++;
-          return () => {
-            this.replaceIdentifierOrLiteral(o, numberLiteral(o.value), p);
-          };
-        }
-      });
-
-      // Create the new function
-      addNodes.push(FunctionDeclaration(initName, [], [...stmts]));
-
-      function truePredicate() {
-        return BinaryExpression(
-          ">",
-          Literal(600 + getRandomInteger(200, 800)),
-          Literal(400 - getRandomInteger(0, 600))
-        );
-      }
-      function falsePredicate() {
-        return BinaryExpression(
-          ">",
-          Literal(400 - getRandomInteger(0, 600)),
-          Literal(600 + getRandomInteger(200, 800))
-        );
-      }
-
-      function safeCallExpression(name, param: number) {
-        return ConditionalExpression(
-          BinaryExpression(
-            "==",
-            UnaryExpression("typeof", Identifier(name)),
-            Literal("function")
-          ),
-          CallExpression(
-            MemberExpression(Identifier(name), Identifier("call"), false),
-            [ThisExpression(), numberLiteral(param)]
-          ),
-          Identifier(name)
-        );
-      }
-
-      function ternaryHell(expr, depth = 1) {
-        if (!depth || depth > 5 || Math.random() > 0.99 / (depth / 2)) {
-          return expr;
-        }
-
-        var deadCode = safeCallExpression(
-          choice(sampledArray),
-          getRandomInteger(-250, 250)
-        );
-
-        if (Math.random() > 0.5) {
-          return ConditionalExpression(
-            truePredicate(),
-            ternaryHell(expr, depth + 1),
-            ternaryHell(deadCode, depth + 1)
-          );
-        }
-
-        return ConditionalExpression(
-          falsePredicate(),
-          ternaryHell(deadCode, depth + 1),
-          ternaryHell(expr, depth + 1)
-        );
-      }
-
-      // Array of random ternary expressions
-      var concealedCall = [];
-
-      // Add 'dead calls', these expression don't call anything
-      Array(getRandomInteger(2, 8))
-        .fill(0)
-        .forEach(() => {
-          concealedCall.push(
-            ExpressionStatement(
-              ternaryHell(
-                safeCallExpression(
-                  choice(deadNameArray),
-                  getRandomInteger(-250, 250)
-                )
-              )
-            )
-          );
-        });
-
-      // The real call to the 'init' function
-      concealedCall.push(
-        ExpressionStatement(ternaryHell(safeCallExpression(initName, check)))
-      );
-
-      shuffle(concealedCall);
-      shuffle(functions);
-
-      object.body = [...addNodes, ...functions, ...concealedCall];
-    };
-  }
-}

package/src/transforms/label.ts

@@ -1,64 +0,0 @@
-import Transform from "./transform";
-import { Identifier, LabeledStatement } from "../util/gen";
-import { walk } from "../traverse";
-import { clone } from "../util/insert";
-import { isLoop } from "../util/compare";
-
-/**
- * Ensures every break; statement has a label to point to.
- *
- * This is because Control Flow Flattening adds For Loops which label-less break statements point to the nearest,
- * when they actually need to point to the original statement.
- */
-export default class Label extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return (
-      isLoop(object) ||
-      (object.type == "BlockStatement" &&
-        parents[0] &&
-        parents[0].type == "LabeledStatement" &&
-        parents[0].body === object)
-    );
-  }
-
-  transform(object, parents) {
-    return () => {
-      var currentLabel =
-        parents[0].type == "LabeledStatement" && parents[0].label.name;
-
-      var label = currentLabel || this.getPlaceholder();
-
-      walk(object, parents, (o, p) => {
-        if (o.type == "BreakStatement" || o.type == "ContinueStatement") {
-          function isContinuableStatement(x) {
-            return isLoop(x) && x.type !== "SwitchStatement";
-          }
-          function isBreakableStatement(x) {
-            return isLoop(x) || (o.label && x.type == "BlockStatement");
-          }
-
-          var fn =
-            o.type == "ContinueStatement"
-              ? isContinuableStatement
-              : isBreakableStatement;
-
-          var loop = p.find(fn);
-          if (object == loop) {
-            if (!o.label) {
-              o.label = Identifier(label);
-            }
-          }
-        }
-      });
-
-      // Append label statement as this loop has none
-      if (!currentLabel) {
-        this.replace(object, LabeledStatement(label, { ...object }));
-      }
-    };
-  }
-}

package/src/transforms/preparation/nameConflicts.ts

@@ -1,102 +0,0 @@
-import { reservedIdentifiers } from "../../constants";
-import { Node } from "../../util/gen";
-import {
-  getDefiningIdentifier,
-  getIdentifierInfo,
-} from "../../util/identifiers";
-import Transform from "../transform";
-
-export class NameMappingAnalysis extends Transform {
-  names: Map<string, Set<Node>>;
-
-  constructor(o) {
-    super(o);
-
-    this.names = new Map();
-  }
-
-  match(object, parents) {
-    return object.type == "Identifier" && !reservedIdentifiers.has(object.name);
-  }
-
-  transform(object, parents) {
-    var info = getIdentifierInfo(object, parents);
-
-    if (info.spec.isReferenced && !info.spec.isDefined) {
-      object.$definedAt = getDefiningIdentifier(object, parents);
-    }
-
-    if (info.spec.isDefined) {
-      if (!this.names.has(object.name)) {
-        this.names.set(object.name, new Set([object]));
-      } else {
-        this.names.get(object.name).add(object);
-      }
-    }
-  }
-}
-
-/**
- * Renames variables & removes conflicts.
- *
- * - This helps transformations like `Dispatcher` not replace re-declared identifiers.
- */
-export default class NameConflicts extends Transform {
-  nameMappingAnalysis: NameMappingAnalysis;
-
-  changes: Map<Node, string>;
-  references: Map<Node, Set<Node>>;
-
-  constructor(o) {
-    super(o);
-
-    this.before.push((this.nameMappingAnalysis = new NameMappingAnalysis(o)));
-    this.changes = new Map();
-    this.references = new Map();
-  }
-
-  match(object, parents) {
-    return (
-      object.type == "Identifier" &&
-      !reservedIdentifiers.has(object.name) &&
-      !this.options.globalVariables.has(object.name)
-    );
-  }
-
-  transform(object: Node, parents: Node[]) {
-    var info = getIdentifierInfo(object, parents);
-
-    if (info.isMethodDefinition) {
-      return;
-    }
-
-    if (object.$definedAt) {
-      object.name = this.changes.get(object.$definedAt[0]) || object.name;
-
-      if (!this.references.has(object.$definedAt[0])) {
-        this.references.set(object.$definedAt[0], new Set([object]));
-      } else {
-        this.references.get(object.$definedAt[0]).add(object);
-      }
-    } else if (info.spec.isDefined) {
-      var set = this.nameMappingAnalysis.names.get(object.name);
-      if (set && set.size > 1) {
-        var index = Array.from(set).indexOf(object);
-
-        var newName = "_".repeat(index) + object.name;
-
-        if (index > 4 || this.nameMappingAnalysis.names.has(newName)) {
-          newName = this.getPlaceholder() + "_" + object.name;
-        }
-
-        object.name = newName;
-        this.changes.set(object, newName);
-        if (this.references.has(object)) {
-          this.references.get(object).forEach((ref) => {
-            ref.name = newName;
-          });
-        }
-      }
-    }
-  }
-}