js-confuser 1.7.1 → 1.7.2

package/src/transforms/string/encoding.ts

@@ -1,16 +1,47 @@
-import Template from "../../templates/template";
-
-const Encoding: {
-  [encoding_name: string]: {
-    encode: (s) => string;
-    decode: (s) => string;
-    template: ReturnType<typeof Template>;
-  };
-} = {
-  base91: {
+import Template, { ITemplate } from "../../templates/template";
+import { choice, shuffle } from "../../util/random";
+
+/**
+ * Defines an encoding implementation the Obfuscator
+ */
+export interface EncodingImplementation {
+  identity: string;
+
+  encode(s): string;
+  decode(s): string;
+  template: ITemplate;
+}
+
+let _hasAllEncodings = false;
+export function hasAllEncodings() {
+  return _hasAllEncodings;
+}
+
+export function createEncodingImplementation(): EncodingImplementation {
+  if (_hasAllEncodings) {
+    return EncodingImplementations[
+      choice(Object.keys(EncodingImplementations))
+    ];
+  }
+
+  // create base91 encoding
+  let strTable =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~"';
+
+  // shuffle table
+  strTable = shuffle(strTable.split("")).join("");
+
+  let identity = "base91_" + strTable;
+
+  if (EncodingImplementations.hasOwnProperty(identity)) {
+    _hasAllEncodings = true;
+    return EncodingImplementations[identity];
+  }
+
+  var encodingImplementation = {
+    identity,
     encode(str) {
-      const table =
-        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~"';
+      const table = strTable;
 
       const raw = Buffer.from(str, "utf-8");
       const len = raw.length;
@@ -45,8 +76,7 @@ const Encoding: {
       return ret;
     },
     decode(str) {
-      const table =
-        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~"';
+      const table = strTable;
 
       const raw = "" + (str || "");
       const len = raw.length;
@@ -81,45 +111,51 @@ const Encoding: {
       return Buffer.from(ret).toString("utf-8");
     },
     template: Template(`  
-      function {name}(str){
-        const table =
-          'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_\`{|}~"';
-
-        const raw = "" + (str || "");
-        const len = raw.length;
-        const ret = [];
-
-        let b = 0;
-        let n = 0;
-        let v = -1;
-
-        for (let i = 0; i < len; i++) {
-          const p = table.indexOf(raw[i]);
-          if (p === -1) continue;
-          if (v < 0) {
-            v = p;
-          } else {
-            v += p * 91;
-            b |= v << n;
-            n += (v & 8191) > 88 ? 13 : 14;
-            do {
-              ret.push(b & 0xff);
-              b >>= 8;
-              n -= 8;
-            } while (n > 7);
-            v = -1;
+        function {__fnName__}(str){
+          var table = '${strTable}';
+  
+          var raw = "" + (str || "");
+          var len = raw.length;
+          var ret = [];
+  
+          var b = 0;
+          var n = 0;
+          var v = -1;
+  
+          for (var i = 0; i < len; i++) {
+            var p = table.indexOf(raw[i]);
+            if (p === -1) continue;
+            if (v < 0) {
+              v = p;
+            } else {
+              v += p * 91;
+              b |= v << n;
+              n += (v & 8191) > 88 ? 13 : 14;
+              do {
+                ret.push(b & 0xff);
+                b >>= 8;
+                n -= 8;
+              } while (n > 7);
+              v = -1;
+            }
           }
+  
+          if (v > -1) {
+            ret.push((b | (v << n)) & 0xff);
+          }
+  
+          return {__bufferToString__}(ret);
         }
+      `).ignoreMissingVariables(),
+  };
 
-        if (v > -1) {
-          ret.push((b | (v << n)) & 0xff);
-        }
-
-        return {bufferToString}(ret);
-      }
-    `),
-  },
+  EncodingImplementations[identity] = encodingImplementation;
+  return encodingImplementation;
+}
 
+export const EncodingImplementations: {
+  [encodingIdentity: string]: EncodingImplementation;
+} = {
   /* ascii85: { This implementation is flaky and causes decoding errors 
     encode(a) {
       var b, c, d, e, f, g, h, i, j, k;
@@ -209,5 +245,3 @@ const Encoding: {
     `),
   }, */
 };
-
-export default Encoding;

package/src/transforms/string/stringCompression.ts

@@ -2,7 +2,7 @@ import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
 import { ComputeProbabilityMap } from "../../probability";
 import Template from "../../templates/template";
-import { isDirective } from "../../util/compare";
+import { isDirective, isModuleSource } from "../../util/compare";
 import {
   CallExpression,
   FunctionDeclaration,
@@ -16,8 +16,8 @@ import {
 } from "../../util/gen";
 import { append, prepend } from "../../util/insert";
 import Transform from "../transform";
-import { isModuleSource } from "./stringConcealing";
-import { chance } from "../../util/random";
+import { predictableFunctionTag } from "../../constants";
+
 function LZ_encode(c) {
   ok(c);
   var x = "charCodeAt",
@@ -94,7 +94,7 @@ export default class StringCompression extends Transform {
     this.map = new Map();
     this.ignore = new Set();
     this.string = "";
-    this.fnName = this.getPlaceholder();
+    this.fnName = this.getPlaceholder() + predictableFunctionTag;
   }
 
   apply(tree) {
@@ -107,7 +107,7 @@ export default class StringCompression extends Transform {
 
     var split = this.getPlaceholder();
     var decoder = this.getPlaceholder();
-    var getStringName = this.getPlaceholder();
+    var getStringName = this.getPlaceholder() + predictableFunctionTag; // Returns the string payload
 
     var encoded = LZ_encode(this.string);
     if (LZ_decode(encoded) !== this.string) {
@@ -210,9 +210,6 @@ export default class StringCompression extends Transform {
       return;
     }
 
-    // HARD CODED LIMIT of 10,000 (after 1,000 elements)
-    if (this.map.size > 1000 && !chance(this.map.size / 100)) return;
-
     var index = this.map.get(object.value);
 
     // New string, add it!

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,36 @@ 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";
+import { criticalFunctionTag, predictableFunctionTag } from "../../constants";
 
-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;
+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 +58,110 @@ 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);
     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,
+      })
     );
 
-    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 = 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,
+      // Not all fake if-statements are needed
+      ifStatements = ifStatements.filter(() => chance(50));
+
+      // This one is always used
+      ifStatements.push(
         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()
+      if ( x !== y ) {
+        return b[x] || (b[x] = a(${this.arrayName}[x]))
+      }
+      `).single()
       );
-    });
 
-    var flowIntegrity = this.getPlaceholder();
+      shuffle(ifStatements);
+
+      var varDeclaration = 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),
       ])
     );
   }
@@ -192,48 +199,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 +295,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,5 +1,10 @@
 import traverse, { ExitCallback } from "../traverse";
-import { AddComment, Node } from "../util/gen";
+import {
+  AddComment,
+  Node,
+  VariableDeclaration,
+  VariableDeclarator,
+} from "../util/gen";
 import {
   alphabeticalGenerator,
   choice,
@@ -15,6 +20,8 @@ import {
   reservedKeywords,
 } from "../constants";
 import { ObfuscateOrder } from "../order";
+import { ITemplate } from "../templates/template";
+import { prepend } from "../util/insert";
 
 /**
  * Base-class for all transformations.
@@ -78,6 +85,8 @@ export default class Transform {
    */
   after: Transform[];
 
+  initVariables = new Map<string, string>();
+
   constructor(obfuscator, priority: number = -1) {
     ok(obfuscator instanceof Obfuscator, "obfuscator should be an Obfuscator");
 
@@ -336,6 +345,26 @@ export default class Transform {
     return identifier;
   }
 
+  createInitVariable = (value: ITemplate, 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.