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

package/src/transforms/identifier/globalConcealing.ts

@@ -4,10 +4,10 @@ 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,
+  reservedNodeModuleIdentifiers,
   variableFunctionName,
 } from "../../constants";
 import {
@@ -16,11 +16,15 @@ import {
   prepend,
 } from "../../utils/ast-utils";
 import { createGetGlobalTemplate } from "../../templates/getGlobalTemplate";
-import { getRandomInteger, getRandomString } from "../../utils/random-utils";
+import {
+  getRandomInteger,
+  getRandomString,
+  shuffle,
+} from "../../utils/random-utils";
 import { ok } from "assert";
 
 const ignoreGlobals = new Set([
-  "require",
+  ...reservedNodeModuleIdentifiers,
   "__dirname",
   "eval",
   "arguments",
@@ -52,19 +56,21 @@ export default ({ Plugin }: PluginArg): PluginObject => {
     }
 
     const createSwitchStatement = () => {
-      const cases = Array.from(globalMapping.keys()).map((originalName) => {
-        var mappedKey = globalMapping.get(originalName);
-
-        return t.switchCase(t.stringLiteral(mappedKey), [
-          t.returnStatement(
-            t.memberExpression(
-              t.identifier(globalVarName),
-              t.stringLiteral(originalName),
-              true
-            )
-          ),
-        ]);
-      });
+      const cases = shuffle(Array.from(globalMapping.keys())).map(
+        (originalName) => {
+          var mappedKey = globalMapping.get(originalName);
+
+          return t.switchCase(t.stringLiteral(mappedKey), [
+            t.returnStatement(
+              t.memberExpression(
+                t.identifier(globalVarName),
+                t.stringLiteral(originalName),
+                true
+              )
+            ),
+          ]);
+        }
+      );
 
       return t.switchStatement(t.identifier("mapping"), cases);
     };
@@ -132,7 +138,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,
@@ -30,6 +28,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
   const definedMap = new Map<t.Node, Set<string>>();
   const referencedMap = new Map<t.Node, Set<string>>();
+  const paramMap = new Map<t.Node, Set<string>>(); // Used for default function parameter special case
   const bindingMap = new Map<t.Node, Map<string, NodePath<t.Identifier>>>();
 
   const renamedVariables = new Map<t.Node, Map<string, string>>();
@@ -50,9 +49,12 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             ];
 
             let isDefined = false;
+            let isParameter = false;
 
             if (path.isBindingIdentifier() && isDefiningIdentifier(path)) {
               isDefined = true;
+              const binding = path.scope.getBinding(path.node.name);
+              if (binding?.kind === "param") isParameter = true;
 
               // Function ID is defined in the parent's function declaration
               if (
@@ -117,7 +119,30 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
       var newName = null;
 
+      const skippedPaths = new Set();
+
       for (let contextPath of contextPaths) {
+        if (skippedPaths.has(contextPath)) continue;
+
+        if (contextPath.isFunction()) {
+          var assignmentPattern = contextPath.find(
+            (p) => p.listKey === "params" && p.parentPath.isFunction()
+          );
+
+          if (assignmentPattern?.isAssignmentPattern()) {
+            var functionPath = assignmentPattern.getFunctionParent();
+
+            if (functionPath) {
+              // The parameters can be still accessed...
+              const params = paramMap.get(functionPath.node);
+              if (params?.has(identifierName)) {
+              } else {
+                skippedPaths.add(functionPath);
+              }
+            }
+          }
+        }
+
         const { node } = contextPath;
 
         const defined = definedMap.get(node);
@@ -140,6 +165,17 @@ export default ({ Plugin }: PluginArg): PluginObject => {
         // 5. Update Identifier node's 'name' property
         node.name = newName;
         node[RENAMED] = true;
+
+        // 6. Additional parameter mapping
+        const binding = identifierPath.scope.getBinding(identifierName);
+        if (binding?.kind === "param") {
+          var mapNode = binding.scope.path.node;
+          if (!paramMap.has(mapNode)) {
+            paramMap.set(mapNode, new Set([identifierName]));
+          } else {
+            paramMap.get(mapNode).add(identifierName);
+          }
+        }
       }
     },
 
@@ -215,19 +251,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/integrity.ts

@@ -5,6 +5,7 @@ import { HashFunction } from "../../templates/integrityTemplate";
 import * as t from "@babel/types";
 import Template from "../../templates/template";
 import { NodePath } from "@babel/traverse";
+import { NameGen } from "../../utils/NameGen";
 
 export interface IntegrityInterface {
   fnPath: NodePath<t.FunctionDeclaration>;
@@ -32,6 +33,11 @@ export default ({ Plugin }: PluginArg): PluginObject => {
     },
   });
 
+  const nameGen = new NameGen(me.options.identifierGenerator, {
+    avoidObjectPrototype: true,
+    avoidReserved: true,
+  });
+
   return {
     visitor: {
       Program: {
@@ -78,12 +84,16 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
           var hashCode = HashFunction(codeTrimmed, seed);
 
+          const selfName = funcDecPath.node.id.name;
+          const selfCacheProperty = nameGen.generate();
+          const selfCacheString = `${selfName}.${selfCacheProperty}`;
+
           // me.log(codeTrimmed, hashCode);
           me.changeData.functions++;
 
           funcDecPath.node.body = t.blockStatement(
             new Template(`
-              var hash = ${obfuscatedHashFnName}(${newFunctionDeclaration.id.name}, ${seed});
+              var hash = ${selfCacheString} || (${selfCacheString} = ${obfuscatedHashFnName}(${newFunctionDeclaration.id.name}, ${seed}));
           if(hash === ${hashCode}) {
             {originalBody}
           } else {

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: [
         `
@@ -107,6 +116,13 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             }
           }
 
+          // Prepack Breaker
+          if(Math.random() > 1) {
+            while(true) {
+            console.log("Prepack Breaker");
+            }
+          }
+
           return namedFunction();
         }
     )();
@@ -127,7 +143,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");
@@ -149,15 +165,13 @@ export default ({ Plugin }: PluginArg): PluginObject => {
   };
   me.globalState.lock.createCountermeasuresCode = createCountermeasuresCode;
 
-  function applyLockToBlock(path: NodePath<t.Block>, customLock: CustomLock) {
-    let times = timesMap.get(customLock);
+  const defaultMaxCount = me.options.lock.defaultMaxCount ?? 25;
 
-    if (typeof times === "undefined") {
-      times = 0;
-    }
+  function applyLockToBlock(path: NodePath<t.Block>, customLock: CustomLock) {
+    let times = timesMap.get(customLock) || 0;
 
-    let maxCount = customLock.maxCount || 100; // 100 is default max count
-    let minCount = customLock.minCount || 1; // 1 is default min count
+    let maxCount = customLock.maxCount ?? defaultMaxCount; // 25 is default max count
+    let minCount = customLock.minCount ?? 1; // 1 is default min count
 
     if (maxCount >= 0 && times > maxCount) {
       // Limit creation, allowing -1 to disable the limit entirely
@@ -356,7 +370,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", () =>
@@ -18,6 +23,45 @@ identifierMap.set("Infinity", () =>
   t.binaryExpression("/", t.numericLiteral(1), t.numericLiteral(0))
 );
 
+function trySimpleDestructuring(id, init) {
+  // Simple array/object destructuring
+  if (id.isArrayPattern() && init.isArrayExpression()) {
+    const elements = id.get("elements");
+    const initElements = init.get("elements");
+
+    if (elements.length === 1 && initElements.length === 1) {
+      id.replaceWith(elements[0]);
+      init.replaceWith(initElements[0]);
+    }
+  }
+
+  if (id.isObjectPattern() && init.isObjectExpression()) {
+    const properties = id.get("properties");
+    const initProperties = init.get("properties");
+
+    if (properties.length === 1 && initProperties.length === 1) {
+      const firstProperty = properties[0];
+      const firstInitProperty = initProperties[0];
+
+      if (
+        firstProperty.isObjectProperty() &&
+        firstInitProperty.isObjectProperty()
+      ) {
+        const firstKey = firstProperty.get("key");
+        const firstInitKey = firstInitProperty.get("key");
+        if (
+          firstKey.isIdentifier() &&
+          firstInitKey.isIdentifier() &&
+          firstKey.node.name === firstInitKey.node.name
+        ) {
+          id.replaceWith(firstProperty.node.value);
+          init.replaceWith(firstInitProperty.node.value);
+        }
+      }
+    }
+  }
+}
+
 /**
  * Minify removes unnecessary code and shortens the length for file size.
  *
@@ -120,6 +164,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 +272,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 (
@@ -241,42 +299,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           const id = path.get("id");
           const init = path.get("init");
 
-          // Simple array/object destructuring
-          if (id.isArrayPattern() && init.isArrayExpression()) {
-            const elements = id.get("elements");
-            const initElements = init.get("elements");
-
-            if (elements.length === 1 && initElements.length === 1) {
-              id.replaceWith(elements[0]);
-              init.replaceWith(initElements[0]);
-            }
-          }
-
-          if (id.isObjectPattern() && init.isObjectExpression()) {
-            const properties = id.get("properties");
-            const initProperties = init.get("properties");
-
-            if (properties.length === 1 && initProperties.length === 1) {
-              const firstProperty = properties[0];
-              const firstInitProperty = initProperties[0];
-
-              if (
-                firstProperty.isObjectProperty() &&
-                firstInitProperty.isObjectProperty()
-              ) {
-                const firstKey = firstProperty.get("key");
-                const firstInitKey = firstInitProperty.get("key");
-                if (
-                  firstKey.isIdentifier() &&
-                  firstInitKey.isIdentifier() &&
-                  firstKey.node.name === firstInitKey.node.name
-                ) {
-                  id.replaceWith(firstProperty.node.value);
-                  init.replaceWith(firstInitProperty.node.value);
-                }
-              }
-            }
-          }
+          trySimpleDestructuring(id, init);
 
           // Remove unused variables
           // Can only remove if it's pure
@@ -285,6 +308,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 (
@@ -304,6 +330,27 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           }
         },
       },
+      // Simple destructuring
+      // Simple arithmetic operations
+      AssignmentExpression: {
+        exit(path) {
+          if (path.node.operator === "=") {
+            trySimpleDestructuring(path.get("left"), path.get("right"));
+          }
+          if (path.node.operator === "+=") {
+            const left = path.get("left");
+            const right = path.get("right");
+
+            // a += 1 -> a++
+            if (right.isNumericLiteral({ value: 1 })) {
+              if (left.isIdentifier() || left.isMemberExpression()) {
+                path.replaceWith(t.updateExpression("++", left.node));
+              }
+            }
+          }
+        },
+      },
+
       // return undefined->return
       ReturnStatement: {
         exit(path) {

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,13 +24,13 @@ 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++;
 
     const depth = path.getAncestry().length;
 
-    return chance(1000 - transformCount - depth * 100);
+    return chance(500 - transformCount - depth * 100);
   }
 
   function wrapWithPredicate(path: NodePath) {

package/src/transforms/pack.ts

@@ -10,22 +10,43 @@ import {
   GEN_NODE,
   NodeSymbol,
   reservedIdentifiers,
+  reservedNodeModuleIdentifiers,
   variableFunctionName,
   WITH_STATEMENT,
 } from "../constants";
 import { PluginArg, PluginObject } from "./plugin";
 import { Order } from "../order";
 
+export interface PackInterface {
+  objectName: string;
+  mappings: Map<string, string>;
+  setterPropsNeeded: Set<string>;
+  typeofMappings: Map<string, string>;
+}
+
 export default function pack({ Plugin }: PluginArg): PluginObject {
   const me = Plugin(Order.Pack, {
     changeData: {
       globals: 0,
     },
   });
-  const objectName = me.obfuscator.nameGen.generate();
-  const mappings = new Map<string, string>();
-  const setterPropsNeeded = new Set<string>();
-  const typeofMappings = new Map<string, string>();
+
+  // RGF functions will re-use parent Pack Interface
+  let packInterface = me.obfuscator.parentObfuscator?.packInterface;
+
+  // Create new Pack Interface (root)
+  if (!packInterface) {
+    packInterface = {
+      objectName: me.obfuscator.nameGen.generate(),
+      mappings: new Map<string, string>(),
+      setterPropsNeeded: new Set<string>(),
+      typeofMappings: new Map<string, string>(),
+    };
+    me.obfuscator.packInterface = packInterface;
+  }
+
+  const { objectName, mappings, setterPropsNeeded, typeofMappings } =
+    packInterface;
 
   const prependNodes: t.Statement[] = [];
 
@@ -53,10 +74,23 @@ export default function pack({ Plugin }: PluginArg): PluginObject {
 
           const identifierName = path.node.name;
           if (reservedIdentifiers.has(identifierName)) return;
-          if (me.obfuscator.options.globalVariables.has(identifierName)) return;
+          if (
+            me.options.target === "node" &&
+            reservedNodeModuleIdentifiers.has(identifierName)
+          ) {
+            // Allow module.exports and require
+          } else {
+            if (me.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" &&
@@ -105,6 +139,8 @@ export default function pack({ Plugin }: PluginArg): PluginObject {
     // Final AST handler
     // Very last step in the obfuscation process
     finalASTHandler(ast) {
+      if (me.obfuscator.parentObfuscator) return ast; // Only for root obfuscator
+
       // Create object expression
       // Very similar to flatten, maybe refactor to use the same code
       const objectProperties: t.ObjectMethod[] = [];