js-confuser 1.7.1 → 1.7.3

package/src/transforms/dispatcher.ts

@@ -34,14 +34,20 @@ 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";
+import { isJSConfuserVar } from "../util/guard";
 
 /**
  * A Dispatcher processes function calls. All the function declarations are brought into a dictionary.
@@ -72,12 +78,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;
@@ -86,8 +110,8 @@ export default class Dispatcher extends Transform {
     return (
       isVarContext(object) &&
       object.type !== "ArrowFunctionExpression" &&
-      !object.$dispatcherSkip &&
-      !parents.find((x) => x.$dispatcherSkip)
+      !object.$multiTransformSkip &&
+      !parents.find((x) => x.$multiTransformSkip)
     );
   }
 
@@ -113,6 +137,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
@@ -133,11 +159,20 @@ export default class Dispatcher extends Transform {
                 o.async ||
                 o.generator ||
                 p.find(
-                  (x) => x.$dispatcherSkip || x.type == "MethodDefinition"
+                  (x) => x.$multiTransformSkip || x.type == "MethodDefinition"
                 ) ||
                 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
@@ -181,6 +216,9 @@ export default class Dispatcher extends Transform {
             if (!info.spec.isReferenced) {
               return;
             }
+            if (isJSConfuserVar(p)) {
+              illegalFnNames.add(o.name);
+            }
             if (info.spec.isDefined) {
               if (info.isFunctionDeclaration) {
                 if (
@@ -217,11 +255,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 +298,8 @@ export default class Dispatcher extends Transform {
                     expression: false,
                     type: "FunctionExpression",
                     id: null,
+                    params: [],
+                    [predictableFunctionTag]: true,
                   };
                   this.addComment(functionExpression, name);
 
@@ -272,48 +319,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 +385,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))
+                          )
+                  )
+                )
+              ),
+
+              new 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 +450,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 +465,7 @@ export default class Dispatcher extends Transform {
                     AssignmentExpression(
                       "=",
                       Identifier(returnProp),
-                      CallExpression(getAccessor(), [Literal(gen.generate())])
+                      CallExpression(getAccessor(), [])
                     )
                   ),
                 ]
@@ -603,7 +629,7 @@ export default class Dispatcher extends Transform {
             VariableDeclaration(
               VariableDeclarator(
                 Identifier(cacheName),
-                Template(`Object.create(null)`).single().expression
+                new Template(`Object.create(null)`).single().expression
               )
             )
           );

package/src/transforms/es5/antiClass.ts

@@ -46,8 +46,10 @@ export default class AntiClass extends Transform {
       var thisName = "this" + this.getPlaceholder();
 
       // self this
-      virtualBody.push(Template(`var ${thisName} = this;`).single());
-      virtualBody.push(Template(`${thisName}["constructor"] = null;`).single());
+      virtualBody.push(new Template(`var ${thisName} = this;`).single());
+      virtualBody.push(
+        new Template(`${thisName}["constructor"] = null;`).single()
+      );
       var superArguments;
       var superBody = [];
 
@@ -60,14 +62,14 @@ export default class AntiClass extends Transform {
 
       // getters/setters
       virtualBody.push(
-        Template(
+        new Template(
           `var ${virtualDescriptorsName} = {getters: {}, setters: {}}`
         ).single()
       );
 
       // getters/setters
       staticBody.push(
-        Template(
+        new Template(
           `var ${staticDescriptorsName} = {getters: {}, setters: {}}`
         ).single()
       );
@@ -94,8 +96,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");
             }
           }
 
@@ -160,7 +171,7 @@ export default class AntiClass extends Transform {
       });
 
       virtualBody.push(
-        Template(`
+        new Template(`
       [...Object.keys(${virtualDescriptorsName}.getters), ...Object.keys(${virtualDescriptorsName}.setters)].forEach(key=>{
   
         if( !${thisName}.hasOwnProperty(key) ) {
@@ -179,7 +190,7 @@ export default class AntiClass extends Transform {
       );
 
       staticBody.push(
-        Template(`
+        new Template(`
       [...Object.keys(${staticDescriptorsName}.getters), ...Object.keys(${staticDescriptorsName}.setters)].forEach(key=>{
   
         if( !${virtualName}.hasOwnProperty(key) ) {
@@ -198,11 +209,11 @@ 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(
-          Template(
+          new Template(
             `
             Object.keys(this).forEach(key=>{
               var descriptor = Object.getOwnPropertyDescriptor(this, key);
@@ -224,17 +235,17 @@ export default class AntiClass extends Transform {
           )
         );
 
-        virtualBody.unshift(Template(`var ${superName} = {}`).single());
+        virtualBody.unshift(new Template(`var ${superName} = {}`).single());
       }
 
       virtualBody.push(
-        Template(
+        new Template(
           `if(!this["constructor"]){this["constructor"] = ()=>{}};`
         ).single()
       );
       if (object.id && object.id.name) {
         virtualBody.push(
-          Template(`Object.defineProperty(this["constructor"], 'name', {
+          new Template(`Object.defineProperty(this["constructor"], 'name', {
           writable: true,
           configurable: true,
           value: '${object.id.name}'
@@ -242,7 +253,9 @@ export default class AntiClass extends Transform {
         );
       }
 
-      virtualBody.push(Template(`this["constructor"](...arguments)`).single());
+      virtualBody.push(
+        new Template(`this["constructor"](...arguments)`).single()
+      );
 
       var virtualFunction = FunctionExpression([], virtualBody);
 

package/src/transforms/es5/antiDestructuring.ts

@@ -126,7 +126,7 @@ class AntiDestructuringParameters extends Transform {
             VariableDeclaration(
               VariableDeclarator(
                 arrayPattern,
-                Template(`Array.prototype.slice.call(arguments)`).single()
+                new Template(`Array.prototype.slice.call(arguments)`).single()
                   .expression
               )
             )

package/src/transforms/es5/antiES6Object.ts

@@ -14,7 +14,7 @@ import { prepend } from "../../util/insert";
 import { getBlock } from "../../traverse";
 import Template from "../../templates/template";
 
-var HelperFunctions = Template(
+var HelperFunctions = new Template(
   `
   function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -187,7 +187,7 @@ export default class AntiES6Object extends Transform {
 
           prepend(
             parents[parents.length - 1] || block,
-            Template(`
+            new Template(`
             function {name}(base, computedProps, getters, setters){
 
               for ( var i = 0; i < computedProps.length; i++ ) {

package/src/transforms/es5/antiTemplate.ts

@@ -71,7 +71,7 @@ export default class AntiTemplate extends Transform {
 
           prepend(
             parents[parents.length - 1],
-            Template(`
+            new Template(`
           function {name}(arr, raw){
             arr.raw = raw;
             return arr;

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

@@ -12,19 +12,17 @@ import {
   CallExpression,
   BinaryExpression,
   FunctionDeclaration,
-  ThisExpression,
   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.
@@ -95,10 +93,7 @@ export default class DuplicateLiteralsRemoval extends Transform {
         VariableDeclaration(
           VariableDeclarator(
             this.arrayName,
-            CallExpression(
-              MemberExpression(Identifier(getArrayFn), Literal("call"), true),
-              [ThisExpression()]
-            )
+            CallExpression(Identifier(getArrayFn), [])
           )
         )
       );
@@ -119,7 +114,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);
@@ -170,7 +165,7 @@ export default class DuplicateLiteralsRemoval extends Transform {
       isPrimitive(object) &&
       !isDirective(object, parents) &&
       !isModuleSource(object, parents) &&
-      !parents.find((x) => x.$dispatcherSkip)
+      !parents.find((x) => x.$multiTransformSkip)
     );
   }
 
@@ -188,7 +183,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 +194,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 +222,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 +232,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 &&