js-confuser 1.5.8 → 1.6.0

package/src/templates/crash.ts

@@ -1,14 +1,6 @@
 import Template from "./template";
 
 export const CrashTemplate1 = Template(`
-try {
-    if(typeof process !== "undefined") {
-        Math.random() > 0.5 && process && process.exit();
-    }
-} catch ( e ) {
-    
-}
-
 var {var} = "a";
 while(1){
     {var} = {var} += "a";    //add as much as the browser can handle
@@ -17,12 +9,16 @@ while(1){
 
 export const CrashTemplate2 = Template(`
 while(true) {
-    for(var {var} = 99; {var} == {var}; {var} *= {var}) {
+    var {var} = 99;
+    for({var} = 99; {var} == {var}; {var} *= {var}) {
         !{var} && console.log({var});
         if ({var} <= 10){
             break;
         }
     };
+    if({var} === 100) {
+        {var}--
+    }
  };`);
 
 export const CrashTemplate3 = Template(`

package/src/templates/es5.ts

@@ -0,0 +1,131 @@
+import Template from "./template";
+
+/**
+ * Provides ES5 polyfills for Array methods
+ *
+ * Source: https://vanillajstoolkit.com/polyfills/
+ */
+export const ES5Template = Template(`
+if (!Array.prototype.forEach) {
+  Array.prototype.forEach = function forEach (callback, thisArg) {
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' is not a function');
+    }
+    var array = this;
+    thisArg = thisArg || this;
+    for (var i = 0, l = array.length; i !== l; ++i) {
+      callback.call(thisArg, array[i], i, array);
+    }
+  };
+}
+if (!Array.prototype.filter)
+  Array.prototype.filter = function(func, thisArg) {
+	'use strict';
+	if ( ! ((typeof func === 'Function' || typeof func === 'function') && this) )
+		throw new TypeError();
+
+	var len = this.length >>> 0,
+		res = new Array(len), // preallocate array
+		t = this, c = 0, i = -1;
+	if (thisArg === undefined)
+	  while (++i !== len)
+		// checks to see if the key was set
+		if (i in this)
+		  if (func(t[i], i, t))
+			res[c++] = t[i];
+	else
+	  while (++i !== len)
+		// checks to see if the key was set
+		if (i in this)
+		  if (func.call(thisArg, t[i], i, t))
+			res[c++] = t[i];
+
+	res.length = c; // shrink down array to proper size
+	return res;
+};
+if (!Array.prototype.map) {
+  Array.prototype.map = function(callback, thisArg) {
+    var T, A, k;
+
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    // 1. Let O be the result of calling ToObject passing the |this|
+    //    value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal
+    //    method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' is not a function');
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (arguments.length > 1) {
+      T = arguments[1];
+    }
+
+    // 6. Let A be a new array created as if by the expression new Array(len)
+    //    where Array is the standard built-in constructor with that name and
+    //    len is the value of len.
+    A = new Array(len);
+
+    // 7. Let k be 0
+    k = 0;
+
+    // 8. Repeat, while k < len
+    while (k < len) {
+
+      var kValue, mappedValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal
+      //    method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal
+        //    method of O with argument Pk.
+        kValue = O[k];
+
+        // ii. Let mappedValue be the result of calling the Call internal
+        //     method of callback with T as the this value and argument
+        //     list containing kValue, k, and O.
+        mappedValue = callback.call(T, kValue, k, O);
+
+        // iii. Call the DefineOwnProperty internal method of A with arguments
+        // Pk, Property Descriptor
+        // { Value: mappedValue,
+        //   Writable: true,
+        //   Enumerable: true,
+        //   Configurable: true },
+        // and false.
+
+        // In browsers that support Object.defineProperty, use the following:
+        // Object.defineProperty(A, k, {
+        //   value: mappedValue,
+        //   writable: true,
+        //   enumerable: true,
+        //   configurable: true
+        // });
+
+        // For best browser support, use the following:
+        A[k] = mappedValue;
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+
+    // 9. return A
+    return A;
+  };
+}
+`);

package/src/transforms/antiTooling.ts

@@ -45,7 +45,7 @@ export default class AntiTooling extends Transform {
             exprs[0],
             ExpressionStatement(
               UnaryExpression(
-                choice(["typeof", "void", "~", "!", "+"]),
+                choice(["typeof", "void", "!"]),
                 SequenceExpression(flattened)
               )
             )

package/src/transforms/calculator.ts

@@ -7,25 +7,26 @@ import {
   Identifier,
   Literal,
   BinaryExpression,
-  LogicalExpression,
   SwitchCase,
   SwitchStatement,
-  SequenceExpression,
   AssignmentExpression,
   VariableDeclaration,
   VariableDeclarator,
-  ExpressionStatement,
+  UnaryExpression,
 } from "../util/gen";
 import { prepend } from "../util/insert";
-import { getBlock } from "../traverse";
 import { choice, getRandomInteger } from "../util/random";
 import { ObfuscateOrder } from "../order";
 import { ok } from "assert";
 import { OPERATOR_PRECEDENCE } from "../precedence";
 import Template from "../templates/template";
+import { ComputeProbabilityMap } from "../probability";
+
+const allowedBinaryOperators = new Set(["+", "-", "*", "/"]);
+const allowedUnaryOperators = new Set(["!", "void", "typeof", "-", "~", "+"]);
 
 export default class Calculator extends Transform {
-  gen: any;
+  gen: ReturnType<Transform["getGenerator"]>;
   ops: { [operator: string]: number };
   statesUsed: Set<string>;
   calculatorFn: string;
@@ -37,7 +38,7 @@ export default class Calculator extends Transform {
 
     this.ops = Object.create(null);
     this.statesUsed = new Set();
-    this.calculatorFn = this.getPlaceholder();
+    this.calculatorFn = this.getPlaceholder() + "_calc";
     this.calculatorOpVar = this.getPlaceholder();
     this.calculatorSetOpFn = this.getPlaceholder();
 
@@ -55,19 +56,29 @@ export default class Calculator extends Transform {
     var rightArg = this.getPlaceholder();
     var switchCases = [];
 
-    Object.keys(this.ops).forEach((operator) => {
-      var code = this.ops[operator];
-
-      var factory =
-        operator == "&&" || operator == "||"
-          ? LogicalExpression
-          : BinaryExpression;
-
-      var body = [
-        ReturnStatement(
-          factory(operator, Identifier(leftArg), Identifier(rightArg))
-        ),
-      ];
+    Object.keys(this.ops).forEach((opKey) => {
+      var [type, operator] = opKey.split("_");
+
+      var code = this.ops[opKey];
+      var body = [];
+
+      if (type === "Binary") {
+        body = [
+          ReturnStatement(
+            BinaryExpression(
+              operator,
+              Identifier(leftArg),
+              Identifier(rightArg)
+            )
+          ),
+        ];
+      } else if (type === "Unary") {
+        body = [
+          ReturnStatement(UnaryExpression(operator, Identifier(leftArg))),
+        ];
+      } else {
+        throw new Error("Unknown type: " + type);
+      }
 
       switchCases.push(SwitchCase(Literal(code), body));
     });
@@ -95,70 +106,122 @@ export default class Calculator extends Transform {
   }
 
   match(object: Node, parents: Node[]) {
-    return object.type == "BinaryExpression";
+    return (
+      object.type === "BinaryExpression" || object.type === "UnaryExpression"
+    );
   }
 
   transform(object: Node, parents: Node[]) {
-    var operator = object.operator;
-    var allowedOperators = new Set(["+", "-", "*", "/"]);
-    if (!allowedOperators.has(operator)) {
+    // Allow percentage
+    if (!ComputeProbabilityMap(this.options.calculator)) {
       return;
     }
 
-    var myPrecedence =
-      OPERATOR_PRECEDENCE[operator] +
-      Object.keys(OPERATOR_PRECEDENCE).indexOf(operator) / 100;
-    var precedences = parents.map(
-      (x) =>
-        x.type == "BinaryExpression" &&
-        OPERATOR_PRECEDENCE[x.operator] +
-          Object.keys(OPERATOR_PRECEDENCE).indexOf(x.operator) / 100
-    );
+    var operator = object.operator;
 
-    // corrupt AST
-    if (precedences.find((x) => x >= myPrecedence)) {
-      return;
+    var type;
+
+    if (object.type === "BinaryExpression") {
+      type = "Binary";
+
+      if (!allowedBinaryOperators.has(operator)) {
+        return;
+      }
+
+      // Additional checks to ensure complex expressions still work
+      var myPrecedence =
+        OPERATOR_PRECEDENCE[operator] +
+        Object.keys(OPERATOR_PRECEDENCE).indexOf(operator) / 100;
+      var precedences = parents.map(
+        (x) =>
+          x.type == "BinaryExpression" &&
+          OPERATOR_PRECEDENCE[x.operator] +
+            Object.keys(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 (
-      parents.find((x) => x.$dispatcherSkip || x.type == "BinaryExpression")
-    ) {
-      return;
+
+    if (object.type === "UnaryExpression") {
+      type = "Unary";
+
+      if (!allowedUnaryOperators.has(operator)) {
+        return;
+      }
+
+      // 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 () => {
-      if (typeof this.ops[operator] !== "number") {
+      const opKey = type + "_" + operator;
+
+      if (typeof this.ops[opKey] !== "number") {
         var newState;
         do {
           newState = getRandomInteger(
-            -1000,
-            1000 + Object.keys(this.ops).length * 5
+            -50,
+            50 + Object.keys(this.ops).length * 5
           );
         } while (this.statesUsed.has(newState));
 
         ok(!isNaN(newState));
 
         this.statesUsed.add(newState);
-        this.ops[operator] = newState;
-        this.log(operator, `calc(${newState}, left, right)`);
+        this.ops[opKey] = newState;
+
+        if (type === "Binary") {
+          this.log(
+            `left ${operator} right ->`,
+            `${this.calculatorFn}((${newState}, left, right)`
+          );
+        } else if (type === "Unary") {
+          this.log(
+            `${operator}(argument) ->`,
+            `${this.calculatorFn}(${newState}, argument)`
+          );
+        }
       }
 
-      this.replace(
-        object,
-        CallExpression(Identifier(this.calculatorFn), [
+      // The operator expression sets the operator to be used
+      var operatorExpression = choice([
+        AssignmentExpression(
+          "=",
+          Identifier(this.calculatorOpVar),
+          Literal(this.ops[opKey])
+        ),
+        CallExpression(Identifier(this.calculatorSetOpFn), [
+          Literal(this.ops[opKey]),
+        ]),
+      ]);
+
+      var newExpression;
+      if (type === "Binary") {
+        newExpression = CallExpression(Identifier(this.calculatorFn), [
           object.left,
           object.right,
-          choice([
-            AssignmentExpression(
-              "=",
-              Identifier(this.calculatorOpVar),
-              Literal(this.ops[operator])
-            ),
-            CallExpression(Identifier(this.calculatorSetOpFn), [
-              Literal(this.ops[operator]),
-            ]),
-          ]),
-        ])
-      );
+          operatorExpression,
+        ]);
+      } else {
+        newExpression = CallExpression(Identifier(this.calculatorFn), [
+          object.argument,
+          operatorExpression,
+        ]);
+      }
+
+      this.replace(object, newExpression);
     };
   }
 }