js-confuser 1.7.0 → 1.7.2

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.

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/identifiers.ts

@@ -94,9 +94,14 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
     parents.find((x) => x.type == "VariableDeclaration") &&
     objectPatternCheck(object, parents);
 
+  var functionIndex = parents.findIndex((x) => isFunction(x));
+
   // Assignment pattern check!
   if (isVariableDeclaration) {
-    var slicedParents = parents.slice(0, varIndex - 1);
+    var slicedParents = parents.slice(
+      0,
+      functionIndex != -1 ? Math.min(varIndex, functionIndex) : varIndex
+    );
     var i = 0;
     for (var parent of slicedParents) {
       var childNode = slicedParents[i - 1] || object;
@@ -113,8 +118,6 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
     forIndex != -1 &&
     parents[forIndex].init == (parents[forIndex - 1] || object);
 
-  var functionIndex = parents.findIndex((x) => isFunction(x));
-
   var isFunctionDeclaration =
     functionIndex != -1 &&
     parents[functionIndex].type == "FunctionDeclaration" &&

package/src/util/insert.ts

@@ -3,6 +3,12 @@ import { getBlock, isBlock } from "../traverse";
 import { Node } from "./gen";
 import { getIdentifierInfo, validateChain } from "./identifiers";
 
+export function isClass(object: Node): boolean {
+  return (
+    object.type === "ClassDeclaration" || object.type === "ClassExpression"
+  );
+}
+
 /**
  * - `FunctionDeclaration`
  * - `FunctionExpression`
@@ -18,6 +24,17 @@ export function isFunction(object: Node): boolean {
   ].includes(object && object.type);
 }
 
+export function isStrictModeFunction(object: Node): boolean {
+  ok(isFunction(object));
+
+  return (
+    object.body.type === "BlockStatement" &&
+    object.body.body[0] &&
+    object.body.body[0].type === "ExpressionStatement" &&
+    object.body.body[0].directive === "use strict"
+  );
+}
+
 /**
  * The function context where the object is.
  *

package/src/util/scope.ts

@@ -1,9 +1,21 @@
+import { ok } from "assert";
 import { isBlock } from "../traverse";
+import { Node } from "./gen";
 
-export function isLexicalScope(object) {
+export function isLexicalScope(object: Node) {
   return isBlock(object) || object.type == "SwitchCase";
 }
 
-export function getLexicalScope(object, parents) {
+export function getLexicalScope(object: Node, parents: Node[]): Node {
   return [object, ...parents].find((node) => isLexicalScope(node));
 }
+
+export function getLexicalScopeBody(object: Node): Node[] {
+  ok(isLexicalScope(object));
+
+  return isBlock(object)
+    ? object.body
+    : object.type === "SwitchCase"
+    ? object.consequent
+    : ok("Unhandled case");
+}

package/test/code/Cash.test.ts

@@ -32,12 +32,18 @@ test("Variant #1: Cash.js on High Preset (Strict Mode)", async () => {
     $: false,
   } as any;
   window.window = window;
+  global.window = window;
 
-  // writeFileSync(join(__dirname, "Cash.output.js"), output, {
-  //   encoding: "utf-8",
-  // });
+  try {
+    eval(output);
+  } catch (e) {
+    console.error(e);
+    writeFileSync("dev.output.js", output, {
+      encoding: "utf-8",
+    });
 
-  eval(output);
+    expect(true).toStrictEqual(false);
+  }
 
   expect(window).toHaveProperty("cash");
 });