js-confuser 1.5.9 → 1.7.0

package/src/transforms/minify.ts

@@ -2,7 +2,6 @@ import Transform from "./transform";
 import { ObfuscateOrder } from "../order";
 import {
   Node,
-  Location,
   VariableDeclaration,
   BinaryExpression,
   ExpressionStatement,
@@ -21,10 +20,9 @@ import {
   getBlockBody,
   clone,
   isForInitialize,
-  isLexContext,
-  getFunction,
-  prepend,
   append,
+  isVarContext,
+  computeFunctionLength,
 } from "../util/insert";
 import { isValidIdentifier, isEquivalent } from "../util/compare";
 import { walk, isBlock } from "../traverse";
@@ -97,7 +95,7 @@ export default class Minify extends Transform {
           var sequences: { index: number; exprs: Node[] }[] = [];
 
           body.forEach((stmt, i) => {
-            if (stmt.type == "ExpressionStatement") {
+            if (stmt.type == "ExpressionStatement" && !stmt.directive) {
               exprs.push(stmt.expression);
               if (startIndex == -1) {
                 startIndex = i;
@@ -129,51 +127,52 @@ export default class Minify extends Transform {
           });
         }
 
-        if (object.type != "SwitchCase") {
-          // Unnecessary return
-          if (body.length && body[body.length - 1]) {
-            var last = body[body.length - 1];
-            if (last.type == "ReturnStatement") {
-              var isUndefined = last.argument == null;
-
-              if (isUndefined) {
-                if (getFunction(object, parents).body == object) {
-                  body.pop();
-                }
-              }
+        // Unnecessary return
+        if (
+          parents[0] &&
+          isVarContext(parents[0]) &&
+          body.length &&
+          body[body.length - 1]
+        ) {
+          var last = body[body.length - 1];
+          if (last.type == "ReturnStatement") {
+            var isUndefined = last.argument == null;
+
+            if (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;
-              } else {
-                lastDec.declarations.push(...clone(x.declarations));
-                remove.unshift(i);
-              }
+        // 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 = null;
+              lastDec.declarations.push(...clone(x.declarations));
+              remove.unshift(i);
             }
-          });
+          } else {
+            lastDec = null;
+          }
+        });
 
-          remove.forEach((x) => {
-            body.splice(x, 1);
-          });
-        }
+        remove.forEach((x) => {
+          body.splice(x, 1);
+        });
       };
     }
 
@@ -203,28 +202,38 @@ export default class Minify extends Transform {
           }
         }
 
-        var blockIndex = parents.findIndex((x) => isLexContext(x));
-        if (blockIndex !== -1) {
-          var block = parents[blockIndex];
-          var body = block.body;
+        if (object.type === "FunctionDeclaration") {
+          var body = parents[0];
           if (!Array.isArray(body)) {
             return;
           }
 
-          var stmt = parents[blockIndex - 2] || object;
-
-          var index = body.indexOf(stmt);
+          var index = body.indexOf(object);
           if (index == -1) {
             return;
           }
 
           var before = body.slice(0, index);
-          ok(!before.includes(stmt));
+          ok(!before.includes(object));
 
-          var set = new Set(before.map((x) => x.type));
-          set.delete("FunctionDeclaration");
+          var beforeTypes = new Set(before.map((x) => x.type));
+          beforeTypes.delete("FunctionDeclaration");
 
-          if (set.size) {
+          if (beforeTypes.size > 0) {
+            return;
+          }
+
+          // Test Variant #25: Don't break redefined function declaration
+          if (
+            object.id &&
+            body.find(
+              (x) =>
+                x.type === "FunctionDeclaration" &&
+                x !== object &&
+                x.id &&
+                x.id.name === object.id.name
+            )
+          ) {
             return;
           }
         }
@@ -250,8 +259,15 @@ export default class Minify extends Transform {
             append(
               parents[parents.length - 1] || object,
               Template(`
-            function ${this.arrowFunctionName}(arrowFn){
-              return function(){ return arrowFn(...arguments) }
+            function ${this.arrowFunctionName}(arrowFn, functionLength){
+              var functionObject = function(){ return arrowFn(...arguments) };
+
+              Object["defineProperty"](functionObject, "length", {
+                "value": functionLength,
+                "configurable": true
+              });
+
+              return functionObject;
             }
             `).single()
             );
@@ -260,6 +276,7 @@ export default class Minify extends Transform {
           const wrap = (object: Node) => {
             return CallExpression(Identifier(this.arrowFunctionName), [
               clone(object),
+              Literal(computeFunctionLength(object.params)),
             ]);
           };
 
@@ -298,7 +315,7 @@ export default class Minify extends Transform {
 
         if (body.length == 1 && stmt1.type == "ReturnStatement") {
           // x=>{a: 1} // Invalid syntax
-          if (stmt1.argument.type != "ObjectExpression") {
+          if (stmt1.argument && stmt1.argument.type != "ObjectExpression") {
             object.body = stmt1.argument;
             object.expression = true;
           }
@@ -544,16 +561,16 @@ export default class Minify extends Transform {
         object.property.type = "Identifier";
         object.property.name = clone(object.property.value);
 
-        obj.name &&
-          this.log(
-            obj.name +
-              "['" +
-              object.property.name +
-              "'] -> " +
-              obj.name +
-              "." +
-              object.property.name
-          );
+        // obj.name &&
+        //   this.log(
+        //     obj.name +
+        //       "['" +
+        //       object.property.name +
+        //       "'] -> " +
+        //       obj.name +
+        //       "." +
+        //       object.property.name
+        //   );
       }
     }
 
@@ -572,7 +589,7 @@ export default class Minify extends Transform {
     }
 
     // { "x": 1 } -> {x: 1}
-    if (object.type == "Property") {
+    if (object.type === "Property" || object.type === "MethodDefinition") {
       if (
         object.key.type == "SequenceExpression" &&
         object.key.expressions.length == 1
@@ -581,15 +598,14 @@ export default class Minify extends Transform {
         object.computed = true;
       }
 
-      if (object.key.type == "Literal" && isValidIdentifier(object.key.value)) {
+      if (
+        object.key.type == "Literal" &&
+        typeof object.key.value === "string" &&
+        isValidIdentifier(object.key.value)
+      ) {
         object.key.type = "Identifier";
         object.key.name = object.key.value;
         object.computed = false;
-      } else if (
-        object.key.type == "Identifier" &&
-        !isValidIdentifier(object.key.name)
-      ) {
-        object.key = Literal(object.key.name);
       }
     }
 

package/src/transforms/opaquePredicates.ts

@@ -64,14 +64,14 @@ export default class OpaquePredicates extends Transform {
   predicate: Node;
   predicates: { [name: string]: Node };
 
-  gen: any;
+  gen: ReturnType<Transform["getGenerator"]>;
   made: number;
 
   constructor(o) {
     super(o, ObfuscateOrder.OpaquePredicates);
 
     this.predicates = Object.create(null);
-    this.gen = this.getGenerator(getRandomInteger(0, 20));
+    this.gen = this.getGenerator();
     this.made = 0;
   }
 

package/src/transforms/preparation.ts

@@ -0,0 +1,238 @@
+import Transform from "./transform";
+
+import {
+  BlockStatement,
+  Identifier,
+  LabeledStatement,
+  Literal,
+  Node,
+  ReturnStatement,
+} from "../util/gen";
+import { ObfuscateOrder } from "../order";
+import { clone, getFunction } from "../util/insert";
+import { getIdentifierInfo } from "../util/identifiers";
+import { isLoop } from "../util/compare";
+import { ExitCallback, walk } from "../traverse";
+
+/**
+ * Preparation arranges the user's code into an AST the obfuscator can easily transform.
+ *
+ * ExplicitIdentifiers
+ * - `object.IDENTIFIER` -> `object['IDENTIFIER']` // Now String Concealing can apply on it
+ * - `{ IDENTIFIER: ... }` -> `{ "IDENTIFIER": ... }`
+ *
+ * ExplicitDeclarations
+ * - `var a,b,c` -> `var a; var b; var c;` // Now Stack can apply on it
+ *
+ * Block
+ * - `x => x * 2` -> `x => { return x * 2 }` // Change into Block Statements
+ * - `if(true) return` -> `if (true) { return }`
+ * - `while(a) a--;` -> `while(a) { a-- }`
+ *
+ * Label
+ * - `for(...) { break; }` -> `_1: for(...) { break _1; }`
+ * - `switch(v) { case 1...break }` -> `_2: switch(v) { case 1...break _2; }`
+ * - // Control Flow Flattening can safely apply now
+ */
+export default class Preparation extends Transform {
+  constructor(o) {
+    super(o, ObfuscateOrder.Preparation);
+  }
+
+  match(object: Node, parents: Node[]) {
+    return !!object.type;
+  }
+
+  transform(object: Node, parents: Node[]): void | ExitCallback {
+    // ExplicitIdentifiers
+    if (object.type === "Identifier") {
+      return this.transformExplicitIdentifiers(object, parents);
+    }
+
+    // ExplicitDeclarations
+    if (object.type === "VariableDeclaration") {
+      return this.transformExplicitDeclarations(object, parents);
+    }
+
+    // Block
+    switch (object.type) {
+      /**
+       * People use shortcuts and its harder to parse.
+       *
+       * - `if (a) b()` -> `if (a) { b() }`
+       * - Ensures all bodies are `BlockStatement`, not individual expression statements
+       */
+      case "IfStatement":
+        if (object.consequent.type != "BlockStatement") {
+          object.consequent = BlockStatement([clone(object.consequent)]);
+        }
+        if (object.alternate && object.alternate.type != "BlockStatement") {
+          object.alternate = BlockStatement([clone(object.alternate)]);
+        }
+        break;
+
+      case "WhileStatement":
+      case "WithStatement":
+      case "ForStatement":
+      case "ForOfStatement":
+      case "ForInStatement":
+        if (object.body.type != "BlockStatement") {
+          object.body = BlockStatement([clone(object.body)]);
+        }
+        break;
+
+      case "ArrowFunctionExpression":
+        if (object.body.type !== "BlockStatement" && object.expression) {
+          object.body = BlockStatement([ReturnStatement(clone(object.body))]);
+          object.expression = false;
+        }
+        break;
+    }
+
+    // Label
+    if (
+      isLoop(object) ||
+      (object.type == "BlockStatement" &&
+        parents[0] &&
+        parents[0].type == "LabeledStatement" &&
+        parents[0].body === object)
+    ) {
+      return this.transformLabel(object, parents);
+    }
+  }
+
+  /**
+   * Ensures every break; statement has a label to point to.
+   *
+   * This is because Control Flow Flattening adds For Loops which label-less break statements point to the nearest,
+   * when they actually need to point to the original statement.
+   */
+  transformLabel(object: Node, parents: Node[]) {
+    return () => {
+      var currentLabel =
+        parents[0].type == "LabeledStatement" && parents[0].label.name;
+
+      var label = currentLabel || this.getPlaceholder();
+
+      walk(object, parents, (o, p) => {
+        if (o.type == "BreakStatement" || o.type == "ContinueStatement") {
+          function isContinuableStatement(x) {
+            return isLoop(x) && x.type !== "SwitchStatement";
+          }
+          function isBreakableStatement(x) {
+            return isLoop(x) || (o.label && x.type == "BlockStatement");
+          }
+
+          var fn =
+            o.type == "ContinueStatement"
+              ? isContinuableStatement
+              : isBreakableStatement;
+
+          var loop = p.find(fn);
+          if (object == loop) {
+            if (!o.label) {
+              o.label = Identifier(label);
+            }
+          }
+        }
+      });
+
+      // Append label statement as this loop has none
+      if (!currentLabel) {
+        this.replace(object, LabeledStatement(label, { ...object }));
+      }
+    };
+  }
+
+  /**
+   * Transforms Identifiers (a.IDENTIFIER, {IDENTIFIER:...}) into string properties
+   */
+  transformExplicitIdentifiers(object: Node, parents: Node[]) {
+    // Mark functions containing 'eval'
+    // Some transformations avoid functions that have 'eval' to not break them
+    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(
+        (x) => x.type == "MethodDefinition" || x.type == "Property"
+      );
+
+      // Don't change constructor!
+      if (propIndex !== -1) {
+        if (
+          parents[propIndex].type == "MethodDefinition" &&
+          parents[propIndex].kind == "constructor"
+        ) {
+          return;
+        }
+      }
+
+      this.replace(object, Literal(object.name));
+      parents[0].computed = true;
+      parents[0].shorthand = false;
+    }
+  }
+
+  /**
+   * Transforms VariableDeclaration into single declarations.
+   */
+  transformExplicitDeclarations(object: Node, parents: Node[]) {
+    // for ( var x in ... ) {...}
+    var forIndex = parents.findIndex(
+      (x) => x.type == "ForInStatement" || x.type == "ForOfStatement"
+    );
+    if (
+      forIndex != -1 &&
+      parents[forIndex].left == (parents[forIndex - 1] || object)
+    ) {
+      object.declarations.forEach((x) => {
+        x.init = null;
+      });
+      return;
+    }
+
+    var body = parents[0];
+    if (isLoop(body) || body.type == "LabeledStatement") {
+      return;
+    }
+
+    if (body.type == "ExportNamedDeclaration") {
+      return;
+    }
+
+    if (!Array.isArray(body)) {
+      this.error(new Error("body is " + body.type));
+    }
+
+    if (object.declarations.length > 1) {
+      // Make singular
+
+      var index = body.indexOf(object);
+      if (index == -1) {
+        this.error(new Error("index is -1"));
+      }
+
+      var after = object.declarations.slice(1);
+
+      body.splice(
+        index + 1,
+        0,
+        ...after.map((x) => {
+          return {
+            type: "VariableDeclaration",
+            declarations: [clone(x)],
+            kind: object.kind,
+          };
+        })
+      );
+
+      object.declarations.length = 1;
+    }
+  }
+}

package/src/transforms/renameLabels.ts

@@ -9,12 +9,12 @@ import Transform from "./transform";
  * Renames the labels to shorter names.
  */
 export default class RenameLabels extends Transform {
-  gen: any;
+  gen: ReturnType<Transform["getGenerator"]>;
 
   constructor(o) {
     super(o, ObfuscateOrder.RenameLabels);
 
-    this.gen = this.getGenerator();
+    this.gen = this.getGenerator("randomized");
   }
 
   match(object, parents) {