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

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)]
                   )
                 ),
               ])
@@ -272,17 +295,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;

package/src/transforms/string/stringConcealing.ts

@@ -3,7 +3,6 @@ import { NodePath } from "@babel/traverse";
 import Template from "../../templates/template";
 import { PluginArg, PluginObject } from "../plugin";
 import { Order } from "../../order";
-import { computeProbabilityMap } from "../../probability";
 import { ok } from "assert";
 import { BufferToStringTemplate } from "../../templates/bufferToStringTemplate";
 import { createGetGlobalTemplate } from "../../templates/getGlobalTemplate";
@@ -22,6 +21,7 @@ import {
 import { CustomStringEncoding } from "../../options";
 import { createDefaultStringEncoding } from "./encoding";
 import { numericLiteral } from "../../utils/node";
+import { NO_REMOVE } from "../../constants";
 
 interface StringConcealingInterface {
   encodingImplementation: CustomStringEncoding;
@@ -139,7 +139,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
                 // Check user setting
                 if (
-                  !computeProbabilityMap(
+                  !me.computeProbabilityMap(
                     me.options.stringConcealing,
                     originalValue
                   )
@@ -271,17 +271,21 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             ok(encodingImplementation.code instanceof Template);
 
             // The decoder function
-            const decoder = encodingImplementation.code.compile({
-              fnName: decodeFnName,
-              __bufferToStringFunction__: bufferToStringName,
-            });
+            const decoder = encodingImplementation.code
+              .addSymbols(NO_REMOVE)
+              .compile({
+                fnName: decodeFnName,
+                __bufferToStringFunction__: bufferToStringName,
+              });
 
             // The main function to get the string value
             const retrieveFunctionDeclaration = new Template(`
               function ${fnName}(index) {
                 return ${decodeFnName}(${stringArrayName}[index]);
               }
-            `).single<t.FunctionDeclaration>();
+            `)
+              .addSymbols(NO_REMOVE)
+              .single<t.FunctionDeclaration>();
 
             prepend(block, [...decoder, retrieveFunctionDeclaration]);
           }

package/src/transforms/string/stringEncoding.ts

@@ -1,8 +1,8 @@
 import { PluginInstance, PluginObject } from "../plugin";
 import * as t from "@babel/types";
 import { choice } from "../../utils/random-utils";
-import { computeProbabilityMap } from "../../probability";
 import { GEN_NODE, NodeSymbol } from "../../constants";
+import { isModuleImport } from "../../utils/ast-utils";
 
 function pad(x: string, len: number): string {
   while (x.length < len) {
@@ -51,10 +51,14 @@ export default (me: PluginInstance): PluginObject => {
     visitor: {
       StringLiteral: {
         exit(path) {
+          // Ignore module imports
+          if (isModuleImport(path)) return;
+
           const { value } = path.node;
 
           // Allow percentages
-          if (!computeProbabilityMap(me.options.stringEncoding, value)) return;
+          if (!me.computeProbabilityMap(me.options.stringEncoding, value))
+            return;
 
           var type = choice(["hexadecimal", "unicode"]);
 

package/src/transforms/string/stringSplitting.ts

@@ -1,10 +1,12 @@
-import { PluginArg, PluginInstance, PluginObject } from "../plugin";
+import { PluginArg, PluginObject } from "../plugin";
 import { getRandomInteger, splitIntoChunks } from "../../utils/random-utils";
-import { computeProbabilityMap } from "../../probability";
 import { binaryExpression, stringLiteral } from "@babel/types";
 import { ok } from "assert";
 import { Order } from "../../order";
-import { ensureComputedExpression } from "../../utils/ast-utils";
+import {
+  ensureComputedExpression,
+  isModuleImport,
+} from "../../utils/ast-utils";
 
 export default ({ Plugin }: PluginArg): PluginObject => {
   const me = Plugin(Order.StringSplitting, {
@@ -19,6 +21,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
         exit(path) {
           var object = path.node;
 
+          // Don't change module imports
+          if (isModuleImport(path)) return;
+
           var size = Math.round(
             Math.max(6, object.value.length / getRandomInteger(3, 8))
           );
@@ -32,7 +37,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           }
 
           if (
-            !computeProbabilityMap(me.options.stringSplitting, object.value)
+            !me.computeProbabilityMap(me.options.stringSplitting, object.value)
           ) {
             return;
           }

package/src/transforms/variableMasking.ts

@@ -2,7 +2,6 @@ import { Binding, NodePath } from "@babel/traverse";
 import { PluginArg, PluginObject } from "./plugin";
 import * as t from "@babel/types";
 import Template from "../templates/template";
-import { computeProbabilityMap } from "../probability";
 import { Order } from "../order";
 import {
   NodeSymbol,
@@ -65,7 +64,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
     const functionName = getFunctionName(fnPath);
 
-    if (!computeProbabilityMap(me.options.variableMasking, functionName)) {
+    if (!me.computeProbabilityMap(me.options.variableMasking, functionName)) {
       return;
     }
 

package/src/utils/NameGen.ts

@@ -2,8 +2,8 @@ import { ok } from "assert";
 import { ObfuscateOptions } from "../options";
 import { alphabeticalGenerator, createZeroWidthGenerator } from "./gen-utils";
 import { choice, getRandomHexString, getRandomInteger } from "./random-utils";
-import { computeProbabilityMap } from "../probability";
 import { reservedKeywords, reservedObjectPrototype } from "../constants";
+import Obfuscator from "../obfuscator";
 
 /**
  * Generate random names for variables and properties.
@@ -33,7 +33,9 @@ export class NameGen {
       return value;
     }
 
-    var mode = computeProbabilityMap(this.identifierGenerator);
+    var mode = Obfuscator.prototype.computeProbabilityMap(
+      this.identifierGenerator
+    );
 
     const randomizedLength = getRandomInteger(6, 8);
 

package/src/utils/PredicateGen.ts

@@ -0,0 +1,61 @@
+import { NodePath } from "@babel/traverse";
+import { PluginInstance } from "../transforms/plugin";
+import * as t from "@babel/types";
+import { prepend } from "./ast-utils";
+import { NameGen } from "./NameGen";
+import Template from "../templates/template";
+
+export default class PredicateGen {
+  constructor(public plugin: PluginInstance) {}
+
+  dummyFunctionName: string | null = null;
+  programPath: NodePath<t.Program> | null = null;
+
+  ensureCreated() {
+    if (this.dummyFunctionName) return;
+
+    this.dummyFunctionName = this.plugin.getPlaceholder("dummyFunction");
+
+    // Insert dummy function
+    prepend(
+      this.programPath,
+
+      this.plugin.skip(
+        t.functionDeclaration(
+          t.identifier(this.dummyFunctionName),
+          [],
+          t.blockStatement([])
+        )
+      )
+    );
+  }
+
+  generateTrueExpression(path: NodePath): t.Expression {
+    return t.unaryExpression("!", this.generateFalseExpression(path));
+  }
+
+  generateFalseExpression(path: NodePath): t.Expression {
+    this.programPath = path.find((p) => p.isProgram()) as NodePath<t.Program>;
+    this.ensureCreated();
+
+    // Overcomplicated way to get a random property name that doesn't exist on the Function
+    var randomProperty: string;
+    var nameGen = new NameGen("randomized");
+
+    function PrototypeCollision() {}
+    PrototypeCollision(); // Call it for code coverage :D
+
+    do {
+      randomProperty = nameGen.generate();
+    } while (
+      !randomProperty ||
+      PrototypeCollision[randomProperty] !== undefined
+    );
+
+    return this.plugin.skip(
+      new Template(
+        `"${randomProperty}" in ${this.dummyFunctionName}`
+      ).expression()
+    );
+  }
+}

package/src/utils/ast-utils.ts

@@ -312,17 +312,21 @@ export function prepend(
     // Preserve import declarations
     // Filter out import declarations
     const body = listParent.get("body");
-    const lastImportIndex = body.findIndex(
-      (path) => !path.isImportDeclaration()
-    );
+    let afterImport = 0;
+    for (var stmt of body) {
+      if (!stmt.isImportDeclaration()) {
+        break;
+      }
+      afterImport++;
+    }
 
-    if (lastImportIndex === 0 || lastImportIndex === -1) {
-      // No non-import declarations, so we can safely unshift everything
+    if (afterImport === 0) {
+      // No import declarations, so we can safely unshift everything
       return registerPaths(listParent.unshiftContainer("body", nodes));
-    } else {
-      // Insert the nodes after the last import declaration
-      return registerPaths(body[lastImportIndex - 1].insertAfter(nodes));
     }
+
+    // Insert the nodes after the last import declaration
+    return registerPaths(body[afterImport - 1].insertAfter(nodes));
   }
 
   if (listParent.isFunction()) {
@@ -343,7 +347,9 @@ export function prepend(
 
   if (listParent.isBlock()) {
     return registerPaths(listParent.unshiftContainer("body", nodes));
-  } else if (listParent.isSwitchCase()) {
+  }
+
+  if (listParent.isSwitchCase()) {
     return registerPaths(listParent.unshiftContainer("consequent", nodes));
   }
 
@@ -356,6 +362,7 @@ export function prependProgram(
 ) {
   var program = path.find((p) => p.isProgram());
   ok(program);
+  ok(program.isProgram());
   return prepend(program, ...nodes);
 }
 

package/src/validateOptions.ts

@@ -190,10 +190,6 @@ export function applyDefaultsToOptions(
         "alert",
         "confirm",
         "location",
-        "btoa",
-        "atob",
-        "unescape",
-        "encodeURIComponent",
       ].forEach((x) => options.globalVariables.add(x));
     } else {
       // node
@@ -248,7 +244,14 @@ export function applyDefaultsToOptions(
       "Uint8Array",
       "Uint16Array",
       "Uint32Array",
+      "Int8Array",
+      "Int16Array",
+      "Int32Array",
       "ArrayBuffer",
+      "btoa",
+      "atob",
+      "unescape",
+      "encodeURIComponent",
     ].forEach((x) => options.globalVariables.add(x));
   }