js-confuser 1.2.1 → 1.4.1

package/src/transforms/identifier/variableAnalysis.ts

@@ -0,0 +1,124 @@
+import { ok } from "assert";
+import { reservedIdentifiers } from "../../constants";
+import { walk } from "../../traverse";
+import { isValidIdentifier } from "../../util/compare";
+import { Node } from "../../util/gen";
+import { getIdentifierInfo } from "../../util/identifiers";
+import {
+  getDefiningContext,
+  getVarContext,
+  getLexContext,
+  isContext,
+  getReferencingContexts,
+} from "../../util/insert";
+import Transform from "../transform";
+
+/**
+ * Keeps track of what identifiers are defined and referenced in each context.
+ */
+export default class VariableAnalysis extends Transform {
+  /**
+   * Node being the context.
+   */
+  defined: Map<Node, Set<string>>;
+
+  /**
+   * Context->Nodes referenced (does not include nested)
+   */
+  references: Map<Node, Set<string>>;
+
+  /**
+   * Set of global identifiers to never be redefined
+   */
+  globals: Set<string>;
+
+  /**
+   * Set of identifers that are defined within the program
+   */
+  notGlobals: Set<string>;
+
+  constructor(o) {
+    super(o);
+
+    this.defined = new Map();
+    this.references = new Map();
+    this.globals = new Set();
+    this.notGlobals = new Set();
+  }
+
+  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 isDefined = info.spec.isDefined;
+
+        // Keep track of defined names within the program
+        if (isDefined) {
+          this.notGlobals.add(o.name);
+          this.globals.delete(o.name);
+        } else if (!this.notGlobals.has(o.name)) {
+          this.globals.add(o.name);
+        }
+
+        var definingContexts = info.spec.isDefined
+          ? [getDefiningContext(o, p)]
+          : getReferencingContexts(o, p, info);
+
+        ok(definingContexts.length);
+
+        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);
+            }
+          }
+        });
+      }
+    });
+  }
+}

package/src/transforms/label.ts

@@ -16,7 +16,13 @@ export default class Label extends Transform {
   }
 
   match(object, parents) {
-    return isLoop(object);
+    return (
+      isLoop(object) ||
+      (object.type == "BlockStatement" &&
+        parents[0] &&
+        parents[0].type == "LabeledStatement" &&
+        parents[0].body === object)
+    );
   }
 
   transform(object, parents) {
@@ -28,7 +34,19 @@ export default class Label extends Transform {
 
       walk(object, parents, (o, p) => {
         if (o.type == "BreakStatement" || o.type == "ContinueStatement") {
-          var loop = p.find((x) => isLoop(x));
+          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);

package/src/transforms/lock/antiDebug.ts

@@ -1,51 +1,86 @@
 import { ObfuscateOrder } from "../../order";
 import Template from "../../templates/template";
 import { isBlock } from "../../traverse";
-import { DebuggerStatement } from "../../util/gen";
+import {
+  AssignmentExpression,
+  DebuggerStatement,
+  ExpressionStatement,
+  FunctionDeclaration,
+  Identifier,
+  IfStatement,
+  Literal,
+  WhileStatement,
+} from "../../util/gen";
 import { getBlockBody, prepend } from "../../util/insert";
 import { getRandomInteger } from "../../util/random";
 import Transform from "../transform";
+import Lock from "./lock";
 
 var DevToolsDetection = Template(
   `
-  function $jsc_debug(){
-    var startTime = new Date();
-    debugger;
-    var endTime = new Date();
-    var isDev = endTime-startTime > 600;
-  
-    while (isDev) {
-      debugger;
-      (function () {}). constructor ("debugger") ()
-    }
-  
-  }
   try {
     if ( setInterval ) {
       setInterval(()=>{
-        $jsc_debug();
+        {functionName}();
       }, 4000);
     }
   } catch ( e ) {
 
   }
- 
 `
 );
 
 export default class AntiDebug extends Transform {
   made: number;
+  lock: Lock;
 
-  constructor(o) {
+  constructor(o, lock) {
     super(o, ObfuscateOrder.Lock);
 
+    this.lock = lock;
     this.made = 0;
   }
 
   apply(tree) {
     super.apply(tree);
 
-    tree.body.unshift(...DevToolsDetection.compile());
+    var fnName = this.getPlaceholder();
+    var startTimeName = this.getPlaceholder();
+    var endTimeName = this.getPlaceholder();
+    var isDevName = this.getPlaceholder();
+    var functionDeclaration = FunctionDeclaration(
+      fnName,
+      [],
+      [
+        ...Template(`
+      var ${startTimeName} = new Date();
+      debugger;
+      var ${endTimeName} = new Date();
+      var ${isDevName} = ${endTimeName}-${startTimeName} > 1000;
+      `).compile(),
+
+        IfStatement(
+          Identifier(isDevName),
+          this.options.lock.countermeasures
+            ? this.lock.getCounterMeasuresCode()
+            : [
+                WhileStatement(Identifier(isDevName), [
+                  ExpressionStatement(
+                    AssignmentExpression(
+                      "=",
+                      Identifier(startTimeName),
+                      Identifier(endTimeName)
+                    )
+                  ),
+                ]),
+              ],
+          null
+        ),
+      ]
+    );
+
+    tree.body.unshift(...DevToolsDetection.compile({ functionName: fnName }));
+    tree.body.push(functionDeclaration);
   }
 
   match(object, parents) {
@@ -53,17 +88,25 @@ export default class AntiDebug extends Transform {
   }
 
   transform(object, parents) {
-    var body = getBlockBody(object.body);
+    return () => {
+      var body = getBlockBody(object.body);
+
+      [...body].forEach((stmt, i) => {
+        var addDebugger = Math.random() < 0.1 / (this.made || 1);
+
+        if (object.type == "Program" && i == 0) {
+          addDebugger = true;
+        }
 
-    [...body].forEach((stmt) => {
-      if (Math.random() < 0.1 / (this.made || 1)) {
-        var index = getRandomInteger(0, body.length);
-        if (body[index].type != "DebuggerStatement") {
-          body.splice(index, 0, DebuggerStatement());
+        if (addDebugger) {
+          var index = getRandomInteger(0, body.length);
+          if (body[index].type != "DebuggerStatement") {
+            body.splice(index, 0, DebuggerStatement());
 
-          this.made++;
+            this.made++;
+          }
         }
-      }
-    });
+      });
+    };
   }
 }

package/src/transforms/lock/lock.ts

@@ -62,7 +62,7 @@ export default class Lock extends Transform {
     }
 
     if (this.options.lock.antiDebug) {
-      this.before.push(new AntiDebug(o));
+      this.before.push(new AntiDebug(o, this));
     }
 
     this.made = 0;
@@ -112,8 +112,7 @@ export default class Lock extends Transform {
         throw new Error(
           "Countermeasures function named '" +
             this.options.lock.countermeasures +
-            "' was not found. Names found: " +
-            Array.from(defined).slice(0, 100).join(", ")
+            "' was not found."
         );
       }
     }
@@ -215,6 +214,9 @@ export default class Lock extends Transform {
     if (this.options.lock.osLock && this.options.lock.osLock.length) {
       choices.push("osLock");
     }
+    if (this.options.lock.selfDefending) {
+      choices.push("selfDefending");
+    }
 
     if (!choices.length) {
       return;
@@ -261,6 +263,38 @@ export default class Lock extends Transform {
       var offset = 0;
 
       switch (type) {
+        case "selfDefending":
+          // A very simple mechanism inspired from https://github.com/javascript-obfuscator/javascript-obfuscator/blob/master/src/custom-code-helpers/self-defending/templates/SelfDefendingNoEvalTemplate.ts
+          // regExp checks for a newline, formatters add these
+          var callExpression = Template(
+            `
+            (
+              function(){
+                // Breaks JSNice.org, beautifier.io
+                var namedFunction = function(){
+                  const test = function(){
+                    const regExp=new RegExp('\\n');
+                    return regExp['test'](namedFunction)
+                  };
+                  return test()
+                }
+
+                return namedFunction();
+              }
+            )()
+            `
+          ).single().expression;
+
+          nodes.push(
+            IfStatement(
+              callExpression,
+              this.getCounterMeasuresCode() || [],
+              null
+            )
+          );
+
+          break;
+
         case "nativeFunction":
           var set = this.options.lock.nativeFunctions;
           if (set === true) {