js-confuser 1.2.1 → 1.4.1

package/src/transforms/minify.ts

@@ -25,159 +25,146 @@ import {
 import { isValidIdentifier, isEquivalent } from "../util/compare";
 import { walk, isBlock } from "../traverse";
 import { ok } from "assert";
+import { isLexicalScope } from "../util/scope";
+
+/**
+ * Basic transformations to reduce code size.
+ *
+ * Examples:
+ * - `if(a) { b() }` **->** `a && b()`
+ * - `if(a){b()}else{c()}` **->** `a?b():c()`
+ * - `x['y']` **->** `x.y`
+ */
+export default class Minify extends Transform {
+  variables: Map<Node, Location[]>;
 
-class MinifyBlock extends Transform {
   constructor(o) {
-    super(o);
+    super(o, ObfuscateOrder.Minify);
+
+    this.variables = new Map();
   }
 
   match(object: Node, parents: Node[]) {
-    return isBlock(object) || object.type == "SwitchCase";
+    return object.hasOwnProperty("type");
   }
 
   transform(object: Node, parents: Node[]) {
-    return () => {
-      var body =
-        object.type == "SwitchCase" ? object.consequent : getBlockBody(object);
-      var earlyReturn = body.length;
-      var fnDecs: [Node, number][] = [];
+    if (isLexicalScope(object)) {
+      return () => {
+        var body =
+          object.type == "SwitchCase"
+            ? object.consequent
+            : getBlockBody(object);
+        var earlyReturn = body.length;
+        var fnDecs: [Node, number][] = [];
 
-      body.forEach((stmt, i) => {
-        if (
-          stmt.type == "ReturnStatement" ||
-          stmt.type == "BreakStatement" ||
-          stmt.type == "ContinueStatement"
-        ) {
-          if (earlyReturn > i + 1) {
-            earlyReturn = i + 1;
+        body.forEach((stmt, i) => {
+          if (
+            stmt.type == "ReturnStatement" ||
+            stmt.type == "BreakStatement" ||
+            stmt.type == "ContinueStatement"
+          ) {
+            if (earlyReturn > i + 1) {
+              earlyReturn = i + 1;
+            }
           }
-        }
 
-        if (stmt.type == "FunctionDeclaration") {
-          fnDecs.push([stmt, i]);
-        }
-      });
+          if (stmt.type == "FunctionDeclaration") {
+            fnDecs.push([stmt, i]);
+          }
+        });
 
-      if (earlyReturn < body.length) {
-        body.length = earlyReturn;
-        body.push(
-          ...fnDecs.filter((x) => x[1] >= earlyReturn).map((x) => x[0])
-        );
-      }
+        if (earlyReturn < body.length) {
+          body.length = earlyReturn;
+          body.push(
+            ...fnDecs.filter((x) => x[1] >= earlyReturn).map((x) => x[0])
+          );
+        }
 
-      // Now combine ExpressionStatements
+        // Now combine ExpressionStatements
 
-      if (body.length > 1) {
-        var exprs = [];
-        var startIndex = -1;
+        if (body.length > 1) {
+          var exprs = [];
+          var startIndex = -1;
 
-        var sequences: { index: number; exprs: Node[] }[] = [];
+          var sequences: { index: number; exprs: Node[] }[] = [];
 
-        body.forEach((stmt, i) => {
-          if (stmt.type == "ExpressionStatement") {
-            exprs.push(stmt.expression);
-            if (startIndex == -1) {
-              startIndex = i;
-            }
-          } else {
-            if (exprs.length) {
-              sequences.push({ exprs: exprs, index: startIndex });
+          body.forEach((stmt, i) => {
+            if (stmt.type == "ExpressionStatement") {
+              exprs.push(stmt.expression);
+              if (startIndex == -1) {
+                startIndex = i;
+              }
+            } else {
+              if (exprs.length) {
+                sequences.push({ exprs: exprs, index: startIndex });
+              }
+              exprs = [];
+              startIndex = -1;
             }
-            exprs = [];
-            startIndex = -1;
+          });
+
+          if (exprs.length) {
+            sequences.push({ exprs: exprs, index: startIndex });
           }
-        });
 
-        if (exprs.length) {
-          sequences.push({ exprs: exprs, index: startIndex });
+          sequences.reverse().forEach((seq) => {
+            ok(seq.index != -1);
+            body.splice(
+              seq.index,
+              seq.exprs.length,
+              ExpressionStatement(
+                seq.exprs.length == 1
+                  ? seq.exprs[0]
+                  : SequenceExpression(seq.exprs)
+              )
+            );
+          });
         }
 
-        sequences.reverse().forEach((seq) => {
-          ok(seq.index != -1);
-          body.splice(
-            seq.index,
-            seq.exprs.length,
-            ExpressionStatement(
-              seq.exprs.length == 1
-                ? seq.exprs[0]
-                : SequenceExpression(seq.exprs)
-            )
-          );
-        });
-      }
-
-      if (object.type != "SwitchCase") {
-        // Unnecessary return
-        if (body.length && body[body.length - 1]) {
-          var last = body[body.length - 1];
-          var isUndefined = last.argument == null;
-          if (last.type == "ReturnStatement" && isUndefined) {
-            body.pop();
+        if (object.type != "SwitchCase") {
+          // Unnecessary return
+          if (body.length && body[body.length - 1]) {
+            var last = body[body.length - 1];
+            var isUndefined = last.argument == null;
+            if (last.type == "ReturnStatement" && isUndefined) {
+              body.pop();
+            }
           }
-        }
 
-        // Variable declaration grouping
-        // var a = 1;
-        // var b = 1;
-        // var c = 1;
-        //
-        // var a=1,b=1,c=1;
-        var lastDec = null;
-
-        var remove = [];
-        body.forEach((x, i) => {
-          if (x.type === "VariableDeclaration") {
-            if (
-              !lastDec ||
-              lastDec.kind !== x.kind ||
-              !lastDec.declarations.length
-            ) {
-              lastDec = x;
+          // Variable declaration grouping
+          // var a = 1;
+          // var b = 1;
+          // var c = 1;
+          //
+          // var a=1,b=1,c=1;
+          var lastDec = null;
+
+          var remove = [];
+          body.forEach((x, i) => {
+            if (x.type === "VariableDeclaration") {
+              if (
+                !lastDec ||
+                lastDec.kind !== x.kind ||
+                !lastDec.declarations.length
+              ) {
+                lastDec = x;
+              } else {
+                lastDec.declarations.push(...x.declarations);
+                remove.unshift(i);
+              }
             } else {
-              lastDec.declarations.push(...x.declarations);
-              remove.unshift(i);
+              lastDec = null;
             }
-          } else {
-            lastDec = null;
-          }
-        });
-
-        remove.forEach((x) => {
-          body.splice(x, 1);
-        });
-      }
-    };
-  }
-}
-
-/**
- * Basic transformations to reduce code size.
- *
- * Examples:
- * - `if(a) { b() }` **->** `a && b()`
- * - `if(a){b()}else{c()}` **->** `a?b():c()`
- * - `x['y']` **->** `x.y`
- */
-export default class Minify extends Transform {
-  variables: Map<Node, Location[]>;
-
-  constructor(o) {
-    super(o, ObfuscateOrder.Minify);
-
-    this.variables = new Map();
+          });
 
-    /**
-     * Minify runs at every Node, making Expression-based minification.
-     * MinifyBlock runs only on Blocks, making Statement-based minification.
-     */
-    this.after.push(new MinifyBlock(o));
-  }
-
-  match(object: Node, parents: Node[]) {
-    return object.hasOwnProperty("type");
-  }
+          remove.forEach((x) => {
+            body.splice(x, 1);
+          });
+        }
+      };
+    }
 
-  transform(object: Node, parents: Node[]) {
     /**
      * ES6 and higher only
      * - `function(){}` -> `()=>{}`
@@ -378,6 +365,7 @@ export default class Minify extends Transform {
       if (last) {
         var lastStatement = last.consequent[last.consequent.length - 1];
         if (
+          lastStatement &&
           lastStatement.type == "BreakStatement" &&
           lastStatement.label == null
         ) {
@@ -538,7 +526,7 @@ export default class Minify extends Transform {
         if (key == "toString" && object.arguments.length == 0) {
           this.replace(
             object,
-            BinaryExpression("+", clone(object.callee.object), Literal(""))
+            BinaryExpression("+", Literal(""), clone(object.callee.object))
           );
         }
       }
@@ -574,6 +562,30 @@ export default class Minify extends Transform {
         }
       }
 
+      if (
+        object.id.type == "ObjectPattern" &&
+        object.init.type == "ObjectExpression"
+      ) {
+        if (
+          object.id.properties.length === 1 &&
+          object.init.properties.length === 1
+        ) {
+          var key1 = object.id.properties[0].computed
+            ? object.id.properties[0].key.value
+            : object.id.properties[0].key.name;
+          var key2 = object.init.properties[0].computed
+            ? object.init.properties[0].key.value
+            : object.init.properties[0].key.name;
+
+          // console.log(key1, key2);
+
+          if (key1 && key2 && key1 === key2) {
+            object.id = object.id.properties[0].value;
+            object.init = object.init.properties[0].value;
+          }
+        }
+      }
+
       // check for redundant patterns
       if (
         object.id.type == "ArrayPattern" &&
@@ -593,7 +605,11 @@ export default class Minify extends Transform {
       return () => {
         switch (typeof object.value) {
           case "boolean":
-            // this.replace(object, UnaryExpression("!", Literal(object.value ? 0 : 1)));
+            this.replaceIdentifierOrLiteral(
+              object,
+              UnaryExpression("!", Literal(object.value ? 0 : 1)),
+              parents
+            );
             break;
         }
       };
@@ -601,9 +617,17 @@ export default class Minify extends Transform {
     if (object.type == "Identifier") {
       return () => {
         if (object.name == "undefined" && !isForInitialize(object, parents)) {
-          this.replace(object, UnaryExpression("void", Literal(0)));
+          this.replaceIdentifierOrLiteral(
+            object,
+            UnaryExpression("void", Literal(0)),
+            parents
+          );
         } else if (object.name == "Infinity") {
-          this.replace(object, BinaryExpression("/", Literal(1), Literal(0)));
+          this.replaceIdentifierOrLiteral(
+            object,
+            BinaryExpression("/", Literal(1), Literal(0)),
+            parents
+          );
         }
       };
     }

package/src/transforms/opaquePredicates.ts

@@ -15,6 +15,8 @@ import {
   VariableDeclarator,
   ConditionalExpression,
   UnaryExpression,
+  ReturnStatement,
+  AssignmentPattern,
 } from "../util/gen";
 import {
   choice,
@@ -93,10 +95,27 @@ export default class OpaquePredicates extends Transform {
       if (!this.predicate) {
         this.predicateName = this.getPlaceholder();
         this.predicate = ObjectExpression([]);
+
+        var tempName = this.getPlaceholder();
+
         prepend(
           parents[parents.length - 1] || object,
           VariableDeclaration(
-            VariableDeclarator(this.predicateName, this.predicate)
+            VariableDeclarator(
+              this.predicateName,
+              CallExpression(
+                FunctionExpression(
+                  [],
+                  [
+                    VariableDeclaration(
+                      VariableDeclarator(tempName, this.predicate)
+                    ),
+                    ReturnStatement(Identifier(tempName)),
+                  ]
+                ),
+                []
+              )
+            )
           )
         );
       }
@@ -119,11 +138,14 @@ export default class OpaquePredicates extends Transform {
             this.predicate.properties.push(
               Property(Identifier(arrayProp), ArrayExpression([]))
             );
+
+            var paramName = this.getPlaceholder();
+
             this.predicate.properties.push(
               Property(
                 Identifier(prop),
                 FunctionExpression(
-                  [],
+                  [AssignmentPattern(Identifier(paramName), Literal("length"))],
                   Template(`
                   if ( !${this.predicateName}.${arrayProp}[0] ) {
                     ${this.predicateName}.${arrayProp}.push(${getRandomInteger(
@@ -131,7 +153,7 @@ export default class OpaquePredicates extends Transform {
                     100
                   )});
                   }
-                  return ${this.predicateName}.${arrayProp}.length;
+                  return ${this.predicateName}.${arrayProp}[${paramName}];
                 `).compile()
                 )
               )

package/src/transforms/preparation/preparation.ts

@@ -13,7 +13,7 @@ import {
   ReturnStatement,
 } from "../../util/gen";
 import { ObfuscateOrder } from "../../order";
-import { getIndexDirect, clone } from "../../util/insert";
+import { getIndexDirect, clone, getFunction } from "../../util/insert";
 import { ok } from "assert";
 import { getIdentifierInfo } from "../../util/identifiers";
 import { walk } from "../../traverse";
@@ -79,6 +79,13 @@ class ExplicitIdentifiers extends Transform {
   }
 
   transform(object, parents) {
+    if (object.name === "eval") {
+      var fn = getFunction(object, parents);
+      if (fn) {
+        fn.$requiresEval = true;
+      }
+    }
+
     var info = getIdentifierInfo(object, parents);
     if (info.isPropertyKey || info.isAccessor) {
       var propIndex = parents.findIndex(

package/src/transforms/renameLabels.ts

@@ -24,13 +24,35 @@ export default class RenameLabels extends Transform {
   transform(object, parents) {
     return () => {
       var newName = null;
+      var isRemovable = object.body.type !== "BlockStatement";
+      var labelNeverUsed = true;
 
       walk(object, parents, (o, p) => {
         if (o.type == "BreakStatement" || o.type == "ContinueStatement") {
-          var labelStatement = p.find((x) => isLoop(x));
+          function isContinuableStatement(x, stmtParents) {
+            return isLoop(x) && x.type !== "SwitchStatement";
+          }
+          function isBreakableStatement(x, stmtParents) {
+            return (
+              isLoop(x) ||
+              (x.type == "BlockStatement" &&
+                o.label &&
+                stmtParents[0] &&
+                stmtParents[0].type == "LabeledStatement")
+            );
+          }
+
+          var fn =
+            o.type == "ContinueStatement"
+              ? isContinuableStatement
+              : isBreakableStatement;
+
+          var labelStatement = p.find((node, i) => {
+            return fn(node, p.slice(i + 1));
+          });
 
           if (o.label && o.label.name == object.label.name) {
-            if (object.body == labelStatement) {
+            if (object.body == labelStatement && isRemovable) {
               // In same loop
 
               o.label = null;
@@ -39,6 +61,7 @@ export default class RenameLabels extends Transform {
                 newName = this.gen.generate();
               }
               o.label = Identifier(newName);
+              labelNeverUsed = false;
             }
           }
         }
@@ -46,7 +69,7 @@ export default class RenameLabels extends Transform {
 
       if (newName) {
         object.label = Identifier(newName);
-      } else {
+      } else if (isRemovable || labelNeverUsed) {
         this.replace(object, clone(object.body));
       }
     };

package/src/transforms/rgf.ts

@@ -76,6 +76,7 @@ export default class RGF extends Transform {
         if (
           object !== contextObject &&
           isFunction(object) &&
+          !object.$requiresEval &&
           !object.async &&
           !object.generator &&
           getVarContext(parents[0], parents.slice(1)) === contextObject
@@ -92,9 +93,12 @@ export default class RGF extends Transform {
               !this.options.globalVariables.has(o.name)
             ) {
               var info = getIdentifierInfo(o, p);
+              if (!info.spec.isReferenced) {
+                return;
+              }
               if (info.spec.isDefined) {
                 defined.add(o.name);
-              } else if (info.spec.isReferenced || info.spec.isModified) {
+              } else {
                 referenced.add(o.name);
               }
             }
@@ -256,6 +260,7 @@ export default class RGF extends Transform {
             integrity: false,
           },
           eval: false,
+          hideInitializingCode: false,
         });
         var transforms = Object.values(obfuscator.transforms).filter(
           (x) => x.priority > this.priority

package/src/transforms/shuffle.ts

@@ -5,10 +5,12 @@ import Template from "../templates/template";
 import {
   BinaryExpression,
   CallExpression,
+  ExpressionStatement,
   ForStatement,
   FunctionExpression,
   Identifier,
   Literal,
+  MemberExpression,
   ReturnStatement,
   UpdateExpression,
   VariableDeclaration,
@@ -91,22 +93,20 @@ export default class Shuffle extends Transform {
         return;
       }
 
-      var mode = ComputeProbabilityMap(
-        this.options.shuffle,
-        (x) => x,
-        object.elements.map((x) => x.value)
-      );
+      var mapped = object.elements.map((x) => x.value);
+
+      var mode = ComputeProbabilityMap(this.options.shuffle, (x) => x, mapped);
       if (mode) {
         var shift = getRandomInteger(
           1,
-          Math.min(100, object.elements.length * 6)
+          Math.min(60, object.elements.length * 6)
         );
 
         var expr = Literal(shift);
         var name = this.getPlaceholder();
 
         if (mode == "hash") {
-          var str = object.elements.map((x) => x.value + "").join("");
+          var str = mapped.join("");
           shift = Hash(str);
 
           if (!this.hashName) {
@@ -140,40 +140,98 @@ export default class Shuffle extends Transform {
         var code = [];
 
         var iName = this.getPlaceholder();
-        code.push(
-          ForStatement(
-            VariableDeclaration(VariableDeclarator(iName, expr)),
-            Identifier(iName),
-            UpdateExpression("--", Identifier(iName), false),
-            [Template(`${name}.unshift(${name}.pop())`).single()]
-          )
-        );
 
         var inPlace = false;
+        var inPlaceName;
+        var inPlaceBody;
+        var inPlaceIndex;
 
         var varDeclarator = parents[0];
         if (varDeclarator.type == "VariableDeclarator") {
           var varDec = parents[2];
           if (varDec.type == "VariableDeclaration") {
             var body = parents[3];
-            if (varDec.declarations.length == 1 && Array.isArray(body)) {
-              inPlace = true;
-
-              var i = body.indexOf(varDec);
-              ok(i != -1);
-
-              body.splice(
-                i + 1,
-                0,
-                VariableDeclaration(
-                  VariableDeclarator(name, Identifier(varDeclarator.id.name))
-                ),
-                ...code
-              );
+            if (
+              varDec.declarations.length == 1 &&
+              Array.isArray(body) &&
+              varDeclarator.id.type === "Identifier" &&
+              varDeclarator.init === object
+            ) {
+              inPlaceIndex = body.indexOf(varDec);
+              inPlaceBody = body;
+              inPlace = inPlaceIndex !== -1;
+              inPlaceName = varDeclarator.id.name;
             }
           }
         }
 
+        if (mode !== "hash") {
+          code.push(
+            Template(`
+            for ( var x = 16; x%4 === 0; x++) {
+              var z = 0;
+              ${
+                inPlace ? `${inPlaceName} = ${name}` : name
+              } = ${name}.concat((function(){
+                z++;
+                if(z === 1){
+                  return [];
+                }
+
+                for( var i = ${getRandomInteger(5, 105)}; i; i-- ){
+                  ${name}.unshift(${name}.pop());
+                }
+                return [];
+              })());
+            }
+            `).single()
+          );
+        }
+
+        code.push(
+          ForStatement(
+            VariableDeclaration(VariableDeclarator(iName, expr)),
+            Identifier(iName),
+            UpdateExpression("--", Identifier(iName), false),
+            [
+              // ${name}.unshift(${name}.pop());
+              ExpressionStatement(
+                CallExpression(
+                  MemberExpression(
+                    Identifier(name),
+                    Identifier("unshift"),
+                    false
+                  ),
+                  [
+                    CallExpression(
+                      MemberExpression(
+                        Identifier(name),
+                        Identifier("pop"),
+                        false
+                      ),
+                      []
+                    ),
+                  ]
+                )
+              ),
+            ]
+          )
+        );
+
+        if (inPlace) {
+          var varDeclarator = parents[0];
+          ok(i != -1);
+
+          inPlaceBody.splice(
+            inPlaceIndex + 1,
+            0,
+            VariableDeclaration(
+              VariableDeclarator(name, Identifier(varDeclarator.id.name))
+            ),
+            ...code
+          );
+        }
+
         if (!inPlace) {
           this.replace(
             object,