js-confuser 1.5.8 → 1.6.0

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) {

package/dist/transforms/rgf.js

@@ -241,7 +241,8 @@ class RGF extends _transform.default {
                     // fn
                     // In most cases the identifier is being used like this (call expression, or referenced to be called later)
                     // Replace it with a simple wrapper function that will pass on the reference array
-                    var conditionalExpression = (0, _gen.ConditionalExpression)((0, _template.default)("typeof ".concat(referenceArray, "[").concat(index, "] === \"function\" && ").concat(referenceArray, "[").concat(index, "][\"").concat(referenceSignatures[index] || "_", "\"]")).single().expression, (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)((0, _gen.CallExpression)(memberExpression, [(0, _gen.Identifier)(referenceArray), (0, _gen.SpreadElement)((0, _gen.Identifier)("arguments"))]))]), memberExpression);
+                    var conditionalExpression = (0, _gen.ConditionalExpression)((0, _template.default)("typeof ".concat(referenceArray, "[").concat(index, "] === \"function\" && ").concat(referenceArray, "[").concat(index, "][\"").concat(referenceSignatures[index] || "_", "\"]")).single().expression, (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)( // clone() is required!
+                    (0, _gen.CallExpression)((0, _insert.clone)(memberExpression), [(0, _gen.Identifier)(referenceArray), (0, _gen.SpreadElement)((0, _gen.Identifier)("arguments"))]))]), (0, _insert.clone)(memberExpression));
                     this.replace(o, conditionalExpression);
                   }
                 }
@@ -258,8 +259,6 @@ class RGF extends _transform.default {
 
         let [object, parents] = _ref2;
         var name = object === null || object === void 0 ? void 0 : (_object$id2 = object.id) === null || _object$id2 === void 0 ? void 0 : _object$id2.name;
-        var hasName = !!name;
-        var params = object.params.map(x => x.name) || [];
         var signature = referenceSignatures[names.get(name)];
         var embeddedName = name || this.getPlaceholder(); // Since `new Function` is completely isolated, create an entire new obfuscator and run remaining transformations.
         // RGF runs early and needs completed code before converting to a string.
@@ -272,9 +271,9 @@ class RGF extends _transform.default {
             integrity: false
           },
           eval: false,
-          hideInitializingCode: false
+          stringEncoding: false
         });
-        var transforms = Object.values(obfuscator.transforms).filter(x => x.priority > this.priority);
+        var transforms = obfuscator.array.filter(x => x.priority > this.priority);
         var embeddedFunction = { ...object,
           type: "FunctionDeclaration",
           id: (0, _gen.Identifier)(embeddedName)

package/dist/transforms/stack.js

@@ -9,6 +9,8 @@ var _assert = require("assert");
 
 var _order = require("../order");
 
+var _probability = require("../probability");
+
 var _template = _interopRequireDefault(require("../templates/template"));
 
 var _traverse = require("../traverse");
@@ -31,9 +33,9 @@ class Stack extends _transform.default {
   constructor(o) {
     super(o, _order.ObfuscateOrder.Stack);
 
-    _defineProperty(this, "made", void 0);
+    _defineProperty(this, "mangledExpressionsMade", void 0);
 
-    this.made = 0;
+    this.mangledExpressionsMade = 0;
   }
 
   match(object, parents) {
@@ -41,10 +43,14 @@ class Stack extends _transform.default {
   }
 
   transform(object, parents) {
+    var _this = this;
+
     return () => {
+      var _getBlockBody$;
+
       // Uncaught SyntaxError: Getter must not have any formal parameters.
       // Uncaught SyntaxError: Setter must have exactly one formal parameter
-      var propIndex = parents.findIndex(x => x.type == "Property");
+      var propIndex = parents.findIndex(x => x.type === "Property" || x.type === "MethodDefinition");
 
       if (propIndex !== -1) {
         if (parents[propIndex].value === (parents[propIndex - 1] || object)) {
@@ -52,13 +58,40 @@ class Stack extends _transform.default {
             return;
           }
         }
+      } // Don't apply to functions with 'use strict' directive
+
+
+      if ((_getBlockBody$ = (0, _insert.getBlockBody)(object.body)[0]) !== null && _getBlockBody$ !== void 0 && _getBlockBody$.directive) {
+        return;
+      }
+
+      if (!(0, _probability.ComputeProbabilityMap)(this.options.stack)) {
+        return;
       }
 
       var defined = new Set();
       var referenced = new Set();
       var illegal = new Set();
+      /**
+       * Maps old names to new indices
+       */
+
       var subscripts = new Map();
       var deadValues = Object.create(null);
+      var propertyGen = this.getGenerator();
+
+      function isTransformableFunction(functionNode) {
+        if (functionNode.$requiresEval) return false; // Check for 'this'
+
+        var isIllegal = false;
+        (0, _traverse.walk)(functionNode.body, [], (o, p) => {
+          if (o.type === "ThisExpression") {
+            isIllegal = true;
+            return "EXIT";
+          }
+        });
+        return !isIllegal;
+      }
 
       function setSubscript(string, index) {
         subscripts.set(string, index + "");
@@ -74,19 +107,21 @@ class Stack extends _transform.default {
         if (o.type == "Identifier") {
           var info = (0, _identifiers.getIdentifierInfo)(o, p);
 
-          if (!info.spec.isReferenced) {
+          if (!info.spec.isReferenced || info.spec.isExported) {
             return;
           }
 
           var c = info.spec.isDefined ? (0, _insert.getDefiningContext)(o, p) : (0, _insert.getReferencingContexts)(o, p).find(x => (0, _insert.isVarContext)(x));
 
           if (c !== object) {
-            this.log(o.name + " is illegal due to different context");
+            // this.log(o.name + " is illegal due to different context");
             illegal.add(o.name);
           }
 
           if (info.isClauseParameter || info.isFunctionParameter || (0, _insert.isForInitialize)(o, p)) {
-            this.log(o.name + " is illegal due to clause parameter/function parameter");
+            // this.log(
+            //   o.name + " is illegal due to clause parameter/function parameter"
+            // );
             illegal.add(o.name);
           }
 
@@ -100,19 +135,47 @@ class Stack extends _transform.default {
             }
 
             if (info.isFunctionDeclaration) {
-              if (p[0] !== object.body.body[0]) {
+              (0, _assert.ok)(p[0].type === "FunctionDeclaration");
+
+              if (p[0] !== object.body.body[0] || !isTransformableFunction(p[0])) {
                 illegal.add(o.name);
               }
-            }
+            } // The new accessors will either be numbered: [index] or as a string .string
+
+
+            var newSubscript = (0, _random.choice)([subscripts.size, propertyGen.generate()]);
+            setSubscript(o.name, newSubscript);
+            defined.add(o.name); // Stack can only process single VariableDeclarations
 
-            setSubscript(o.name, subscripts.size);
-            defined.add(o.name);
             var varIndex = p.findIndex(x => x.type == "VariableDeclaration");
 
-            if (varIndex !== -1 && (varIndex !== 2 || p[varIndex].declarations.length > 1)) {
-              illegal.add(o.name);
+            if (varIndex !== -1) {
+              // Invalid 'id' property (must be Identifier)
+              if (varIndex !== 2) {
+                illegal.add(o.name);
+              } else if (p[varIndex].declarations.length > 1) {
+                illegal.add(o.name);
+              } else {
+                var value = p[varIndex].declarations[0].init;
+
+                if (value && !isTransformableFunction(value)) {
+                  illegal.add(o.name);
+                }
+              }
             }
           } else if (info.spec.isReferenced) {
+            if (info.spec.isModified) {
+              var assignmentIndex = p.findIndex(x => x.type === "AssignmentExpression");
+
+              if (assignmentIndex !== -1) {
+                var value = p[assignmentIndex].right;
+
+                if (value && !isTransformableFunction(value)) {
+                  illegal.add(o.name);
+                }
+              }
+            }
+
             referenced.add(o.name);
           }
         }
@@ -136,14 +199,15 @@ class Stack extends _transform.default {
         return;
       }
 
-      function numberLiteral(number) {
+      const numberLiteral = function (number) {
         let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
         (0, _assert.ok)(number === number);
 
-        if (typeof number !== "number" || !Object.keys(deadValues).length || depth > 5 || Math.random() > (depth == 0 ? 0.9 : 0.8 / (depth * 2))) {
+        if (typeof number !== "number" || !Object.keys(deadValues).length || depth > 4 || (0, _random.chance)(75 + depth * 15 + _this.mangledExpressionsMade / 25)) {
           return (0, _gen.Literal)(number);
         }
 
+        _this.mangledExpressionsMade++;
         var opposingIndex = (0, _random.choice)(Object.keys(deadValues));
 
         if (typeof opposingIndex === "undefined") {
@@ -153,15 +217,14 @@ class Stack extends _transform.default {
         var actualValue = deadValues[opposingIndex];
         (0, _assert.ok)(typeof actualValue === "number");
         return (0, _gen.BinaryExpression)("-", (0, _gen.MemberExpression)((0, _gen.Identifier)(stackName), numberLiteral(isNaN(parseFloat(opposingIndex)) ? opposingIndex : parseFloat(opposingIndex), depth + 1), true), numberLiteral(actualValue - number, depth + 1));
-      }
+      };
 
       function getMemberExpression(index) {
         (0, _assert.ok)(typeof index === "string", typeof index);
         return (0, _gen.MemberExpression)((0, _gen.Identifier)(stackName), numberLiteral(isNaN(parseFloat(index)) ? index : parseFloat(index)), true);
       }
 
-      var stackName = this.getPlaceholder();
-      var made = 1;
+      var stackName = this.getPlaceholder() + "_stack";
 
       const scan = (o, p) => {
         if (o.type == "Identifier") {
@@ -216,8 +279,7 @@ class Stack extends _transform.default {
           }
         }
 
-        if (o.type == "Literal" && typeof o.value === "number" && Math.floor(o.value) === o.value && Math.abs(o.value) < 100000 && Math.random() < 4 / made && p.find(x => (0, _insert.isFunction)(x)) === object) {
-          made++;
+        if (o.type == "Literal" && typeof o.value === "number" && Math.floor(o.value) === o.value && Math.abs(o.value) < 100000 && p.find(x => (0, _insert.isFunction)(x)) === object && (0, _random.chance)(50)) {
           return () => {
             this.replaceIdentifierOrLiteral(o, numberLiteral(o.value, 0), p);
           };
@@ -228,9 +290,9 @@ class Stack extends _transform.default {
       object.body.body.forEach((stmt, index) => {
         var isFirst = index == 0;
 
-        if (isFirst || Math.random() < 0.9 / index) {
+        if (isFirst || (0, _random.chance)(50 - index * 10)) {
           var exprs = [];
-          var changes = (0, _random.getRandomInteger)(isFirst ? 2 : 1, isFirst ? 3 : 2);
+          var changes = (0, _random.getRandomInteger)(1, 3);
 
           for (var i = 0; i < changes; i++) {
             var expr;
@@ -240,7 +302,7 @@ class Stack extends _transform.default {
             var i = 0;
 
             do {
-              newIndex = (0, _random.getRandomInteger)(0, 250 + subscripts.size + i * 1000) + "";
+              newIndex = (0, _random.choice)([propertyGen.generate(), (0, _random.getRandomInteger)(0, 250 + subscripts.size + i * 1000) + ""]);
               i++;
             } while (valueSet.has(newIndex));
 
@@ -254,9 +316,9 @@ class Stack extends _transform.default {
                 break;
 
               case "deadValue":
-                var rand = (0, _random.getRandomInteger)(-250, 250); // modify an already existing dead value index
+                var rand = (0, _random.getRandomInteger)(-150, 150); // modify an already existing dead value index
 
-                if (Math.random() > 0.5) {
+                if ((0, _random.chance)(50)) {
                   var alreadyExisting = (0, _random.choice)(Object.keys(deadValues));
 
                   if (typeof alreadyExisting === "string") {
@@ -265,7 +327,6 @@ class Stack extends _transform.default {
                 }
 
                 expr = (0, _gen.AssignmentExpression)("=", getMemberExpression(newIndex), numberLiteral(rand));
-                (0, _assert.ok)(!subscripts.has(newIndex));
                 deadValues[newIndex] = rand;
                 break;
             }
@@ -295,7 +356,7 @@ class Stack extends _transform.default {
 
       object.params = [(0, _gen.RestElement)((0, _gen.Identifier)(stackName))]; // Ensure the array is correct length
 
-      (0, _insert.prepend)(object.body, (0, _template.default)("".concat(stackName, ".length = ").concat(startingSize)).single());
+      (0, _insert.prepend)(object.body, (0, _template.default)("".concat(stackName, "[\"length\"] = ").concat(startingSize)).single());
     };
   }