js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/transforms/extraction/objectExtraction.js

@@ -1,242 +1,158 @@
 "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 _traverse = require("../../traverse");
-var _gen = require("../../util/gen");
-var _insert = require("../../util/insert");
+exports["default"] = void 0;
 var _order = require("../../order");
-var _identifiers = require("../../util/identifiers");
-var _compare = require("../../util/compare");
+var t = _interopRequireWildcard(require("@babel/types"));
+var _astUtils = require("../../utils/ast-utils");
 var _probability = require("../../probability");
-var _assert = require("assert");
-var _guard = require("../../util/guard");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * Extracts keys out of an object if possible.
- * ```js
- * // Input
- * var utils = {
- *   isString: x=>typeof x === "string",
- *   isBoolean: x=>typeof x === "boolean"
- * }
- * if ( utils.isString("Hello") ) {
- *   ...
- * }
- *
- * // Output
- * var utils_isString = x=>typeof x === "string";
- * var utils_isBoolean = x=>typeof x === "boolean"
- *
- * if ( utils_isString("Hello") ) {
- *   ...
- * }
- * ```
- */
-class ObjectExtraction extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.ObjectExtraction);
-  }
-  match(object, parents) {
-    return (0, _insert.isVarContext)(object);
-  }
-  transform(context, contextParents) {
-    // ObjectExpression Extractor
+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; }
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.ObjectExtraction, {
+    changeData: {
+      objects: 0
+    }
+  });
+  return {
+    visitor: {
+      Program: {
+        enter: function enter(path) {
+          path.scope.crawl();
+        }
+      },
+      VariableDeclaration: function VariableDeclaration(varDecPath) {
+        if (varDecPath.node.declarations.length !== 1) return;
+        var declaration = varDecPath.get("declarations.0");
 
-    return () => {
-      // First pass through to find the maps
-      var objectDefs = Object.create(null);
-      var objectDefiningIdentifiers = Object.create(null);
-      var illegal = new Set();
-      (0, _traverse.walk)(context, contextParents, (object, parents) => {
-        if (object.type == "ObjectExpression") {
-          // this.log(object, parents);
-          if (parents[0].type == "VariableDeclarator" && parents[0].init == object && parents[0].id.type == "Identifier") {
-            var name = parents[0].id.name;
-            if (name) {
-              if ((0, _insert.getVarContext)(object, parents) != context) {
-                illegal.add(name);
-                return;
-              }
-              if (!object.properties.length) {
-                illegal.add(name);
-                return;
-              }
+        // Must be simple variable declaration (No destructuring)
+        var identifier = declaration.get("id");
+        if (!identifier.isIdentifier()) return;
 
-              // duplicate name
-              if (objectDefiningIdentifiers[name]) {
-                illegal.add(name);
-                return;
-              }
+        // Must be an object expression
+        var objectExpression = declaration.get("init");
+        if (!objectExpression.isObjectExpression()) return;
+
+        // Not allowed to reassign the object
+        var binding = varDecPath.scope.getBinding(identifier.node.name);
+        if (!binding || binding.constantViolations.length > 0) return;
+        var pendingReplacements = [];
+        var newObjectName = me.getPlaceholder() + "_" + identifier.node.name;
+        var newPropertyMappings = new Map();
+
+        // Create new property names from the original object properties
+        var newDeclarations = [];
+        var _iterator = _createForOfIteratorHelper(objectExpression.get("properties")),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var property = _step.value;
+            if (!property.isObjectProperty()) return;
+            var propertyKey = (0, _astUtils.getObjectPropertyAsString)(property.node);
+            if (!propertyKey) {
+              // Property key is not a static string, not allowed
+              return;
+            }
+            var newPropertyName = newPropertyMappings.get(propertyKey);
+            if (newPropertyName) {
+              // Duplicate property, not allowed
+              return;
+            } else {
+              newPropertyName = newObjectName + "_" + (t.isValidIdentifier(propertyKey) ? propertyKey : me.getPlaceholder());
+              newPropertyMappings.set(propertyKey, newPropertyName);
+            }
 
-              // check for computed properties
-              // Change String literals to non-computed
-              object.properties.forEach(prop => {
-                if (prop.computed && (0, _guard.isStringLiteral)(prop.key)) {
-                  prop.computed = false;
+            // Check function for referencing 'this'
+            var value = property.get("value");
+            if (value.isFunction()) {
+              var referencesThis = false;
+              value.traverse({
+                ThisExpression: function ThisExpression(thisPath) {
+                  referencesThis = true;
                 }
               });
-              var nonInitOrComputed = object.properties.find(x => x.kind !== "init" || x.computed);
-              if (nonInitOrComputed) {
-                if (nonInitOrComputed.key) {
-                  this.log(name + " has non-init/computed property: " + nonInitOrComputed.key.name || nonInitOrComputed.key.value);
-                } else {
-                  this.log(name + " has spread-element or other type of property");
-                }
-                illegal.add(name);
+              if (referencesThis) {
+                // Function references 'this', not allowed
+                // When extracted, this will not refer to the original object
                 return;
-              } else {
-                var illegalName = object.properties.map(x => x.computed ? x.key.value : x.key.name || x.key.value).find(x => !x || !(0, _compare.isValidIdentifier)(x));
-                if (illegalName) {
-                  this.log(name + " has an illegal property '" + illegalName + "'");
-                  illegal.add(name);
-                  return;
-                } else {
-                  var isIllegal = false;
-                  (0, _traverse.walk)(object, parents, (o, p) => {
-                    if (o.type == "ThisExpression" || o.type == "Super") {
-                      isIllegal = true;
-                      return "EXIT";
-                    }
-                  });
-                  if (isIllegal) {
-                    illegal.add(name);
-                    return;
-                  }
-                  objectDefs[name] = [object, parents];
-                  objectDefiningIdentifiers[name] = [parents[0].id, [...parents]];
-                }
               }
             }
+            newDeclarations.push(t.variableDeclarator(t.identifier(newPropertyName), value.node));
           }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
         }
-      });
-      illegal.forEach(name => {
-        delete objectDefs[name];
-        delete objectDefiningIdentifiers[name];
-      });
+        var isObjectSafe = true;
+        (0, _astUtils.getParentFunctionOrProgram)(varDecPath).traverse({
+          Identifier: {
+            exit: function exit(idPath) {
+              if (idPath.node.name !== identifier.node.name) return;
+              if (idPath === identifier) return; // Skip the original declaration
 
-      // this.log("object defs", objectDefs);
-      // huge map of changes
-      var objectDefChanges = {};
-      if (Object.keys(objectDefs).length) {
-        // A second pass through is only required when extracting object keys
+              var memberExpression = idPath.parentPath;
+              if (!memberExpression || !memberExpression.isMemberExpression()) {
+                isObjectSafe = false;
+                return;
+              }
+              var property = (0, _astUtils.getMemberExpressionPropertyAsString)(memberExpression.node);
+              if (!property) {
+                isObjectSafe = false;
+                return;
+              }
 
-        // Second pass through the exclude the dynamic map (counting keys, re-assigning)
-        (0, _traverse.walk)(context, contextParents, (object, parents) => {
-          if (object.type == "Identifier") {
-            var info = (0, _identifiers.getIdentifierInfo)(object, parents);
-            if (!info.spec.isReferenced) {
-              return;
-            }
-            var def = objectDefs[object.name];
-            if (def) {
-              var isIllegal = false;
-              if (info.spec.isDefined) {
-                if (objectDefiningIdentifiers[object.name][0] !== object) {
-                  this.log(object.name, "you can't redefine the object");
-                  isIllegal = true;
-                }
-              } else {
-                var isMemberExpression = parents[0].type == "MemberExpression" && parents[0].object == object;
-                if (parents.find(x => x.type == "AssignmentExpression") && !isMemberExpression || parents.find(x => x.type == "UnaryExpression" && x.operator == "delete")) {
-                  this.log(object.name, "you can't re-assign the object");
-                  isIllegal = true;
-                } else if (isMemberExpression) {
-                  var key = parents[0].property.value || parents[0].property.name;
-                  if (parents[0].computed && parents[0].property.type !== "Literal") {
-                    this.log(object.name, "object[expr] detected, only object['key'] is allowed");
-                    isIllegal = true;
-                  } else if (!parents[0].computed && parents[0].property.type !== "Identifier") {
-                    this.log(object.name, "object.<expr> detected, only object.key is allowed");
-                    isIllegal = true;
-                  } else if (!key || !def[0].properties.some(x => (x.key.value || x.key.name) == key)) {
-                    // check if initialized property
-                    // not in initialized object.
-                    this.log(object.name, "not in initialized object.", def[0].properties, key);
-                    isIllegal = true;
-                  }
-                  if (!isIllegal && key) {
-                    // allowed.
-                    // start the array if first time
-                    if (!objectDefChanges[object.name]) {
-                      objectDefChanges[object.name] = [];
-                    }
-                    // add to array
-                    objectDefChanges[object.name].push({
-                      key: key,
-                      object: object,
-                      parents: parents
-                    });
-                  }
-                } else {
-                  this.log(object.name, "you must access a property on the when referring to the identifier (accessors must be hard-coded literals), parent is " + parents[0].type);
-                  isIllegal = true;
-                }
+              // Delete expression check
+              if (memberExpression.parentPath.isUnaryExpression({
+                operator: "delete"
+              })) {
+                // Deleting object properties is not allowed
+                isObjectSafe = false;
+                return;
               }
-              if (isIllegal) {
-                // this is illegal, delete it from being moved and delete accessor changes from happening
-                this.log(object.name + " is illegal");
-                delete objectDefs[object.name];
-                delete objectDefChanges[object.name];
+              var newPropertyName = newPropertyMappings.get(property);
+              if (!newPropertyName) {
+                // Property added later on, not allowed
+                isObjectSafe = false;
+                return;
               }
+              var extractedIdentifier = t.identifier(newPropertyName);
+              pendingReplacements.push({
+                path: memberExpression,
+                replaceWith: extractedIdentifier
+              });
             }
           }
         });
-        Object.keys(objectDefs).forEach(name => {
-          if (!(0, _probability.ComputeProbabilityMap)(this.options.objectExtraction, x => x, name)) {
-            //continue;
-            return;
-          }
-          var [object, parents] = objectDefs[name];
-          var declarator = parents[0];
-          var declaration = parents[2];
-          (0, _assert.ok)(declarator.type === "VariableDeclarator");
-          (0, _assert.ok)(declaration.type === "VariableDeclaration");
-          var properties = object.properties;
-          // change the prop names while extracting
-          var newPropNames = {};
-          var variableDeclarators = [];
-          properties.forEach(property => {
-            var keyName = property.key.name || property.key.value;
-            var nn = name + "_" + keyName;
-            newPropNames[keyName] = nn;
-            var v = property.value;
-            variableDeclarators.push((0, _gen.VariableDeclarator)(nn, this.addComment(v, `${name}.${keyName}`)));
-          });
-          declaration.declarations.splice(declaration.declarations.indexOf(declarator), 1, ...variableDeclarators);
-
-          // const can only be safely changed to let
-          if (declaration.kind === "const") {
-            declaration.kind = "let";
-          }
 
-          // update all identifiers that pointed to the old object
-          objectDefChanges[name] && objectDefChanges[name].forEach(change => {
-            if (!change.key) {
-              this.error(new Error("key is undefined"));
-            }
-            if (newPropNames[change.key]) {
-              var memberExpression = change.parents[0];
-              if (memberExpression.type == "MemberExpression") {
-                this.replace(memberExpression, this.addComment((0, _gen.Identifier)(newPropNames[change.key]), `Original Accessor: ${name}.${change.key}`));
-              } else {
-                // Provide error with more information:
-                console.log(memberExpression);
-                this.error(new Error(`should be MemberExpression, found type=${memberExpression.type}`));
-              }
-            } else {
-              console.log(objectDefChanges[name], newPropNames);
-              this.error(new Error(`"${change.key}" not found in [${Object.keys(newPropNames).join(", ")}] while flattening ${name}.`));
-            }
-          });
-          this.log(`Extracted ${Object.keys(newPropNames).length} properties from ${name}, affecting ${Object.keys(objectDefChanges[name] || {}).length} line(s) of code.`);
+        // Object references are too complex to safely extract
+        if (!isObjectSafe) return;
+        if (!(0, _probability.computeProbabilityMap)(me.options.objectExtraction, identifier.node.name)) return;
+        var newDeclarationKind = varDecPath.node.kind === "const" ? "let" : varDecPath.node.kind;
+        varDecPath.replaceWithMultiple(newDeclarations.map(function (declaration) {
+          return t.variableDeclaration(newDeclarationKind, [declaration]);
+        })).forEach(function (path) {
+          // Make sure to register the new declarations
+          path.scope.registerDeclaration(path);
         });
+
+        // Replace all references to new singular identifiers
+        for (var _i = 0, _pendingReplacements = pendingReplacements; _i < _pendingReplacements.length; _i++) {
+          var _pendingReplacements$ = _pendingReplacements[_i],
+            path = _pendingReplacements$.path,
+            replaceWith = _pendingReplacements$.replaceWith;
+          path.replaceWith(replaceWith);
+        }
+        me.log("Extracted object", identifier.node.name);
+        me.changeData.objects++;
       }
-    };
-  }
-}
-exports.default = ObjectExtraction;
+    }
+  };
+};

package/dist/transforms/finalizer.js

@@ -3,66 +3,63 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
 var _order = require("../order");
-var _gen = require("../util/gen");
 var _stringEncoding = _interopRequireDefault(require("./string/stringEncoding"));
-var _transform = _interopRequireDefault(require("./transform"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _constants = require("../constants");
+var _assert = require("assert");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+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 _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); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * The Finalizer is the last transformation before the code is ready to be generated.
- *
- * Hexadecimal numbers:
- * - Convert integer literals into `Identifier` nodes with the name being a hexadecimal number
- *
- * BigInt support:
- * - Convert BigInt literals into `Identifier` nodes with the name being the raw BigInt string value + "n"
- *
- * String Encoding:
- * - Convert String literals into `Identifier` nodes with the name being a unicode escaped string
- */
-class Finalizer extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.Finalizer);
-    _defineProperty(this, "stringEncoding", void 0);
-    this.stringEncoding = new _stringEncoding.default(o);
-  }
-  isNumberLiteral(object) {
-    return object.type === "Literal" && typeof object.value === "number" && Math.floor(object.value) === object.value;
-  }
-  isBigIntLiteral(object) {
-    return object.type === "Literal" && typeof object.value === "bigint";
-  }
-  match(object, parents) {
-    return object.type === "Literal";
-  }
-  transform(object, parents) {
-    // Hexadecimal Numbers
-    if (this.options.hexadecimalNumbers && this.isNumberLiteral(object)) {
-      return () => {
-        // Technically, a Literal will never be negative because it's supposed to be inside a UnaryExpression with a "-" operator.
-        // This code handles it regardless
-        var isNegative = object.value < 0;
-        var hex = Math.abs(object.value).toString(16);
-        var newStr = (isNegative ? "-" : "") + "0x" + hex;
-        this.replace(object, (0, _gen.Identifier)(newStr));
-      };
-    }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.Finalizer);
+  var stringEncodingPlugin = (0, _stringEncoding["default"])(me);
+  return {
+    visitor: _objectSpread(_objectSpread(_objectSpread({}, stringEncodingPlugin.visitor), me.obfuscator.hasPlugin(_order.Order.RenameVariables) ? {} : {
+      CallExpression: {
+        exit: function exit(path) {
+          if (path.get("callee").isIdentifier({
+            name: _constants.variableFunctionName
+          })) {
+            var args = path.get("arguments");
+            (0, _assert.ok)(args.length === 1);
+            var arg = args[0];
+            (0, _assert.ok)(arg.isIdentifier());
+            var name = arg.node.name;
+            path.replaceWith(t.stringLiteral(name));
+          }
+        }
+      }
+    }), {}, {
+      // Hexadecimal numbers
+      NumberLiteral: {
+        exit: function exit(path) {
+          if (me.options.hexadecimalNumbers) {
+            var value = path.node.value;
+            if (Number.isNaN(value) || !Number.isFinite(value) || Math.floor(value) !== value) {
+              return;
+            }
 
-    // BigInt support
-    if (this.isBigIntLiteral(object)) {
-      // https://github.com/MichaelXF/js-confuser/issues/79
-      return () => {
-        // Use an Identifier with the raw string
-        this.replace(object, (0, _gen.Identifier)(object.raw));
-      };
-    }
-    if (this.options.stringEncoding && this.stringEncoding.match(object, parents)) {
-      return this.stringEncoding.transform(object, parents);
-    }
-  }
-}
-exports.default = Finalizer;
+            // Technically, a Literal will never be negative because it's supposed to be inside a UnaryExpression with a "-" operator.
+            // This code handles it regardless
+            var isNegative = value < 0;
+            var hex = Math.abs(value).toString(16);
+            var newStr = (isNegative ? "-" : "") + "0x" + hex;
+            var id = t.identifier(newStr);
+            id[_constants.GEN_NODE] = true;
+            path.replaceWith(id);
+            path.skip();
+          }
+        }
+      }
+    })
+  };
+};