js-confuser 1.5.9 → 1.7.0

package/dist/transforms/identifier/variableAnalysis.js

@@ -9,8 +9,6 @@ var _assert = require("assert");
 
 var _constants = require("../../constants");
 
-var _traverse = require("../../traverse");
-
 var _compare = require("../../util/compare");
 
 var _identifiers = require("../../util/identifiers");
@@ -37,10 +35,12 @@ class VariableAnalysis extends _transform.default {
 
   /**
    * Set of global identifiers to never be redefined
+   *
+   * - Used to not accidentally block access to a global variable
    */
 
   /**
-   * Set of identifers that are defined within the program
+   * Set of identifiers that are defined within the program
    */
   constructor(o) {
     super(o);
@@ -60,72 +60,68 @@ class VariableAnalysis extends _transform.default {
   }
 
   match(object, parents) {
-    return (0, _insert.isContext)(object);
+    return object.type === "Identifier";
   }
 
   transform(object, parents) {
-    (0, _traverse.walk)(object, parents, (o, p) => {
-      if (o.type == "Identifier") {
-        var name = o.name;
-        (0, _assert.ok)(typeof name === "string");
-
-        if (!(0, _compare.isValidIdentifier)(name)) {
-          return;
-        }
-
-        if (_constants.reservedIdentifiers.has(name)) {
-          return;
-        }
-
-        if (this.options.globalVariables.has(name)) {
-          return;
-        }
-
-        var info = (0, _identifiers.getIdentifierInfo)(o, p);
-
-        if (!info.spec.isReferenced) {
-          return;
-        }
-
-        if (info.spec.isExported) {
-          return;
+    var name = object.name;
+    (0, _assert.ok)(typeof name === "string");
+
+    if (!(0, _compare.isValidIdentifier)(name)) {
+      return;
+    }
+
+    if (_constants.reservedIdentifiers.has(name)) {
+      return;
+    }
+
+    if (this.options.globalVariables.has(name)) {
+      return;
+    }
+
+    var info = (0, _identifiers.getIdentifierInfo)(object, parents);
+
+    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(object.name);
+      this.globals.delete(object.name);
+    } else if (!this.notGlobals.has(object.name)) {
+      this.globals.add(object.name);
+    }
+
+    var definingContexts = info.spec.isDefined ? (0, _insert.getAllDefiningContexts)(object, parents) : (0, _insert.getReferencingContexts)(object, parents, info);
+    (0, _assert.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());
         }
 
-        var isDefined = info.spec.isDefined; // Keep track of defined names within the program
+        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());
+          }
 
-        if (isDefined) {
-          this.notGlobals.add(o.name);
-          this.globals.delete(o.name);
-        } else if (!this.notGlobals.has(o.name)) {
-          this.globals.add(o.name);
+          this.references.get(definingContext).add(name);
         }
-
-        var definingContexts = info.spec.isDefined ? (0, _insert.getAllDefiningContexts)(o, p) : (0, _insert.getReferencingContexts)(o, p, info);
-        (0, _assert.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/dist/transforms/lock/lock.js

@@ -194,10 +194,6 @@ class Lock extends _transform.default {
       choices.push("domainLock");
     }
 
-    if (this.options.lock.nativeFunctions) {
-      choices.push("nativeFunction");
-    }
-
     if (this.options.lock.context && this.options.lock.context.length) {
       choices.push("context");
     }
@@ -248,39 +244,6 @@ class Lock extends _transform.default {
           nodes.push((0, _gen.IfStatement)(callExpression, this.getCounterMeasuresCode(object, parents) || [], null));
           break;
 
-        case "nativeFunction":
-          var set = this.options.lock.nativeFunctions;
-
-          if (set === true) {
-            if (this.options.target == "node") {
-              set = new Set(["Function", "String"]);
-            } else {
-              set = new Set(["Function", "String", "fetch"]);
-            }
-          }
-
-          if (Array.isArray(set)) {
-            set = new Set(set);
-          }
-
-          if (!set) {
-            set = new Set();
-          }
-
-          var fn = (0, _random.choice)(Array.from(set));
-
-          if (fn) {
-            test = (0, _template.default)("(".concat(fn, "+\"\").indexOf(\"[native code]\") == -1")).single().expression;
-
-            if (Math.random() > 0.5) {
-              test = (0, _template.default)("".concat(fn, ".toString().split(\"{ [native code] }\").length <= 1")).single().expression;
-            }
-
-            nodes.push((0, _gen.IfStatement)(test, this.getCounterMeasuresCode(object, parents) || [], null));
-          }
-
-          break;
-
         case "startDate":
           test = (0, _gen.BinaryExpression)("<", dateNow, (0, _gen.Literal)(this.getTime(this.options.lock.startDate)));
           nodes.push((0, _gen.IfStatement)(test, this.getCounterMeasuresCode(object, parents) || [], null));

package/dist/transforms/minify.js

@@ -78,7 +78,7 @@ class Minify extends _transform.default {
           var startIndex = -1;
           var sequences = [];
           body.forEach((stmt, i) => {
-            if (stmt.type == "ExpressionStatement") {
+            if (stmt.type == "ExpressionStatement" && !stmt.directive) {
               exprs.push(stmt.expression);
 
               if (startIndex == -1) {
@@ -108,48 +108,44 @@ class Minify extends _transform.default {
             (0, _assert.ok)(seq.index != -1);
             body.splice(seq.index, seq.exprs.length, (0, _gen.ExpressionStatement)(seq.exprs.length == 1 ? seq.exprs[0] : (0, _gen.SequenceExpression)(seq.exprs)));
           });
-        }
+        } // Unnecessary return
 
-        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 (parents[0] && (0, _insert.isVarContext)(parents[0]) && body.length && body[body.length - 1]) {
+          var last = body[body.length - 1];
 
-              if (isUndefined) {
-                if ((0, _insert.getFunction)(object, parents).body == object) {
-                  body.pop();
-                }
-              }
+          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(...(0, _insert.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(...(0, _insert.clone)(x.declarations));
+              remove.unshift(i);
             }
-          });
-          remove.forEach(x => {
-            body.splice(x, 1);
-          });
-        }
+          } else {
+            lastDec = null;
+          }
+        });
+        remove.forEach(x => {
+          body.splice(x, 1);
+        });
       };
     }
     /**
@@ -172,29 +168,30 @@ class Minify extends _transform.default {
           }
         }
 
-        var blockIndex = parents.findIndex(x => (0, _insert.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);
-          (0, _assert.ok)(!before.includes(stmt));
-          var set = new Set(before.map(x => x.type));
-          set.delete("FunctionDeclaration");
+          (0, _assert.ok)(!before.includes(object));
+          var beforeTypes = new Set(before.map(x => x.type));
+          beforeTypes.delete("FunctionDeclaration");
+
+          if (beforeTypes.size > 0) {
+            return;
+          } // Test Variant #25: Don't break redefined function declaration
+
 
-          if (set.size) {
+          if (object.id && body.find(x => x.type === "FunctionDeclaration" && x !== object && x.id && x.id.name === object.id.name)) {
             return;
           }
         }
@@ -217,11 +214,11 @@ class Minify extends _transform.default {
         if (canTransform) {
           if (!this.arrowFunctionName) {
             this.arrowFunctionName = this.getPlaceholder();
-            (0, _insert.append)(parents[parents.length - 1] || object, (0, _template.default)("\n            function ".concat(this.arrowFunctionName, "(arrowFn){\n              return function(){ return arrowFn(...arguments) }\n            }\n            ")).single());
+            (0, _insert.append)(parents[parents.length - 1] || object, (0, _template.default)("\n            function ".concat(this.arrowFunctionName, "(arrowFn, functionLength){\n              var functionObject = function(){ return arrowFn(...arguments) };\n\n              Object[\"defineProperty\"](functionObject, \"length\", {\n                \"value\": functionLength,\n                \"configurable\": true\n              });\n\n              return functionObject;\n            }\n            ")).single());
           }
 
           const wrap = object => {
-            return (0, _gen.CallExpression)((0, _gen.Identifier)(this.arrowFunctionName), [(0, _insert.clone)(object)]);
+            return (0, _gen.CallExpression)((0, _gen.Identifier)(this.arrowFunctionName), [(0, _insert.clone)(object), (0, _gen.Literal)((0, _insert.computeFunctionLength)(object.params))]);
           };
 
           if (object.type == "FunctionExpression") {
@@ -253,7 +250,7 @@ class Minify extends _transform.default {
 
         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;
           }
@@ -421,8 +418,16 @@ class Minify extends _transform.default {
       if (property.type == "Literal" && (0, _compare.isValidIdentifier)(property.value)) {
         object.computed = false;
         object.property.type = "Identifier";
-        object.property.name = (0, _insert.clone)(object.property.value);
-        obj.name && this.log(obj.name + "['" + object.property.name + "'] -> " + obj.name + "." + object.property.name);
+        object.property.name = (0, _insert.clone)(object.property.value); // obj.name &&
+        //   this.log(
+        //     obj.name +
+        //       "['" +
+        //       object.property.name +
+        //       "'] -> " +
+        //       obj.name +
+        //       "." +
+        //       object.property.name
+        //   );
       }
     }
 
@@ -437,18 +442,16 @@ class Minify extends _transform.default {
     } // { "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) {
         object.key = object.key.expressions[0];
         object.computed = true;
       }
 
-      if (object.key.type == "Literal" && (0, _compare.isValidIdentifier)(object.key.value)) {
+      if (object.key.type == "Literal" && typeof object.key.value === "string" && (0, _compare.isValidIdentifier)(object.key.value)) {
         object.key.type = "Identifier";
         object.key.name = object.key.value;
         object.computed = false;
-      } else if (object.key.type == "Identifier" && !(0, _compare.isValidIdentifier)(object.key.name)) {
-        object.key = (0, _gen.Literal)(object.key.name);
       }
     }
 

package/dist/transforms/opaquePredicates.js

@@ -66,7 +66,7 @@ class OpaquePredicates extends _transform.default {
     _defineProperty(this, "made", void 0);
 
     this.predicates = Object.create(null);
-    this.gen = this.getGenerator((0, _random.getRandomInteger)(0, 20));
+    this.gen = this.getGenerator();
     this.made = 0;
   }
 

package/dist/transforms/preparation/preparation.js

@@ -103,9 +103,9 @@ class ExplicitIdentifiers extends _transform.default {
         if (parents[propIndex].type == "MethodDefinition" && parents[propIndex].kind == "constructor") {
           return;
         }
-      }
+      } // this.log(object.name, "->", `'${object.name}'`);
+
 
-      this.log(object.name, "->", "'".concat(object.name, "'"));
       this.replace(object, (0, _gen.Literal)(object.name));
       parents[0].computed = true;
       parents[0].shorthand = false;

package/dist/transforms/preparation.js

@@ -0,0 +1,231 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _transform = _interopRequireDefault(require("./transform"));
+
+var _gen = require("../util/gen");
+
+var _order = require("../order");
+
+var _insert = require("../util/insert");
+
+var _identifiers = require("../util/identifiers");
+
+var _compare = require("../util/compare");
+
+var _traverse = require("../traverse");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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
+ */
+class Preparation extends _transform.default {
+  constructor(o) {
+    super(o, _order.ObfuscateOrder.Preparation);
+  }
+
+  match(object, parents) {
+    return !!object.type;
+  }
+
+  transform(object, parents) {
+    // 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 = (0, _gen.BlockStatement)([(0, _insert.clone)(object.consequent)]);
+        }
+
+        if (object.alternate && object.alternate.type != "BlockStatement") {
+          object.alternate = (0, _gen.BlockStatement)([(0, _insert.clone)(object.alternate)]);
+        }
+
+        break;
+
+      case "WhileStatement":
+      case "WithStatement":
+      case "ForStatement":
+      case "ForOfStatement":
+      case "ForInStatement":
+        if (object.body.type != "BlockStatement") {
+          object.body = (0, _gen.BlockStatement)([(0, _insert.clone)(object.body)]);
+        }
+
+        break;
+
+      case "ArrowFunctionExpression":
+        if (object.body.type !== "BlockStatement" && object.expression) {
+          object.body = (0, _gen.BlockStatement)([(0, _gen.ReturnStatement)((0, _insert.clone)(object.body))]);
+          object.expression = false;
+        }
+
+        break;
+    } // Label
+
+
+    if ((0, _compare.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, parents) {
+    return () => {
+      var currentLabel = parents[0].type == "LabeledStatement" && parents[0].label.name;
+      var label = currentLabel || this.getPlaceholder();
+      (0, _traverse.walk)(object, parents, (o, p) => {
+        if (o.type == "BreakStatement" || o.type == "ContinueStatement") {
+          function isContinuableStatement(x) {
+            return (0, _compare.isLoop)(x) && x.type !== "SwitchStatement";
+          }
+
+          function isBreakableStatement(x) {
+            return (0, _compare.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 = (0, _gen.Identifier)(label);
+            }
+          }
+        }
+      }); // Append label statement as this loop has none
+
+      if (!currentLabel) {
+        this.replace(object, (0, _gen.LabeledStatement)(label, { ...object
+        }));
+      }
+    };
+  }
+  /**
+   * Transforms Identifiers (a.IDENTIFIER, {IDENTIFIER:...}) into string properties
+   */
+
+
+  transformExplicitIdentifiers(object, parents) {
+    // Mark functions containing 'eval'
+    // Some transformations avoid functions that have 'eval' to not break them
+    if (object.name === "eval") {
+      var fn = (0, _insert.getFunction)(object, parents);
+
+      if (fn) {
+        fn.$requiresEval = true;
+      }
+    }
+
+    var info = (0, _identifiers.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, (0, _gen.Literal)(object.name));
+      parents[0].computed = true;
+      parents[0].shorthand = false;
+    }
+  }
+  /**
+   * Transforms VariableDeclaration into single declarations.
+   */
+
+
+  transformExplicitDeclarations(object, parents) {
+    // 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 ((0, _compare.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: [(0, _insert.clone)(x)],
+          kind: object.kind
+        };
+      }));
+      object.declarations.length = 1;
+    }
+  }
+
+}
+
+exports.default = Preparation;

package/dist/transforms/renameLabels.js

@@ -30,7 +30,7 @@ class RenameLabels extends _transform.default {
 
     _defineProperty(this, "gen", void 0);
 
-    this.gen = this.getGenerator();
+    this.gen = this.getGenerator("randomized");
   }
 
   match(object, parents) {