js-confuser 1.7.1 → 1.7.2

package/dist/templates/template.js

@@ -4,62 +4,103 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = Template;
-
 var _parser = require("../parser");
+var _assert = require("assert");
+var _random = require("../util/random");
+var _constants = require("../constants");
+function Template() {
+  for (var _len = arguments.length, templates = new Array(_len), _key = 0; _key < _len; _key++) {
+    templates[_key] = arguments[_key];
+  }
+  (0, _assert.ok)(templates.length);
+  var requiredVariables = new Set();
+  var providedVariables = {};
+  var defaultVariables = Object.create(null);
 
-function Template(template) {
-  var neededVariables = 0;
+  // This may picked up "$mb[pP`x]" from String Encoding function
+  // ignoreMissingVariables() prevents this
+  var matches = templates[0].match(/{[$A-z0-9_]+}/g);
+  if (matches !== null) {
+    matches.forEach(variable => {
+      var name = variable.slice(1, -1);
 
-  while (template.includes("{$".concat(neededVariables + 1, "}"))) {
-    neededVariables++;
+      // $ variables are for default variables
+      if (name.startsWith("$")) {
+        defaultVariables[name] = _constants.placeholderVariablePrefix + "td_" + Object.keys(defaultVariables).length;
+      } else {
+        requiredVariables.add(name);
+      }
+    });
   }
+  function fill() {
+    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Object.create(null);
+    var userVariables = {
+      ...providedVariables,
+      ...variables
+    };
 
-  var vars = Object.create(null);
-  new Array(neededVariables + 1).fill(0).forEach((x, i) => {
-    vars["\\$" + i] = "temp_" + i;
-  });
-
-  function fill(variables) {
-    if (!variables) {
-      variables = Object.create(null);
+    // Validate all variables were passed in
+    for (var requiredVariable of requiredVariables) {
+      if (typeof userVariables[requiredVariable] === "undefined") {
+        throw new Error(templates[0] + " missing variable: " + requiredVariable + " from " + JSON.stringify(userVariables));
+      }
     }
-
-    var cloned = template;
-    var keys = { ...variables,
-      ...vars
+    var template = (0, _random.choice)(templates);
+    var output = template;
+    var allVariables = {
+      ...defaultVariables,
+      ...userVariables
     };
-    Object.keys(keys).forEach(name => {
-      var bracketName = "{" + name + "}";
-      var value = keys[name] + "";
+    Object.keys(allVariables).forEach(name => {
+      var bracketName = "{" + name.replace("$", "\\$") + "}";
+      var value = allVariables[name] + "";
       var reg = new RegExp(bracketName, "g");
-      cloned = cloned.replace(reg, value);
+      output = output.replace(reg, value);
     });
-    return cloned;
+    return {
+      output,
+      template
+    };
   }
-
   function compile(variables) {
-    var code = fill(variables);
-
+    var {
+      output,
+      template
+    } = fill(variables);
     try {
-      var program = (0, _parser.parseSnippet)(code);
+      var program = (0, _parser.parseSnippet)(output);
       return program.body;
     } catch (e) {
       console.error(e);
       console.error(template);
-      throw new Error("Template failed to parse");
+      console.error({
+        ...providedVariables,
+        ...variables
+      });
+      throw new Error("Template failed to parse: OUTPUT= " + output + " SOURCE= " + template);
     }
   }
-
   function single(variables) {
     var nodes = compile(variables);
     return nodes[0];
   }
-
+  function variables(newVariables) {
+    Object.assign(providedVariables, newVariables);
+    return obj;
+  }
+  function ignoreMissingVariables() {
+    defaultVariables = Object.create(null);
+    requiredVariables.clear();
+    return obj;
+  }
   var obj = {
     fill,
     compile,
     single,
-    source: template
+    templates,
+    variables,
+    ignoreMissingVariables,
+    source: templates[0]
   };
   return obj;
 }

package/dist/transforms/antiTooling.js

@@ -4,35 +4,41 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _order = require("../order");
-
+var _template = _interopRequireDefault(require("../templates/template"));
 var _traverse = require("../traverse");
-
 var _gen = require("../util/gen");
-
-var _random = require("../util/random");
-
+var _insert = require("../util/insert");
 var _transform = _interopRequireDefault(require("./transform"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 // JsNice.org tries to separate sequence expressions into multiple lines, this stops that.
 class AntiTooling extends _transform.default {
   constructor(o) {
     super(o, _order.ObfuscateOrder.AntiTooling);
+    _defineProperty(this, "fnName", void 0);
+  }
+  apply(tree) {
+    super.apply(tree);
+    if (typeof this.fnName === "string") {
+      (0, _insert.prepend)(tree, (0, _template.default)(`
+      function {fnName}(){
+      }
+      `).single({
+        fnName: this.fnName
+      }));
+    }
   }
-
   match(object, parents) {
     return (0, _traverse.isBlock)(object) || object.type == "SwitchCase";
   }
-
   transform(object, parents) {
     return () => {
       var exprs = [];
       var deleteExprs = [];
       var body = object.type == "SwitchCase" ? object.consequent : object.body;
-
       const end = () => {
         function flatten(expr) {
           if (expr.type == "ExpressionStatement") {
@@ -43,25 +49,26 @@ class AntiTooling extends _transform.default {
             flattened.push(expr);
           }
         }
-
         var flattened = [];
         exprs.forEach(flatten);
-
         if (flattened.length > 1) {
-          flattened[0] = { ...flattened[0]
+          flattened[0] = {
+            ...flattened[0]
           };
-          this.replace(exprs[0], (0, _gen.ExpressionStatement)((0, _gen.UnaryExpression)((0, _random.choice)(["typeof", "void", "!"]), (0, _gen.SequenceExpression)(flattened))));
+          if (!this.fnName) {
+            this.fnName = this.getPlaceholder();
+          }
+
+          // (expr1,expr2,expr3) -> F(expr1, expr2, expr3)
+          this.replace(exprs[0], (0, _gen.ExpressionStatement)((0, _gen.CallExpression)((0, _gen.Identifier)(this.fnName), [...flattened])));
           deleteExprs.push(...exprs.slice(1));
         }
-
         exprs = [];
       };
-
       body.forEach((stmt, i) => {
         if (stmt.hidden || stmt.directive) {
           return;
         }
-
         if (stmt.type == "ExpressionStatement") {
           exprs.push(stmt);
         } else {
@@ -71,14 +78,11 @@ class AntiTooling extends _transform.default {
       end();
       deleteExprs.forEach(expr => {
         var index = body.indexOf(expr);
-
         if (index !== -1) {
           body.splice(index, 1);
         }
       });
     };
   }
-
 }
-
 exports.default = AntiTooling;

package/dist/transforms/calculator.js

@@ -4,48 +4,30 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _transform = _interopRequireDefault(require("./transform"));
-
 var _gen = require("../util/gen");
-
 var _insert = require("../util/insert");
-
 var _random = require("../util/random");
-
 var _order = require("../order");
-
 var _assert = require("assert");
-
 var _precedence = require("../precedence");
-
 var _template = _interopRequireDefault(require("../templates/template"));
-
 var _probability = require("../probability");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 const allowedBinaryOperators = new Set(["+", "-", "*", "/"]);
 const allowedUnaryOperators = new Set(["!", "void", "typeof", "-", "~", "+"]);
-
 class Calculator extends _transform.default {
   constructor(o) {
     super(o, _order.ObfuscateOrder.Calculator);
-
     _defineProperty(this, "gen", void 0);
-
     _defineProperty(this, "ops", void 0);
-
     _defineProperty(this, "statesUsed", void 0);
-
     _defineProperty(this, "calculatorFn", void 0);
-
     _defineProperty(this, "calculatorOpVar", void 0);
-
     _defineProperty(this, "calculatorSetOpFn", void 0);
-
     this.ops = Object.create(null);
     this.statesUsed = new Set();
     this.calculatorFn = this.getPlaceholder() + "_calc";
@@ -53,14 +35,11 @@ class Calculator extends _transform.default {
     this.calculatorSetOpFn = this.getPlaceholder();
     this.gen = this.getGenerator();
   }
-
   apply(tree) {
     super.apply(tree);
-
     if (Object.keys(this.ops).length == 0) {
       return;
     }
-
     var leftArg = this.getPlaceholder();
     var rightArg = this.getPlaceholder();
     var switchCases = [];
@@ -68,7 +47,6 @@ class Calculator extends _transform.default {
       var [type, operator] = opKey.split("_");
       var code = this.ops[opKey];
       var body = [];
-
       if (type === "Binary") {
         body = [(0, _gen.ReturnStatement)((0, _gen.BinaryExpression)(operator, (0, _gen.Identifier)(leftArg), (0, _gen.Identifier)(rightArg)))];
       } else if (type === "Unary") {
@@ -76,101 +54,87 @@ class Calculator extends _transform.default {
       } else {
         throw new Error("Unknown type: " + type);
       }
-
       switchCases.push((0, _gen.SwitchCase)((0, _gen.Literal)(code), body));
     });
     var func = (0, _gen.FunctionDeclaration)(this.calculatorFn, [leftArg, rightArg].map(x => (0, _gen.Identifier)(x)), [(0, _gen.SwitchStatement)((0, _gen.Identifier)(this.calculatorOpVar), switchCases)]);
     (0, _insert.prepend)(tree, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(this.calculatorOpVar)));
-    (0, _insert.prepend)(tree, (0, _template.default)("function {name}(a){\n        a = {b} + ({b}=a, 0);\n        return a;\n      }").single({
+    (0, _insert.prepend)(tree, (0, _template.default)(`function {name}(a){
+        a = {b} + ({b}=a, 0);
+        return a;
+      }`).single({
       name: this.calculatorSetOpFn,
       b: this.calculatorOpVar
     }));
     (0, _insert.prepend)(tree, func);
   }
-
   match(object, parents) {
     return object.type === "BinaryExpression" || object.type === "UnaryExpression";
   }
-
   transform(object, parents) {
     // Allow percentage
     if (!(0, _probability.ComputeProbabilityMap)(this.options.calculator)) {
       return;
     }
-
     var operator = object.operator;
     var type;
-
     if (object.type === "BinaryExpression") {
       type = "Binary";
-
       if (!allowedBinaryOperators.has(operator)) {
         return;
-      } // Additional checks to ensure complex expressions still work
-
+      }
 
+      // Additional checks to ensure complex expressions still work
       var myPrecedence = _precedence.OPERATOR_PRECEDENCE[operator] + Object.keys(_precedence.OPERATOR_PRECEDENCE).indexOf(operator) / 100;
-      var precedences = parents.map(x => x.type == "BinaryExpression" && _precedence.OPERATOR_PRECEDENCE[x.operator] + Object.keys(_precedence.OPERATOR_PRECEDENCE).indexOf(x.operator) / 100); // corrupt AST
+      var precedences = parents.map(x => x.type == "BinaryExpression" && _precedence.OPERATOR_PRECEDENCE[x.operator] + Object.keys(_precedence.OPERATOR_PRECEDENCE).indexOf(x.operator) / 100);
 
+      // corrupt AST
       if (precedences.find(x => x >= myPrecedence)) {
         return;
       }
-
       if (parents.find(x => x.$dispatcherSkip || x.type == "BinaryExpression")) {
         return;
       }
     }
-
     if (object.type === "UnaryExpression") {
       type = "Unary";
-
       if (!allowedUnaryOperators.has(operator)) {
         return;
-      } // Typeof expression fix
-
+      }
 
+      // Typeof expression fix
       if (operator === "typeof" && object.argument.type === "Identifier") {
         // `typeof name` is special because it can reference the variable `name` without
         // throwing any errors. If changed, an error could be thrown, breaking the users code
         return;
       }
     }
-
     return () => {
       const opKey = type + "_" + operator;
-
       if (typeof this.ops[opKey] !== "number") {
         var newState;
-
         do {
           newState = (0, _random.getRandomInteger)(-50, 50 + Object.keys(this.ops).length * 5);
         } while (this.statesUsed.has(newState));
-
         (0, _assert.ok)(!isNaN(newState));
         this.statesUsed.add(newState);
         this.ops[opKey] = newState;
-
         if (type === "Binary") {
-          this.log("left ".concat(operator, " right ->"), "".concat(this.calculatorFn, "((").concat(newState, ", left, right)"));
+          this.log(`left ${operator} right ->`, `${this.calculatorFn}((${newState}, left, right)`);
         } else if (type === "Unary") {
-          this.log("".concat(operator, "(argument) ->"), "".concat(this.calculatorFn, "(").concat(newState, ", argument)"));
+          this.log(`${operator}(argument) ->`, `${this.calculatorFn}(${newState}, argument)`);
         }
-      } // The operator expression sets the operator to be used
-
+      }
 
+      // The operator expression sets the operator to be used
       var operatorExpression = (0, _random.choice)([(0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(this.calculatorOpVar), (0, _gen.Literal)(this.ops[opKey])), (0, _gen.CallExpression)((0, _gen.Identifier)(this.calculatorSetOpFn), [(0, _gen.Literal)(this.ops[opKey])])]);
       var newExpression;
-
       if (type === "Binary") {
         newExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(this.calculatorFn), [object.left, object.right, operatorExpression]);
       } else {
         newExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(this.calculatorFn), [object.argument, operatorExpression]);
       }
-
       this.replace(object, newExpression);
     };
   }
-
 }
-
 exports.default = Calculator;