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

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/preparation.ts

@@ -2,7 +2,6 @@ import { NodePath } from "@babel/traverse";
 import { PluginArg, PluginObject } from "./plugin";
 import * as t from "@babel/types";
 import { Order } from "../order";
-import path from "path";
 import {
   NodeSymbol,
   PREDICTABLE,
@@ -13,8 +12,10 @@ import { ok } from "assert";
 import {
   getParentFunctionOrProgram,
   getPatternIdentifierNames,
+  isVariableIdentifier,
 } from "../utils/ast-utils";
 import { isVariableFunctionIdentifier } from "../utils/function-utils";
+import Template from "../templates/template";
 
 /**
  * Preparation arranges the user's code into an AST the obfuscator can easily transform.
@@ -53,6 +54,37 @@ export default ({ Plugin }: PluginArg): PluginObject => {
         },
       },
 
+      // @js-confuser-var "myVar" -> __JS_CONFUSER_VAR__(myVar)
+      StringLiteral: {
+        exit(path) {
+          // Check for @js-confuser-var comment
+          if (
+            path.node.leadingComments?.find((comment) =>
+              comment.value.includes("@js-confuser-var")
+            )
+          ) {
+            var identifierName = path.node.value;
+            ok(
+              t.isValidIdentifier(identifierName),
+              "Invalid identifier name: " + identifierName
+            );
+
+            // Create a new __JS_CONFUSER_VAR__ call with the identifier
+            var newExpression = new Template(
+              `__JS_CONFUSER_VAR__({identifier})`
+            ).expression({
+              identifier: t.identifier(identifierName),
+            });
+
+            path.replaceWith(newExpression);
+
+            // Remove comment and skip further processing
+            path.node.leadingComments = [];
+            path.skip();
+          }
+        },
+      },
+
       // `Hello ${username}` -> "Hello " + username
       TemplateLiteral: {
         exit(path) {
@@ -310,51 +342,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             }
           },
         },
-
-      // 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(path) {
-          for (var param of path.get("params")) {
-            param.traverse({
-              "FunctionExpression|ArrowFunctionExpression"(_innerPath) {
-                let innerPath = _innerPath as NodePath<
-                  t.FunctionExpression | t.ArrowFunctionExpression
-                >;
-                const child = innerPath.find((path) =>
-                  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), [])
-                  );
-                }
-              },
-            });
-          }
-        },
-      },
     },
   };
 };

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
               )

package/src/transforms/rgf.ts

@@ -3,7 +3,6 @@ import { PluginArg, PluginObject } from "./plugin";
 import { Order } from "../order";
 import * as t from "@babel/types";
 import Obfuscator from "../obfuscator";
-import { computeProbabilityMap } from "../probability";
 import {
   append,
   getFunctionName,
@@ -13,6 +12,7 @@ import {
   prepend,
 } from "../utils/ast-utils";
 import {
+  MULTI_TRANSFORM,
   NodeSymbol,
   PREDICTABLE,
   reservedIdentifiers,
@@ -24,6 +24,8 @@ import { numericLiteral } from "../utils/node";
 import Template from "../templates/template";
 import { createEvalIntegrityTemplate } from "../templates/tamperProtectionTemplates";
 
+const RGF_ELIGIBLE = Symbol("rgfEligible");
+
 /**
  * RGF (Runtime-Generated-Function) uses the `new Function("code")` syntax to create executable code from strings.
  *
@@ -96,14 +98,21 @@ export default ({ Plugin }: PluginArg): PluginObject => {
         },
       },
       "FunctionDeclaration|FunctionExpression": {
-        exit(_path) {
+        enter(_path) {
           if (!active) return;
+
+          // On enter, determine if Function is eligible for RGF transformation
+
           const path = _path as NodePath<
             t.FunctionDeclaration | t.FunctionExpression
           >;
 
           if (me.isSkipped(path)) return;
 
+          // Skip nested functions if the parent function is already deemed eligible
+          if (path.find((p) => p.node[RGF_ELIGIBLE] || p.node[MULTI_TRANSFORM]))
+            return;
+
           // Skip async and generator functions
           if (path.node.async || path.node.generator) return;
 
@@ -111,10 +120,8 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           if (name === me.options.lock?.countermeasures) return;
           if (me.obfuscator.isInternalVariable(name)) return;
 
-          me.log(name);
-
           if (
-            !computeProbabilityMap(
+            !me.computeProbabilityMap(
               me.options.rgf,
               name,
               path.getFunctionParent() === null
@@ -140,13 +147,14 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
               const binding = idPath.scope.getBinding(name);
               if (!binding) {
-                identifierPreventingTransform = name;
-                idPath.stop();
+                // Global variables are allowed
                 return;
               }
 
+              var isOutsideVariable =
+                path.scope.parent.getBinding(name) === binding;
               // If the binding is not in the current scope, it is an outside reference
-              if (binding.scope !== path.scope) {
+              if (isOutsideVariable) {
                 identifierPreventingTransform = name;
                 idPath.stop();
               }
@@ -163,9 +171,24 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             return;
           }
 
+          me.log("Function " + name + " is eligible for RGF transformation");
+          path.node[RGF_ELIGIBLE] = true;
+        },
+        exit(_path) {
+          if (!active) return;
+
+          const path = _path as NodePath<
+            t.FunctionDeclaration | t.FunctionExpression
+          >;
+
+          if (me.isSkipped(path)) return;
+
+          // Function is not eligible for RGF transformation
+          if (!path.node[RGF_ELIGIBLE]) return;
+
           const embeddedName = me.getPlaceholder() + "_embedded";
           const replacementName = me.getPlaceholder() + "_replacement";
-          const thisName = me.getPlaceholder() + "_this";
+          const argumentsName = me.getPlaceholder() + "_args";
 
           const lastNode = t.expressionStatement(t.identifier(embeddedName));
           (lastNode as NodeSymbol)[SKIP] = true;
@@ -179,10 +202,10 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                 t.variableDeclaration("var", [
                   t.variableDeclarator(
                     t.arrayPattern([
-                      t.identifier(thisName),
                       t.identifier(rgfArrayName),
+                      t.identifier(argumentsName),
                     ]),
-                    t.thisExpression()
+                    t.identifier("arguments")
                   ),
                 ]),
                 t.functionDeclaration(
@@ -196,7 +219,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                       t.identifier(replacementName),
                       t.identifier("apply")
                     ),
-                    [t.identifier(thisName), t.identifier("arguments")]
+                    [t.thisExpression(), t.identifier(argumentsName)]
                   )
                 ),
               ])
@@ -225,16 +248,20 @@ export default ({ Plugin }: PluginArg): PluginObject => {
               .map((plugin) => plugin.pluginInstance.order)
           );
 
-          newObfuscator.plugins = newObfuscator.plugins.filter((plugin) => {
-            return (
-              plugin.pluginInstance.order == Order.Preparation ||
-              !hasRan.has(plugin.pluginInstance.order)
-            );
-          });
+          // Global Concealing will likely cause issues when Pack is also enabled
+          const disallowedTransforms = new Set([Order.GlobalConcealing]);
+
+          newObfuscator.plugins = newObfuscator.plugins.filter(
+            ({ pluginInstance }) => {
+              return (
+                (pluginInstance.order == Order.Preparation ||
+                  !hasRan.has(pluginInstance.order)) &&
+                !disallowedTransforms.has(pluginInstance.order)
+              );
+            }
+          );
 
-          newObfuscator.obfuscateAST(evalFile, {
-            disablePack: true,
-          });
+          newObfuscator.obfuscateAST(evalFile);
 
           const generated = Obfuscator.generateCode(evalFile);
 
@@ -272,17 +299,19 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                       true
                     ),
                     [
+                      t.thisExpression(),
                       t.arrayExpression([
-                        t.thisExpression(),
                         t.identifier(rgfArrayName),
+                        t.identifier("arguments"),
                       ]),
-                      t.identifier("arguments"),
                     ]
                   )
                 ),
               ])
             );
 
+          path.skip();
+
           me.setFunctionLength(path, originalLength);
 
           me.changeData.functions++;

package/src/transforms/shuffle.ts

@@ -1,13 +1,12 @@
-import { NodePath } from "@babel/traverse";
 import { PluginArg, PluginObject } from "./plugin";
 import * as t from "@babel/types";
-import { computeProbabilityMap } from "../probability";
 import { getRandomInteger } from "../utils/random-utils";
 import Template from "../templates/template";
 import { Order } from "../order";
 import { isStaticValue } from "../utils/static-utils";
-import { NodeSymbol, PREDICTABLE } from "../constants";
+import { PREDICTABLE } from "../constants";
 import { numericLiteral } from "../utils/node";
+import { prependProgram } from "../utils/ast-utils";
 
 export default ({ Plugin }: PluginArg): PluginObject => {
   const me = Plugin(Order.Shuffle, {
@@ -16,6 +15,8 @@ export default ({ Plugin }: PluginArg): PluginObject => {
     },
   });
 
+  let fnName: string | null = null;
+
   return {
     visitor: {
       ArrayExpression: {
@@ -29,10 +30,31 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
           if (illegalElement) return;
 
-          if (!computeProbabilityMap(me.options.shuffle)) {
+          if (!me.computeProbabilityMap(me.options.shuffle)) {
             return;
           }
 
+          // Create un-shuffling function
+          if (!fnName) {
+            fnName = me.getPlaceholder() + "_shuffle";
+
+            prependProgram(
+              path,
+              new Template(
+                `
+          function ${fnName}(arr, shift) {
+            for (var i = 0; i < shift; i++) {
+              arr["push"](arr["shift"]());
+            }
+            return arr;
+          }
+          `
+              )
+                .addSymbols(PREDICTABLE)
+                .single<t.FunctionDeclaration>()
+            );
+          }
+
           var shift = getRandomInteger(
             1,
             Math.min(30, path.node.elements.length * 6)
@@ -43,30 +65,10 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             shiftedElements.unshift(shiftedElements.pop());
           }
 
-          var block = path.find((p) => p.isBlock()) as NodePath<t.Block>;
-
-          var functionExpression = new Template(
-            `
-          (function(arr) {
-            for (var i = 0; i < {shiftNode}; i++) {
-              arr.push(arr.shift());
-            }
-            return arr;
-          })
-          `
-          ).expression<t.FunctionExpression>({
-            shiftNode: numericLiteral(shift),
-          });
-
-          (functionExpression as NodeSymbol)[PREDICTABLE] = true;
-
-          var memberExpression = me
-            .getControlObject(block)
-            .addProperty(functionExpression);
-
           path.replaceWith(
-            t.callExpression(memberExpression, [
+            t.callExpression(t.identifier(fnName), [
               t.arrayExpression(shiftedElements),
+              numericLiteral(shift),
             ])
           );
 

package/src/transforms/string/encoding.ts

@@ -1,6 +1,6 @@
 import { CustomStringEncoding } from "../../options";
 import Template from "../../templates/template";
-import { choice, shuffle } from "../../utils/random-utils";
+import { shuffle } from "../../utils/random-utils";
 import * as t from "@babel/types";
 
 let hasAllEncodings = false;

package/src/transforms/string/stringCompression.ts

@@ -1,20 +1,20 @@
 import { PluginArg, PluginObject } from "../plugin";
 import * as t from "@babel/types";
 import { Order } from "../../order";
-import { computeProbabilityMap } from "../../probability";
 import {
   ensureComputedExpression,
+  isModuleImport,
   prependProgram,
 } from "../../utils/ast-utils";
 import { numericLiteral } from "../../utils/node";
 import {
-  PakoInflateMin,
+  StringCompressionLibraryMinified,
   StringCompressionTemplate,
 } from "../../templates/stringCompressionTemplate";
 import Obfuscator from "../../obfuscator";
 import { createGetGlobalTemplate } from "../../templates/getGlobalTemplate";
 import { NO_RENAME } from "../../constants";
-const pako = require("pako");
+const LZString = require("lz-string");
 
 export default ({ Plugin }: PluginArg): PluginObject => {
   const me = Plugin(Order.StringCompression, {
@@ -23,6 +23,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
     },
   });
 
+  // String Compression is only applied to the main obfuscator
+  // Any RGF functions will not have string compression due to the size of the decompression function
+
   const stringDelimiter = "|";
 
   return {
@@ -36,6 +39,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           programPath.traverse({
             StringLiteral: {
               exit: (path) => {
+                // Don't change module imports
+                if (isModuleImport(path)) return;
+
                 const originalValue = path.node.value;
 
                 // Must be at least 3 characters long
@@ -48,7 +54,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                 if (typeof index === "undefined") {
                   // Allow user option to skip compression for certain strings
                   if (
-                    !computeProbabilityMap(
+                    !me.computeProbabilityMap(
                       me.options.stringCompression,
                       originalValue
                     )
@@ -81,11 +87,10 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           );
 
           // Compress the string
-          var compressedBuffer: Uint8Array = pako.deflate(stringPayload);
-          var compressedBase64 =
-            Buffer.from(compressedBuffer).toString("base64");
+          var compressedString = LZString.compressToUTF16(stringPayload);
 
-          let pakoName = me.obfuscator.getStringCompressionLibraryName();
+          let stringCompressionLibraryName =
+            me.obfuscator.getStringCompressionLibraryName();
           let insertStringCompressionLibrary = !me.obfuscator.parentObfuscator;
 
           prependProgram(
@@ -95,19 +100,23 @@ export default ({ Plugin }: PluginArg): PluginObject => {
               stringName: me.getPlaceholder(),
               stringArray: me.getPlaceholder(),
               stringDelimiter: () => t.stringLiteral(stringDelimiter),
-              stringValue: () => t.stringLiteral(compressedBase64),
+              stringValue: () => t.stringLiteral(compressedString),
               GetGlobalTemplate: createGetGlobalTemplate(me, programPath),
               getGlobalFnName: me.getPlaceholder(),
-              pakoName: pakoName,
+              StringCompressionLibrary: stringCompressionLibraryName,
             })
           );
 
           if (insertStringCompressionLibrary) {
-            // RGF function should also clone the entire decompression function
+            // RGF functions should not clone the entire decompression function
             prependProgram(
               programPath,
-              Obfuscator.parseCode(PakoInflateMin.replace(/{pako}/g, pakoName))
-                .program.body
+              Obfuscator.parseCode(
+                StringCompressionLibraryMinified.replace(
+                  /{StringCompressionLibrary}/g,
+                  stringCompressionLibraryName
+                )
+              ).program.body
             )[0]
               .get("declarations")[0]
               .get("id").node[NO_RENAME] = true;