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

package/src/transforms/controlFlowFlattening.ts

@@ -1,7 +1,6 @@
 import traverse, { NodePath, Scope, Visitor } from "@babel/traverse";
 import { PluginArg, PluginObject } from "./plugin";
 import { Order } from "../order";
-import { computeProbabilityMap } from "../probability";
 import {
   ensureComputedExpression,
   getParentFunctionOrProgram,
@@ -30,9 +29,11 @@ import {
   PREDICTABLE,
   variableFunctionName,
   WITH_STATEMENT,
-  CONTROL_OBJECTS,
 } from "../constants";
 
+// Function deemed unsafe for CFF
+const CFF_UNSAFE = Symbol("CFF_UNSAFE");
+
 /**
  * Breaks functions into DAGs (Directed Acyclic Graphs)
  *
@@ -77,13 +78,44 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
   const functionsModified = new Set<t.Node>();
 
+  function flagFunctionToAvoid(path: NodePath, reason: string) {
+    var fnOrProgram = getParentFunctionOrProgram(path);
+
+    fnOrProgram.node[CFF_UNSAFE] = reason;
+  }
+
   return {
     post: () => {
       functionsModified.forEach((node) => {
         (node as NodeSymbol)[UNSAFE] = true;
       });
     },
+
     visitor: {
+      // Unsafe detection
+      ThisExpression(path) {
+        flagFunctionToAvoid(path, "this");
+      },
+      VariableDeclaration(path) {
+        if (path.node.declarations.length !== 1) {
+          path.getAncestry().forEach((p) => {
+            p.node[CFF_UNSAFE] = "multipleDeclarations";
+          });
+        }
+      },
+      Identifier(path) {
+        if (
+          path.node.name === variableFunctionName ||
+          path.node.name === "arguments"
+        ) {
+          flagFunctionToAvoid(path, "arguments");
+        }
+      },
+      "Super|MetaProperty|AwaitExpression|YieldExpression"(path) {
+        flagFunctionToAvoid(path, "functionSpecific");
+      },
+
+      // Main CFF transformation
       "Program|Function": {
         exit(_path) {
           let programOrFunctionPath = _path as NodePath<t.Program | t.Function>;
@@ -94,6 +126,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           )
             return;
 
+          // Exclude 'CFF_UNSAFE' functions
+          if (programOrFunctionPath.node[CFF_UNSAFE]) return;
+
           let programPath = _path.isProgram() ? _path : null;
           let functionPath = _path.isFunction() ? _path : null;
 
@@ -116,13 +151,16 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           if (blockPath.node.body.length < 3) return;
 
           // Check user's threshold setting
-          if (!computeProbabilityMap(me.options.controlFlowFlattening)) {
+          if (!me.computeProbabilityMap(me.options.controlFlowFlattening)) {
             return;
           }
 
-          // Avoid unsafe functions
-          if (functionPath && (functionPath.node as NodeSymbol)[UNSAFE]) return;
+          if (functionPath) {
+            // Avoid unsafe functions
+            if ((functionPath.node as NodeSymbol)[UNSAFE]) return;
 
+            if (functionPath.node.async || functionPath.node.generator) return;
+          }
           programOrFunctionPath.scope.crawl();
 
           const blockFnParent = getParentFunctionOrProgram(blockPath);
@@ -130,30 +168,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           let hasIllegalNode = false;
           const bindingNames = new Set<string>();
           blockPath.traverse({
-            "Super|MetaProperty|AwaitExpression|YieldExpression"(path) {
-              if (
-                getParentFunctionOrProgram(path).node === blockFnParent.node
-              ) {
-                hasIllegalNode = true;
-                path.stop();
-              }
-            },
-            VariableDeclaration(path) {
-              if (path.node.declarations.length !== 1) {
-                hasIllegalNode = true;
-                path.stop();
-              }
-            },
             Identifier(path) {
-              if (
-                path.node.name === variableFunctionName ||
-                path.node.name === "arguments"
-              ) {
-                hasIllegalNode = true;
-                path.stop();
-                return;
-              }
-
               if (!path.isBindingIdentifier()) return;
               const binding = path.scope.getBinding(path.node.name);
               if (!binding) return;
@@ -319,7 +334,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                     identity: "${this.propertyName}"
                   })
                     `).expression()
-                : new Template(`Object["create"](null)`).expression();
+                : new Template(`({})`).expression();
             }
 
             getMemberExpression(name: string) {
@@ -375,6 +390,25 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                 );
               }
 
+              if (this === mainScope) {
+                // Reset With logic
+                properties.push(
+                  t.objectProperty(
+                    t.stringLiteral(resetWithProperty),
+                    new Template(`
+                        (function(newStateValues, alwaysUndefined){
+                          {withMemberExpression} = alwaysUndefined;
+                          {arrayPattern} = newStateValues
+                        })
+                      `).expression({
+                      withMemberExpression: deepClone(withMemberExpression),
+                      arrayPattern: t.arrayPattern(deepClone(stateVars)),
+                    }),
+                    true
+                  )
+                );
+              }
+
               return t.objectExpression(properties);
             }
 
@@ -660,7 +694,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                   !flattenFunctionDeclarations ||
                   statement.node.async ||
                   statement.node.generator ||
-                  (statement.node as NodeSymbol)[UNSAFE]
+                  (statement.node as NodeSymbol)[UNSAFE] ||
+                  (statement.node as NodeSymbol)[CFF_UNSAFE] ||
+                  isStrictMode(statement)
                 ) {
                   isIllegal = true;
                 }
@@ -872,20 +908,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
           basicBlocks.get(endLabel).allowWithDiscriminant = false;
 
-          // Add with / reset with logic
-          basicBlocks.get(startLabel).body.unshift(
-            new Template(`
-              {resetWithMemberExpression} = function(newStateValues){
-                {withMemberExpression} = undefined;
-                {arrayPattern} = newStateValues
-              }
-              `).single({
-              arrayPattern: t.arrayPattern(deepClone(stateVars)),
-              resetWithMemberExpression: deepClone(resetWithMemberExpression),
-              withMemberExpression: deepClone(withMemberExpression),
-            })
-          );
-
           if (!isDebug && addDeadCode) {
             // DEAD CODE 1/3: Add fake chunks that are never reached
             const fakeChunkCount = getRandomInteger(1, 5);
@@ -1081,7 +1103,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                   const identifierName = path.node.name;
                   if (identifierName === gotoFunctionName) return;
 
-                  var binding = basicBlock.scope.getBinding(identifierName);
+                  var binding = path.scope.getBinding(identifierName);
                   if (!binding) {
                     return;
                   }
@@ -1139,6 +1161,17 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
                   path.replaceWith(memberExpression);
                   path.skip();
+
+                  // Preserve proper 'this' context when directly calling functions
+                  // X.Y.Z() -> (1, X.Y.Z)()
+                  if (
+                    path.parentPath.isCallExpression() &&
+                    path.key === "callee"
+                  ) {
+                    path.replaceWith(
+                      t.sequenceExpression([t.numericLiteral(1), path.node])
+                    );
+                  }
                 },
               },
 
@@ -1212,15 +1245,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                         // console.log(oldValue, newValue);
                         if (oldValue === newValue) continue; // No diff needed if the value doesn't change
 
-                        const leftValue = jumpBlock.withDiscriminant
-                          ? jumpBlock.withDiscriminant.getMemberExpression(
-                              stateVars[i].name
-                            )
-                          : deepClone(stateVars[i]);
-
                         let assignment = t.assignmentExpression(
                           "=",
-                          leftValue,
+                          deepClone(stateVars[i]),
                           numericLiteral(newValue)
                         );
 
@@ -1271,7 +1298,8 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           const mainScope = basicBlocks.get(startLabel).scopeManager;
           const predicateNumbers = new Map<string, number>();
           const predicateNumberCount =
-            isDebug || !addPredicateTests ? 0 : getRandomInteger(2, 5);
+            isDebug || !addPredicateTests ? 0 : getRandomInteger(1, 4);
+
           for (let i = 0; i < predicateNumberCount; i++) {
             const name = mainScope.getNewName(
               me.getPlaceholder("predicate_" + i)
@@ -1279,27 +1307,47 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
             const number = getRandomInteger(-250, 250);
             predicateNumbers.set(name, number);
+          }
 
-            const createAssignment = (value: number) => {
-              return new Template(`
-                {memberExpression} = {number}
-                `).single({
-                memberExpression: mainScope.getMemberExpression(name),
-                number: numericLiteral(number),
-              });
-            };
+          const predicateSymbol = Symbol("predicate");
+
+          const createAssignment = (values: number[]) => {
+            var exprStmt = new Template(`
+              ({predicateVariables} = {values})
+              `).single({
+              predicateVariables: t.arrayPattern(
+                Array.from(predicateNumbers.keys()).map((name) =>
+                  mainScope.getMemberExpression(name)
+                )
+              ),
+              values: t.arrayExpression(
+                values.map((value) => numericLiteral(value))
+              ),
+            });
 
-            basicBlocks.get(startLabel).body.unshift(createAssignment(number));
+            exprStmt[predicateSymbol] = true;
 
-            // Add random assignments to impossible blocks
-            var fakeAssignmentCount = getRandomInteger(0, 3);
-            for (let i = 0; i < fakeAssignmentCount; i++) {
-              var impossibleBlock = choice(getImpossibleBasicBlocks());
-              if (impossibleBlock) {
-                impossibleBlock.body.unshift(
-                  createAssignment(getRandomInteger(-250, 250))
-                );
-              }
+            return exprStmt;
+          };
+
+          basicBlocks
+            .get(startLabel)
+            .body.unshift(
+              createAssignment(Array.from(predicateNumbers.values()))
+            );
+
+          // Add random assignments to impossible blocks
+          var fakeAssignmentCount = getRandomInteger(1, 3);
+
+          for (let i = 0; i < fakeAssignmentCount; i++) {
+            var impossibleBlock = choice(getImpossibleBasicBlocks());
+            if (impossibleBlock) {
+              if (impossibleBlock.body[0]?.[predicateSymbol]) continue;
+
+              var fakeValues = new Array(predicateNumberCount)
+                .fill(0)
+                .map(() => getRandomInteger(-250, 250));
+              impossibleBlock.body.unshift(createAssignment(fakeValues));
             }
           }
 
@@ -1467,9 +1515,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             ),
             t.blockStatement([
               t.withStatement(
-                new Template(
-                  `{withDiscriminant} || Object["create"](null)`
-                ).expression({
+                new Template(`{withDiscriminant} || {}`).expression({
                   withDiscriminant: deepClone(withMemberExpression),
                 }),
                 t.blockStatement([switchStatement])
@@ -1533,6 +1579,17 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             );
           }
 
+          const startProgramObjectExpression = basicBlocks
+            .get(startLabel)
+            .scopeManager.getObjectExpression(startLabel);
+
+          const mainParameters: t.FunctionDeclaration["params"] = parameters;
+          const scopeParameter = mainParameters.pop() as t.Identifier;
+
+          mainParameters.push(
+            t.assignmentPattern(scopeParameter, startProgramObjectExpression)
+          );
+
           const mainFnDeclaration = t.functionDeclaration(
             deepClone(mainFnName),
             parameters,
@@ -1544,17 +1601,19 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           var startProgramExpression = t.callExpression(deepClone(mainFnName), [
             ...startStateValues.map((stateValue) => numericLiteral(stateValue)),
             t.identifier("undefined"),
-            basicBlocks
-              .get(startLabel)
-              .scopeManager.getObjectExpression(startLabel),
           ]);
 
-          var resultVar = withIdentifier("result");
-          var allowReturns = blockPath.find((p) => p.isFunction());
+          const resultVar = withIdentifier("result");
+
+          const isTopLevel = blockPath.isProgram();
+          const allowReturns =
+            !isTopLevel && blockPath.find((p) => p.isFunction());
+
+          const startPrefix = allowReturns ? `var {resultVar} = ` : "";
 
           const startProgramStatements = new Template(`
             ${allowReturns ? `var {didReturnVar};` : ""}
-            var {resultVar} = {startProgramExpression};
+            ${startPrefix}{startProgramExpression};
             ${
               allowReturns
                 ? `
@@ -1580,9 +1639,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           // Reset all bindings here
           blockPath.scope.bindings = Object.create(null);
 
-          // Bindings changed - breaking control objects
-          delete (blockPath.node as NodeSymbol)[CONTROL_OBJECTS];
-
           // Register new declarations
           for (var node of blockPath.get("body")) {
             blockPath.scope.registerDeclaration(node);

package/src/transforms/deadCode.ts

@@ -1,12 +1,11 @@
 import { PluginArg, PluginObject } from "./plugin";
-import { chance, choice } from "../utils/random-utils";
+import { choice } from "../utils/random-utils";
 import { deadCodeTemplates } from "../templates/deadCodeTemplates";
-import { computeProbabilityMap } from "../probability";
 import { Order } from "../order";
 import * as t from "@babel/types";
 import Template from "../templates/template";
-import { NameGen } from "../utils/NameGen";
 import { prepend } from "../utils/ast-utils";
+import PredicateGen from "../utils/PredicateGen";
 
 export default ({ Plugin }: PluginArg): PluginObject => {
   const me = Plugin(Order.DeadCode, {
@@ -14,7 +13,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
       deadCode: 0,
     },
   });
-  let created = 0;
+  let predicateGen = new PredicateGen(me);
 
   return {
     visitor: {
@@ -22,29 +21,41 @@ export default ({ Plugin }: PluginArg): PluginObject => {
         exit(blockPath) {
           if (blockPath.find((p) => me.isSkipped(p))) return;
 
-          if (!computeProbabilityMap(me.options.deadCode)) {
+          if (!me.computeProbabilityMap(me.options.deadCode)) {
             return;
           }
 
-          if (typeof me.options.deadCode !== "function") {
-            let suggestedMax = 25;
+          // Default limit on dead code
+          // May be overridden by user
+          if (
+            typeof me.options.deadCode !== "function" &&
+            typeof me.options.deadCode !== "object"
+          ) {
+            let suggestedMax = 20;
             if (me.obfuscator.parentObfuscator) {
               // RGF should contain less dead code
               suggestedMax = 5;
             }
 
-            if (created > suggestedMax && chance(created - suggestedMax))
+            if (me.changeData.deadCode >= suggestedMax) {
               return;
-            created++;
+            }
           }
 
+          // Increment dead code counter
+          me.changeData.deadCode++;
+
           var template = choice(deadCodeTemplates);
           var nodes = template.compile();
 
-          var containingFnName = me.getPlaceholder("dead_" + created);
+          var containingFnName = me.getPlaceholder(
+            "dead_" + me.changeData.deadCode
+          );
+
+          // Insert dummy function
+          prepend(
+            blockPath,
 
-          var newPath = blockPath.unshiftContainer(
-            "body",
             t.functionDeclaration(
               t.identifier(containingFnName),
               [],
@@ -52,29 +63,15 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             )
           );
 
-          // 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
-          );
-
-          me.changeData.deadCode++;
-
           prepend(
             blockPath,
             new Template(`
-              if("${randomProperty}" in ${containingFnName}) {
+              if({falsePredicate}) {
                 ${containingFnName}()
               }
-              `).single()
+              `).single({
+              falsePredicate: predicateGen.generateFalseExpression(blockPath),
+            })
           );
 
           me.skip(blockPath);

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 {
@@ -127,11 +126,31 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                   return;
                 }
 
+                var hasAssignmentPattern = false;
+
+                for (var param of path.get("params")) {
+                  if (param.isAssignmentPattern()) {
+                    hasAssignmentPattern = true;
+                    break;
+                  }
+                  param.traverse({
+                    AssignmentPattern(innerPath) {
+                      var fn = innerPath.getFunctionParent();
+                      if (fn === path) {
+                        hasAssignmentPattern = true;
+                        innerPath.stop();
+                      } else {
+                        innerPath.skip();
+                      }
+                    },
+                  });
+
+                  if (hasAssignmentPattern) break;
+                }
+
                 // Functions with default parameters are not fully supported
                 // (Could be a Function Expression referencing outer scope)
-                if (
-                  path.node.params.find((x) => x.type === "AssignmentPattern")
-                ) {
+                if (hasAssignmentPattern) {
                   illegalNames.add(name);
                   return;
                 }
@@ -146,7 +165,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;