js-confuser 1.2.2 → 1.4.2

package/src/transforms/hideInitializingCode.ts

@@ -1,425 +1,432 @@
-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);
-
-      function numberLiteral(num: number, depth = 1) {
-        if (depth > 6 || Math.random() > 0.8 / depth) {
-          return Literal(num);
-        }
-
-        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];
-    };
-  }
-}
+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];
+    };
+  }
+}