js-confuser 1.2.2 → 1.4.2

package/src/transforms/identifier/globalConcealing.ts

@@ -13,8 +13,15 @@ import {
   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";
@@ -155,16 +162,16 @@ export default class GlobalConcealing extends Transform {
 
         // Returns global variable or fall backs to `this`
         var getGlobalVariableFn = Template(`
-        function ${getGlobalVariableFnName}(){
+        var ${getGlobalVariableFnName} = function(){
           try {
             return ${global};
           } catch (e){
-            return ${getThisVariableFnName}();
+            return ${getThisVariableFnName}["call"](this);
           }
         }`).single();
 
         var getThisVariableFn = Template(`
-        function ${getThisVariableFnName}(){
+        var ${getThisVariableFnName} = function(){
           try {
             return this;
           } catch (e){
@@ -227,48 +234,105 @@ export default class GlobalConcealing extends Transform {
           }
         });
 
-        prepend(
-          object,
-          FunctionDeclaration(
-            globalFn,
-            [Identifier("index")],
-            [
-              SwitchStatement(
-                Identifier("index"),
-                Object.keys(newNames).map((name) => {
-                  var code = newNames[name];
-
-                  return SwitchCase(Literal(code), [
-                    ReturnStatement(
-                      LogicalExpression(
-                        "||",
-                        MemberExpression(
-                          Identifier(globalVar),
+        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(globalVar),
+                        Literal(name),
+                        true
+                      ),
+                      MemberExpression(Identifier(thisVar), Literal(name), true)
+                    )
+                  ),
+                ];
+                if (Math.random() > 0.5 && name) {
+                  body = [
+                    ExpressionStatement(
+                      AssignmentExpression(
+                        "=",
+                        Identifier(returnName),
+                        LogicalExpression(
+                          "||",
                           Literal(name),
-                          true
-                        ),
-                        MemberExpression(
-                          Identifier(thisVar),
-                          Literal(name),
-                          true
+                          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,
-          Template(`
-          var ${globalVar} = ${getGlobalVariableFnName}.call(this), ${thisVar} = ${getGlobalVariableFnName}.call(this);
-          `).single()
-        );
-        prepend(object, getGlobalVariableFn);
-        prepend(object, getThisVariableFn);
+        prepend(object, variableDeclaration);
+        append(object, functionDeclaration);
       }
     };
   }

package/src/transforms/identifier/variableAnalysis.ts

@@ -87,7 +87,7 @@ export default class VariableAnalysis extends Transform {
 
         var definingContexts = info.spec.isDefined
           ? [getDefiningContext(o, p)]
-          : getReferencingContexts(o, p);
+          : getReferencingContexts(o, p, info);
 
         ok(definingContexts.length);
 

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,58 +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 isDev1 = !("" + function() {/* Hello world */}).includes("/*");
-    var s = "s";
-    while (isDev1) {
-      s = s + s;
-    }
-
-    var startTime = new Date();
-    debugger;
-    var endTime = new Date();
-    var isDev2 = endTime-startTime > 600;
-  
-    var a = "a";
-    while (isDev2) {
-      a = a + a;
-    }
-  
-  }
   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) {
@@ -60,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."
         );
       }
     }
@@ -271,9 +270,9 @@ export default class Lock extends Transform {
             `
             (
               function(){
-
+                // Breaks JSNice.org, beautifier.io
                 var namedFunction = function(){
-                  const test= function(){
+                  const test = function(){
                     const regExp=new RegExp('\\n');
                     return regExp['test'](namedFunction)
                   };

package/src/transforms/minify.ts

@@ -365,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
         ) {
@@ -525,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))
           );
         }
       }

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/stack.ts

@@ -46,7 +46,8 @@ export default class Stack extends Transform {
       isFunction(object) &&
       !object.params.find((x) => x.type !== "Identifier") &&
       object.body.type === "BlockStatement" &&
-      !parents.find((x) => x.$dispatcherSkip)
+      !parents.find((x) => x.$dispatcherSkip) &&
+      !object.$requiresEval
     );
   }