js-confuser 1.7.3 → 2.0.0-alpha.0

package/src/transforms/opaquePredicates.ts

@@ -1,242 +1,103 @@
-import Transform from "./transform";
-import {
-  Node,
-  BinaryExpression,
-  MemberExpression,
-  Identifier,
-  CallExpression,
-  Literal,
-  VariableDeclaration,
-  ObjectExpression,
-  Property,
-  FunctionExpression,
-  ArrayExpression,
-  LogicalExpression,
-  VariableDeclarator,
-  ConditionalExpression,
-  UnaryExpression,
-  ReturnStatement,
-  AssignmentPattern,
-} from "../util/gen";
-import {
-  choice,
-  getRandomInteger,
-  getRandomString,
-  shuffle,
-} from "../util/random";
-import { ObfuscateOrder } from "../order";
-import { clone, prepend } from "../util/insert";
-import Template from "../templates/template";
-import { ComputeProbabilityMap } from "../probability";
-import { ok } from "assert";
-
-const testTypes = new Set([
-  "ForStatement",
-  "WhileStatement",
-  "DoWhileStatement",
-  "IfStatement",
-  "ConditionExpression",
-]);
-
-function isTestExpression(object: Node, parents: Node[]) {
-  if (!object || !parents[0]) {
-    return false;
+import { PluginArg, PluginObject } from "./plugin";
+import { Order } from "../order";
+import { NodePath } from "@babel/traverse";
+import * as t from "@babel/types";
+import { getBlock } from "../utils/ast-utils";
+import { chance, getRandomString } from "../utils/random-utils";
+import { computeProbabilityMap } from "../probability";
+
+export default ({ Plugin }: PluginArg): PluginObject => {
+  const me = Plugin(Order.OpaquePredicates, {
+    changeData: {
+      opaquePredicates: 0,
+    },
+  });
+
+  function createTruePredicate(path: NodePath) {
+    const controlObject = me.getControlObject(getBlock(path));
+
+    var trueValue = controlObject.createTruePredicate();
+
+    return trueValue;
   }
 
-  if (testTypes.has(parents[0].type) && parents[0].test === object) {
-    return true;
-  }
-
-  return false;
-}
+  let active = true;
+  let transformCount = 0;
+  function shouldTransform(path: NodePath) {
+    if (!active) return false;
+    if (path.find((p) => me.isSkipped(p))) return false;
 
-/**
- * Changes test expression (such as if statements, for loops) to add predicates.
- *
- * Predicates are computed at runtime.
- */
-export default class OpaquePredicates extends Transform {
-  undefinedVar: string;
-  nullVar: string;
-  numberVar: string;
+    if (!computeProbabilityMap(me.options.opaquePredicates)) return false;
 
-  predicateName: string;
-  predicate: Node;
-  predicates: { [name: string]: Node };
+    transformCount++;
 
-  gen: ReturnType<Transform["getGenerator"]>;
-  made: number;
+    const depth = path.getAncestry().length;
 
-  constructor(o) {
-    super(o, ObfuscateOrder.OpaquePredicates);
-
-    this.predicates = Object.create(null);
-    this.gen = this.getGenerator();
-    this.made = 0;
+    return chance(1000 - transformCount - depth * 100);
   }
 
-  match(object: Node, parents: Node[]) {
-    return (
-      (isTestExpression(object, parents) || object.type == "SwitchCase") &&
-      !parents.find((x) => x.$multiTransformSkip || x.type == "AwaitExpression")
+  function wrapWithPredicate(path: NodePath) {
+    let newExpression = t.logicalExpression(
+      "&&",
+      createTruePredicate(path),
+      path.node as t.Expression
     );
+
+    me.changeData.opaquePredicates++;
+
+    path.replaceWith(me.skip(newExpression));
   }
 
-  transform(object: Node, parents: Node[]) {
-    return () => {
-      if (!ComputeProbabilityMap(this.options.opaquePredicates)) {
-        return;
-      }
-      this.made++;
-      if (this.made > 150) {
-        return;
-      }
-
-      if (!this.predicate) {
-        this.predicateName = this.getPlaceholder();
-        this.predicate = ObjectExpression([]);
-
-        var tempName = this.getPlaceholder();
-
-        prepend(
-          parents[parents.length - 1] || object,
-          VariableDeclaration(
-            VariableDeclarator(
-              this.predicateName,
-              CallExpression(
-                FunctionExpression(
-                  [],
-                  [
-                    VariableDeclaration(
-                      VariableDeclarator(tempName, this.predicate)
-                    ),
-                    ReturnStatement(Identifier(tempName)),
-                  ]
-                ),
-                []
-              )
+  return {
+    visitor: {
+      // if (test) -> if (PREDICATE() && test) {}
+      IfStatement: {
+        exit(path) {
+          if (!shouldTransform(path)) return;
+          wrapWithPredicate(path.get("test"));
+        },
+      },
+
+      // test ? a : b -> PREDICATE() && test ? a : b
+      ConditionalExpression: {
+        exit(path) {
+          if (!shouldTransform(path)) return;
+
+          wrapWithPredicate(path.get("test"));
+        },
+      },
+
+      // case test: -> case PREDICATE() && test:
+      SwitchCase: {
+        exit(path) {
+          if (!path.node.test) return;
+          if (!shouldTransform(path)) return;
+
+          wrapWithPredicate(path.get("test"));
+        },
+      },
+
+      // return test -> if (predicate()) { return test } else { return fake }
+      ReturnStatement: {
+        exit(path) {
+          if (!path.node.argument) return;
+          if (!shouldTransform(path)) return;
+
+          me.changeData.opaquePredicates++;
+
+          path.replaceWith(
+            t.ifStatement(
+              createTruePredicate(path),
+              t.blockStatement([t.returnStatement(path.node.argument)]),
+              t.blockStatement([
+                t.returnStatement(t.stringLiteral(getRandomString(6))),
+              ])
             )
-          )
-        );
-      }
-
-      var expr = choice(Object.values(this.predicates));
-
-      if (
-        !expr ||
-        Math.random() < 0.5 / (Object.keys(this.predicates).length || 1)
-      ) {
-        var prop = this.gen.generate();
-        var accessor = MemberExpression(
-          Identifier(this.predicateName),
-          Identifier(prop),
-          false
-        );
-        switch (choice(["array", "number", "string"])) {
-          case "array":
-            var arrayProp = this.gen.generate();
-            this.predicate.properties.push(
-              Property(Identifier(arrayProp), ArrayExpression([]))
-            );
-
-            var paramName = this.getPlaceholder();
-
-            this.predicate.properties.push(
-              Property(
-                Identifier(prop),
-                FunctionExpression(
-                  [AssignmentPattern(Identifier(paramName), Literal("length"))],
-                  new Template(`
-                  if ( !${this.predicateName}.${arrayProp}[0] ) {
-                    ${this.predicateName}.${arrayProp}.push(${getRandomInteger(
-                    -100,
-                    100
-                  )});
-                  }
-                  return ${this.predicateName}.${arrayProp}[${paramName}];
-                `).compile()
-                )
-              )
-            );
-            expr = CallExpression(accessor, []);
-            break;
-
-          case "number":
-            this.predicate.properties.push(
-              Property(Identifier(prop), Literal(getRandomInteger(15, 90)))
-            );
-            expr = BinaryExpression(
-              ">",
-              accessor,
-              Literal(getRandomInteger(-90, 10))
-            );
-            break;
-
-          case "string":
-            var str = this.gen.generate();
-            var index = getRandomInteger(0, str.length);
-            var fn = Math.random() > 0.5 ? "charAt" : "charCodeAt";
-
-            this.predicate.properties.push(
-              Property(Identifier(prop), Literal(str))
-            );
-            expr = BinaryExpression(
-              "==",
-              CallExpression(MemberExpression(accessor, Literal(fn), true), [
-                Literal(index),
-              ]),
-              Literal(str[fn](index))
-            );
-            break;
-        }
-
-        ok(expr);
-        this.predicates[prop] = expr;
-
-        if (Math.random() > 0.8) {
-          shuffle(this.predicate.properties);
-        }
-      }
-
-      var cloned = clone(expr);
-      if (object.type == "SwitchCase" && object.test) {
-        var matching: Node = Identifier(choice(["undefined", "null"]));
-
-        var test = object.test;
-
-        if (test.type == "Literal") {
-          if (typeof test.value === "number") {
-            matching = Literal(getRandomInteger(-250, 250));
-          } else if (typeof test.value === "string") {
-            matching = Literal(getRandomString(4));
-          }
-        }
-
-        var conditionalExpression = ConditionalExpression(
-          cloned,
-          clone(test),
-          matching
-        );
-        if (Math.random() > 0.5) {
-          conditionalExpression = ConditionalExpression(
-            UnaryExpression("!", cloned),
-            matching,
-            clone(test)
           );
-        }
-
-        this.replace(test, conditionalExpression);
-      } else if (isTestExpression(object, parents)) {
-        if (object.type == "Literal" && !object.regex) {
-          if (object.value) {
-            this.replace(object, cloned);
-          } else {
-            this.replace(object, UnaryExpression("!", cloned));
-          }
-        } else {
-          this.replace(object, LogicalExpression("&&", clone(object), cloned));
-        }
-      }
-    };
-  }
-}
+
+          me.skip(path);
+        },
+      },
+    },
+  };
+};

package/src/transforms/pack.ts

@@ -0,0 +1,195 @@
+import * as t from "@babel/types";
+import Obfuscator from "../obfuscator";
+import Template from "../templates/template";
+import {
+  isDefiningIdentifier,
+  isModifiedIdentifier,
+  isVariableIdentifier,
+} from "../utils/ast-utils";
+import {
+  GEN_NODE,
+  NodeSymbol,
+  reservedIdentifiers,
+  variableFunctionName,
+  WITH_STATEMENT,
+} from "../constants";
+import { PluginArg, PluginObject } from "./plugin";
+import { Order } from "../order";
+
+export default function pack({ Plugin }: PluginArg): PluginObject {
+  const me = Plugin(Order.Pack, {
+    changeData: {
+      globals: 0,
+    },
+  });
+  const objectName = me.obfuscator.nameGen.generate();
+  const mappings = new Map<string, string>();
+  const setterPropsNeeded = new Set<string>();
+  const typeofMappings = new Map<string, string>();
+
+  const prependNodes: t.Statement[] = [];
+
+  return {
+    // Transform identifiers, preserve import statements
+    visitor: {
+      ImportDeclaration(path) {
+        prependNodes.push(path.node);
+        path.remove();
+
+        // Ensure bindings are removed -> variable becomes a global -> added to mappings object
+        path.scope.crawl();
+      },
+      Program(path) {
+        path.scope.crawl();
+      },
+
+      Identifier: {
+        exit(path) {
+          if (!isVariableIdentifier(path)) return;
+
+          if (isDefiningIdentifier(path)) return;
+          if ((path.node as NodeSymbol)[GEN_NODE]) return;
+          if ((path.node as NodeSymbol)[WITH_STATEMENT]) return;
+
+          const identifierName = path.node.name;
+          if (reservedIdentifiers.has(identifierName)) return;
+          if (me.obfuscator.options.globalVariables.has(identifierName)) return;
+          if (identifierName === variableFunctionName) return;
+
+          if (!path.scope.hasGlobal(identifierName)) return;
+
+          if (
+            path.key === "argument" &&
+            path.parentPath.isUnaryExpression({ operator: "typeof" })
+          ) {
+            const unaryExpression = path.parentPath;
+
+            let propertyName = typeofMappings.get(identifierName);
+            if (!propertyName) {
+              propertyName = me.obfuscator.nameGen.generate();
+              typeofMappings.set(identifierName, propertyName);
+            }
+
+            unaryExpression.replaceWith(
+              t.memberExpression(
+                t.identifier(objectName),
+                t.stringLiteral(propertyName),
+                true
+              )
+            );
+            return;
+          }
+
+          let propertyName = mappings.get(identifierName);
+          if (!propertyName) {
+            propertyName = me.obfuscator.nameGen.generate();
+            mappings.set(identifierName, propertyName);
+          }
+
+          // Only add setter if the identifier is modified
+          if (isModifiedIdentifier(path)) {
+            setterPropsNeeded.add(identifierName);
+          }
+
+          path.replaceWith(
+            t.memberExpression(
+              t.identifier(objectName),
+              t.stringLiteral(propertyName),
+              true
+            )
+          );
+        },
+      },
+    },
+
+    // Final AST handler
+    // Very last step in the obfuscation process
+    finalASTHandler(ast) {
+      // Create object expression
+      // Very similar to flatten, maybe refactor to use the same code
+      const objectProperties: t.ObjectMethod[] = [];
+
+      me.changeData.globals = mappings.size;
+
+      for (const [identifierName, propertyName] of mappings) {
+        // get identifier() { return identifier; }
+        objectProperties.push(
+          t.objectMethod(
+            "get",
+            t.stringLiteral(propertyName),
+            [],
+            t.blockStatement([t.returnStatement(t.identifier(identifierName))])
+          )
+        );
+
+        // Only add setter if the identifier is modified
+        if (setterPropsNeeded.has(identifierName)) {
+          // set identifier(value) { return identifier = value; }
+          objectProperties.push(
+            t.objectMethod(
+              "set",
+              t.stringLiteral(propertyName),
+              [t.identifier(objectName)],
+              t.blockStatement([
+                t.returnStatement(
+                  t.assignmentExpression(
+                    "=",
+                    t.identifier(identifierName),
+                    t.identifier(objectName)
+                  )
+                ),
+              ])
+            )
+          );
+        }
+      }
+
+      // Add typeof mappings
+      for (const [identifierName, propertyName] of typeofMappings) {
+        // get typeof identifier() { return typeof identifier; }
+        objectProperties.push(
+          t.objectMethod(
+            "get",
+            t.stringLiteral(propertyName),
+            [],
+            t.blockStatement([
+              t.returnStatement(
+                t.unaryExpression("typeof", t.identifier(identifierName))
+              ),
+            ])
+          )
+        );
+      }
+
+      const objectExpression = t.objectExpression(objectProperties);
+
+      // Convert last expression to return statement
+      // This preserves the last expression in the packed code
+      var lastStatement = ast.program.body.at(-1);
+      if (lastStatement && t.isExpressionStatement(lastStatement)) {
+        Object.assign(
+          lastStatement,
+
+          t.returnStatement(lastStatement.expression)
+        );
+      }
+
+      const outputCode = Obfuscator.generateCode(ast, {
+        ...me.obfuscator.options,
+        compact: true,
+      });
+
+      var newAST = new Template(`
+    {prependNodes}
+    Function({objectName}, {outputCode})({objectExpression});
+  `).file({
+        objectName: () => t.stringLiteral(objectName),
+        outputCode: () => t.stringLiteral(outputCode),
+        objectExpression: objectExpression,
+        prependNodes: prependNodes,
+      });
+
+      return newAST;
+    },
+  };
+}