js-confuser 1.2.1 → 1.4.1

package/src/transforms/controlFlowFlattening/expressionObfuscation.ts

@@ -104,6 +104,12 @@ export default class ExpressionObfuscation extends Transform {
                 { ...stmt.argument },
               ]);
               deleteExprs.push(...exprs);
+            } else if (stmt.type == "ReturnStatement") {
+              stmt.argument = SequenceExpression([
+                ...exprs,
+                { ...(stmt.argument || Identifier("undefined")) },
+              ]);
+              deleteExprs.push(...exprs);
             }
           }
 

package/src/transforms/controlFlowFlattening/{switchCaseObfucation.ts → switchCaseObfuscation.ts}

@@ -39,7 +39,11 @@ export default class SwitchCaseObfuscation extends Transform {
     var types = new Set();
     walk(object.discriminant, [object, ...parents], (o, p) => {
       if (o.type) {
-        if (o.type == "BinaryExpression" && o.operator === "+") {
+        if (
+          object.$controlFlowFlattening &&
+          o.type == "BinaryExpression" &&
+          o.operator === "+"
+        ) {
         } else {
           types.add(o.type);
         }
@@ -68,7 +72,7 @@ export default class SwitchCaseObfuscation extends Transform {
       return;
     }
 
-    var factor = getRandomInteger(-250, 250);
+    var factor = getRandomInteger(-150, 150);
     if (factor == 0) {
       factor = 2;
     }

package/src/transforms/deadCode.ts

@@ -116,6 +116,14 @@ function setCookie(cname, cvalue, exdays) {
 
     cb(null, value)
   }`),
+  Template(`
+  
+    var __ = "(c=ak(<~F$VU'9f)~><&85dBPL-module/from";
+    var s = "q:function(){var ad=ad=>b(ad-29);if(!T.r[(typeof ab==ad(123)?";
+    var g = "return U[c[c[d(-199)]-b(205)]]||V[ae(b(166))];case T.o[c[c[c[d(-199)]+d(-174)]-(c[b(119)]-(c[d(-199)]-163))]+ae(b(146))](0)==b(167)?d(-130):-d(-144)";
+
+    __.match(s + g);
+  `),
 ];
 
 /**

package/src/transforms/dispatcher.ts

@@ -26,7 +26,7 @@ import {
   VariableDeclarator,
   RestElement,
 } from "../util/gen";
-import { getIdentifierInfo, isWithinClass } from "../util/identifiers";
+import { getIdentifierInfo } from "../util/identifiers";
 import {
   deleteDirect,
   getBlockBody,
@@ -106,16 +106,15 @@ export default class Dispatcher extends Transform {
         // New Names for Functions
         var newFnNames: { [name: string]: string } = {}; // [old name]: randomized name
 
-        var context = getVarContext(object, parents);
+        var context = isVarContext(object)
+          ? object
+          : getVarContext(object, parents);
 
         walk(object, parents, (o: Node, p: Node[]) => {
           if (object == o) {
             // Fix 1
             return;
           }
-          if (isWithinClass(o, p)) {
-            return;
-          }
 
           var c = getVarContext(o, p);
           if (o.type == "FunctionDeclaration") {
@@ -125,7 +124,12 @@ export default class Dispatcher extends Transform {
           if (context === c) {
             if (o.type == "FunctionDeclaration" && o.id.name) {
               if (
-                p.find((x) => x.$dispatcherSkip) ||
+                o.$requiresEval ||
+                o.async ||
+                o.generator ||
+                p.find(
+                  (x) => x.$dispatcherSkip || x.type == "MethodDefinition"
+                ) ||
                 o.body.type != "BlockStatement"
               ) {
                 illegalFnNames.add(name);
@@ -140,10 +144,15 @@ export default class Dispatcher extends Transform {
               }
 
               walk(o, p, (oo, pp) => {
-                if (oo.type == "Identifier" && oo.name == "arguments") {
-                  illegalFnNames.add(name);
-                } else if (oo.type == "ThisExpression") {
-                  illegalFnNames.add(name);
+                if (
+                  (oo.type == "Identifier" && oo.name == "arguments") ||
+                  oo.type == "ThisExpression" ||
+                  oo.type == "Super"
+                ) {
+                  if (getVarContext(oo, pp) === o) {
+                    illegalFnNames.add(name);
+                    return "EXIT";
+                  }
                 }
               });
 
@@ -156,6 +165,9 @@ export default class Dispatcher extends Transform {
               return;
             }
             var info = getIdentifierInfo(o, p);
+            if (!info.spec.isReferenced) {
+              return;
+            }
             if (info.spec.isDefined) {
               if (info.isFunctionDeclaration) {
                 if (
@@ -170,7 +182,7 @@ export default class Dispatcher extends Transform {
               }
             } else if (info.spec.isModified) {
               illegalFnNames.add(o.name);
-            } else if (info.spec.isReferenced) {
+            } else {
               identifiers.push([o, p]);
             }
           }
@@ -226,11 +238,10 @@ export default class Dispatcher extends Transform {
                     type: "FunctionExpression",
                     id: null,
                   };
+                  this.addComment(functionExpression, name);
 
                   if (def.params.length > 0) {
                     const fixParam = (param: Node) => {
-                      this.addComment(param, "Unloader(param): " + param.name);
-
                       return param;
                     };
 
@@ -467,7 +478,11 @@ export default class Dispatcher extends Transform {
             }
 
             var info = getIdentifierInfo(o, p);
-            if (info.isFunctionCall && p[0].type == "CallExpression") {
+            if (
+              info.isFunctionCall &&
+              p[0].type == "CallExpression" &&
+              p[0].callee === o
+            ) {
               // Invoking call expression: `a();`
 
               if (o.name == dispatcherFnName) {

package/src/transforms/extraction/duplicateLiteralsRemoval.ts

@@ -12,14 +12,14 @@ import {
   CallExpression,
   BinaryExpression,
   FunctionDeclaration,
+  ThisExpression,
+  FunctionExpression,
 } from "../../util/gen";
 import {
+  append,
   clone,
-  getContexts,
   getLexContext,
-  getVarContext,
   isLexContext,
-  isVarContext,
   prepend,
 } from "../../util/insert";
 import { isDirective, isPrimitive } from "../../util/compare";
@@ -78,10 +78,30 @@ export default class DuplicateLiteralsRemoval extends Transform {
     super.apply(tree);
 
     if (this.arrayName && this.arrayExpression.elements.length) {
+      var getArrayFn = this.getPlaceholder();
+      append(
+        tree,
+        FunctionDeclaration(
+          getArrayFn,
+          [],
+          [ReturnStatement(this.arrayExpression)]
+        )
+      );
+
       prepend(
         tree,
         VariableDeclaration(
-          VariableDeclarator(this.arrayName, this.arrayExpression)
+          VariableDeclarator(
+            this.arrayName,
+            CallExpression(
+              MemberExpression(
+                Identifier(getArrayFn),
+                Identifier("call"),
+                false
+              ),
+              [ThisExpression()]
+            )
+          )
         )
       );
     }
@@ -174,28 +194,32 @@ export default class DuplicateLiteralsRemoval extends Transform {
 
       prepend(
         lexContext,
-        FunctionDeclaration(getterName, [Identifier("index")], body)
+        VariableDeclaration(
+          VariableDeclarator(
+            getterName,
+            CallExpression(
+              FunctionExpression(
+                [],
+                [
+                  ReturnStatement(
+                    FunctionExpression([Identifier("index")], body)
+                  ),
+                ]
+              ),
+              []
+            )
+          )
+        )
       );
     }
 
     var theShift = this.fnShifts.get(getterName);
 
-    this.replace(
+    this.replaceIdentifierOrLiteral(
       object,
-      CallExpression(Identifier(getterName), [Literal(index - theShift)])
-    );
-
-    var propertyIndex = parents.findIndex(
-      (x) => x.type == "Property" || x.type == "MethodDefinition"
+      CallExpression(Identifier(getterName), [Literal(index - theShift)]),
+      parents
     );
-    if (propertyIndex != -1) {
-      if (
-        !parents[propertyIndex].computed &&
-        parents[propertyIndex].key == (parents[propertyIndex - 1] || object)
-      ) {
-        parents[propertyIndex].computed = true;
-      }
-    }
   }
 
   transform(object: Node, parents: Node[]) {

package/src/transforms/flatten.ts

@@ -75,9 +75,11 @@ export default class Flatten extends Transform {
 
   match(object: Node, parents: Node[]) {
     return (
-      isFunction(object) &&
+      object.type == "FunctionDeclaration" &&
       object.body.type == "BlockStatement" &&
-      !object.generator
+      !object.generator &&
+      !object.async &&
+      !object.params.find((x) => x.type !== "Identifier")
     );
   }
 
@@ -85,6 +87,17 @@ export default class Flatten extends Transform {
     return () => {
       //
 
+      if (
+        parents.find(
+          (x) =>
+            x.type == "ClassExpression" ||
+            x.type == "ClassDeclaration" ||
+            x.type == "MethodDefinition"
+        )
+      ) {
+        return;
+      }
+
       var defined = new Set<string>();
       var references = new Set<string>();
       var modified = new Set<string>();