js-confuser 1.7.2 → 2.0.0-alpha.0

package/src/transforms/extraction/objectExtraction.ts

@@ -1,360 +1,187 @@
-import Transform from "../transform";
-import { walk } from "../../traverse";
-import { Node, Location, Identifier, VariableDeclarator } from "../../util/gen";
-import { getVarContext, isVarContext } from "../../util/insert";
-import { ObfuscateOrder } from "../../order";
-import { getIdentifierInfo } from "../../util/identifiers";
-import { isValidIdentifier } from "../../util/compare";
-import { ComputeProbabilityMap } from "../../probability";
-import { ok } from "assert";
-import { isStringLiteral } from "../../util/guard";
+import { NodePath } from "@babel/core";
+import { PluginArg, PluginObject } from "../plugin";
+import { Order } from "../../order";
+import * as t from "@babel/types";
+import {
+  getMemberExpressionPropertyAsString,
+  getObjectPropertyAsString,
+  getParentFunctionOrProgram,
+} from "../../utils/ast-utils";
+import { computeProbabilityMap } from "../../probability";
+
+export default ({ Plugin }: PluginArg): PluginObject => {
+  const me = Plugin(Order.ObjectExtraction, {
+    changeData: {
+      objects: 0,
+    },
+  });
+
+  return {
+    visitor: {
+      Program: {
+        enter(path) {
+          path.scope.crawl();
+        },
+      },
+      VariableDeclaration(varDecPath) {
+        if (varDecPath.node.declarations.length !== 1) return;
+        const declaration = varDecPath.get(
+          "declarations.0"
+        ) as NodePath<t.VariableDeclarator>;
+
+        // Must be simple variable declaration (No destructuring)
+        const identifier = declaration.get("id");
+        if (!identifier.isIdentifier()) return;
+
+        // Must be an object expression
+        const objectExpression = declaration.get("init");
+        if (!objectExpression.isObjectExpression()) return;
+
+        // Not allowed to reassign the object
+        const binding = varDecPath.scope.getBinding(identifier.node.name);
+        if (!binding || binding.constantViolations.length > 0) return;
+
+        var pendingReplacements: {
+          path: NodePath<t.MemberExpression>;
+          replaceWith: t.Expression;
+        }[] = [];
+
+        const newObjectName = me.getPlaceholder() + "_" + identifier.node.name;
+        const newPropertyMappings = new Map<string, string>();
+
+        // Create new property names from the original object properties
+        var newDeclarations: t.VariableDeclarator[] = [];
+        for (var property of objectExpression.get("properties")) {
+          if (!property.isObjectProperty()) return;
+          const propertyKey = getObjectPropertyAsString(property.node);
+          if (!propertyKey) {
+            // Property key is not a static string, not allowed
+            return;
+          }
 
-/**
- * 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") ) {
- *   ...
- * }
- * ```
- */
-export default class ObjectExtraction extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.ObjectExtraction);
-  }
+          let newPropertyName = newPropertyMappings.get(propertyKey);
+          if (newPropertyName) {
+            // Duplicate property, not allowed
+            return;
+          } else {
+            newPropertyName =
+              newObjectName +
+              "_" +
+              (t.isValidIdentifier(propertyKey)
+                ? propertyKey
+                : me.getPlaceholder());
+            newPropertyMappings.set(propertyKey, newPropertyName);
+          }
 
-  match(object: Node, parents: Node[]) {
-    return isVarContext(object);
-  }
+          // Check function for referencing 'this'
+          const value = property.get("value");
+          if (value.isFunction()) {
+            var referencesThis = false;
 
-  transform(context: Node, contextParents: Node[]) {
-    // ObjectExpression Extractor
+            value.traverse({
+              ThisExpression(thisPath) {
+                referencesThis = true;
+              },
+            });
 
-    return () => {
-      // First pass through to find the maps
-      var objectDefs: { [name: string]: Location } = Object.create(null);
-      var objectDefiningIdentifiers: { [name: string]: Location } =
-        Object.create(null);
+            if (referencesThis) {
+              // Function references 'this', not allowed
+              // When extracted, this will not refer to the original object
+              return;
+            }
+          }
 
-      var illegal = new Set<string>();
+          newDeclarations.push(
+            t.variableDeclarator(
+              t.identifier(newPropertyName),
+              value.node as t.Expression
+            )
+          );
+        }
+
+        var isObjectSafe = true;
 
-      walk(context, contextParents, (object: Node, parents: Node[]) => {
-        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 (getVarContext(object, parents) != context) {
-                illegal.add(name);
+        getParentFunctionOrProgram(varDecPath).traverse({
+          Identifier: {
+            exit(idPath) {
+              if (idPath.node.name !== identifier.node.name) return;
+              if (idPath === identifier) return; // Skip the original declaration
+
+              const memberExpression = idPath.parentPath;
+              if (!memberExpression || !memberExpression.isMemberExpression()) {
+                isObjectSafe = false;
                 return;
               }
-              if (!object.properties.length) {
-                illegal.add(name);
+              const property = getMemberExpressionPropertyAsString(
+                memberExpression.node
+              );
+              if (!property) {
+                isObjectSafe = false;
                 return;
               }
 
-              // duplicate name
-              if (objectDefiningIdentifiers[name]) {
-                illegal.add(name);
+              // Delete expression check
+              if (
+                memberExpression.parentPath.isUnaryExpression({
+                  operator: "delete",
+                })
+              ) {
+                // Deleting object properties is not allowed
+                isObjectSafe = false;
                 return;
               }
 
-              // check for computed properties
-              // Change String literals to non-computed
-              object.properties.forEach((prop) => {
-                if (prop.computed && isStringLiteral(prop.key)) {
-                  prop.computed = false;
-                }
-              });
-
-              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);
+              let newPropertyName = newPropertyMappings.get(property);
+              if (!newPropertyName) {
+                // Property added later on, not allowed
+                isObjectSafe = false;
                 return;
-              } else {
-                var illegalName = object.properties
-                  .map((x) =>
-                    x.computed ? x.key.value : x.key.name || x.key.value
-                  )
-                  .find((x) => !x || !isValidIdentifier(x));
-
-                if (illegalName) {
-                  this.log(
-                    name + " has an illegal property '" + illegalName + "'"
-                  );
-                  illegal.add(name);
-                  return;
-                } else {
-                  var isIllegal = false;
-                  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],
-                  ];
-                }
               }
-            }
-          }
-        }
-      });
-
-      illegal.forEach((name) => {
-        delete objectDefs[name];
-        delete objectDefiningIdentifiers[name];
-      });
-
-      // this.log("object defs", objectDefs);
-      // huge map of changes
-      var objectDefChanges: {
-        [name: string]: { key: string; object: Node; parents: Node[] }[];
-      } = {};
-
-      if (Object.keys(objectDefs).length) {
-        // A second pass through is only required when extracting object keys
-
-        // Second pass through the exclude the dynamic map (counting keys, re-assigning)
-        walk(context, contextParents, (object: any, parents: Node[]) => {
-          if (object.type == "Identifier") {
-            var info = 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;
+              const extractedIdentifier = t.identifier(newPropertyName);
 
-                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;
-                }
-              }
-
-              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];
-              }
-            }
-          }
+              pendingReplacements.push({
+                path: memberExpression,
+                replaceWith: extractedIdentifier,
+              });
+            },
+          },
         });
 
-        Object.keys(objectDefs).forEach((name) => {
-          if (
-            !ComputeProbabilityMap(
-              this.options.objectExtraction,
-              (x) => x,
-              name
-            )
-          ) {
-            //continue;
-            return;
-          }
-
-          var [object, parents] = objectDefs[name];
-          var declarator = parents[0];
-          var declaration = parents[2];
-
-          ok(declarator.type === "VariableDeclarator");
-          ok(declaration.type === "VariableDeclaration");
-
-          var properties = object.properties;
-          // change the prop names while extracting
-          var newPropNames: { [key: string]: string } = {};
-
-          var variableDeclarators = [];
+        // Object references are too complex to safely extract
+        if (!isObjectSafe) return;
 
-          properties.forEach((property: Node) => {
-            var keyName = property.key.name || property.key.value;
+        if (
+          !computeProbabilityMap(
+            me.options.objectExtraction,
+            identifier.node.name
+          )
+        )
+          return;
 
-            var nn = name + "_" + keyName;
-            newPropNames[keyName] = nn;
+        const newDeclarationKind =
+          varDecPath.node.kind === "const" ? "let" : varDecPath.node.kind;
 
-            var v = property.value;
-
-            variableDeclarators.push(
-              VariableDeclarator(nn, this.addComment(v, `${name}.${keyName}`))
-            );
+        varDecPath
+          .replaceWithMultiple(
+            newDeclarations.map((declaration) =>
+              t.variableDeclaration(newDeclarationKind, [declaration])
+            )
+          )
+          .forEach((path) => {
+            // Make sure to register the new declarations
+            path.scope.registerDeclaration(path);
           });
 
-          declaration.declarations.splice(
-            declaration.declarations.indexOf(declarator),
-            1,
-            ...variableDeclarators
-          );
-
-          // const can only be safely changed to let
-          if (declaration.kind === "const") {
-            declaration.kind = "let";
-          }
+        // Replace all references to new singular identifiers
+        for (const { path, replaceWith } of pendingReplacements) {
+          path.replaceWith(replaceWith);
+        }
 
-          // 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(
-                      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}.`
-                  )
-                );
-              }
-            });
+        me.log("Extracted object", identifier.node.name);
 
-          this.log(
-            `Extracted ${
-              Object.keys(newPropNames).length
-            } properties from ${name}, affecting ${
-              Object.keys(objectDefChanges[name] || {}).length
-            } line(s) of code.`
-          );
-        });
-      }
-    };
-  }
-}
+        me.changeData.objects++;
+      },
+    },
+  };
+};

package/src/transforms/finalizer.ts

@@ -1,75 +1,74 @@
-import { ObfuscateOrder } from "../order";
-import { ExitCallback } from "../traverse";
-import { Identifier, Node } from "../util/gen";
-import StringEncoding from "./string/stringEncoding";
-import Transform from "./transform";
+import { PluginArg, PluginObject } from "./plugin";
+import * as t from "@babel/types";
+import { Order } from "../order";
+import stringEncoding from "./string/stringEncoding";
+import { GEN_NODE, NodeSymbol, variableFunctionName } from "../constants";
+import { ok } from "assert";
 
-/**
- * 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
- */
-export default class Finalizer extends Transform {
-  stringEncoding: StringEncoding;
+export default ({ Plugin }: PluginArg): PluginObject => {
+  const me = Plugin(Order.Finalizer);
+  const stringEncodingPlugin = stringEncoding(me);
 
-  constructor(o) {
-    super(o, ObfuscateOrder.Finalizer);
+  return {
+    visitor: {
+      // String encoding
+      ...stringEncodingPlugin.visitor,
 
-    this.stringEncoding = new StringEncoding(o);
-  }
+      // Backup __JS_CONFUSER_VAR__ replacement
+      // While done in Preparation, Rename Variables
+      // This accounts for when Rename Variables is disabled and an inserted Template adds __JS_CONFUSER_VAR__ calls
+      ...(me.obfuscator.hasPlugin(Order.RenameVariables)
+        ? {}
+        : {
+            CallExpression: {
+              exit(path) {
+                if (
+                  path.get("callee").isIdentifier({
+                    name: variableFunctionName,
+                  })
+                ) {
+                  var args = path.get("arguments");
+                  ok(args.length === 1);
 
-  isNumberLiteral(object: Node) {
-    return (
-      object.type === "Literal" &&
-      typeof object.value === "number" &&
-      Math.floor(object.value) === object.value
-    );
-  }
+                  var arg = args[0];
+                  ok(arg.isIdentifier());
 
-  isBigIntLiteral(object: Node) {
-    return object.type === "Literal" && typeof object.value === "bigint";
-  }
+                  var name = arg.node.name;
+                  path.replaceWith(t.stringLiteral(name));
+                }
+              },
+            },
+          }),
 
-  match(object, parents) {
-    return object.type === "Literal";
-  }
+      // Hexadecimal numbers
+      NumberLiteral: {
+        exit(path) {
+          if (me.options.hexadecimalNumbers) {
+            const { value } = path.node;
 
-  transform(object: Node, parents: Node[]): void | ExitCallback {
-    // 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);
+            if (
+              Number.isNaN(value) ||
+              !Number.isFinite(value) ||
+              Math.floor(value) !== value
+            ) {
+              return;
+            }
 
-        var newStr = (isNegative ? "-" : "") + "0x" + hex;
+            // 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);
 
-        this.replace(object, Identifier(newStr));
-      };
-    }
+            var newStr = (isNegative ? "-" : "") + "0x" + hex;
 
-    // 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, Identifier(object.raw));
-      };
-    }
+            var id = t.identifier(newStr);
+            (id as NodeSymbol)[GEN_NODE] = true;
 
-    if (
-      this.options.stringEncoding &&
-      this.stringEncoding.match(object, parents)
-    ) {
-      return this.stringEncoding.transform(object, parents);
-    }
-  }
-}
+            path.replaceWith(id);
+            path.skip();
+          }
+        },
+      },
+    },
+  };
+};