js-confuser 2.0.0-alpha.2 → 2.0.0-alpha.3

package/src/transforms/dispatcher.ts

@@ -4,7 +4,6 @@ import * as t from "@babel/types";
 import Template from "../templates/template";
 import { ok } from "assert";
 import { chance, getRandomString } from "../utils/random-utils";
-import { computeProbabilityMap } from "../probability";
 import { Order } from "../order";
 import { NodeSymbol, PREDICTABLE, UNSAFE } from "../constants";
 import {
@@ -146,7 +145,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           }
 
           for (var name of functionPaths.keys()) {
-            if (!computeProbabilityMap(me.options.dispatcher, name)) {
+            if (!me.computeProbabilityMap(me.options.dispatcher, name)) {
               functionPaths.delete(name);
             }
           }

package/src/transforms/extraction/duplicateLiteralsRemoval.ts

@@ -2,7 +2,11 @@ import * as t from "@babel/types";
 import { ok } from "assert";
 import { PluginArg, PluginObject } from "../plugin";
 import { Order } from "../../order";
-import { ensureComputedExpression, prepend } from "../../utils/ast-utils";
+import {
+  ensureComputedExpression,
+  isModuleImport,
+  prepend,
+} from "../../utils/ast-utils";
 import { createLiteral, LiteralValue, numericLiteral } from "../../utils/node";
 import { NodePath } from "@babel/traverse";
 
@@ -49,6 +53,11 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                 t.Literal | t.Identifier
               >;
 
+              // Don't change module imports
+              if (literalPath.isStringLiteral()) {
+                if (isModuleImport(literalPath)) return;
+              }
+
               let node = literalPath.node;
               var isUndefined = false;
               if (literalPath.isIdentifier()) {

package/src/transforms/extraction/objectExtraction.ts

@@ -7,7 +7,6 @@ import {
   getObjectPropertyAsString,
   getParentFunctionOrProgram,
 } from "../../utils/ast-utils";
-import { computeProbabilityMap } from "../../probability";
 
 export default ({ Plugin }: PluginArg): PluginObject => {
   const me = Plugin(Order.ObjectExtraction, {
@@ -152,7 +151,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
         if (!isObjectSafe) return;
 
         if (
-          !computeProbabilityMap(
+          !me.computeProbabilityMap(
             me.options.objectExtraction,
             identifier.node.name
           )

package/src/transforms/finalizer.ts

@@ -41,7 +41,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           }),
 
       // Hexadecimal numbers
-      NumberLiteral: {
+      NumericLiteral: {
         exit(path) {
           if (me.options.hexadecimalNumbers) {
             const { value } = path.node;

package/src/transforms/flatten.ts

@@ -11,7 +11,6 @@ import {
   prependProgram,
 } from "../utils/ast-utils";
 import { PluginArg, PluginObject } from "./plugin";
-import { computeProbabilityMap } from "../probability";
 import { Order } from "../order";
 import { NodeSymbol, PREDICTABLE, UNSAFE } from "../constants";
 import {
@@ -58,7 +57,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
       functionName = "anonymous";
     }
 
-    if (!computeProbabilityMap(me.options.flatten, functionName)) {
+    if (!me.computeProbabilityMap(me.options.flatten, functionName)) {
       return;
     }
 
@@ -117,26 +116,8 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             return;
           }
 
-          var definedLocal = identifierPath.scope;
-          do {
-            if (definedLocal.hasOwnBinding(identifierName)) return;
-            if (definedLocal === fnPath.scope) break;
-
-            definedLocal = definedLocal.parent;
-            if (definedLocal === program.scope)
-              ok(functionName + ":" + identifierName);
-          } while (definedLocal);
-
-          var cursor: Scope = fnPath.scope.parent;
-          var isOutsideVariable = false;
-
-          do {
-            if (cursor.hasBinding(identifierName)) {
-              isOutsideVariable = true;
-              break;
-            }
-            cursor = cursor.parent;
-          } while (cursor);
+          var isOutsideVariable =
+            fnPath.scope.parent.getBinding(identifierName) === binding;
 
           if (!isOutsideVariable) {
             return;

package/src/transforms/identifier/globalConcealing.ts

@@ -4,7 +4,6 @@ import { NameGen } from "../../utils/NameGen";
 import Template from "../../templates/template";
 import { PluginArg, PluginObject } from "../plugin";
 import { Order } from "../../order";
-import { computeProbabilityMap } from "../../probability";
 import {
   MULTI_TRANSFORM,
   reservedIdentifiers,
@@ -132,7 +131,10 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             if (!mapping) {
               // Allow user to disable custom global variables
               if (
-                !computeProbabilityMap(me.options.globalConcealing, globalName)
+                !me.computeProbabilityMap(
+                  me.options.globalConcealing,
+                  globalName
+                )
               )
                 continue;
 

package/src/transforms/identifier/movedDeclarations.ts

@@ -65,8 +65,12 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           if (!functionPath || !(functionPath.node as NodeSymbol)[PREDICTABLE])
             return;
 
+          var fnBody = functionPath.get("body");
+
+          if (!fnBody.isBlockStatement()) return;
+
           // Must be direct child of the function
-          if (path.parentPath !== functionPath.get("body")) return;
+          if (path.parentPath !== fnBody) return;
 
           const functionName = path.node.id.name;
 
@@ -99,7 +103,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           }
 
           prepend(
-            functionPath,
+            fnBody,
             new Template(`
               if(!${functionName}) {
                 ${functionName} = {functionExpression};
@@ -113,6 +117,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
       },
       VariableDeclaration: {
         exit(path) {
+          if (me.isSkipped(path)) return;
           if (path.node.kind !== "var") return;
           if (path.node.declarations.length !== 1) return;
 
@@ -150,7 +155,11 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           let isDefinedAtTop = false;
           const parentPath = path.parentPath;
           if (parentPath.isBlock()) {
-            isDefinedAtTop = parentPath.get("body").indexOf(path) === 0;
+            isDefinedAtTop =
+              parentPath
+                .get("body")
+                .filter((x) => x.type !== "ImportDeclaration")
+                .indexOf(path) === 0;
           }
 
           // Already at the top - nothing will change
@@ -214,7 +223,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                 path.isBlock()
               ) as NodePath<t.Block>;
 
-              var topNode = block.node.body[0];
+              var topNode = block.node.body.filter(
+                (x) => x.type !== "ImportDeclaration"
+              )[0];
               const variableDeclarator = t.variableDeclarator(
                 t.identifier(name)
               );
@@ -223,8 +234,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                 topNode.declarations.push(variableDeclarator);
                 break;
               } else {
-                block.node.body.unshift(
-                  t.variableDeclaration("var", [variableDeclarator])
+                prepend(
+                  block,
+                  me.skip(t.variableDeclaration("var", [variableDeclarator]))
                 );
               }
 

package/src/transforms/identifier/renameVariables.ts

@@ -6,9 +6,7 @@ import { Order } from "../../order";
 import {
   noRenameVariablePrefix,
   placeholderVariablePrefix,
-  variableFunctionName,
 } from "../../constants";
-import { computeProbabilityMap } from "../../probability";
 import {
   getParentFunctionOrProgram,
   isDefiningIdentifier,
@@ -215,19 +213,25 @@ export default ({ Plugin }: PluginArg): PluginObject => {
         // Placeholder variables should always be renamed
         if (name.startsWith(placeholderVariablePrefix)) return true;
 
-        // Do not rename exports
-        if (isExportedIdentifier(bindings?.get(name))) return false;
+        const binding = bindings?.get(name);
+
+        if (binding) {
+          // Do not rename exports
+          if (isExportedIdentifier(binding)) return false;
+        }
 
         if (name === me.obfuscator.getStringCompressionLibraryName())
           return false;
 
         // Global variables are additionally checked against user option
         if (isGlobal) {
-          if (!computeProbabilityMap(me.options.renameGlobals, name))
+          if (!me.computeProbabilityMap(me.options.renameGlobals, name))
             return false;
         }
 
-        if (!computeProbabilityMap(me.options.renameVariables, name, isGlobal))
+        if (
+          !me.computeProbabilityMap(me.options.renameVariables, name, isGlobal)
+        )
           return false;
 
         return true;

package/src/transforms/lock/lock.ts

@@ -26,7 +26,6 @@ import {
   NativeFunctionTemplate,
   StrictModeTemplate,
 } from "../../templates/tamperProtectionTemplates";
-import { computeProbabilityMap } from "../../probability";
 
 export default ({ Plugin }: PluginArg): PluginObject => {
   const me = Plugin(Order.Lock, {
@@ -36,6 +35,11 @@ export default ({ Plugin }: PluginArg): PluginObject => {
   });
 
   if (me.options.lock.startDate instanceof Date) {
+    // Ensure date is in the past
+    if (me.options.lock.startDate.getTime() > Date.now()) {
+      me.warn("lock.startDate is detected to be in the future");
+    }
+
     me.options.lock.customLocks.push({
       code: [
         `
@@ -54,6 +58,11 @@ export default ({ Plugin }: PluginArg): PluginObject => {
   }
 
   if (me.options.lock.endDate instanceof Date) {
+    // Ensure date is in the future
+    if (me.options.lock.endDate.getTime() < Date.now()) {
+      me.warn("lock.endDate is detected to be in the past");
+    }
+
     me.options.lock.customLocks.push({
       code: [
         `
@@ -127,7 +136,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
   const timesMap = new WeakMap<CustomLock, number>();
 
   let countermeasuresNode: NodePath<t.Identifier>;
-  let invokeCountermeasuresFnName;
+  let invokeCountermeasuresFnName: string;
 
   if (me.options.lock.countermeasures) {
     invokeCountermeasuresFnName = me.getPlaceholder("invokeCountermeasures");
@@ -356,7 +365,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           // Don't apply to invokeCountermeasures function (Intended)
           if (me.obfuscator.isInternalVariable(functionName)) return;
 
-          if (!computeProbabilityMap(me.options.lock.integrity, functionName))
+          if (
+            !me.computeProbabilityMap(me.options.lock.integrity, functionName)
+          )
             return;
 
           var newFnName = me.getPlaceholder();

package/src/transforms/minify.ts

@@ -8,7 +8,12 @@ import {
   isUndefined,
 } from "../utils/ast-utils";
 import { Binding, Scope } from "@babel/traverse";
-import { NodeSymbol, placeholderVariablePrefix, UNSAFE } from "../constants";
+import {
+  NO_REMOVE,
+  NodeSymbol,
+  placeholderVariablePrefix,
+  UNSAFE,
+} from "../constants";
 
 const identifierMap = new Map<string, () => t.Expression>();
 identifierMap.set("undefined", () =>
@@ -120,6 +125,19 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           }
         },
       },
+      // "a" + "b" -> "ab"
+      BinaryExpression: {
+        exit(path) {
+          if (path.node.operator !== "+") return;
+
+          const left = path.get("left");
+          const right = path.get("right");
+
+          if (!left.isStringLiteral() || !right.isStringLiteral()) return;
+
+          path.replaceWith(t.stringLiteral(left.node.value + right.node.value));
+        },
+      },
       // a["key"] -> a.key
       MemberExpression: {
         exit(path) {
@@ -215,7 +233,8 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           const id = path.get("id");
           if (
             id.isIdentifier() &&
-            !id.node.name.startsWith(placeholderVariablePrefix)
+            !id.node.name.startsWith(placeholderVariablePrefix) &&
+            !(path.node as NodeSymbol)[NO_REMOVE]
           ) {
             const binding = path.scope.getBinding(id.node.name);
             if (
@@ -285,6 +304,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             const fn = getParentFunctionOrProgram(path);
             if ((fn.node as NodeSymbol)[UNSAFE]) return;
 
+            // Node explicitly marked as not to be removed
+            if ((id as NodeSymbol)[NO_REMOVE]) return;
+
             const binding = path.scope.getBinding(id.node.name);
 
             if (

package/src/transforms/opaquePredicates.ts

@@ -2,9 +2,8 @@ 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";
+import PredicateGen from "../utils/PredicateGen";
 
 export default ({ Plugin }: PluginArg): PluginObject => {
   const me = Plugin(Order.OpaquePredicates, {
@@ -13,12 +12,10 @@ export default ({ Plugin }: PluginArg): PluginObject => {
     },
   });
 
-  function createTruePredicate(path: NodePath) {
-    const controlObject = me.getControlObject(getBlock(path));
-
-    var trueValue = controlObject.createTruePredicate();
+  const predicateGen = new PredicateGen(me);
 
-    return trueValue;
+  function createTruePredicate(path: NodePath) {
+    return predicateGen.generateTrueExpression(path);
   }
 
   let active = true;
@@ -27,7 +24,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
     if (!active) return false;
     if (path.find((p) => me.isSkipped(p))) return false;
 
-    if (!computeProbabilityMap(me.options.opaquePredicates)) return false;
+    if (!me.computeProbabilityMap(me.options.opaquePredicates)) return false;
 
     transformCount++;
 

package/src/transforms/pack.ts

@@ -55,8 +55,14 @@ export default function pack({ Plugin }: PluginArg): PluginObject {
           if (reservedIdentifiers.has(identifierName)) return;
           if (me.obfuscator.options.globalVariables.has(identifierName)) return;
           if (identifierName === variableFunctionName) return;
+          if (identifierName === objectName) return;
 
           if (!path.scope.hasGlobal(identifierName)) return;
+          if (path.scope.hasBinding(identifierName)) return;
+
+          // Check user's custom implementation
+          if (!me.computeProbabilityMap(me.options.pack, identifierName))
+            return;
 
           if (
             path.key === "argument" &&

package/src/transforms/plugin.ts

@@ -1,13 +1,11 @@
 import { NodePath, Visitor } from "@babel/traverse";
 import Obfuscator from "../obfuscator";
-import { chance, choice, getRandomString } from "../utils/random-utils";
+import { getRandomString } from "../utils/random-utils";
 import { Order } from "../order";
 import * as t from "@babel/types";
-import { FN_LENGTH, NodeSymbol, SKIP, CONTROL_OBJECTS } from "../constants";
+import { FN_LENGTH, NodeSymbol, SKIP } from "../constants";
 import { SetFunctionLengthTemplate } from "../templates/setFunctionLengthTemplate";
 import { prepend, prependProgram } from "../utils/ast-utils";
-import ControlObject from "../utils/ControlObject";
-import { ok } from "assert";
 import { numericLiteral } from "../utils/node";
 
 export interface PluginObject {
@@ -30,9 +28,14 @@ export class PluginInstance {
   constructor(
     public pluginOptions: { name?: string; order?: number },
     public obfuscator: Obfuscator
-  ) {}
+  ) {
+    this.computeProbabilityMap = obfuscator.computeProbabilityMap.bind(
+      this.obfuscator
+    );
+  }
 
   public changeData: { [key: string]: number } = {};
+  public computeProbabilityMap: Obfuscator["computeProbabilityMap"];
 
   get name() {
     return this.pluginOptions.name || "unnamed";
@@ -74,43 +77,48 @@ export class PluginInstance {
   setFunctionLength(path: NodePath<t.Function>, originalLength: number) {
     (path.node as NodeSymbol)[FN_LENGTH] = originalLength;
 
-    // Function length
-    if (this.options.preserveFunctionLength && originalLength > 0) {
-      if (!this.setFunctionLengthName) {
-        this.setFunctionLengthName = this.getPlaceholder("fnLength");
-
-        this.skip(
-          prependProgram(
-            path,
-            SetFunctionLengthTemplate.compile({
-              fnName: this.setFunctionLengthName,
-            })
-          )
-        );
-      }
-      if (t.isFunctionDeclaration(path.node)) {
-        prepend(
-          path.parentPath,
-          t.expressionStatement(
-            t.callExpression(t.identifier(this.setFunctionLengthName), [
-              t.identifier(path.node.id.name),
-              numericLiteral(originalLength),
-            ])
-          )
-        );
-      } else if (
-        t.isFunctionExpression(path.node) ||
-        t.isArrowFunctionExpression(path.node)
-      ) {
-        path.replaceWith(
+    // Skip if user disabled this feature
+    if (!this.options.preserveFunctionLength) return;
+
+    // Skip if function has no parameters
+    if (originalLength === 0) return;
+
+    // Create the function length setter if it doesn't exist
+    if (!this.setFunctionLengthName) {
+      this.setFunctionLengthName = this.getPlaceholder("fnLength");
+
+      this.skip(
+        prependProgram(
+          path,
+          SetFunctionLengthTemplate.compile({
+            fnName: this.setFunctionLengthName,
+          })
+        )
+      );
+    }
+
+    if (t.isFunctionDeclaration(path.node)) {
+      prepend(
+        path.parentPath,
+        t.expressionStatement(
           t.callExpression(t.identifier(this.setFunctionLengthName), [
-            path.node,
+            t.identifier(path.node.id.name),
             numericLiteral(originalLength),
           ])
-        );
-      } else {
-        // TODO
-      }
+        )
+      );
+    } else if (
+      t.isFunctionExpression(path.node) ||
+      t.isArrowFunctionExpression(path.node)
+    ) {
+      path.replaceWith(
+        t.callExpression(t.identifier(this.setFunctionLengthName), [
+          path.node,
+          numericLiteral(originalLength),
+        ])
+      );
+    } else {
+      // TODO
     }
   }
 
@@ -125,36 +133,6 @@ export class PluginInstance {
     return "__p_" + getRandomString(4) + (suffix ? "_" + suffix : "");
   }
 
-  /**
-   * Retrieves (or creates) a `ControlObject` for the given `blockPath`.
-   */
-  getControlObject(blockPath: NodePath<t.Block>, createMultiple = true) {
-    ok(blockPath.isBlock());
-
-    var controlObjects = (blockPath.node as NodeSymbol)[CONTROL_OBJECTS];
-    if (!controlObjects) {
-      controlObjects = [];
-    }
-
-    if (
-      controlObjects.length === 0 ||
-      (createMultiple &&
-        chance(
-          controlObjects[0].propertyNames.size - 15 * controlObjects.length
-        ))
-    ) {
-      var newControlObject = new ControlObject(this, blockPath);
-
-      controlObjects.push(newControlObject);
-
-      (blockPath.node as NodeSymbol)[CONTROL_OBJECTS] = controlObjects;
-
-      return newControlObject;
-    }
-
-    return choice(controlObjects);
-  }
-
   /**
    * Logs a message to the console, only if `verbose` is enabled.
    * @param messages

package/src/transforms/renameLabels.ts

@@ -4,7 +4,6 @@ import { PluginArg, PluginObject } from "./plugin";
 import { Order } from "../order";
 import { NameGen } from "../utils/NameGen";
 import { ok } from "assert";
-import { computeProbabilityMap } from "../probability";
 
 const LABEL = Symbol("label");
 
@@ -127,7 +126,7 @@ export default function ({ Plugin }: PluginArg): PluginObject {
           if (isRequired) {
             var newName = labelInterface.label;
             if (
-              computeProbabilityMap(
+              me.computeProbabilityMap(
                 me.options.renameLabels,
                 labelInterface.label
               )