js-confuser 1.7.1 → 1.7.3

package/src/transforms/string/stringConcealing.ts

@@ -1,12 +1,11 @@
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
 import Template from "../../templates/template";
-import { isBlock } from "../../traverse";
-import { isDirective } from "../../util/compare";
+import { getBlock } from "../../traverse";
+import { isDirective, isModuleSource } from "../../util/compare";
 import {
   ArrayExpression,
   CallExpression,
-  FunctionExpression,
   Identifier,
   Literal,
   MemberExpression,
@@ -22,54 +21,39 @@ import {
   choice,
   getRandomInteger,
   getRandomString,
+  shuffle,
 } from "../../util/random";
 import Transform from "../transform";
-import Encoding from "./encoding";
+import {
+  EncodingImplementation,
+  EncodingImplementations,
+  createEncodingImplementation,
+  hasAllEncodings,
+} from "./encoding";
 import { ComputeProbabilityMap } from "../../probability";
-import { BufferToStringTemplate } from "../../templates/bufferToString";
-
-export function isModuleSource(object: Node, parents: Node[]) {
-  if (!parents[0]) {
-    return false;
-  }
-
-  if (parents[0].type == "ImportDeclaration" && parents[0].source == object) {
-    return true;
-  }
-
-  if (parents[0].type == "ImportExpression" && parents[0].source == object) {
-    return true;
-  }
-
-  if (
-    parents[1] &&
-    parents[1].type == "CallExpression" &&
-    parents[1].arguments[0] === object &&
-    parents[1].callee.type == "Identifier"
-  ) {
-    if (
-      parents[1].callee.name == "require" ||
-      parents[1].callee.name == "import"
-    ) {
-      return true;
-    }
-  }
-
-  return false;
+import {
+  BufferToStringTemplate,
+  createGetGlobalTemplate,
+} from "../../templates/bufferToString";
+import { criticalFunctionTag, predictableFunctionTag } from "../../constants";
+
+interface FunctionObject {
+  block: Node;
+  fnName: string;
+  encodingImplementation: EncodingImplementation;
 }
 
 export default class StringConcealing extends Transform {
   arrayExpression: Node;
   set: Set<string>;
-  index: { [str: string]: [number, string] };
+  index: { [str: string]: [number, string, Node] }; // index, fnName, block
 
   arrayName = this.getPlaceholder();
   ignore = new Set<string>();
   variablesMade = 1;
-  encoding: { [type: string]: string } = Object.create(null);
   gen: ReturnType<Transform["getGenerator"]>;
 
-  hasAllEncodings: boolean;
+  functionObjects: FunctionObject[] = [];
 
   constructor(o) {
     super(o, ObfuscateOrder.StringConcealing);
@@ -77,84 +61,111 @@ export default class StringConcealing extends Transform {
     this.set = new Set();
     this.index = Object.create(null);
     this.arrayExpression = ArrayExpression([]);
-    this.hasAllEncodings = false;
     this.gen = this.getGenerator();
+  }
+
+  apply(tree) {
+    super.apply(tree);
 
     // Pad array with useless strings
-    var dead = getRandomInteger(5, 15);
+    var dead = getRandomInteger(50, 200);
     for (var i = 0; i < dead; i++) {
       var str = getRandomString(getRandomInteger(5, 40));
-      var fn = this.transform(Literal(str), []);
+      var fn = this.transform(Literal(str), [tree]);
       if (fn) {
         fn();
       }
     }
-  }
-
-  apply(tree) {
-    super.apply(tree);
 
     var cacheName = this.getPlaceholder();
-    var bufferToStringName = this.getPlaceholder();
+    var bufferToStringName = this.getPlaceholder() + predictableFunctionTag;
 
     // This helper functions convert UInt8 Array to UTf-string
     prepend(
       tree,
-      ...BufferToStringTemplate.compile({ name: bufferToStringName })
+      ...BufferToStringTemplate.compile({
+        name: bufferToStringName,
+        getGlobalFnName: this.getPlaceholder() + predictableFunctionTag,
+        GetGlobalTemplate: createGetGlobalTemplate(this, tree, []),
+      })
     );
 
-    Object.keys(this.encoding).forEach((type) => {
-      var { template } = Encoding[type];
-      var decodeFn = this.getPlaceholder();
-      var getterFn = this.encoding[type];
+    for (var functionObject of this.functionObjects) {
+      var {
+        block,
+        fnName: getterFnName,
+        encodingImplementation,
+      } = functionObject;
+
+      var decodeFn =
+        this.getPlaceholder() + predictableFunctionTag + criticalFunctionTag;
 
       append(
-        tree,
-        template.single({ name: decodeFn, bufferToString: bufferToStringName })
+        block,
+        encodingImplementation.template.single({
+          __fnName__: decodeFn,
+          __bufferToString__: bufferToStringName,
+        })
       );
+      // All these are fake and never ran
+      var ifStatements = new Template(`if ( z == x ) {
+          return y[${cacheName}[z]] = ${getterFnName}(x, y);
+        }
+        if ( y ) {
+          [b, y] = [a(b), x || z]
+          return ${getterFnName}(x, b, z)
+        }
+        if ( z && a !== ${decodeFn} ) {
+          ${getterFnName} = ${decodeFn}
+          return ${getterFnName}(x, -1, z, a, b)
+        }
+        if ( a === ${getterFnName} ) {
+          ${decodeFn} = y
+          return ${decodeFn}(z)
+        }
+        if( a === undefined ) {
+          ${getterFnName} = b
+        }
+        if( z == a ) {
+          return y ? x[b[y]] : ${cacheName}[x] || (z=(b[x] || a), ${cacheName}[x] = z(${this.arrayName}[x]))
+        }
+        `).compile();
 
-      append(
-        tree,
-        Template(`
-            
-            function ${getterFn}(x, y, z, a = ${decodeFn}, b = ${cacheName}){
-              if ( z ) {
-                return y[${cacheName}[z]] = ${getterFn}(x, y);
-              } else if ( y ) {
-                [b, y] = [a(b), x || z]
-              }
-            
-              return y ? x[b[y]] : ${cacheName}[x] || (z=(b[x], a), ${cacheName}[x] = z(${this.arrayName}[x]))
-            }
-  
-            `).single()
+      // Not all fake if-statements are needed
+      ifStatements = ifStatements.filter(() => chance(50));
+
+      // This one is always used
+      ifStatements.push(
+        new Template(`
+      if ( x !== y ) {
+        return b[x] || (b[x] = a(${this.arrayName}[x]))
+      }
+      `).single()
       );
-    });
 
-    var flowIntegrity = this.getPlaceholder();
+      shuffle(ifStatements);
+
+      var varDeclaration = new Template(`
+      var ${getterFnName} = (x, y, z, a, b)=>{
+        if(typeof a === "undefined") {
+          a = ${decodeFn}
+        }
+        if(typeof b === "undefined") {
+          b = ${cacheName}
+        }
+      }
+      `).single();
+
+      varDeclaration.declarations[0].init.body.body.push(...ifStatements);
+
+      prepend(block, varDeclaration);
+    }
 
     prepend(
       tree,
       VariableDeclaration([
         VariableDeclarator(cacheName, ArrayExpression([])),
-        VariableDeclarator(flowIntegrity, Literal(0)),
-        VariableDeclarator(
-          this.arrayName,
-          CallExpression(
-            FunctionExpression(
-              [],
-              [
-                VariableDeclaration(
-                  VariableDeclarator("a", this.arrayExpression)
-                ),
-                Template(
-                  `return (${flowIntegrity} ? a["pop"]() : ${flowIntegrity}++, a)`
-                ).single(),
-              ]
-            ),
-            []
-          )
-        ),
+        VariableDeclarator(this.arrayName, this.arrayExpression),
       ])
     );
   }
@@ -166,7 +177,7 @@ export default class StringConcealing extends Transform {
       object.value.length >= 3 &&
       !isModuleSource(object, parents) &&
       !isDirective(object, parents) //&&
-      /*!parents.find((x) => x.$dispatcherSkip)*/
+      /*!parents.find((x) => x.$multiTransformSkip)*/
     );
   }
 
@@ -192,48 +203,67 @@ export default class StringConcealing extends Transform {
         return;
       }
 
-      // HARD CODED LIMIT of 10,000 (after 1,000 elements)
-      if (this.set.size > 1000 && !chance(this.set.size / 100)) return;
+      var currentBlock = getBlock(object, parents);
 
-      var types = Object.keys(this.encoding);
+      // Find created functions
+      var functionObjects: FunctionObject[] = parents
+        .filter((node) => node.$stringConcealingFunctionObject)
+        .map((item) => item.$stringConcealingFunctionObject);
 
-      var type = choice(types);
-      if (!type || (!this.hasAllEncodings && chance(10))) {
-        var allowed = Object.keys(Encoding).filter(
-          (type) => !this.encoding[type]
-        );
+      // Choose random functionObject to use
+      var functionObject = choice(functionObjects);
+
+      if (
+        !functionObject ||
+        (!hasAllEncodings() &&
+          chance(25 / this.functionObjects.length) &&
+          !currentBlock.$stringConcealingFunctionObject)
+      ) {
+        // No functions, create one
 
-        if (!allowed.length) {
-          this.hasAllEncodings = true;
-        } else {
-          var random = choice(allowed);
-          type = random;
+        var newFunctionObject: FunctionObject = {
+          block: currentBlock,
+          encodingImplementation: createEncodingImplementation(),
+          fnName: this.getPlaceholder() + predictableFunctionTag,
+        };
 
-          this.encoding[random] = this.getPlaceholder();
-        }
+        this.functionObjects.push(newFunctionObject);
+        currentBlock.$stringConcealingFunctionObject = newFunctionObject;
+        functionObject = newFunctionObject;
       }
 
-      var fnName = this.encoding[type];
-      var encoder = Encoding[type];
+      var { fnName, encodingImplementation } = functionObject;
 
-      // The decode function must return correct result
-      var encoded = encoder.encode(object.value);
-      if (encoder.decode(encoded) != object.value) {
-        this.ignore.add(object.value);
-        this.warn(type, object.value.slice(0, 100));
-        return;
+      var index = -1;
+
+      // String already decoded?
+      if (this.set.has(object.value)) {
+        var row = this.index[object.value];
+        if (parents.includes(row[2])) {
+          [index, fnName] = row;
+          ok(typeof index === "number");
+        }
       }
 
-      var index = -1;
-      if (!this.set.has(object.value)) {
+      if (index == -1) {
+        // The decode function must return correct result
+        var encoded = encodingImplementation.encode(object.value);
+        if (encodingImplementation.decode(encoded) !== object.value) {
+          this.ignore.add(object.value);
+          this.warn(
+            encodingImplementation.identity,
+            object.value.slice(0, 100)
+          );
+          delete EncodingImplementations[encodingImplementation.identity];
+
+          return;
+        }
+
         this.arrayExpression.elements.push(Literal(encoded));
         index = this.arrayExpression.elements.length - 1;
-        this.index[object.value] = [index, fnName];
+        this.index[object.value] = [index, fnName, currentBlock];
 
         this.set.add(object.value);
-      } else {
-        [index, fnName] = this.index[object.value];
-        ok(typeof index === "number");
       }
 
       ok(index != -1, "index == -1");
@@ -269,7 +299,7 @@ export default class StringConcealing extends Transform {
 
         var constantReferenceType = choice(["variable", "array", "object"]);
 
-        var place = choice(parents.filter((node) => isBlock(node)));
+        var place = currentBlock;
         if (!place) {
           this.error(new Error("No lexical block to insert code"));
         }

package/src/transforms/string/stringEncoding.ts

@@ -1,7 +1,6 @@
 import Transform from "../transform";
 import { choice } from "../../util/random";
-import { isDirective } from "../../util/compare";
-import { isModuleSource } from "./stringConcealing";
+import { isDirective, isModuleSource } from "../../util/compare";
 import { ComputeProbabilityMap } from "../../probability";
 import { Identifier } from "../../util/gen";
 

package/src/transforms/string/stringSplitting.ts

@@ -3,8 +3,7 @@ import { Node, Literal, BinaryExpression } from "../../util/gen";
 import { clone } from "../../util/insert";
 import { getRandomInteger, shuffle, splitIntoChunks } from "../../util/random";
 import { ObfuscateOrder } from "../../order";
-import { isModuleSource } from "./stringConcealing";
-import { isDirective } from "../../util/compare";
+import { isDirective, isModuleSource } from "../../util/compare";
 import { ok } from "assert";
 import { ComputeProbabilityMap } from "../../probability";
 

package/src/transforms/transform.ts

@@ -1,13 +1,19 @@
 import traverse, { ExitCallback } from "../traverse";
-import { AddComment, Node } from "../util/gen";
+import {
+  AddComment,
+  Node,
+  VariableDeclaration,
+  VariableDeclarator,
+} from "../util/gen";
 import {
   alphabeticalGenerator,
   choice,
+  createZeroWidthGenerator,
   getRandomInteger,
+  shuffle,
 } from "../util/random";
 import { ok } from "assert";
 import Obfuscator from "../obfuscator";
-import { ObfuscateOptions } from "../options";
 import { ComputeProbabilityMap } from "../probability";
 import {
   placeholderVariablePrefix,
@@ -15,6 +21,9 @@ import {
   reservedKeywords,
 } from "../constants";
 import { ObfuscateOrder } from "../order";
+import { prepend } from "../util/insert";
+import Lock from "./lock/lock";
+import Template from "../templates/template";
 
 /**
  * Base-class for all transformations.
@@ -61,7 +70,7 @@ export default class Transform {
   /**
    * The user's options.
    */
-  options: ObfuscateOptions;
+  options: Obfuscator["options"];
 
   /**
    * Only required for top-level transformations.
@@ -78,6 +87,10 @@ export default class Transform {
    */
   after: Transform[];
 
+  initVariables = new Map<string, string>();
+
+  zeroWidthGenerator = createZeroWidthGenerator();
+
   constructor(obfuscator, priority: number = -1) {
     ok(obfuscator instanceof Obfuscator, "obfuscator should be an Obfuscator");
 
@@ -99,6 +112,32 @@ export default class Transform {
     );
   }
 
+  /**
+   * Gets the `Lock` transformation.
+   */
+  get lockTransform(): Lock {
+    var transform = this.obfuscator.transforms["Lock"] as Lock;
+
+    ok(transform, "Lock transform not created");
+
+    return transform;
+  }
+
+  /**
+   * Wraps the given name with the `__JS_CONFUSER_VAR__` function call.
+   *
+   * If `Rename Variables` is disabled, the name is returned as-is.
+   * @param name
+   * @returns
+   */
+  jsConfuserVar(name: string) {
+    if (!this.obfuscator.transforms["RenameVariables"]) {
+      return `"${name}"`;
+    }
+
+    return `__JS_CONFUSER_VAR__(${name})`;
+  }
+
   /**
    * Run an AST through the transformation (including `pre` and `post` transforms)
    * @param tree
@@ -277,49 +316,7 @@ export default class Transform {
               return "var_" + count;
 
             case "zeroWidth":
-              var keyWords = [
-                "if",
-                "in",
-                "for",
-                "let",
-                "new",
-                "try",
-                "var",
-                "case",
-                "else",
-                "null",
-                "break",
-                "catch",
-                "class",
-                "const",
-                "super",
-                "throw",
-                "while",
-                "yield",
-                "delete",
-                "export",
-                "import",
-                "public",
-                "return",
-                "switch",
-                "default",
-                "finally",
-                "private",
-                "continue",
-                "debugger",
-                "function",
-                "arguments",
-                "protected",
-                "instanceof",
-                "function",
-                "await",
-                "async",
-              ];
-
-              var safe = "\u200C".repeat(count + 1);
-
-              var base = choice(keyWords) + safe;
-              return base;
+              return this.zeroWidthGenerator.generate();
           }
 
           throw new Error("Invalid 'identifierGenerator' mode: " + mode);
@@ -336,6 +333,26 @@ export default class Transform {
     return identifier;
   }
 
+  createInitVariable = (value: Template, parents: Node[]) => {
+    var key = value.templates[0];
+    if (this.initVariables.has(key)) {
+      return this.initVariables.get(key);
+    }
+
+    var root = parents[parents.length - 1];
+    ok(root.type === "Program");
+
+    var name = this.getPlaceholder();
+    this.initVariables.set(key, name);
+
+    prepend(
+      root,
+      VariableDeclaration(VariableDeclarator(name, value.single().expression))
+    );
+
+    return name;
+  };
+
   /**
    * Smartly appends a comment to a Node.
    * - Includes the transformation's name.

package/src/types.ts

@@ -1,5 +1,6 @@
 import Obfuscator from "./obfuscator";
 import { ObfuscateOptions } from "./options";
+import Template from "./templates/template";
 import Transform from "./transforms/transform";
 
 /**
@@ -21,6 +22,7 @@ export interface IJsConfuser {
 
   Transform: typeof Transform;
   Obfuscator: typeof Obfuscator;
+  Template: typeof Template;
 }
 
 /**

package/src/util/compare.ts

@@ -74,19 +74,52 @@ export function isDirective(object: Node, parents: Node[]) {
   return parents[dIndex].expression == (parents[dIndex - 1] || object);
 }
 
+export function isModuleSource(object: Node, parents: Node[]) {
+  if (!parents[0]) {
+    return false;
+  }
+
+  if (parents[0].type == "ImportDeclaration" && parents[0].source == object) {
+    return true;
+  }
+
+  if (parents[0].type == "ImportExpression" && parents[0].source == object) {
+    return true;
+  }
+
+  if (
+    parents[1] &&
+    parents[1].type == "CallExpression" &&
+    parents[1].arguments[0] === object &&
+    parents[1].callee.type == "Identifier"
+  ) {
+    if (
+      parents[1].callee.name == "require" ||
+      parents[1].callee.name == "import"
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function isMoveable(object: Node, parents: Node[]) {
+  return !isDirective(object, parents) && !isModuleSource(object, parents);
+}
+
 export function isIndependent(object: Node, parents: Node[]) {
   if (object.type == "Literal") {
     return true;
   }
 
-  var parent = parents[0];
-
   if (object.type == "Identifier") {
-    var set = new Set(["null", "undefined"]);
-    if (set.has(object.name)) {
+    if (primitiveIdentifiers.has(object.name)) {
       return true;
     }
-    if (parent.type == "Property") {
+
+    var parent = parents[0];
+    if (parent && parent.type == "Property") {
       if (!parent.computed && parent.key == object) {
         return true;
       }
@@ -105,6 +138,7 @@ export function isIndependent(object: Node, parents: Node[]) {
       if (object != $object) {
         if (!Array.isArray($object) && !isIndependent($object, $parents)) {
           allowIt = false;
+          return "EXIT";
         }
       }
     });

package/src/util/gen.ts

@@ -1,4 +1,5 @@
 import { ok } from "assert";
+import { predictableFunctionTag } from "../constants";
 import { isValidIdentifier } from "./compare";
 
 export type Type =
@@ -306,6 +307,7 @@ export function FunctionExpression(params: Node[], body: any[]) {
     generator: false,
     expression: false,
     async: false,
+    [predictableFunctionTag]: true,
   };
 }
 
@@ -340,6 +342,7 @@ export function FunctionDeclaration(
     generator: false,
     expression: false,
     async: false,
+    [predictableFunctionTag]: true,
   };
 }
 
@@ -529,16 +532,20 @@ export function AddComment(node: Node, text: string) {
   return node;
 }
 
+export function Super() {
+  return { type: "Super" };
+}
+
 export function MethodDefinition(
-  identifier: Node,
+  key: Node,
   functionExpression: Node,
   kind: "method" | "constructor" | "get" | "set",
-  isStatic = true,
+  isStatic = false,
   computed = false
 ) {
   return {
     type: "MethodDefinition",
-    key: identifier,
+    key: key,
     computed: computed,
     value: functionExpression,
     kind: kind,

package/src/util/guard.ts

@@ -1,3 +1,4 @@
+import { variableFunctionName } from "../constants";
 import { Node } from "./gen";
 
 export function isStringLiteral(node: Node) {
@@ -5,3 +6,12 @@ export function isStringLiteral(node: Node) {
     node.type === "Literal" && typeof node.value === "string" && !node.regex
   );
 }
+
+export function isJSConfuserVar(p: Node[]) {
+  return p.find(
+    (x) =>
+      x.type === "CallExpression" &&
+      x.callee.type === "Identifier" &&
+      x.callee.name == variableFunctionName
+  );
+}