js-confuser 1.7.1 → 1.7.3

package/src/transforms/antiTooling.ts

@@ -1,32 +1,51 @@
 import { ObfuscateOrder } from "../order";
+import Template from "../templates/template";
 import { isBlock } from "../traverse";
 import {
+  Node,
   ExpressionStatement,
-  SequenceExpression,
-  UnaryExpression,
+  CallExpression,
+  Identifier,
 } from "../util/gen";
-import { choice } from "../util/random";
+import { prepend } from "../util/insert";
 import Transform from "./transform";
 
 // JsNice.org tries to separate sequence expressions into multiple lines, this stops that.
 export default class AntiTooling extends Transform {
+  fnName: string;
+
   constructor(o) {
     super(o, ObfuscateOrder.AntiTooling);
   }
 
+  apply(tree: Node) {
+    super.apply(tree);
+
+    if (typeof this.fnName === "string") {
+      prepend(
+        tree,
+        new Template(`
+      function {fnName}(){
+      }
+      `).single({ fnName: this.fnName })
+      );
+    }
+  }
+
   match(object, parents) {
     return isBlock(object) || object.type == "SwitchCase";
   }
 
   transform(object, parents) {
     return () => {
-      var exprs = [];
-      var deleteExprs = [];
+      var exprs: Node[] = [];
+      var deleteExprs: Node[] = [];
 
-      var body = object.type == "SwitchCase" ? object.consequent : object.body;
+      var body: Node[] =
+        object.type == "SwitchCase" ? object.consequent : object.body;
 
       const end = () => {
-        function flatten(expr) {
+        function flatten(expr: Node) {
           if (expr.type == "ExpressionStatement") {
             flatten(expr.expression);
           } else if (expr.type == "SequenceExpression") {
@@ -41,13 +60,16 @@ export default class AntiTooling extends Transform {
 
         if (flattened.length > 1) {
           flattened[0] = { ...flattened[0] };
+
+          if (!this.fnName) {
+            this.fnName = this.getPlaceholder();
+          }
+
+          // (expr1,expr2,expr3) -> F(expr1, expr2, expr3)
           this.replace(
             exprs[0],
             ExpressionStatement(
-              UnaryExpression(
-                choice(["typeof", "void", "!"]),
-                SequenceExpression(flattened)
-              )
+              CallExpression(Identifier(this.fnName), [...flattened])
             )
           );
 

package/src/transforms/calculator.ts

@@ -96,7 +96,7 @@ export default class Calculator extends Transform {
 
     prepend(
       tree,
-      Template(`function {name}(a){
+      new Template(`function {name}(a){
         a = {b} + ({b}=a, 0);
         return a;
       }`).single({ name: this.calculatorSetOpFn, b: this.calculatorOpVar })
@@ -144,7 +144,9 @@ export default class Calculator extends Transform {
         return;
       }
       if (
-        parents.find((x) => x.$dispatcherSkip || x.type == "BinaryExpression")
+        parents.find(
+          (x) => x.$multiTransformSkip || x.type == "BinaryExpression"
+        )
       ) {
         return;
       }

package/src/transforms/controlFlowFlattening/controlFlowFlattening.ts

@@ -47,9 +47,9 @@ import {
 import { chance, choice, getRandomInteger, shuffle } from "../../util/random";
 import Transform from "../transform";
 import ExpressionObfuscation from "./expressionObfuscation";
-import { isModuleSource } from "../string/stringConcealing";
-import { reservedIdentifiers } from "../../constants";
-import { isDirective } from "../../util/compare";
+import { reservedIdentifiers, variableFunctionName } from "../../constants";
+import { isDirective, isModuleSource } from "../../util/compare";
+import { isJSConfuserVar } from "../../util/guard";
 
 const flattenStructures = new Set([
   "IfStatement",
@@ -1367,7 +1367,7 @@ export default class ControlFlowFlattening extends Transform {
             VariableDeclaration(VariableDeclarator(tempVar, callExpression))
           );
 
-          const t = (str): Node => Template(str).single().expression;
+          const t = (str): Node => new Template(str).single().expression;
 
           newStatements.push(
             IfStatement(
@@ -1571,6 +1571,7 @@ export default class ControlFlowFlattening extends Transform {
               !this.isDebug &&
               o.type === "Identifier" &&
               this.mangleIdentifiers &&
+              !reservedIdentifiers.has(o.name) &&
               chance(50 - this.mangledExpressionsMade / 100) &&
               !p.find((x) => isVarContext(x))
             ) {
@@ -1585,6 +1586,11 @@ export default class ControlFlowFlattening extends Transform {
                 return;
               }
 
+              // Ignore __JS_CONFUSER_VAR__()
+              if (isJSConfuserVar(p)) {
+                return;
+              }
+
               // TYPEOF expression check
               if (
                 p[0] &&
@@ -1896,7 +1902,8 @@ export default class ControlFlowFlattening extends Transform {
         shuffle(controlProperties);
       }
 
-      var discriminant = Template(`${stateVars.join("+")}`).single().expression;
+      var discriminant = new Template(`${stateVars.join("+")}`).single()
+        .expression;
 
       objectBody.length = 0;
       // Perverse position of import declarations

package/src/transforms/controlFlowFlattening/expressionObfuscation.ts

@@ -1,15 +1,48 @@
+import { criticalFunctionTag } from "../../constants";
+import Template from "../../templates/template";
 import { isBlock } from "../../traverse";
-import { Identifier, SequenceExpression } from "../../util/gen";
+import {
+  CallExpression,
+  Identifier,
+  Node,
+  SequenceExpression,
+} from "../../util/gen";
+import { prepend } from "../../util/insert";
 import Transform from "../transform";
 
 /**
  * Expression Obfuscation runs before Control Flow Flattening
  */
 export default class ExpressionObfuscation extends Transform {
+  fnName: string;
+
   constructor(o) {
     super(o);
   }
 
+  apply(tree: Node): void {
+    super.apply(tree);
+
+    if (typeof this.fnName === "string") {
+      prepend(
+        tree,
+        new Template(`
+        function {fnName}(...args){
+          return args[args["length"] - 1]
+        }
+        `).single({ fnName: this.fnName })
+      );
+    }
+  }
+
+  createSequenceExpression(expressions: Node[]): Node {
+    if (!this.fnName) {
+      this.fnName = this.getPlaceholder() + criticalFunctionTag;
+    }
+
+    return CallExpression(Identifier(this.fnName), [...expressions]);
+  }
+
   match(object, parents) {
     return isBlock(object);
   }
@@ -54,12 +87,12 @@ export default class ExpressionObfuscation extends Transform {
                     stmt.test.left.argument.type === "Identifier"
                   ) // typeof is special
                 ) {
-                  stmt.test.left.argument = SequenceExpression([
+                  stmt.test.left.argument = this.createSequenceExpression([
                     ...exprs,
                     { ...stmt.test.left.argument },
                   ]);
                 } else {
-                  stmt.test.left = SequenceExpression([
+                  stmt.test.left = this.createSequenceExpression([
                     ...exprs,
                     { ...stmt.test.left },
                   ]);
@@ -70,12 +103,15 @@ export default class ExpressionObfuscation extends Transform {
                 stmt.test.operator !== "**" &&
                 stmt.test.left.left.type == "UnaryExpression"
               ) {
-                stmt.test.left.left.argument = SequenceExpression([
+                stmt.test.left.left.argument = this.createSequenceExpression([
                   ...exprs,
                   { ...stmt.test.left.left.argument },
                 ]);
               } else {
-                stmt.test = SequenceExpression([...exprs, { ...stmt.test }]);
+                stmt.test = this.createSequenceExpression([
+                  ...exprs,
+                  { ...stmt.test },
+                ]);
               }
               deleteExprs.push(...exprs);
             } else if (
@@ -88,7 +124,7 @@ export default class ExpressionObfuscation extends Transform {
 
               if (init) {
                 if (init.type == "VariableDeclaration") {
-                  init.declarations[0].init = SequenceExpression([
+                  init.declarations[0].init = this.createSequenceExpression([
                     ...exprs,
                     {
                       ...(init.declarations[0].init || Identifier("undefined")),
@@ -96,7 +132,7 @@ export default class ExpressionObfuscation extends Transform {
                   ]);
                   deleteExprs.push(...exprs);
                 } else if (init.type == "AssignmentExpression") {
-                  init.right = SequenceExpression([
+                  init.right = this.createSequenceExpression([
                     ...exprs,
                     {
                       ...(init.right || Identifier("undefined")),
@@ -106,7 +142,7 @@ export default class ExpressionObfuscation extends Transform {
                 }
               }
             } else if (stmt.type == "VariableDeclaration") {
-              stmt.declarations[0].init = SequenceExpression([
+              stmt.declarations[0].init = this.createSequenceExpression([
                 ...exprs,
                 {
                   ...(stmt.declarations[0].init || Identifier("undefined")),
@@ -114,13 +150,13 @@ export default class ExpressionObfuscation extends Transform {
               ]);
               deleteExprs.push(...exprs);
             } else if (stmt.type == "ThrowStatement") {
-              stmt.argument = SequenceExpression([
+              stmt.argument = this.createSequenceExpression([
                 ...exprs,
                 { ...stmt.argument },
               ]);
               deleteExprs.push(...exprs);
             } else if (stmt.type == "ReturnStatement") {
-              stmt.argument = SequenceExpression([
+              stmt.argument = this.createSequenceExpression([
                 ...exprs,
                 { ...(stmt.argument || Identifier("undefined")) },
               ]);

package/src/transforms/deadCode.ts

@@ -3,19 +3,24 @@ import { ComputeProbabilityMap } from "../probability";
 import Template from "../templates/template";
 import { isBlock } from "../traverse";
 import {
+  AssignmentExpression,
+  BinaryExpression,
+  ExpressionStatement,
   Identifier,
   IfStatement,
   Literal,
+  MemberExpression,
   Node,
+  ObjectExpression,
   VariableDeclaration,
   VariableDeclarator,
 } from "../util/gen";
 import { getBlockBody, isFunction, prepend } from "../util/insert";
-import { choice, getRandomInteger } from "../util/random";
+import { chance, choice, getRandomInteger } from "../util/random";
 import Transform from "./transform";
 
 const templates = [
-  Template(`
+  new Template(`
   function curCSS( elem, name, computed ) {
     var ret;
   
@@ -36,7 +41,7 @@ const templates = [
       ret + "" :
       ret;
   }`),
-  Template(`
+  new Template(`
   function Example() {
     var state = redacted.useState(false);
     return x(
@@ -49,7 +54,7 @@ const templates = [
     );
   }`),
 
-  Template(`
+  new Template(`
   const path = require('path');
 const { version } = require('../../package');
 const { version: dashboardPluginVersion } = require('@redacted/enterprise-plugin/package');
@@ -60,7 +65,7 @@ const resolveLocalRedactedPath = require('./resolve-local-redacted-path');
 
 const redactedPath = path.resolve(__dirname, '../redacted.js');`),
 
-  Template(`
+  new Template(`
 module.exports = async (resolveLocalRedactedPath = ()=>{throw new Error("No redacted path provided")}) => {
   const cliParams = new Set(process.argv.slice(2));
   if (!cliParams.has('--version')) {
@@ -76,7 +81,7 @@ module.exports = async (resolveLocalRedactedPath = ()=>{throw new Error("No reda
 
   return true;
 };`),
-  Template(`
+  new Template(`
 function setCookie(cname, cvalue, exdays) {
   var d = new Date();
   d.setTime(d.getTime() + (exdays*24*60*60*1000));
@@ -84,7 +89,7 @@ function setCookie(cname, cvalue, exdays) {
   document.cookie = cname + "=" + cvalue + ";" + expires + ";path=/";
 }`),
 
-  Template(`function getCookie(cname) {
+  new Template(`function getCookie(cname) {
   var name = cname + "=";
   var decodedCookie = decodeURIComponent(document.cookie);
   var ca = decodedCookie.split(';');
@@ -100,7 +105,7 @@ function setCookie(cname, cvalue, exdays) {
   return "";
 }`),
 
-  Template(`function getLocalStorageValue(key, cb){
+  new Template(`function getLocalStorageValue(key, cb){
     if ( typeof key !== "string" ) {
       throw new Error("Invalid data key provided (not type string)")
     }
@@ -116,7 +121,7 @@ function setCookie(cname, cvalue, exdays) {
 
     cb(null, value)
   }`),
-  Template(`
+  new Template(`
   
     var __ = "(c=ak(<~F$VU'9f)~><&85dBPL-module/from";
     var s = "q:function(){var ad=ad=>b(ad-29);if(!T.r[(typeof ab==ad(123)?";
@@ -124,7 +129,7 @@ function setCookie(cname, cvalue, exdays) {
 
     __.match(s + g);
   `),
-  Template(`
+  new Template(`
   function vec_pack(vec) {
     return vec[1] * 67108864 + (vec[0] < 0 ? 33554432 | vec[0] : vec[0]);
   }
@@ -161,7 +166,7 @@ function setCookie(cname, cvalue, exdays) {
   console.log(vec_unpack(e)); // [4, 8]
   console.log(vec_unpack(f)); // [2, 4]
   `),
-  Template(`
+  new Template(`
   function buildCharacterMap(str) {
     const characterMap = {};
   
@@ -188,10 +193,6 @@ function setCookie(cname, cvalue, exdays) {
     return true;
   }
   
-  /**
-   * @param {TreeNode} root
-   * @return {boolean}
-   */
   function isBalanced(root) {
     const height = getHeightBalanced(root);
     return height !== Infinity;
@@ -226,7 +227,7 @@ function setCookie(cname, cvalue, exdays) {
     getHeightBalanced,
   };
   `),
-  Template(`
+  new Template(`
   function ListNode(){}
   var addTwoNumbers = function(l1, l2) {
     var carry = 0;
@@ -249,7 +250,7 @@ function setCookie(cname, cvalue, exdays) {
 
   console.log(addTwoNumbers)
   `),
-  Template(`
+  new Template(`
   var threeSum = function(nums) {
     var len = nums.length;
     var res = [];
@@ -278,7 +279,7 @@ function setCookie(cname, cvalue, exdays) {
   };
   console.log(threeSum)
   `),
-  Template(`
+  new Template(`
   var combinationSum2 = function(candidates, target) {
     var res = [];
     var len = candidates.length;
@@ -302,7 +303,7 @@ function setCookie(cname, cvalue, exdays) {
 
   console.log(combinationSum2);
   `),
-  Template(`
+  new Template(`
   var isScramble = function(s1, s2) {
     return helper({}, s1, s2);
   };
@@ -343,7 +344,7 @@ function setCookie(cname, cvalue, exdays) {
 
   console.log(isScramble);
   `),
-  Template(`
+  new Template(`
   var candy = function(ratings) {
     var len = ratings.length;
     var res = [];
@@ -360,7 +361,7 @@ function setCookie(cname, cvalue, exdays) {
   
   console.log(candy)
   `),
-  Template(`
+  new Template(`
   var maxPoints = function(points) {
     var max = 0;
     var map = {};
@@ -391,7 +392,7 @@ function setCookie(cname, cvalue, exdays) {
   
   console.log(maxPoints)
   `),
-  Template(`
+  new Template(`
   var maximumGap = function(nums) {
     var len = nums.length;
     if (len < 2) return 0;
@@ -425,10 +426,7 @@ function setCookie(cname, cvalue, exdays) {
 
   console.log(maximumGap);
   `),
-  Template(`
-  /**
-   * @param {number} capacity
-   */
+  new Template(`
   var LRUCache = function(capacity) {
     this.capacity = capacity;
     this.length = 0;
@@ -437,10 +435,6 @@ function setCookie(cname, cvalue, exdays) {
     this.tail = null;
   };
   
-  /** 
-   * @param {number} key
-   * @return {number}
-   */
   LRUCache.prototype.get = function(key) {
     var node = this.map[key];
     if (node) {
@@ -452,11 +446,6 @@ function setCookie(cname, cvalue, exdays) {
     }
   };
   
-  /** 
-   * @param {number} key 
-   * @param {number} value
-   * @return {void}
-   */
   LRUCache.prototype.put = function(key, value) {
     if (this.map[key]) {
       this.remove(this.map[key]);
@@ -504,7 +493,7 @@ function setCookie(cname, cvalue, exdays) {
 
   console.log(LRUCache);
   `),
-  Template(`
+  new Template(`
   var isInterleave = function(s1, s2, s3) {
     var dp = {};
     if (s3.length !== s1.length + s2.length) return false;
@@ -532,7 +521,7 @@ function setCookie(cname, cvalue, exdays) {
 
   console.log(isInterleave);
   `),
-  Template(`
+  new Template(`
   var solveNQueens = function(n) {
     var res = [];
     if (n === 1 || n >= 4) dfs(res, [], n, 0);
@@ -587,6 +576,9 @@ function setCookie(cname, cvalue, exdays) {
 export default class DeadCode extends Transform {
   made: number;
 
+  compareObjectName: string;
+  gen = this.getGenerator("randomized");
+
   constructor(o) {
     super(o, ObfuscateOrder.DeadCode);
 
@@ -597,7 +589,8 @@ export default class DeadCode extends Transform {
     return (
       isFunction(object) &&
       isBlock(object.body) &&
-      !parents.find((x) => x.$dispatcherSkip)
+      !object.$multiTransformSkip &&
+      !parents.find((x) => x.$multiTransformSkip)
     );
   }
 
@@ -624,17 +617,56 @@ export default class DeadCode extends Transform {
 
       var index = getRandomInteger(safeOffset, body.length);
 
+      if (!this.compareObjectName) {
+        this.compareObjectName = this.getPlaceholder();
+
+        prepend(
+          parents[parents.length - 1] || object,
+          VariableDeclaration(
+            VariableDeclarator(
+              this.compareObjectName,
+              new Template(`Object["create"](null)`).single().expression
+            )
+          )
+        );
+      }
+
       var name = this.getPlaceholder();
       var variableDeclaration = VariableDeclaration(
-        VariableDeclarator(name, Literal(false))
+        VariableDeclarator(
+          name,
+          BinaryExpression(
+            "in",
+            Literal(this.gen.generate()),
+            Identifier(this.compareObjectName)
+          )
+        )
       );
 
-      var template;
+      var template: Template;
       do {
         template = choice(templates);
-      } while (this.options.es5 && template.source.includes("async"));
+      } while (this.options.es5 && template.templates[0].includes("async"));
+
+      var nodes = template.compile();
+
+      if (chance(50)) {
+        nodes.unshift(
+          ExpressionStatement(
+            AssignmentExpression(
+              "=",
+              MemberExpression(
+                Identifier(this.compareObjectName),
+                Literal(this.gen.generate()),
+                true
+              ),
+              Literal(this.gen.generate())
+            )
+          )
+        );
+      }
 
-      var ifStatement = IfStatement(Identifier(name), template.compile(), null);
+      var ifStatement = IfStatement(Identifier(name), nodes, null);
 
       body.splice(index, 0, ifStatement);