js-confuser 1.7.1 → 1.7.2

package/src/transforms/dispatcher.ts

@@ -34,14 +34,19 @@ import {
   isVarContext,
   prepend,
   append,
+  computeFunctionLength,
+  isFunction,
 } from "../util/insert";
 import Transform from "./transform";
 import { isInsideType } from "../util/compare";
 import { choice, shuffle } from "../util/random";
 import { ComputeProbabilityMap } from "../probability";
-import { reservedIdentifiers } from "../constants";
+import { predictableFunctionTag, reservedIdentifiers } from "../constants";
 import { ObfuscateOrder } from "../order";
 import Template from "../templates/template";
+import { FunctionLengthTemplate } from "../templates/functionLength";
+import { ObjectDefineProperty } from "../templates/globals";
+import { getLexicalScope } from "../util/scope";
 
 /**
  * A Dispatcher processes function calls. All the function declarations are brought into a dictionary.
@@ -72,12 +77,30 @@ export default class Dispatcher extends Transform {
   isDebug = false;
   count: number;
 
+  functionLengthName: string;
+
   constructor(o) {
     super(o, ObfuscateOrder.Dispatcher);
 
     this.count = 0;
   }
 
+  apply(tree: Node): void {
+    super.apply(tree);
+
+    if (this.options.preserveFunctionLength && this.functionLengthName) {
+      prepend(
+        tree,
+        FunctionLengthTemplate.single({
+          name: this.functionLengthName,
+          ObjectDefineProperty: this.createInitVariable(ObjectDefineProperty, [
+            tree,
+          ]),
+        })
+      );
+    }
+  }
+
   match(object: Node, parents: Node[]) {
     if (isInsideType("AwaitExpression", object, parents)) {
       return false;
@@ -113,6 +136,8 @@ export default class Dispatcher extends Transform {
           ? object
           : getVarContext(object, parents);
 
+        var lexicalScope = isFunction(context) ? context.body : context;
+
         walk(object, parents, (o: Node, p: Node[]) => {
           if (object == o) {
             // Fix 1
@@ -138,6 +163,15 @@ export default class Dispatcher extends Transform {
                 o.body.type != "BlockStatement"
               ) {
                 illegalFnNames.add(name);
+                return;
+              }
+
+              // Must defined in the same block as the current function being scanned
+              // Solves 'let' and 'class' declaration issue
+              var ls = getLexicalScope(o, p);
+              if (ls !== lexicalScope) {
+                illegalFnNames.add(name);
+                return;
               }
 
               // If dupe, no routing
@@ -217,11 +251,18 @@ export default class Dispatcher extends Transform {
 
         // Only make a dispatcher function if it caught any functions
         if (set.size > 0) {
+          if (!this.functionLengthName) {
+            this.functionLengthName = this.getPlaceholder();
+          }
+
           var payloadArg =
             this.getPlaceholder() + "_dispatcher_" + this.count + "_payload";
 
           var dispatcherFnName =
-            this.getPlaceholder() + "_dispatcher_" + this.count;
+            this.getPlaceholder() +
+            "_dispatcher_" +
+            this.count +
+            predictableFunctionTag;
 
           this.log(dispatcherFnName, set);
           this.count++;
@@ -253,6 +294,8 @@ export default class Dispatcher extends Transform {
                     expression: false,
                     type: "FunctionExpression",
                     id: null,
+                    params: [],
+                    [predictableFunctionTag]: true,
                   };
                   this.addComment(functionExpression, name);
 
@@ -272,48 +315,6 @@ export default class Dispatcher extends Transform {
                     );
 
                     prepend(def.body, variableDeclaration);
-
-                    // replace params with random identifiers
-                    var args = [0, 1, 2].map((x) => this.getPlaceholder());
-                    functionExpression.params = args.map((x) => Identifier(x));
-
-                    var deadCode = choice(["fakeReturn", "ifStatement"]);
-
-                    switch (deadCode) {
-                      case "fakeReturn":
-                        // Dead code...
-                        var ifStatement = IfStatement(
-                          UnaryExpression("!", Identifier(args[0])),
-                          [
-                            ReturnStatement(
-                              CallExpression(Identifier(args[1]), [
-                                ThisExpression(),
-                                Identifier(args[2]),
-                              ])
-                            ),
-                          ],
-                          null
-                        );
-
-                        body.unshift(ifStatement);
-                        break;
-
-                      case "ifStatement":
-                        var test = LogicalExpression(
-                          "||",
-                          Identifier(args[0]),
-                          AssignmentExpression(
-                            "=",
-                            Identifier(args[1]),
-                            CallExpression(Identifier(args[2]), [])
-                          )
-                        );
-                        def.body = BlockStatement([
-                          IfStatement(test, [...body], null),
-                          ReturnStatement(Identifier(args[1])),
-                        ]);
-                        break;
-                    }
                   }
 
                   // For logging purposes
@@ -380,6 +381,48 @@ export default class Dispatcher extends Transform {
                 null
               ),
 
+              VariableDeclaration(
+                VariableDeclarator(
+                  Identifier("lengths"),
+                  ObjectExpression(
+                    !this.options.preserveFunctionLength
+                      ? []
+                      : shuffledKeys
+                          .map((name) => {
+                            var [def, defParents] = functionDeclarations[name];
+
+                            return {
+                              key: newFnNames[name],
+                              value: computeFunctionLength(def.params),
+                            };
+                          })
+                          .filter((item) => item.value !== 0)
+                          .map((item) =>
+                            Property(Literal(item.key), Literal(item.value))
+                          )
+                  )
+                )
+              ),
+
+              Template(`
+              function makeFn${predictableFunctionTag}(){
+                var fn = function(...args){
+                  ${payloadArg} = args;
+                  return ${mapName}[${x}].call(this)
+                }, a = lengths[${x}]
+
+                ${
+                  this.options.preserveFunctionLength
+                    ? `if(a){
+                    return ${this.functionLengthName}(fn, a)
+                  }`
+                    : ""
+                }
+                
+                return fn
+              }
+              `).single(),
+
               // Arg to get a function reference
               IfStatement(
                 BinaryExpression("==", Identifier(y), Literal(expectedGet)),
@@ -403,30 +446,9 @@ export default class Dispatcher extends Transform {
                             Identifier(x),
                             true
                           ),
-                          FunctionExpression(
-                            [RestElement(Identifier(getterArgName))],
-                            [
-                              // Arg setter
-                              ExpressionStatement(
-                                AssignmentExpression(
-                                  "=",
-                                  Identifier(payloadArg),
-                                  Identifier(getterArgName)
-                                )
-                              ),
-
-                              // Call fn & return
-                              ReturnStatement(
-                                CallExpression(
-                                  MemberExpression(
-                                    getAccessor(),
-                                    Identifier("call"),
-                                    false
-                                  ),
-                                  [ThisExpression(), Literal(gen.generate())]
-                                )
-                              ),
-                            ]
+                          CallExpression(
+                            Identifier(`makeFn${predictableFunctionTag}`),
+                            []
                           )
                         )
                       )
@@ -439,7 +461,7 @@ export default class Dispatcher extends Transform {
                     AssignmentExpression(
                       "=",
                       Identifier(returnProp),
-                      CallExpression(getAccessor(), [Literal(gen.generate())])
+                      CallExpression(getAccessor(), [])
                     )
                   ),
                 ]

package/src/transforms/es5/antiClass.ts

@@ -94,8 +94,17 @@ export default class AntiClass extends Transform {
             first.expression.type == "CallExpression"
           ) {
             if (first.expression.callee.type == "Super") {
+              /// super(...args)
               superArguments = first.expression.arguments;
               value.body.body.shift();
+            } else if (
+              // F(super(...args))
+              first.expression.arguments[0] &&
+              first.expression.arguments[0].type === "CallExpression" &&
+              first.expression.arguments[0].callee.type === "Super"
+            ) {
+              superArguments = first.expression.arguments[0].arguments;
+              first.expression.arguments[0] = Identifier("undefined");
             }
           }
 
@@ -198,7 +207,7 @@ export default class AntiClass extends Transform {
       );
 
       if (superName) {
-        ok(superArguments, "Super class with no super arguments");
+        ok(superArguments, "Failed to find super() arguments");
 
         // save the super state
         virtualBody.unshift(

package/src/transforms/extraction/classExtraction.ts

@@ -0,0 +1,168 @@
+import { ok } from "assert";
+import { ExitCallback, getBlock, walk } from "../../traverse";
+import {
+  CallExpression,
+  FunctionDeclaration,
+  FunctionExpression,
+  Identifier,
+  Literal,
+  MemberExpression,
+  MethodDefinition,
+  Node,
+  ReturnStatement,
+  Super,
+  ThisExpression,
+} from "../../util/gen";
+import { isStringLiteral } from "../../util/guard";
+import { isClass, prepend } from "../../util/insert";
+import { getLexicalScope } from "../../util/scope";
+import Transform from "../transform";
+
+export default class ClassExtraction extends Transform {
+  constructor(o) {
+    super(o);
+  }
+
+  match(object: Node, parents: Node[]): boolean {
+    return (
+      object.type === "ClassDeclaration" || object.type === "ClassExpression"
+    );
+  }
+
+  extractKeyString(property: Node): string | null {
+    if (property.key.type === "Identifier" && !property.key.computed) {
+      return property.key.name;
+    }
+
+    if (isStringLiteral(property.key)) {
+      return property.key.value;
+    }
+
+    return null;
+  }
+
+  transform(object: Node, parents: Node[]): void | ExitCallback {
+    return () => {
+      var classBody = object.body;
+      var className = object.id?.type === "Identifier" && object.id?.name;
+
+      if (!className) className = this.getPlaceholder();
+
+      var lexicalScope = getLexicalScope(object, parents);
+
+      var superMethodName: string;
+
+      for (var methodDefinition of classBody.body) {
+        if (
+          methodDefinition.type === "MethodDefinition" &&
+          methodDefinition.value.type === "FunctionExpression"
+        ) {
+          // Don't change constructors calling super()
+          if (methodDefinition.kind === "constructor" && object.superClass)
+            continue;
+
+          var functionExpression: Node = methodDefinition.value;
+
+          var fnName =
+            className +
+              "_" +
+              methodDefinition.kind +
+              "_" +
+              this.extractKeyString(methodDefinition) || this.getPlaceholder();
+
+          walk(
+            functionExpression,
+            [methodDefinition, object, ...parents],
+            (o, p) => {
+              if (o.type === "Super") {
+                var classContext = p.find((node) => isClass(node));
+                if (classContext !== object) return;
+
+                return () => {
+                  if (!superMethodName) {
+                    superMethodName =
+                      this.getGenerator("randomized").generate();
+                  }
+
+                  var memberExpression = p[0];
+                  if (memberExpression.type === "CallExpression") {
+                    throw new Error("Failed to detect super() usage");
+                  }
+                  ok(memberExpression.type === "MemberExpression");
+
+                  var propertyArg = memberExpression.computed
+                    ? memberExpression.property
+                    : (ok(memberExpression.property.type === "Identifier"),
+                      Literal(memberExpression.property.name));
+
+                  var getSuperExpression = CallExpression(
+                    MemberExpression(
+                      ThisExpression(),
+                      Literal(superMethodName),
+                      true
+                    ),
+                    [propertyArg]
+                  );
+
+                  if (p[1].type === "CallExpression" && p[1].callee === p[0]) {
+                    getSuperExpression = CallExpression(
+                      MemberExpression(
+                        getSuperExpression,
+                        Literal("bind"),
+                        true
+                      ),
+                      [ThisExpression()]
+                    );
+                  }
+
+                  this.replace(p[0], getSuperExpression);
+                };
+              }
+            }
+          );
+
+          var originalParams = functionExpression.params;
+          var originalBody = functionExpression.body.body;
+
+          functionExpression.body.body = [
+            ReturnStatement(
+              CallExpression(
+                MemberExpression(Identifier(fnName), Literal("apply"), true),
+                [ThisExpression(), Identifier("arguments")]
+              )
+            ),
+          ];
+
+          functionExpression.params = [];
+          if (methodDefinition.kind === "set") {
+            functionExpression.params = [Identifier(this.getPlaceholder())];
+          }
+
+          prepend(
+            lexicalScope,
+            FunctionDeclaration(fnName, [...originalParams], [...originalBody])
+          );
+        }
+      }
+
+      if (superMethodName) {
+        classBody.body.push(
+          MethodDefinition(
+            Literal(superMethodName),
+            FunctionExpression(
+              [Identifier("key")],
+              [
+                ReturnStatement(
+                  MemberExpression(Super(), Identifier("key"), true)
+                ),
+              ]
+            ),
+            "method",
+            false,
+            true
+          )
+        );
+      }
+    };
+  }
+}

package/src/transforms/extraction/duplicateLiteralsRemoval.ts

@@ -16,15 +16,14 @@ import {
   ConditionalExpression,
 } from "../../util/gen";
 import { append, clone, prepend } from "../../util/insert";
-import { isDirective, isPrimitive } from "../../util/compare";
-
+import { isDirective, isModuleSource, isPrimitive } from "../../util/compare";
 import { ObfuscateOrder } from "../../order";
-import { isModuleSource } from "../string/stringConcealing";
 import { ComputeProbabilityMap } from "../../probability";
 import { ok } from "assert";
 import { chance, choice, getRandomInteger } from "../../util/random";
 import { getBlock } from "../../traverse";
 import { getIdentifierInfo } from "../../util/identifiers";
+import { predictableFunctionTag } from "../../constants";
 
 /**
  * [Duplicate Literals Removal](https://docs.jscrambler.com/code-integrity/documentation/transformations/duplicate-literals-removal) replaces duplicate literals with a variable name.
@@ -119,7 +118,7 @@ export default class DuplicateLiteralsRemoval extends Transform {
         ];
 
         // The function uses mangling to hide the index being accessed
-        var mangleCount = getRandomInteger(1, 10);
+        var mangleCount = getRandomInteger(1, 5);
         for (var i = 0; i < mangleCount; i++) {
           var operator = choice([">", "<"]);
           var compareValue = choice(indexRangeInclusive);
@@ -188,7 +187,7 @@ export default class DuplicateLiteralsRemoval extends Transform {
       var root = parents[parents.length - 1];
       var rootFunctionName = this.getPlaceholder() + "_dLR_0";
       this.functions.set(root, {
-        functionName: rootFunctionName,
+        functionName: rootFunctionName + predictableFunctionTag,
         indexShift: getRandomInteger(-100, 100),
       });
 
@@ -199,7 +198,10 @@ export default class DuplicateLiteralsRemoval extends Transform {
     var block = getBlock(object, parents);
     if (!this.functions.has(block) && chance(50 - this.functions.size)) {
       var newFunctionName =
-        this.getPlaceholder() + "_dLR_" + this.functions.size;
+        this.getPlaceholder() +
+        "_dLR_" +
+        this.functions.size +
+        predictableFunctionTag;
 
       this.functions.set(block, {
         functionName: newFunctionName,
@@ -224,7 +226,7 @@ export default class DuplicateLiteralsRemoval extends Transform {
     return () => {
       if (object.type === "Identifier") {
         var info = getIdentifierInfo(object, parents);
-        if (info.isLabel || info.spec.isDefined) return;
+        if (info.isLabel || info.spec.isDefined || info.spec.isModified) return;
       }
       if (object.regex) {
         return;
@@ -234,9 +236,6 @@ export default class DuplicateLiteralsRemoval extends Transform {
         return;
       }
 
-      // HARD CODED LIMIT of 10,000 (after 1,000 elements)
-      if (this.map.size > 1000 && chance(this.map.size / 100)) return;
-
       if (
         this.arrayName &&
         parents[0].object &&

package/src/transforms/extraction/objectExtraction.ts

@@ -1,19 +1,7 @@
 import Transform from "../transform";
 import { walk } from "../../traverse";
-import {
-  Node,
-  Location,
-  Identifier,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../../util/gen";
-import {
-  clone,
-  deleteDeclaration,
-  getVarContext,
-  isVarContext,
-  prepend,
-} from "../../util/insert";
+import { Node, Location, Identifier, VariableDeclarator } from "../../util/gen";
+import { getVarContext, isVarContext } from "../../util/insert";
 import { ObfuscateOrder } from "../../order";
 import { getIdentifierInfo } from "../../util/identifiers";
 import { isValidIdentifier } from "../../util/compare";
@@ -316,8 +304,9 @@ export default class ObjectExtraction extends Transform {
             ...variableDeclarators
           );
 
+          // const can only be safely changed to let
           if (declaration.kind === "const") {
-            declaration.kind = "var";
+            declaration.kind = "let";
           }
 
           // update all identifiers that pointed to the old object

package/src/transforms/flatten.ts

@@ -1,5 +1,9 @@
 import { ok } from "assert";
-import { noRenameVariablePrefix, reservedIdentifiers } from "../constants";
+import {
+  noRenameVariablePrefix,
+  predictableFunctionTag,
+  reservedIdentifiers,
+} from "../constants";
 import { ObfuscateOrder } from "../order";
 import { walk } from "../traverse";
 import {
@@ -35,6 +39,7 @@ import {
 import { shuffle } from "../util/random";
 import Transform from "./transform";
 import { FunctionLengthTemplate } from "../templates/functionLength";
+import { ObjectDefineProperty } from "../templates/globals";
 
 /**
  * Flatten takes functions and isolates them from their original scope, and brings it to the top level of the program.
@@ -235,7 +240,11 @@ export default class Flatten extends Transform {
         return;
       }
 
-      var newFnName = this.getPlaceholder() + "_flat_" + currentFnName;
+      var newFnName =
+        this.getPlaceholder() +
+        "_flat_" +
+        currentFnName +
+        predictableFunctionTag;
       var flatObjectName = this.getPlaceholder() + "_flat_object";
 
       const getFlatObjectMember = (propertyName: string) => {
@@ -498,15 +507,21 @@ export default class Flatten extends Transform {
       // Preserve function.length property
       var originalFunctionLength = computeFunctionLength(object.params);
 
-      object.params = [SpreadElement(Identifier(argumentsName))];
+      object.params = [RestElement(Identifier(argumentsName))];
 
-      if (originalFunctionLength !== 0) {
+      if (this.options.preserveFunctionLength && originalFunctionLength !== 0) {
         if (!this.functionLengthName) {
           this.functionLengthName = this.getPlaceholder();
 
           prepend(
             parents[parents.length - 1] || object,
-            FunctionLengthTemplate.single({ name: this.functionLengthName })
+            FunctionLengthTemplate.single({
+              name: this.functionLengthName,
+              ObjectDefineProperty: this.createInitVariable(
+                ObjectDefineProperty,
+                parents
+              ),
+            })
           );
         }