js-confuser 1.2.1 → 1.4.1

package/src/transforms/identifier/globalConcealing.ts

@@ -12,8 +12,16 @@ import {
   MemberExpression,
   SwitchStatement,
   SwitchCase,
+  LogicalExpression,
+  VariableDeclarator,
+  FunctionExpression,
+  ExpressionStatement,
+  SequenceExpression,
+  AssignmentExpression,
+  VariableDeclaration,
+  BreakStatement,
 } from "../../util/gen";
-import { prepend } from "../../util/insert";
+import { append, prepend } from "../../util/insert";
 import { getIdentifierInfo } from "../../util/identifiers";
 import { getRandomInteger } from "../../util/random";
 import { reservedIdentifiers, reservedKeywords } from "../../constants";
@@ -98,15 +106,12 @@ class GlobalAnalysis extends Transform {
  */
 export default class GlobalConcealing extends Transform {
   globalAnalysis: GlobalAnalysis;
-  globalVar: string;
 
   constructor(o) {
     super(o, ObfuscateOrder.GlobalConcealing);
 
     this.globalAnalysis = new GlobalAnalysis(o);
     this.before.push(this.globalAnalysis);
-
-    this.globalVar = null;
   }
 
   match(object: Node, parents: Node[]) {
@@ -120,6 +125,8 @@ export default class GlobalConcealing extends Transform {
         delete globals[del];
       });
 
+      delete globals["require"];
+
       reservedIdentifiers.forEach((x) => {
         delete globals[x];
       });
@@ -141,28 +148,38 @@ export default class GlobalConcealing extends Transform {
 
         // 1. Make getter function
 
-        this.globalVar = this.getPlaceholder();
+        // holds "window" or "global"
+        var globalVar = this.getPlaceholder();
+
+        // holds outermost "this"
+        var thisVar = this.getPlaceholder();
+
         // "window" or "global" in node
         var global =
           this.options.globalVariables.values().next().value || "window";
-        var callee = this.getPlaceholder();
+        var getGlobalVariableFnName = this.getPlaceholder();
+        var getThisVariableFnName = this.getPlaceholder();
 
         // Returns global variable or fall backs to `this`
-        var functionDeclaration = Template(`
-        function ${callee}(){
+        var getGlobalVariableFn = Template(`
+        var ${getGlobalVariableFnName} = function(){
           try {
             return ${global};
           } catch (e){
+            return ${getThisVariableFnName}["call"](this);
+          }
+        }`).single();
+
+        var getThisVariableFn = Template(`
+        var ${getThisVariableFnName} = function(){
+          try {
             return this;
+          } catch (e){
+            return null;
           }
         }`).single();
 
         // 2. Replace old accessors
-
-        var variableDeclaration = Template(`
-        var ${this.globalVar} = ${callee}.call(this);
-        `).single();
-
         var globalFn = this.getPlaceholder();
 
         var newNames = Object.create(null);
@@ -179,6 +196,20 @@ export default class GlobalConcealing extends Transform {
 
           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)])
@@ -188,49 +219,120 @@ export default class GlobalConcealing extends Transform {
         });
 
         // Adds all global variables to the switch statement
-        // this.options.globalVariables.forEach((name) => {
-        //   if (!newNames[name]) {
-        //     var state;
-        //     do {
-        //       state = getRandomInteger(
-        //         -1000,
-        //         1000 + used.size + this.options.globalVariables.size
-        //       );
-        //     } while (used.has(state));
-        //     used.add(state);
-
-        //     newNames[name] = state;
-        //   }
-        // });
-
-        prepend(
-          object,
-          FunctionDeclaration(
-            globalFn,
-            [Identifier("index")],
-            [
-              SwitchStatement(
-                Identifier("index"),
-                Object.keys(newNames).map((name) => {
-                  var code = newNames[name];
-
-                  return SwitchCase(Literal(code), [
-                    ReturnStatement(
+        this.options.globalVariables.forEach((name) => {
+          if (!newNames[name]) {
+            var state;
+            do {
+              state = getRandomInteger(
+                -1000,
+                1000 + used.size + this.options.globalVariables.size * 100
+              );
+            } while (used.has(state));
+            used.add(state);
+
+            newNames[name] = state;
+          }
+        });
+
+        var indexParamName = this.getPlaceholder();
+        var returnName = this.getPlaceholder();
+
+        var functionDeclaration = FunctionDeclaration(
+          globalFn,
+          [Identifier(indexParamName)],
+          [
+            VariableDeclaration(VariableDeclarator(returnName)),
+            SwitchStatement(
+              Identifier(indexParamName),
+              Object.keys(newNames).map((name) => {
+                var code = newNames[name];
+                var body: Node[] = [
+                  ReturnStatement(
+                    LogicalExpression(
+                      "||",
                       MemberExpression(
-                        Identifier(this.globalVar),
+                        Identifier(globalVar),
                         Literal(name),
                         true
+                      ),
+                      MemberExpression(Identifier(thisVar), Literal(name), true)
+                    )
+                  ),
+                ];
+                if (Math.random() > 0.5 && name) {
+                  body = [
+                    ExpressionStatement(
+                      AssignmentExpression(
+                        "=",
+                        Identifier(returnName),
+                        LogicalExpression(
+                          "||",
+                          Literal(name),
+                          MemberExpression(
+                            Identifier(thisVar),
+                            Literal(name),
+                            true
+                          )
+                        )
                       )
                     ),
-                  ]);
-                })
+                    BreakStatement(),
+                  ];
+                }
+
+                return SwitchCase(Literal(code), body);
+              })
+            ),
+            ReturnStatement(
+              LogicalExpression(
+                "||",
+                MemberExpression(
+                  Identifier(globalVar),
+                  Identifier(returnName),
+                  true
+                ),
+                MemberExpression(
+                  Identifier(thisVar),
+                  Identifier(returnName),
+                  true
+                )
+              )
+            ),
+          ]
+        );
+
+        var tempVar = this.getPlaceholder();
+
+        var variableDeclaration = Template(`
+        var ${globalVar}, ${thisVar};
+        `).single();
+
+        variableDeclaration.declarations.push(
+          VariableDeclarator(
+            tempVar,
+            CallExpression(
+              MemberExpression(
+                FunctionExpression(
+                  [],
+                  [
+                    getGlobalVariableFn,
+                    getThisVariableFn,
+
+                    Template(
+                      `return ${thisVar} = ${getThisVariableFnName}["call"](this, ${globalFn}), ${globalVar} = ${getGlobalVariableFnName}["call"](this)`
+                    ).single(),
+                  ]
+                ),
+                Literal("call"),
+                true
               ),
-            ]
+              []
+            )
           )
         );
 
         prepend(object, variableDeclaration);
-        prepend(object, functionDeclaration);
+        append(object, functionDeclaration);
       }
     };
   }

package/src/transforms/identifier/movedDeclarations.ts

@@ -7,14 +7,16 @@ import {
   AssignmentExpression,
   Identifier,
   Node,
-  VariableDeclaration,
   VariableDeclarator,
+  VariableDeclaration,
 } from "../../util/gen";
 import { clone, isForInitialize, isFunction, 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.
@@ -25,139 +27,114 @@ export default class MovedDeclarations extends Transform {
   }
 
   match(object, parents) {
-    return isBlock(object) && (!parents[0] || !isLoop(parents[0]));
+    return isLexicalScope(object);
   }
 
   transform(object: Node, parents: Node[]) {
     return () => {
-      var block = getBlock(object, parents);
+      var body = isBlock(object) ? object.body : object.consequent;
+      ok(Array.isArray(body));
 
-      var varDecs: Location[] = [];
-      var varNames = new Set<string>();
       var illegal = new Set<string>();
-      var toReplace: [string[], Node, Node][] = [];
-      var definingIdentifiers = new Map<string, Node>();
-
-      walk(object, parents, (o: Node, p: Node[]) => {
-        if (o.type == "Identifier" && !illegal.has(o.name)) {
-          var info = getIdentifierInfo(o, p);
-          if (info.spec.isDefined && definingIdentifiers.has(o.name)) {
+      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 (getLexicalScope(o, p) !== object) {
             illegal.add(o.name);
-            this.log(o.name, "is illegal due to detected being redefined");
-          }
-          if (info.spec.isDefined && p.find((x) => x.type == "SwitchCase")) {
-            illegal.add(o.name);
-            this.log(o.name, "is illegal due being in switch case");
-          }
+          } else {
+            var info = getIdentifierInfo(o, p);
+            if (!info.spec.isReferenced) {
+              return;
+            }
 
-          if (o.hidden) {
-            illegal.add(o.name);
+            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);
+                }
+              }
+            }
           }
         }
 
-        var s = getBlock(o, p);
-        if (s == block) {
+        if (o.type == "VariableDeclaration") {
           return () => {
             if (
-              o.type == "VariableDeclaration" &&
-              o.declarations.length &&
-              o.kind !== "let" &&
-              !o.declarations.find(
-                (x) => x.id.type !== "Identifier" || illegal.has(x.id.name)
-              )
+              o.declarations.length === 1 &&
+              o.declarations[0].id.type === "Identifier"
             ) {
-              var index = block.body.indexOf(o);
-              if (index === 0 || o.hidden) {
-                o.declarations.forEach((x) => {
-                  illegal.add(x.id.name);
-                });
-                this.log(
-                  o.declarations.map((x) => x.id.name).join(", "),
-                  "is/are illegal due to already being at the top"
-                );
+              var name = o.declarations[0].id.name;
+
+              // Check if duplicate
+              if (variableDeclarations[name] || o.kind !== "var") {
+                illegal.add(name);
                 return;
               }
 
-              if (isForInitialize(o, p)) {
-                this.log(
-                  o.declarations.map((x) => x.id.name).join(", "),
-                  "is/are illegal due to being in for initializer"
-                );
+              // Check if already at top
+              if (body[0] === o) {
+                illegal.add(name);
                 return;
               }
 
-              var isIllegal = false;
-              o.declarations.forEach((x) => {
-                if (varNames.has(x.id.name)) {
-                  illegal.add(x.id.name);
-                  isIllegal = true;
-
-                  this.log(
-                    x.id.name,
-                    "is illegal due to already being defined"
-                  );
-                }
-              });
-
-              if (!isIllegal) {
-                varDecs.push([o, p]);
-
-                o.declarations.forEach((x) => {
-                  ok(x.id.name);
-                  varNames.add(x.id.name);
-
-                  definingIdentifiers.set(x.id.name, x.id);
-                });
-
-                // Change this line to assignment expressions
-
-                var assignmentExpressions = o.declarations.map((x) =>
-                  AssignmentExpression(
-                    "=",
-                    clone(x.id),
-                    clone(x.init) || Identifier("undefined")
-                  )
-                );
-
-                ok(assignmentExpressions.length, "Should be at least 1");
-
-                var value: Node = SequenceExpression(assignmentExpressions);
-
-                value = ExpressionStatement(value);
-
-                toReplace.push([
-                  o.declarations.map((x) => x.id.name),
-                  o,
-                  value,
-                ]);
+              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,
+              };
             }
           };
         }
       });
 
       illegal.forEach((name) => {
-        varNames.delete(name);
+        delete variableDeclarations[name];
       });
 
-      toReplace.forEach((x) => {
-        if (!x[0].find((x) => illegal.has(x))) {
-          this.replace(x[1], x[2]);
-        }
-      });
+      var movingNames = Object.keys(variableDeclarations);
 
-      // Define the names in this block as 1 variable declaration
-      if (varNames.size > 0) {
-        this.log("Moved", varNames);
+      if (movingNames.length === 0) {
+        return;
+      }
 
-        var variableDeclaration = VariableDeclaration(
-          Array.from(varNames).map((x) => {
-            return VariableDeclarator(x);
-          })
-        );
+      var variableDeclaration = VariableDeclaration(
+        movingNames.map((name) => {
+          return VariableDeclarator(name);
+        })
+      );
 
-        prepend(block, variableDeclaration);
+      if (object.type == "Program") {
+        prepend(object, variableDeclaration);
+      } else {
+        body.unshift(variableDeclaration);
       }
+
+      movingNames.forEach((name) => {
+        var { location, replace } = variableDeclarations[name];
+        this.replace(location[0], replace);
+      });
     };
   }
 }

package/src/transforms/identifier/renameVariables.ts

@@ -15,91 +15,7 @@ import { isValidIdentifier } from "../../util/compare";
 import Transform from "../transform";
 import { reservedIdentifiers } from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
-
-/**
- * Keeps track of what identifiers are defined and referenced in each context.
- */
-export class VariableAnalysis extends Transform {
-  /**
-   * Node being the context.
-   */
-  defined: Map<Node, Set<string>>;
-  references: Map<Node, Set<string>>;
-
-  constructor(o) {
-    super(o);
-
-    this.defined = new Map();
-    this.references = new Map();
-  }
-
-  match(object, parents) {
-    return isContext(object);
-  }
-
-  transform(object, parents) {
-    walk(object, parents, (o, p) => {
-      if (o.type == "Identifier") {
-        var name = o.name;
-        ok(typeof name === "string");
-        if (!isValidIdentifier(name)) {
-          return;
-        }
-
-        if (reservedIdentifiers.has(name)) {
-          return;
-        }
-        if (this.options.globalVariables.has(name)) {
-          return;
-        }
-
-        var info = getIdentifierInfo(o, p);
-        if (!info.spec.isReferenced) {
-          return;
-        }
-
-        if (info.spec.isExported) {
-          return;
-        }
-
-        var definingContexts = info.spec.isDefined
-          ? [getDefiningContext(o, p)]
-          : [getVarContext(o, p), getLexContext(o, p)];
-
-        ok(definingContexts.length);
-
-        var isDefined = info.spec.isDefined;
-        definingContexts.forEach((definingContext) => {
-          ok(
-            isContext(definingContext),
-            `${definingContext.type} is not a context`
-          );
-
-          if (isDefined) {
-            // Add to defined Map
-            if (!this.defined.has(definingContext)) {
-              this.defined.set(definingContext, new Set());
-            }
-            this.defined.get(definingContext).add(name);
-            this.references.has(definingContext) &&
-              this.references.get(definingContext).delete(name);
-          } else {
-            // Add to references Map
-            if (
-              !this.defined.has(definingContext) ||
-              !this.defined.get(definingContext).has(name)
-            ) {
-              if (!this.references.has(definingContext)) {
-                this.references.set(definingContext, new Set());
-              }
-              this.references.get(definingContext).add(name);
-            }
-          }
-        });
-      }
-    });
-  }
-}
+import VariableAnalysis from "./variableAnalysis";
 
 /**
  * Rename variables to randomly generated names.
@@ -123,7 +39,9 @@ export default class RenameVariables extends Transform {
     super(o, ObfuscateOrder.RenameVariables);
 
     this.changed = new Map();
-    this.before.push((this.variableAnalysis = new VariableAnalysis(o)));
+
+    this.variableAnalysis = new VariableAnalysis(o);
+    this.before.push(this.variableAnalysis);
     this.gen = this.getGenerator();
     this.generated = [];
   }
@@ -204,16 +122,23 @@ export default class RenameVariables extends Transform {
           isGlobal
         )
       ) {
-        if (possible.size) {
-          var first = possible.values().next().value;
-          possible.delete(first);
-          newNames[name] = first;
-        } else {
-          // Fix 1. Use `generateIdentifier` over `gen.generate()` so Integrity can get unique variable names
-          var g = this.generateIdentifier();
-          newNames[name] = g;
-          this.generated.push(g);
-        }
+        // Fix 2. Ensure global names aren't overridden
+        var newName;
+        do {
+          if (possible.size) {
+            var first = possible.values().next().value;
+            possible.delete(first);
+            newName = first;
+          } else {
+            // Fix 1. Use `generateIdentifier` over `gen.generate()` so Integrity can get unique variable names
+            var g = this.generateIdentifier();
+
+            newName = g;
+            this.generated.push(g);
+          }
+        } while (this.variableAnalysis.globals.has(newName));
+
+        newNames[name] = newName;
       } else {
         newNames[name] = name;
       }