js-confuser 1.7.3 → 2.0.0-alpha.0

package/dist/transforms/preparation.js

@@ -1,18 +1,21 @@
 "use strict";
 
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-var _transform = _interopRequireDefault(require("./transform"));
-var _gen = require("../util/gen");
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
 var _order = require("../order");
-var _insert = require("../util/insert");
-var _identifiers = require("../util/identifiers");
-var _compare = require("../util/compare");
-var _traverse = require("../traverse");
 var _constants = require("../constants");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _assert = require("assert");
+var _astUtils = require("../utils/ast-utils");
+var _functionUtils = require("../utils/function-utils");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /**
  * Preparation arranges the user's code into an AST the obfuscator can easily transform.
  *
@@ -27,184 +30,269 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * - `x => x * 2` -> `x => { return x * 2 }` // Change into Block Statements
  * - `if(true) return` -> `if (true) { return }`
  * - `while(a) a--;` -> `while(a) { a-- }`
- *
- * Label
- * - `for(...) { break; }` -> `_1: for(...) { break _1; }`
- * - `switch(v) { case 1...break }` -> `_2: switch(v) { case 1...break _2; }`
- * - // Control Flow Flattening can safely apply now
  */
-class Preparation extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.Preparation);
-  }
-  match(object, parents) {
-    return !!object.type;
-  }
-  transform(object, parents) {
-    // ExplicitIdentifiers
-    if (object.type === "Identifier") {
-      return this.transformExplicitIdentifiers(object, parents);
-    }
-
-    // __JS_CONFUSER_VAR__ - Remove when Rename Variables is disabled
-    if (object.type === "CallExpression" && object.callee.type === "Identifier" && object.callee.name === _constants.variableFunctionName) {
-      if (object.arguments[0].type === "Identifier") {
-        if (!this.obfuscator.transforms["RenameVariables"]) {
-          return () => {
-            this.replace(object, (0, _gen.Literal)(object.arguments[0].name));
-          };
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.Preparation);
+  var markFunctionUnsafe = function markFunctionUnsafe(path) {
+    var functionPath = path.findParent(function (path) {
+      return path.isFunction() || path.isProgram();
+    });
+    if (!functionPath) return;
+    var functionNode = functionPath.node;
+    functionNode[_constants.UNSAFE] = true;
+  };
+  return {
+    visitor: {
+      "ThisExpression|Super": {
+        exit: function exit(path) {
+          markFunctionUnsafe(path);
         }
-      }
-    }
+      },
+      // `Hello ${username}` -> "Hello " + username
+      TemplateLiteral: {
+        exit: function exit(path) {
+          // Check if this is a tagged template literal, if yes, skip it
+          if (t.isTaggedTemplateExpression(path.parent)) {
+            return;
+          }
+          var _path$node = path.node,
+            quasis = _path$node.quasis,
+            expressions = _path$node.expressions;
 
-    // ExplicitDeclarations
-    if (object.type === "VariableDeclaration") {
-      return this.transformExplicitDeclarations(object, parents);
-    }
+          // Start with the first quasi (template string part)
+          var binaryExpression = t.stringLiteral(quasis[0].value.cooked);
 
-    // Block
-    switch (object.type) {
-      /**
-       * People use shortcuts and its harder to parse.
-       *
-       * - `if (a) b()` -> `if (a) { b() }`
-       * - Ensures all bodies are `BlockStatement`, not individual expression statements
-       */
-      case "IfStatement":
-        if (object.consequent.type != "BlockStatement") {
-          object.consequent = (0, _gen.BlockStatement)([(0, _insert.clone)(object.consequent)]);
-        }
-        if (object.alternate && object.alternate.type != "BlockStatement") {
-          object.alternate = (0, _gen.BlockStatement)([(0, _insert.clone)(object.alternate)]);
-        }
-        break;
-      case "WhileStatement":
-      case "WithStatement":
-      case "ForStatement":
-      case "ForOfStatement":
-      case "ForInStatement":
-        if (object.body.type != "BlockStatement") {
-          object.body = (0, _gen.BlockStatement)([(0, _insert.clone)(object.body)]);
+          // Loop over the remaining quasis and expressions, concatenating them
+          for (var i = 0; i < expressions.length; i++) {
+            // Add the expression as part of the binary concatenation
+            binaryExpression = t.binaryExpression("+", binaryExpression, expressions[i]);
+
+            // Add the next quasi (template string part)
+            if (quasis[i + 1].value.cooked !== "") {
+              binaryExpression = t.binaryExpression("+", binaryExpression, t.stringLiteral(quasis[i + 1].value.cooked));
+            }
+          }
+
+          // Replace the template literal with the constructed binary expression
+          path.replaceWith(binaryExpression);
         }
-        break;
-      case "ArrowFunctionExpression":
-        if (object.body.type !== "BlockStatement" && object.expression) {
-          object.body = (0, _gen.BlockStatement)([(0, _gen.ReturnStatement)((0, _insert.clone)(object.body))]);
-          object.expression = false;
+      },
+      // /Hello World/g -> new RegExp("Hello World", "g")
+      RegExpLiteral: {
+        exit: function exit(path) {
+          var _path$node2 = path.node,
+            pattern = _path$node2.pattern,
+            flags = _path$node2.flags;
+
+          // Create a new RegExp() expression using the pattern and flags
+          var newRegExpCall = t.newExpression(t.identifier("RegExp"),
+          // Identifier for RegExp constructor
+          [t.stringLiteral(pattern),
+          // First argument: the pattern (no extra escaping needed)
+          flags ? t.stringLiteral(flags) : t.stringLiteral("") // Second argument: the flags (if any)
+          ]);
+
+          // Replace the literal regex with the new RegExp() call
+          path.replaceWith(newRegExpCall);
         }
-        break;
-    }
+      },
+      ReferencedIdentifier: {
+        exit: function exit(path) {
+          var name = path.node.name;
+          if (["arguments", "eval"].includes(name)) {
+            markFunctionUnsafe(path);
+          }
 
-    // Label
-    if ((0, _compare.isLoop)(object) || object.type == "BlockStatement" && parents[0] && parents[0].type == "LabeledStatement" && parents[0].body === object) {
-      return this.transformLabel(object, parents);
-    }
-  }
+          // When Rename Variables is disabled, __JS_CONFUSER_VAR__ must still be removed
+          if (!me.obfuscator.hasPlugin(_order.Order.RenameVariables) && (0, _functionUtils.isVariableFunctionIdentifier)(path)) {
+            (0, _assert.ok)(path.parentPath.isCallExpression(), _constants.variableFunctionName + " must be directly called");
+            var argument = path.parentPath.node.arguments[0];
+            t.assertIdentifier(argument);
+
+            // Remove the variableFunctionName call
+            path.parentPath.replaceWith(t.stringLiteral(argument.name));
+          }
+        }
+      },
+      FunctionDeclaration: {
+        exit: function exit(path) {
+          // A function is 'predictable' if the parameter lengths are guaranteed to be known
+          // a(true) -> predictable
+          // (a || b)(true) -> unpredictable (Must be directly in a Call Expression)
+          // a(...args) -> unpredictable (Cannot use SpreadElement)
 
-  /**
-   * 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.
-   */
-  transformLabel(object, parents) {
-    return () => {
-      var currentLabel = parents[0].type == "LabeledStatement" && parents[0].label.name;
-      var label = currentLabel || this.getPlaceholder();
-      (0, _traverse.walk)(object, parents, (o, p) => {
-        if (o.type == "BreakStatement" || o.type == "ContinueStatement") {
-          function isContinuableStatement(x) {
-            return (0, _compare.isLoop)(x) && x.type !== "SwitchStatement";
+          var name = path.node.id.name;
+          var binding = path.scope.getBinding(name);
+          var predictable = true;
+          var maxArgLength = 0;
+          var _iterator = _createForOfIteratorHelper(binding.referencePaths),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var referencePath = _step.value;
+              if (!referencePath.parentPath.isCallExpression()) {
+                predictable = false;
+                break;
+              }
+              var argsPath = referencePath.parentPath.get("arguments");
+              var _iterator2 = _createForOfIteratorHelper(argsPath),
+                _step2;
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  var arg = _step2.value;
+                  if (arg.isSpreadElement()) {
+                    predictable = false;
+                    break;
+                  }
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+              if (argsPath.length > maxArgLength) {
+                maxArgLength = argsPath.length;
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          var definedArgLength = path.get("params").length;
+          if (predictable && definedArgLength >= maxArgLength) {
+            path.node[_constants.PREDICTABLE] = true;
+          }
+        }
+      },
+      // console.log() -> console["log"]();
+      MemberExpression: {
+        exit: function exit(path) {
+          if (!path.node.computed && path.node.property.type === "Identifier") {
+            path.node.property = t.stringLiteral(path.node.property.name);
+            path.node.computed = true;
           }
-          function isBreakableStatement(x) {
-            return (0, _compare.isLoop)(x) || o.label && x.type == "BlockStatement";
+        }
+      },
+      // { key: true } -> { "key": true }
+      "Property|Method": {
+        exit: function exit(_path) {
+          var path = _path;
+          if (t.isClassPrivateProperty(path.node)) return;
+          if (!path.node.computed && path.node.key.type === "Identifier") {
+            // Don't change constructor key
+            if (t.isClassMethod(path.node) && path.node.kind === "constructor") return;
+            path.node.key = t.stringLiteral(path.node.key.name);
+            path.node.computed = true;
           }
-          var fn = o.type == "ContinueStatement" ? isContinuableStatement : isBreakableStatement;
-          var loop = p.find(fn);
-          if (object == loop) {
-            if (!o.label) {
-              o.label = (0, _gen.Identifier)(label);
+        }
+      },
+      // var a,b,c -> var a; var b; var c;
+      VariableDeclaration: {
+        exit: function exit(path) {
+          if (path.node.declarations.length > 1) {
+            // E.g. for (var i = 0, j = 1;;)
+            if (path.key === "init" && path.parentPath.isForStatement()) {
+              if (!path.parentPath.node.test && !path.parentPath.node.update && path.node.kind === "var") {
+                path.parentPath.insertBefore(path.node.declarations.map(function (declaration) {
+                  return t.variableDeclaration(path.node.kind, [declaration]);
+                }));
+                path.remove();
+              }
+            } else {
+              if (path.parentPath.isExportNamedDeclaration()) {
+                path.parentPath.replaceWithMultiple(path.node.declarations.map(function (declaration) {
+                  return t.exportNamedDeclaration(t.variableDeclaration(path.node.kind, [declaration]));
+                }));
+              } else {
+                path.replaceWithMultiple(path.node.declarations.map(function (declaration, i) {
+                  var names = Array.from((0, _astUtils.getPatternIdentifierNames)(path.get("declarations")[i]));
+                  names.forEach(function (name) {
+                    path.scope.removeBinding(name);
+                  });
+                  var newNode = t.variableDeclaration(path.node.kind, [declaration]);
+                  return newNode;
+                })).forEach(function (newPath) {
+                  if (newPath.node.kind === "var") {
+                    var functionOrProgram = (0, _astUtils.getParentFunctionOrProgram)(newPath);
+                    functionOrProgram.scope.registerDeclaration(newPath);
+                  }
+                  newPath.scope.registerDeclaration(newPath);
+                });
+              }
             }
           }
         }
-      });
-
-      // Append label statement as this loop has none
-      if (!currentLabel) {
-        this.replace(object, (0, _gen.LabeledStatement)(label, {
-          ...object
-        }));
-      }
-    };
-  }
-
-  /**
-   * Transforms Identifiers (a.IDENTIFIER, {IDENTIFIER:...}) into string properties
-   */
-  transformExplicitIdentifiers(object, parents) {
-    // Mark functions containing 'eval'
-    // Some transformations avoid functions that have 'eval' to not break them
-    if (object.name === "eval") {
-      var fn = (0, _insert.getFunction)(object, parents);
-      if (fn) {
-        fn.$requiresEval = true;
-      }
-    }
-    var info = (0, _identifiers.getIdentifierInfo)(object, parents);
-    if (info.isPropertyKey || info.isAccessor) {
-      var propIndex = parents.findIndex(x => x.type == "MethodDefinition" || x.type == "Property");
-
-      // Don't change constructor!
-      if (propIndex !== -1) {
-        if (parents[propIndex].type == "MethodDefinition" && parents[propIndex].kind == "constructor") {
-          return;
+      },
+      // () => a() -> () => { return a(); }
+      ArrowFunctionExpression: {
+        exit: function exit(path) {
+          if (path.node.body.type !== "BlockStatement") {
+            path.node.expression = false;
+            path.node.body = t.blockStatement([t.returnStatement(path.node.body)]);
+          }
+        }
+      },
+      // if (a) b() -> if (a) { b(); }
+      // if (a) {b()} else c() -> if (a) { b(); } else { c(); }
+      IfStatement: {
+        exit: function exit(path) {
+          if (path.node.consequent.type !== "BlockStatement") {
+            path.node.consequent = t.blockStatement([path.node.consequent]);
+          }
+          if (path.node.alternate && path.node.alternate.type !== "BlockStatement") {
+            path.node.alternate = t.blockStatement([path.node.alternate]);
+          }
+        }
+      },
+      // for() d() -> for() { d(); }
+      // while(a) b() -> while(a) { b(); }
+      // with(a) b() -> with(a) { b(); }
+      "ForStatement|ForInStatement|ForOfStatement|WhileStatement|WithStatement": {
+        exit: function exit(_path) {
+          var path = _path;
+          if (path.node.body.type !== "BlockStatement") {
+            path.node.body = t.blockStatement([path.node.body]);
+          }
+        }
+      },
+      // function a(param = ()=>b)
+      // _getB = ()=> ()=>b
+      // function a(param = _getB())
+      // Basically Babel scope.rename misses this edge case, so we need to manually handle it
+      // Here were essentially making the variables easier to understand
+      Function: {
+        exit: function exit(path) {
+          var _iterator3 = _createForOfIteratorHelper(path.get("params")),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var param = _step3.value;
+              param.traverse({
+                "FunctionExpression|ArrowFunctionExpression": function FunctionExpressionArrowFunctionExpression(_innerPath) {
+                  var innerPath = _innerPath;
+                  var child = innerPath.find(function (path) {
+                    var _path$parentPath;
+                    return (_path$parentPath = path.parentPath) === null || _path$parentPath === void 0 ? void 0 : _path$parentPath.isAssignmentPattern();
+                  });
+                  if (!child) return;
+                  if (t.isAssignmentPattern(child.parent) && child.parent.right === child.node) {
+                    var creatorName = me.getPlaceholder();
+                    var insertPath = path.insertBefore(t.variableDeclaration("const", [t.variableDeclarator(t.identifier(creatorName), t.arrowFunctionExpression([], innerPath.node, false))]))[0];
+                    path.scope.parent.registerDeclaration(insertPath);
+                    innerPath.replaceWith(t.callExpression(t.identifier(creatorName), []));
+                  }
+                }
+              });
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
         }
       }
-      this.replace(object, (0, _gen.Literal)(object.name));
-      parents[0].computed = true;
-      parents[0].shorthand = false;
-    }
-  }
-
-  /**
-   * Transforms VariableDeclaration into single declarations.
-   */
-  transformExplicitDeclarations(object, parents) {
-    // for ( var x in ... ) {...}
-    var forIndex = parents.findIndex(x => x.type == "ForInStatement" || x.type == "ForOfStatement");
-    if (forIndex != -1 && parents[forIndex].left == (parents[forIndex - 1] || object)) {
-      object.declarations.forEach(x => {
-        x.init = null;
-      });
-      return;
-    }
-    var body = parents[0];
-    if ((0, _compare.isLoop)(body) || body.type == "LabeledStatement") {
-      return;
-    }
-    if (body.type == "ExportNamedDeclaration") {
-      return;
-    }
-    if (!Array.isArray(body)) {
-      this.error(new Error("body is " + body.type));
-    }
-    if (object.declarations.length > 1) {
-      // Make singular
-
-      var index = body.indexOf(object);
-      if (index == -1) {
-        this.error(new Error("index is -1"));
-      }
-      var after = object.declarations.slice(1);
-      body.splice(index + 1, 0, ...after.map(x => {
-        return {
-          type: "VariableDeclaration",
-          declarations: [(0, _insert.clone)(x)],
-          kind: object.kind
-        };
-      }));
-      object.declarations.length = 1;
     }
-  }
-}
-exports.default = Preparation;
+  };
+};