js-confuser 1.7.1 → 1.7.2

package/src/templates/bufferToString.ts

@@ -1,19 +1,59 @@
+import {
+  placeholderVariablePrefix,
+  predictableFunctionTag,
+} from "../constants";
 import Template from "./template";
 
-export const BufferToStringTemplate = Template(`
-  function __getGlobal(){
+export const GetGlobalTemplate = Template(`
+  function ${placeholderVariablePrefix}CFG__getGlobalThis${predictableFunctionTag}(){
+    return globalThis
+  }
+
+  function ${placeholderVariablePrefix}CFG__getGlobal${predictableFunctionTag}(){
+    return global
+  }
+
+  function ${placeholderVariablePrefix}CFG__getWindow${predictableFunctionTag}(){
+    return window
+  }
+
+  function ${placeholderVariablePrefix}CFG__getThisFunction${predictableFunctionTag}(){
+    return new Function("return this")()
+  }
+
+  function {getGlobalFnName}(array = [
+    ${placeholderVariablePrefix}CFG__getGlobalThis${predictableFunctionTag},
+    ${placeholderVariablePrefix}CFG__getGlobal${predictableFunctionTag},
+    ${placeholderVariablePrefix}CFG__getWindow${predictableFunctionTag},
+    ${placeholderVariablePrefix}CFG__getThisFunction${predictableFunctionTag}
+  ]){
+    var bestMatch
+    var itemsToSearch = []
     try {
-      return global||window|| ( new Function("return this") )();
-    } catch ( e ) {
+      bestMatch = Object
+      itemsToSearch["push"](("")["__proto__"]["constructor"]["name"])
+    } catch(e) {
+
+    }
+    A: for(var i = 0; i < array["length"]; i++) {
       try {
-        return this;
-      } catch ( e ) {
-        return {};
-      }
+        bestMatch = array[i]()
+        for(var j = 0; j < itemsToSearch["length"]; j++) {
+          if(typeof bestMatch[itemsToSearch[j]] === "undefined") continue A;
+        }
+        return bestMatch
+      } catch(e) {}
     }
+
+		return bestMatch || this;
   }
+`);
 
-  var __globalObject = __getGlobal() || {};
+export const BufferToStringTemplate = Template(`
+
+  ${GetGlobalTemplate.source}
+
+  var __globalObject = {getGlobalFnName}() || {};
   var __TextDecoder = __globalObject["TextDecoder"];
   var __Uint8Array = __globalObject["Uint8Array"];
   var __Buffer = __globalObject["Buffer"];
@@ -63,6 +103,4 @@ export const BufferToStringTemplate = Template(`
       return utf8ArrayToStr(buffer);
     }
   }
-
-  
 `);

package/src/templates/functionLength.ts

@@ -3,12 +3,30 @@ import Template from "./template";
 /**
  * Helper function to set `function.length` property.
  */
-export const FunctionLengthTemplate = Template(`
+export const FunctionLengthTemplate = Template(
+  `
 function {name}(functionObject, functionLength){
-  Object["defineProperty"](functionObject, "length", {
+  {ObjectDefineProperty}(functionObject, "length", {
     "value": functionLength,
     "configurable": true
   });
   return functionObject;
 }
-`);
+`,
+  `
+function {name}(functionObject, functionLength){
+  return {ObjectDefineProperty}(functionObject, "length", {
+    "value": functionLength,
+    "configurable": true
+  });
+}
+`,
+  `
+function {name}(functionObject, functionLength){
+  return {ObjectDefineProperty}["call"](null, functionObject, "length", {
+    "value": functionLength,
+    "configurable": true
+  });
+}
+`
+);

package/src/templates/globals.ts

@@ -0,0 +1,3 @@
+import Template from "./template";
+
+export const ObjectDefineProperty = Template(`Object["defineProperty"]`);

package/src/templates/template.ts

@@ -1,57 +1,103 @@
 import { Node } from "../util/gen";
 import { parseSnippet, parseSync } from "../parser";
+import { ok } from "assert";
+import { choice } from "../util/random";
+import { placeholderVariablePrefix } from "../constants";
 
 export interface ITemplate {
-  fill(variables?: { [name: string]: string | number }): string;
+  fill(variables?: { [name: string]: string | number }): {
+    output: string;
+    template: string;
+  };
 
   compile(variables?: { [name: string]: string | number }): Node[];
 
   single(variables?: { [name: string]: string | number }): Node;
 
+  variables(variables): ITemplate;
+
+  ignoreMissingVariables(): ITemplate;
+
+  templates: string[];
   source: string;
 }
 
-export default function Template(template: string): ITemplate {
-  var neededVariables = 0;
-  while (template.includes(`{$${neededVariables + 1}}`)) {
-    neededVariables++;
+export default function Template(...templates: string[]): ITemplate {
+  ok(templates.length);
+
+  var requiredVariables = new Set<string>();
+  var providedVariables = {};
+  var defaultVariables: { [key: string]: string } = Object.create(null);
+
+  // 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);
+
+      // $ variables are for default variables
+      if (name.startsWith("$")) {
+        defaultVariables[name] =
+          placeholderVariablePrefix +
+          "td_" +
+          Object.keys(defaultVariables).length;
+      } else {
+        requiredVariables.add(name);
+      }
+    });
   }
-  var vars = Object.create(null);
-  new Array(neededVariables + 1).fill(0).forEach((x, i) => {
-    vars["\\$" + i] = "temp_" + i;
-  });
-
-  function fill(variables?: { [name: string]: string | number }): string {
-    if (!variables) {
-      variables = Object.create(null);
-    }
 
-    var cloned = template;
+  function fill(
+    variables: { [name: string]: string | number } = Object.create(null)
+  ) {
+    var userVariables = { ...providedVariables, ...variables };
+
+    // 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 keys = { ...variables, ...vars };
+    var template = 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: { [name: string]: string | number }): Node[] {
-    var code = fill(variables);
+    var { output, template } = fill(variables);
     try {
-      var program = parseSnippet(code);
+      var program = 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
+      );
     }
   }
 
@@ -60,11 +106,25 @@ export default function Template(template: string): ITemplate {
     return nodes[0];
   }
 
+  function variables(newVariables) {
+    Object.assign(providedVariables, newVariables);
+    return obj;
+  }
+
+  function ignoreMissingVariables() {
+    defaultVariables = Object.create(null);
+    requiredVariables.clear();
+    return obj;
+  }
+
   var obj: ITemplate = {
     fill,
     compile,
     single,
-    source: template,
+    templates,
+    variables,
+    ignoreMissingVariables,
+    source: templates[0],
   };
 
   return obj;

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,
+        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/controlFlowFlattening/controlFlowFlattening.ts

@@ -47,9 +47,8 @@ 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 { isDirective, isModuleSource } from "../../util/compare";
 
 const flattenStructures = new Set([
   "IfStatement",
@@ -1571,6 +1570,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))
             ) {

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,
+        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

@@ -188,10 +188,6 @@ function setCookie(cname, cvalue, exdays) {
     return true;
   }
   
-  /**
-   * @param {TreeNode} root
-   * @return {boolean}
-   */
   function isBalanced(root) {
     const height = getHeightBalanced(root);
     return height !== Infinity;
@@ -426,9 +422,6 @@ function setCookie(cname, cvalue, exdays) {
   console.log(maximumGap);
   `),
   Template(`
-  /**
-   * @param {number} capacity
-   */
   var LRUCache = function(capacity) {
     this.capacity = capacity;
     this.length = 0;
@@ -437,10 +430,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 +441,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]);