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

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;
@@ -38,6 +38,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
   const me = Plugin(Order.StringConcealing, {
     changeData: {
       strings: 0,
+      decryptionFunctions: 0,
     },
   });
 
@@ -93,6 +94,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
       encoding.code = new Template(encoding.code);
     }
 
+    me.changeData.decryptionFunctions++;
     encodingImplementations[encoding.identity] = encoding;
 
     return encoding;
@@ -139,7 +141,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
                 // Check user setting
                 if (
-                  !computeProbabilityMap(
+                  !me.computeProbabilityMap(
                     me.options.stringConcealing,
                     originalValue
                   )
@@ -271,17 +273,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;
     }
 
@@ -155,6 +154,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
     fnPath.traverse({
       Identifier(path) {
         if (!isVariableIdentifier(path)) return;
+        if (fnPath.get("id") === path) return; // Skip this function's name (Test #21)
 
         if (reservedIdentifiers.has(path.node.name)) return;
         if (me.options.globalVariables.has(path.node.name)) return;

package/src/utils/NameGen.ts

@@ -1,9 +1,14 @@
 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 {
+  choice,
+  getRandomChineseString,
+  getRandomHexString,
+  getRandomInteger,
+} from "./random-utils";
 import { reservedKeywords, reservedObjectPrototype } from "../constants";
+import Obfuscator from "../obfuscator";
 
 /**
  * Generate random names for variables and properties.
@@ -33,7 +38,9 @@ export class NameGen {
       return value;
     }
 
-    var mode = computeProbabilityMap(this.identifierGenerator);
+    var mode = Obfuscator.prototype.computeProbabilityMap(
+      this.identifierGenerator
+    );
 
     const randomizedLength = getRandomInteger(6, 8);
 
@@ -68,6 +75,9 @@ export class NameGen {
       case "zeroWidth":
         return this.zeroWidthGenerator.generate();
 
+      case "chinese":
+        return getRandomChineseString(randomizedLength);
+
       default:
         throw new Error(
           "Invalid identifier generator mode: " + this.identifierGenerator

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/utils/random-utils.ts

@@ -41,6 +41,20 @@ export function getRandomHexString(length: number) {
     .toUpperCase();
 }
 
+/**
+ * @see https://github.com/MichaelXF/js-confuser/issues/150#issuecomment-2466159582
+ */
+export function getRandomChineseString(length: number) {
+  const characters: string[] = [];
+  for (let i = 0; i < length; i++)
+    characters.push(
+      String.fromCharCode(
+        Math.floor(Math.random() * (0x9fff - 0x4e00)) + 0x4e00
+      )
+    );
+  return characters.join("");
+}
+
 /**
  * Returns a random string.
  */

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));
   }
 

package/src/probability.ts

@@ -1,110 +0,0 @@
-import { ok } from "assert";
-import { createObject } from "./utils/object-utils";
-import { ProbabilityMap } from "./options";
-
-/**
- * Evaluates a ProbabilityMap.
- * @param map The setting object.
- * @param customFnArgs Args given to user-implemented function, such as a variable name.
- */
-export function computeProbabilityMap<
-  T,
-  F extends (...args: any[]) => any = (...args: any[]) => any
->(
-  map: ProbabilityMap<T, F>,
-  ...customImplementationArgs: F extends (...args: infer P) => any ? P : never
-): boolean | string {
-  if (!map) {
-    return false;
-  }
-  if (map === true || map === 1) {
-    return true;
-  }
-  if (typeof map === "number") {
-    return Math.random() < map;
-  }
-
-  if (typeof map === "function") {
-    return (map as Function)(...customImplementationArgs);
-  }
-
-  if (typeof map === "string") {
-    return map;
-  }
-
-  var asObject: { [mode: string]: number } = {};
-  if (Array.isArray(map)) {
-    map.forEach((x: any) => {
-      asObject[x.toString()] = 1;
-    });
-  } else {
-    asObject = map as any;
-  }
-
-  var total = Object.values(asObject).reduce((a, b) => a + b);
-  var percentages = createObject(
-    Object.keys(asObject),
-    Object.values(asObject).map((x) => x / total)
-  );
-
-  var ticket = Math.random();
-
-  var count = 0;
-  var winner = null;
-  Object.keys(percentages).forEach((key) => {
-    var x = Number(percentages[key]);
-
-    if (ticket >= count && ticket < count + x) {
-      winner = key;
-    }
-    count += x;
-  });
-
-  return winner;
-}
-
-/**
- * Determines if a probability map can return a positive result (true, or some string mode).
- * - Negative probability maps are used to remove transformations from running entirely.
- * @param map
- */
-export function isProbabilityMapProbable<T>(map: ProbabilityMap<T>): boolean {
-  ok(!Number.isNaN(map), "Numbers cannot be NaN");
-
-  if (!map || typeof map === "undefined") {
-    return false;
-  }
-  if (typeof map === "function") {
-    return true;
-  }
-  if (typeof map === "number") {
-    if (map > 1 || map < 0) {
-      throw new Error(`Numbers must be between 0 and 1 for 0% - 100%`);
-    }
-  }
-  if (Array.isArray(map)) {
-    ok(
-      map.length != 0,
-      "Empty arrays are not allowed for options. Use false instead."
-    );
-
-    if (map.length == 1) {
-      return !!map[0];
-    }
-  }
-  if (typeof map === "object") {
-    if (map instanceof Date) return true;
-    if (map instanceof RegExp) return true;
-
-    var keys = Object.keys(map);
-    ok(
-      keys.length != 0,
-      "Empty objects are not allowed for options. Use false instead."
-    );
-
-    if (keys.length == 1) {
-      return !!keys[0];
-    }
-  }
-  return true;
-}

package/src/transforms/functionOutlining.ts

@@ -1,225 +0,0 @@
-import { NodePath } from "@babel/traverse";
-import { PluginArg, PluginObject } from "./plugin";
-import { Order } from "../order";
-import { ensureComputedExpression, prepend } from "../utils/ast-utils";
-import * as t from "@babel/types";
-import { NameGen } from "../utils/NameGen";
-import { chance, getRandomInteger } from "../utils/random-utils";
-import { Binding, Visitor } from "@babel/traverse";
-import { computeProbabilityMap } from "../probability";
-
-function isSafeForOutlining(path: NodePath): {
-  isSafe: boolean;
-  bindings?: Binding[];
-} {
-  if (path.isIdentifier() || path.isLiteral()) return { isSafe: false };
-
-  // Skip direct invocations ('this' will be different)
-  if (path.key === "callee" && path.parentPath.isCallExpression()) {
-    return { isSafe: false };
-  }
-
-  // Skip typeof and delete expressions (identifier behavior is different)
-  if (path.key === "argument" && path.parentPath.isUnaryExpression()) {
-    return { isSafe: false };
-  }
-
-  if (
-    path.isReturnStatement() ||
-    path.isYieldExpression() ||
-    path.isAwaitExpression() ||
-    path.isContinueStatement() ||
-    path.isBreakStatement() ||
-    path.isThrowStatement() ||
-    path.isDebuggerStatement() ||
-    path.isImportDeclaration() ||
-    path.isExportDeclaration()
-  ) {
-    return { isSafe: false };
-  }
-
-  var isSafe = true;
-  var bindings: Binding[] = [];
-  var fnPath = path.getFunctionParent();
-
-  var visitor: Visitor = {
-    ThisExpression(path) {
-      isSafe = false;
-      path.stop();
-    },
-    Identifier(path) {
-      if (["arguments", "eval"].includes(path.node.name)) {
-        isSafe = false;
-        path.stop();
-      }
-    },
-    BindingIdentifier(path) {
-      var binding = path.scope.getBinding(path.node.name);
-      if (binding) {
-        bindings.push(binding);
-      }
-    },
-    // Function flow guard
-    "ReturnStatement|YieldExpression|AwaitExpression"(path) {
-      if (path.getFunctionParent() === fnPath) {
-        isSafe = false;
-        path.stop();
-      }
-    },
-  };
-
-  // Exclude 'ThisExpression' and semantic 'Identifier' nodes
-  if (visitor[path.type]) return { isSafe: false };
-
-  path.traverse(visitor);
-
-  return { isSafe, bindings };
-}
-
-export default ({ Plugin }: PluginArg): PluginObject => {
-  const me = Plugin(Order.FunctionOutlining, {
-    changeData: {
-      functionsMade: 0,
-    },
-  });
-
-  var changesMade = 0;
-
-  function checkProbability() {
-    if (!computeProbabilityMap(me.options.functionOutlining)) return false;
-
-    if (changesMade > 100 && chance(changesMade - 100)) return false;
-
-    return true;
-  }
-
-  return {
-    visitor: {
-      Block: {
-        exit(blockPath) {
-          if (blockPath.isProgram()) {
-            blockPath.scope.crawl();
-          }
-
-          if (blockPath.find((p) => me.isSkipped(p))) return;
-
-          if (!checkProbability()) return;
-
-          // Extract a random number of statements
-
-          var statements = blockPath.get("body");
-          // var startIndex = getRandomInteger(0, statements.length);
-          // var endIndex = getRandomInteger(startIndex, statements.length);
-
-          var startIndex = 0;
-          var endIndex = statements.length;
-
-          var extractedStatements = statements.slice(startIndex, endIndex);
-          if (!extractedStatements.length) return;
-
-          var bindings: Binding[] = [];
-
-          for (var statement of extractedStatements) {
-            // Don't override the control node
-            if (me.isSkipped(statement)) return;
-
-            var result = isSafeForOutlining(statement);
-            if (!result.isSafe) {
-              return;
-            }
-
-            bindings.push(...result.bindings);
-          }
-
-          const extractedStatementSet = new Set<NodePath>(extractedStatements);
-
-          for (var binding of bindings) {
-            for (var referencePath of binding.referencePaths) {
-              var found = referencePath.find((p) =>
-                extractedStatementSet.has(p)
-              );
-              if (!found) {
-                return;
-              }
-            }
-            for (var constantViolation of binding.constantViolations) {
-              var found = constantViolation.find((p) =>
-                extractedStatementSet.has(p)
-              );
-              if (!found) {
-                return;
-              }
-            }
-          }
-
-          changesMade++;
-
-          var isFirst = true;
-          for (var statement of extractedStatements) {
-            if (isFirst) {
-              isFirst = false;
-              var memberExpression = me
-                .getControlObject(blockPath)
-                .addProperty(
-                  t.functionExpression(
-                    null,
-                    [],
-                    t.blockStatement(extractedStatements.map((x) => x.node))
-                  )
-                );
-
-              me.changeData.functionsMade++;
-
-              var callExpression = t.callExpression(memberExpression, []);
-
-              statement.replaceWith(callExpression);
-              continue;
-            }
-            statement.remove();
-          }
-        },
-      },
-      Expression: {
-        exit(path) {
-          // Skip assignment left
-          if (
-            path.find(
-              (p) =>
-                p.key === "left" &&
-                p.parentPath?.type === "AssignmentExpression"
-            )
-          ) {
-            return;
-          }
-
-          if (!checkProbability()) return;
-
-          if (path.find((p) => me.isSkipped(p))) return;
-          if (!isSafeForOutlining(path).isSafe) return;
-
-          changesMade++;
-
-          var blockPath = path.find((p) => p.isBlock()) as NodePath<t.Block>;
-
-          var memberExpression = me
-            .getControlObject(blockPath)
-            .addProperty(
-              t.functionExpression(
-                null,
-                [],
-                t.blockStatement([t.returnStatement(t.cloneNode(path.node))])
-              )
-            );
-
-          me.changeData.functionsMade++;
-
-          var callExpression = t.callExpression(memberExpression, []);
-
-          ensureComputedExpression(path);
-          path.replaceWith(callExpression);
-          me.skip(path);
-        },
-      },
-    },
-  };
-};