js-confuser 1.5.9 → 1.7.0

package/src/transforms/identifier/globalAnalysis.ts

@@ -0,0 +1,85 @@
+import { reservedKeywords } from "../../constants";
+import { Location, Node } from "../../util/gen";
+import { getIdentifierInfo } from "../../util/identifiers";
+import Transform from "../transform";
+
+/**
+ * Global Analysis is responsible for finding all the global variables used in the code.
+ *
+ * A 'global variable' is one that is:
+ * - Referenced
+ * - Never defined or overridden
+ */
+export default class GlobalAnalysis extends Transform {
+  notGlobals: Set<string>;
+  globals: { [name: string]: Location[] };
+
+  constructor(o) {
+    super(o);
+
+    this.globals = Object.create(null);
+    this.notGlobals = new Set();
+  }
+
+  match(object: Node, parents: Node[]) {
+    return object.type == "Identifier" && !reservedKeywords.has(object.name);
+  }
+
+  transform(object: Node, parents: Node[]) {
+    // no touching `import()` or `import x from ...`
+    var importIndex = parents.findIndex(
+      (x) => x.type == "ImportExpression" || x.type == "ImportDeclaration"
+    );
+    if (importIndex !== -1) {
+      if (
+        parents[importIndex].source === (parents[importIndex - 1] || object)
+      ) {
+        return;
+      }
+    }
+
+    var info = getIdentifierInfo(object, parents);
+    if (!info.spec.isReferenced) {
+      return;
+    }
+
+    // Cannot be defined or overridden
+    if (info.spec.isDefined || info.spec.isModified) {
+      delete this.globals[object.name];
+
+      this.notGlobals.add(object.name);
+      return;
+    }
+
+    // Add to globals
+    if (!this.notGlobals.has(object.name)) {
+      if (!this.globals[object.name]) {
+        this.globals[object.name] = [];
+      }
+
+      this.globals[object.name].push([object, parents]);
+    }
+
+    var assignmentIndex = parents.findIndex(
+      (x) => x.type == "AssignmentExpression"
+    );
+    var updateIndex = parents.findIndex((x) => x.type == "UpdateExpression");
+
+    if (
+      (assignmentIndex != -1 &&
+        parents[assignmentIndex].left ===
+          (parents[assignmentIndex - 1] || object)) ||
+      updateIndex != -1
+    ) {
+      var memberIndex = parents.findIndex((x) => x.type == "MemberExpression");
+      if (
+        memberIndex == -1 ||
+        memberIndex > (assignmentIndex == -1 ? assignmentIndex : updateIndex)
+      ) {
+        delete this.globals[object.name];
+
+        this.notGlobals.add(object.name);
+      }
+    }
+  }
+}

package/src/transforms/identifier/globalConcealing.ts

@@ -16,88 +16,15 @@ import {
   VariableDeclarator,
   FunctionExpression,
   ExpressionStatement,
-  SequenceExpression,
   AssignmentExpression,
   VariableDeclaration,
   BreakStatement,
 } from "../../util/gen";
 import { append, prepend } from "../../util/insert";
-import { getIdentifierInfo } from "../../util/identifiers";
-import { getRandomInteger } from "../../util/random";
-import { reservedIdentifiers, reservedKeywords } from "../../constants";
+import { chance, getRandomInteger } from "../../util/random";
+import { reservedIdentifiers } from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
-
-class GlobalAnalysis extends Transform {
-  notGlobals: Set<string>;
-  globals: { [name: string]: Location[] };
-
-  constructor(o) {
-    super(o);
-
-    this.globals = Object.create(null);
-    this.notGlobals = new Set();
-  }
-
-  match(object: Node, parents: Node[]) {
-    return object.type == "Identifier" && !reservedKeywords.has(object.name);
-  }
-
-  transform(object: Node, parents: Node[]) {
-    // no touching `import()` or `import x from ...`
-    var importIndex = parents.findIndex(
-      (x) => x.type == "ImportExpression" || x.type == "ImportDeclaration"
-    );
-    if (importIndex !== -1) {
-      if (
-        parents[importIndex].source === (parents[importIndex - 1] || object)
-      ) {
-        return;
-      }
-    }
-
-    var info = getIdentifierInfo(object, parents);
-    if (!info.spec.isReferenced) {
-      return;
-    }
-
-    // Add to globals
-    if (!this.notGlobals.has(object.name)) {
-      if (!this.globals[object.name]) {
-        this.globals[object.name] = [];
-      }
-
-      this.globals[object.name].push([object, parents]);
-    }
-
-    if (info.spec.isDefined || info.spec.isModified) {
-      delete this.globals[object.name];
-
-      this.notGlobals.add(object.name);
-    }
-
-    var assignmentIndex = parents.findIndex(
-      (x) => x.type == "AssignmentExpression"
-    );
-    var updateIndex = parents.findIndex((x) => x.type == "UpdateExpression");
-
-    if (
-      (assignmentIndex != -1 &&
-        parents[assignmentIndex].left ===
-          (parents[assignmentIndex - 1] || object)) ||
-      updateIndex != -1
-    ) {
-      var memberIndex = parents.findIndex((x) => x.type == "MemberExpression");
-      if (
-        memberIndex == -1 ||
-        memberIndex > (assignmentIndex == -1 ? assignmentIndex : updateIndex)
-      ) {
-        delete this.globals[object.name];
-
-        this.notGlobals.add(object.name);
-      }
-    }
-  }
-}
+import GlobalAnalysis from "./globalAnalysis";
 
 /**
  * Global Concealing hides global variables being accessed.
@@ -141,12 +68,10 @@ export default class GlobalConcealing extends Transform {
         }
       });
 
-      // this.log(Object.keys(globals).join(', '))
-
       if (Object.keys(globals).length > 0) {
         var used = new Set();
 
-        // 1. Make getter function
+        // Make getter function
 
         // holds "window" or "global"
         var globalVar = this.getPlaceholder();
@@ -157,6 +82,8 @@ export default class GlobalConcealing extends Transform {
         // "window" or "global" in node
         var global =
           this.options.globalVariables.values().next().value || "window";
+        var alternateGlobal = global === "window" ? "global" : "window";
+
         var getGlobalVariableFnName = this.getPlaceholder();
         var getThisVariableFnName = this.getPlaceholder();
 
@@ -164,7 +91,7 @@ export default class GlobalConcealing extends Transform {
         var getGlobalVariableFn = Template(`
         var ${getGlobalVariableFnName} = function(){
           try {
-            return ${global};
+            return ${global} || ${alternateGlobal} || (new Function("return this"))();
           } catch (e){
             return ${getThisVariableFnName}["call"](this);
           }
@@ -182,7 +109,7 @@ export default class GlobalConcealing extends Transform {
         // 2. Replace old accessors
         var globalFn = this.getPlaceholder();
 
-        var newNames = Object.create(null);
+        var newNames: { [globalVarName: string]: number } = Object.create(null);
 
         Object.keys(globals).forEach((name) => {
           var locations: Location[] = globals[name];
@@ -195,26 +122,10 @@ export default class GlobalConcealing extends Transform {
           newNames[name] = state;
 
           locations.forEach(([node, parents]) => {
-            if (!parents.find((x) => x.$dispatcherSkip)) {
-              // Do not replace
-              if (parents[0]) {
-                if (
-                  parents[0].type == "ClassDeclaration" ||
-                  parents[0].type == "ClassExpression" ||
-                  parents[0].type == "FunctionExpression" ||
-                  parents[0].type == "FunctionDeclaration"
-                ) {
-                  if (parents[0].id === node) {
-                    return;
-                  }
-                }
-              }
-
-              this.replace(
-                node,
-                CallExpression(Identifier(globalFn), [Literal(state)])
-              );
-            }
+            this.replace(
+              node,
+              CallExpression(Identifier(globalFn), [Literal(state)])
+            );
           });
         });
 
@@ -224,7 +135,7 @@ export default class GlobalConcealing extends Transform {
             var state;
             do {
               state = getRandomInteger(
-                -1000,
+                0,
                 1000 + used.size + this.options.globalVariables.size * 100
               );
             } while (used.has(state));
@@ -259,7 +170,7 @@ export default class GlobalConcealing extends Transform {
                     )
                   ),
                 ];
-                if (Math.random() > 0.5 && name) {
+                if (chance(50)) {
                   body = [
                     ExpressionStatement(
                       AssignmentExpression(

package/src/transforms/identifier/movedDeclarations.ts

@@ -1,22 +1,15 @@
 import Transform from "../transform";
-import { isBlock, getBlock, walk } from "../../traverse";
+import { isBlock } from "../../traverse";
 import {
-  Location,
   ExpressionStatement,
-  SequenceExpression,
   AssignmentExpression,
   Identifier,
   Node,
   VariableDeclarator,
-  VariableDeclaration,
 } from "../../util/gen";
-import { clone, isForInitialize, isFunction, prepend } from "../../util/insert";
+import { isForInitialize, prepend } from "../../util/insert";
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
-import { getIdentifierInfo } from "../../util/identifiers";
-import { isLoop } from "../../util/compare";
-import { reservedIdentifiers } from "../../constants";
-import { isLexicalScope, getLexicalScope } from "../../util/scope";
 
 /**
  * Defines all the names at the top of every lexical block.
@@ -27,114 +20,68 @@ export default class MovedDeclarations extends Transform {
   }
 
   match(object, parents) {
-    return isLexicalScope(object);
+    return (
+      object.type === "VariableDeclaration" &&
+      object.kind === "var" &&
+      object.declarations.length === 1 &&
+      object.declarations[0].id.type === "Identifier"
+    );
   }
 
   transform(object: Node, parents: Node[]) {
     return () => {
-      var body = isBlock(object) ? object.body : object.consequent;
-      ok(Array.isArray(body));
+      var forInitializeType = isForInitialize(object, parents);
 
-      var illegal = new Set<string>();
-      var defined = new Set<string>();
-      var variableDeclarations: {
-        [name: string]: {
-          location: Location;
-          replace: Node;
-        };
-      } = Object.create(null);
-
-      walk(object, parents, (o, p) => {
-        if (o.type == "Identifier") {
-          if (o.hidden || getLexicalScope(o, p) !== object) {
-            illegal.add(o.name);
-          } else {
-            var info = getIdentifierInfo(o, p);
-            if (!info.spec.isReferenced) {
-              return;
-            }
-
-            if (info.spec.isDefined) {
-              if (info.isFunctionDeclaration || info.isClassDeclaration) {
-                illegal.add(o.name);
-              } else {
-                if (defined.has(o.name)) {
-                  illegal.add(o.name);
-                } else {
-                  defined.add(o.name);
-                }
-              }
-            }
-          }
-        }
+      // Get the block statement or Program node
+      var blockIndex = parents.findIndex((x) => isBlock(x));
+      var block = parents[blockIndex];
+      var body = block.body;
+      var bodyObject = parents[blockIndex - 2] || object;
 
-        if (o.type == "VariableDeclaration") {
-          return () => {
-            if (
-              o.declarations.length === 1 &&
-              o.declarations[0].id.type === "Identifier"
-            ) {
-              var name = o.declarations[0].id.name;
+      // Make sure in the block statement, and not already at the top of it
+      var index = body.indexOf(bodyObject);
+      if (index === -1 || index === 0) return;
 
-              // Check if duplicate
-              if (variableDeclarations[name] || o.kind !== "var") {
-                illegal.add(name);
-                return;
-              }
-
-              // Check if already at top
-              if (body[0] === o) {
-                illegal.add(name);
-                return;
-              }
-
-              var replace: Node = AssignmentExpression(
-                "=",
-                Identifier(name),
-                o.declarations[0].init || Identifier("undefined")
-              );
-
-              var forType = isForInitialize(o, p);
-              if (forType === "left-hand") {
-                replace = Identifier(name);
-              } else if (!forType) {
-                replace = ExpressionStatement(replace);
-              }
-              variableDeclarations[name] = {
-                location: [o, p],
-                replace: replace,
-              };
-            }
-          };
-        }
-      });
+      var topVariableDeclaration;
+      if (body[0].type === "VariableDeclaration" && body[0].kind === "var") {
+        topVariableDeclaration = body[0];
+      } else {
+        topVariableDeclaration = {
+          type: "VariableDeclaration",
+          declarations: [],
+          kind: "var",
+        };
 
-      illegal.forEach((name) => {
-        delete variableDeclarations[name];
-      });
+        prepend(block, topVariableDeclaration);
+      }
 
-      var movingNames = Object.keys(variableDeclarations);
+      var varName = object.declarations[0].id.name;
+      ok(typeof varName === "string");
 
-      if (movingNames.length === 0) {
-        return;
-      }
+      // Add `var x` at the top of the block
+      topVariableDeclaration.declarations.push(
+        VariableDeclarator(Identifier(varName))
+      );
 
-      var variableDeclaration = VariableDeclaration(
-        movingNames.map((name) => {
-          return VariableDeclarator(name);
-        })
+      var assignmentExpression = AssignmentExpression(
+        "=",
+        Identifier(varName),
+        object.declarations[0].init || Identifier(varName)
       );
 
-      if (object.type == "Program") {
-        prepend(object, variableDeclaration);
+      if (forInitializeType) {
+        if (forInitializeType === "initializer") {
+          // Replace `for (var i = 0...)` to `for (i = 0...)`
+          this.replace(object, assignmentExpression);
+        } else if (forInitializeType === "left-hand") {
+          // Replace `for (var k in...)` to `for (k in ...)`
+
+          this.replace(object, Identifier(varName));
+        }
       } else {
-        body.unshift(variableDeclaration);
+        // Replace `var x = value` to `x = value`
+        this.replace(object, ExpressionStatement(assignmentExpression));
       }
-
-      movingNames.forEach((name) => {
-        var { location, replace } = variableDeclarations[name];
-        this.replace(location[0], replace);
-      });
     };
   }
 }