js-confuser 1.5.9 → 1.7.0

package/src/transforms/string/stringCompression.ts

@@ -17,6 +17,7 @@ import {
 import { append, prepend } from "../../util/insert";
 import Transform from "../transform";
 import { isModuleSource } from "./stringConcealing";
+import { chance } from "../../util/random";
 function LZ_encode(c) {
   ok(c);
   var x = "charCodeAt",
@@ -83,7 +84,7 @@ export default class StringCompression extends Transform {
   map: Map<string, number>;
   ignore: Set<string>;
   string: string;
-  delimiter = "1";
+  delimiter = "|";
 
   fnName: string;
 
@@ -110,7 +111,11 @@ export default class StringCompression extends Transform {
 
     var encoded = LZ_encode(this.string);
     if (LZ_decode(encoded) !== this.string) {
-      this.error(new Error("String failed to be decoded"));
+      this.error(
+        new Error(
+          "String failed to be decoded. Try disabling the 'stringCompression' option."
+        )
+      );
     }
 
     var getStringParamName = this.getPlaceholder();
@@ -195,37 +200,41 @@ export default class StringCompression extends Transform {
       return;
     }
 
-    if (!ComputeProbabilityMap(object.value, (x) => x)) {
+    if (
+      !ComputeProbabilityMap(
+        this.options.stringCompression,
+        (x) => x,
+        object.value
+      )
+    ) {
       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!
     if (typeof index !== "number") {
+      // Ensure the string gets properly decoded
       if (LZ_decode(LZ_encode(object.value)) !== object.value) {
         this.ignore.add(object.value);
         return;
       }
 
-      var before = this.string;
-
       index = this.map.size;
       this.map.set(object.value, index);
       this.string += object.value + this.delimiter;
-
-      // allow rollback if string becomes corrupted
-      if (LZ_decode(LZ_encode(this.string)) !== this.string) {
-        this.string = before;
-        this.map.delete(object.value);
-        this.ignore.add(object.value);
-        return;
-      }
     }
     ok(typeof index === "number");
 
-    this.replaceIdentifierOrLiteral(
-      object,
-      CallExpression(Identifier(this.fnName), [Literal(index)]),
-      parents
-    );
+    return () => {
+      this.replaceIdentifierOrLiteral(
+        object,
+        CallExpression(Identifier(this.fnName), [Literal(index)]),
+        parents
+      );
+    };
   }
 }

package/src/transforms/string/stringConcealing.ts

@@ -13,14 +13,20 @@ import {
   Node,
   ObjectExpression,
   Property,
-  ThisExpression,
   VariableDeclaration,
   VariableDeclarator,
 } from "../../util/gen";
 import { append, prepend } from "../../util/insert";
-import { choice, getRandomInteger, getRandomString } from "../../util/random";
+import {
+  chance,
+  choice,
+  getRandomInteger,
+  getRandomString,
+} from "../../util/random";
 import Transform from "../transform";
 import Encoding from "./encoding";
+import { ComputeProbabilityMap } from "../../probability";
+import { BufferToStringTemplate } from "../../templates/bufferToString";
 
 export function isModuleSource(object: Node, parents: Node[]) {
   if (!parents[0]) {
@@ -89,13 +95,23 @@ export default class StringConcealing extends Transform {
     super.apply(tree);
 
     var cacheName = this.getPlaceholder();
+    var bufferToStringName = this.getPlaceholder();
+
+    // This helper functions convert UInt8 Array to UTf-string
+    prepend(
+      tree,
+      ...BufferToStringTemplate.compile({ name: bufferToStringName })
+    );
 
     Object.keys(this.encoding).forEach((type) => {
       var { template } = Encoding[type];
       var decodeFn = this.getPlaceholder();
       var getterFn = this.encoding[type];
 
-      append(tree, template.single({ name: decodeFn }));
+      append(
+        tree,
+        template.single({ name: decodeFn, bufferToString: bufferToStringName })
+      );
 
       append(
         tree,
@@ -165,10 +181,24 @@ export default class StringConcealing extends Transform {
         return;
       }
 
+      // Allow user to choose which strings get changed
+      if (
+        !ComputeProbabilityMap(
+          this.options.stringConcealing,
+          (x) => x,
+          object.value
+        )
+      ) {
+        return;
+      }
+
+      // HARD CODED LIMIT of 10,000 (after 1,000 elements)
+      if (this.set.size > 1000 && !chance(this.set.size / 100)) return;
+
       var types = Object.keys(this.encoding);
 
       var type = choice(types);
-      if (!type || (!this.hasAllEncodings && Math.random() > 0.9)) {
+      if (!type || (!this.hasAllEncodings && chance(10))) {
         var allowed = Object.keys(Encoding).filter(
           (type) => !this.encoding[type]
         );
@@ -211,23 +241,23 @@ export default class StringConcealing extends Transform {
       var callExpr = CallExpression(Identifier(fnName), [Literal(index)]);
 
       // use `.apply` to fool automated de-obfuscators
-      if (Math.random() > 0.5) {
+      if (chance(10)) {
         callExpr = CallExpression(
-          MemberExpression(Identifier(fnName), Identifier("apply"), false),
+          MemberExpression(Identifier(fnName), Literal("apply"), true),
           [Identifier("undefined"), ArrayExpression([Literal(index)])]
         );
       }
 
       // use `.call`
-      else if (Math.random() > 0.5) {
+      else if (chance(10)) {
         callExpr = CallExpression(
-          MemberExpression(Identifier(fnName), Identifier("call"), false),
+          MemberExpression(Identifier(fnName), Literal("call"), true),
           [Identifier("undefined"), Literal(index)]
         );
       }
 
       var referenceType = "call";
-      if (parents.length && Math.random() < 0.5 / this.variablesMade) {
+      if (parents.length && chance(50 - this.variablesMade)) {
         referenceType = "constantReference";
       }
 

package/src/transforms/string/stringEncoding.ts

@@ -1,8 +1,9 @@
 import Transform from "../transform";
 import { choice } from "../../util/random";
-import { ObfuscateOrder } from "../../order";
 import { isDirective } from "../../util/compare";
 import { isModuleSource } from "./stringConcealing";
+import { ComputeProbabilityMap } from "../../probability";
+import { Identifier } from "../../util/gen";
 
 function pad(x: string, len: number): string {
   while (x.length < len) {
@@ -54,32 +55,30 @@ function toUnicodeRepresentation(str: string) {
  * - Cost Low
  */
 export default class StringEncoding extends Transform {
-  seen: Set<Node>;
-
   constructor(o) {
-    super(o, ObfuscateOrder.StringEncoding);
-  }
-
-  apply(tree) {
-    this.seen = new Set();
-    super.apply(tree);
+    super(o);
   }
 
   match(object, parents) {
     return (
       object.type == "Literal" &&
       typeof object.value === "string" &&
+      object.value.length > 0 &&
       !isModuleSource(object, parents) &&
       !isDirective(object, parents)
     );
   }
 
   transform(object, parents) {
-    // Todo fix circular json problems
-    if (this.seen.has(object)) {
+    // Allow percentages
+    if (
+      !ComputeProbabilityMap(
+        this.options.stringEncoding,
+        (x) => x,
+        object.value
+      )
+    )
       return;
-    }
-    this.seen.add(object);
 
     var type = choice(["hexadecimal", "unicode"]);
 
@@ -87,10 +86,11 @@ export default class StringEncoding extends Transform {
       type == "hexadecimal" ? toHexRepresentation : toUnicodeRepresentation
     )(object.value);
 
-    // escodegen tries to escape backslashes, here is a work-around
-    this.replace(object, {
-      type: "Identifier",
-      name: `'${escapedString}'`,
-    });
+    return () => {
+      if (object.type !== "Literal") return;
+
+      // ESCodeGen tries to escape backslashes, here is a work-around
+      this.replace(object, Identifier(`'${escapedString}'`));
+    };
   }
 }

package/src/transforms/transform.ts

@@ -9,7 +9,11 @@ import { ok } from "assert";
 import Obfuscator from "../obfuscator";
 import { ObfuscateOptions } from "../options";
 import { ComputeProbabilityMap } from "../probability";
-import { reservedIdentifiers, reservedKeywords } from "../constants";
+import {
+  placeholderVariablePrefix,
+  reservedIdentifiers,
+  reservedKeywords,
+} from "../constants";
 import { ObfuscateOrder } from "../order";
 
 /**
@@ -74,11 +78,6 @@ export default class Transform {
    */
   after: Transform[];
 
-  /**
-   * Transformations to run at the same time (can cause conflicts so use sparingly)
-   */
-  concurrent: Transform[];
-
   constructor(obfuscator, priority: number = -1) {
     ok(obfuscator instanceof Obfuscator, "obfuscator should be an Obfuscator");
 
@@ -89,8 +88,6 @@ export default class Transform {
 
     this.before = [];
     this.after = [];
-
-    this.concurrent = [];
   }
 
   /**
@@ -120,14 +117,11 @@ export default class Transform {
      */
     this.before.forEach((x) => x.apply(tree));
 
+    /**
+     * Run this transformation
+     */
     traverse(tree, (object, parents) => {
-      var fns = [];
-      fns.push(this.input(object, parents));
-
-      // Fix 1. Increase performance with multiple transforms on one iteration.
-      this.concurrent.forEach((x) => fns.push(x.input(object, parents)));
-
-      return () => fns.forEach((x) => x && x());
+      return this.input(object, parents);
     });
 
     /**
@@ -186,23 +180,23 @@ export default class Transform {
       [...Array(size)]
         .map(() => Math.floor(Math.random() * 10).toString(10))
         .join("");
-    return "__p_" + genRanHex(10);
+    return placeholderVariablePrefix + genRanHex(10);
   }
 
   /**
    * Returns an independent name generator with it's own counter.
-   * @param offset
+   * @param overrideMode - Override the user's `identifierGenerator` option
    * @returns
    */
-  getGenerator(offset = 0) {
-    var count = offset;
+  getGenerator(overrideMode?: string) {
+    var count = 0;
     var identifiers = new Set();
     return {
       generate: () => {
-        var retValue;
+        var retValue: string;
         do {
           count++;
-          retValue = this.generateIdentifier(-1, count);
+          retValue = this.generateIdentifier(-1, count, overrideMode);
         } while (identifiers.has(retValue));
 
         identifiers.add(retValue);
@@ -217,7 +211,11 @@ export default class Transform {
    * @param length Default length is 6 to 10 characters.
    * @returns **`string`**
    */
-  generateIdentifier(length: number = -1, count = -1): string {
+  generateIdentifier(
+    length: number = -1,
+    count = -1,
+    overrideMode?: string
+  ): string {
     if (length == -1) {
       length = getRandomInteger(6, 8);
     }
@@ -233,7 +231,7 @@ export default class Transform {
     var identifier;
     do {
       identifier = ComputeProbabilityMap(
-        this.options.identifierGenerator,
+        overrideMode || this.options.identifierGenerator,
         (mode = "randomized") => {
           switch (mode) {
             case "randomized":

package/src/traverse.ts

@@ -44,9 +44,9 @@ export function walk(
   if (typeof object === "object" && object) {
     var newParents: Node[] = [object as Node, ...parents];
 
-    if (!Array.isArray(object)) {
-      validateChain(object, parents);
-    }
+    // if (!Array.isArray(object)) {
+    //   validateChain(object, parents);
+    // }
 
     // 1. Call `onEnter` function and remember any onExit callback returned
     var onExit = onEnter(object as Node, parents);
@@ -59,7 +59,6 @@ export function walk(
           return "EXIT";
         }
       }
-      copy.forEach((x) => {});
     } else {
       var keys = Object.keys(object);
       for (var key of keys) {
@@ -99,3 +98,23 @@ export function walk(
 export default function traverse(tree, onEnter: EnterCallback) {
   walk(tree, [], onEnter);
 }
+
+/**
+ * This is debugging function used to test for circular references.
+ */
+export function assertNoCircular(object) {
+  var seen = new Set();
+
+  traverse(object, (node, nodeParents) => {
+    if (node && typeof node === "object") {
+      if (seen.has(node)) {
+        console.log(nodeParents);
+        console.log(node);
+
+        throw new Error("FOUND CIRCULAR REFERENCE");
+      }
+
+      seen.add(node);
+    }
+  });
+}

package/src/types.ts

@@ -118,7 +118,8 @@ export type IJsConfuserDebugTransformations = (
 export type IJsConfuserDebugObfuscation = (
   code: string,
   options: ObfuscateOptions,
-  callback: (name: string, complete: number, totalTransforms: number) => void
+  callback: (name: string, complete: number, totalTransforms: number) => void,
+  performance: Performance
 ) => Promise<{
   obfuscated: string;
   transformationTimes: { [transformName: string]: number };

package/src/util/gen.ts

@@ -171,7 +171,12 @@ export function BreakStatement(label?: string) {
   };
 }
 
-export function Property(key: Node, value: Node, computed = false) {
+export function Property(
+  key: Node,
+  value: Node,
+  computed = false,
+  kind: "init" | "set" | "get" = "init"
+) {
   if (!key) {
     throw new Error("key is undefined");
   }
@@ -183,7 +188,7 @@ export function Property(key: Node, value: Node, computed = false) {
     key: key,
     computed: computed,
     value: value,
-    kind: "init",
+    kind: kind,
     method: false,
     shorthand: false,
   };
@@ -557,6 +562,22 @@ export function ClassDeclaration(
   } as Node;
 }
 
+export function ClassExpression(
+  id: Node | null,
+  superClass: Node = null,
+  body: Node[] = []
+) {
+  return {
+    type: "ClassExpression",
+    id: id,
+    superClass: superClass,
+    body: {
+      type: "ClassBody",
+      body: body,
+    },
+  } as Node;
+}
+
 export function ThrowStatement(argument: Node) {
   return {
     type: "ThrowStatement",
@@ -607,7 +628,11 @@ export function CatchClause(param: Node = null, body) {
   };
 }
 
-export function TryStatement(body: Node[], handler: Node, finallyBody: Node[]) {
+export function TryStatement(
+  body: Node[],
+  handler: Node,
+  finallyBody?: Node[]
+) {
   ok(handler);
   ok(handler.type == "CatchClause");
   return {

package/src/util/identifiers.ts

@@ -30,6 +30,23 @@ export function validateChain(object: Node, parents: Node[]) {
   }
 }
 
+function objectPatternCheck(object: Node, parents: Node[]) {
+  var objectPatternIndex = parents.findIndex((x) => x.type === "ObjectPattern");
+  if (objectPatternIndex == -1) {
+    return true;
+  }
+
+  var property = parents[objectPatternIndex].properties.find(
+    (property) => parents[objectPatternIndex - 2] === property
+  );
+
+  if (property.key === (parents[objectPatternIndex - 3] || object)) {
+    return false;
+  }
+
+  return true;
+}
+
 /**
  * Returns detailed information about the given Identifier node.
  * @param object
@@ -74,7 +91,22 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
   var isVariableDeclaration =
     varIndex != -1 &&
     parents[varIndex].id == (parents[varIndex - 1] || object) &&
-    parents.find((x) => x.type == "VariableDeclaration");
+    parents.find((x) => x.type == "VariableDeclaration") &&
+    objectPatternCheck(object, parents);
+
+  // Assignment pattern check!
+  if (isVariableDeclaration) {
+    var slicedParents = parents.slice(0, varIndex - 1);
+    var i = 0;
+    for (var parent of slicedParents) {
+      var childNode = slicedParents[i - 1] || object;
+      if (parent.type === "AssignmentPattern" && parent.right === childNode) {
+        isVariableDeclaration = false;
+        break;
+      }
+      i++;
+    }
+  }
 
   var forIndex = parents.findIndex((x) => x.type == "ForStatement");
   var isForInitializer =
@@ -87,6 +119,12 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
     functionIndex != -1 &&
     parents[functionIndex].type == "FunctionDeclaration" &&
     parents[functionIndex].id == object;
+
+  var isNamedFunctionExpression =
+    functionIndex != -1 &&
+    parents[functionIndex].type === "FunctionExpression" &&
+    parents[functionIndex].id === object;
+
   var isAFunctionParameter = isFunctionParameter(object, parents);
 
   var isClauseParameter = false;
@@ -112,7 +150,9 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
 
   var isAssignmentLeft =
     assignmentIndex !== -1 &&
-    parents[assignmentIndex].left === (parents[assignmentIndex - 1] || object);
+    parents[assignmentIndex].left ===
+      (parents[assignmentIndex - 1] || object) &&
+    objectPatternCheck(object, parents);
   var isAssignmentValue =
     assignmentIndex !== -1 &&
     parents[assignmentIndex].right === (parents[assignmentIndex - 1] || object);
@@ -272,6 +312,7 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
       isDefined:
         isVariableDeclaration ||
         isFunctionDeclaration ||
+        isNamedFunctionExpression ||
         isAFunctionParameter ||
         isClassDeclaration ||
         isClauseParameter ||

package/src/util/insert.ts

@@ -145,13 +145,13 @@ export function getAllDefiningContexts(o: Node, p: Node[]): Node[] {
     // Get Function
     var fn = getFunction(o, p);
 
-    contexts.push(fn.body);
+    // contexts.push(fn.body);
   }
 
   if (info.isClauseParameter) {
     var catchClause = p.find((x) => x.type === "CatchClause");
     if (catchClause) {
-      contexts.push(catchClause.body);
+      return [catchClause];
     }
   }
 
@@ -280,8 +280,19 @@ export function prepend(block: Node, ...nodes: Node[]) {
     });
 
     block.body.splice(moveBy, 0, ...nodes);
+  } else if (block.type === "SwitchCase") {
+    block.consequent.unshift(...nodes);
   } else {
-    getBlockBody(block).unshift(...nodes);
+    var bodyArray = getBlockBody(block);
+
+    // Check for 'use strict'
+    if (bodyArray[0] && bodyArray[0].directive) {
+      // Insert under 'use strict' directive
+      bodyArray.splice(1, 0, ...nodes);
+    } else {
+      // Prepend at the top of the block
+      bodyArray.unshift(...nodes);
+    }
   }
 }
 
@@ -365,3 +376,27 @@ export function isForInitialize(
 
   return false;
 }
+
+/**
+ * Computes the `function.length` property given the parameter nodes.
+ *
+ * @param params
+ * @returns
+ */
+export function computeFunctionLength(params: Node[]): number {
+  var count = 0;
+
+  for (var parameterNode of params) {
+    if (
+      parameterNode.type === "Identifier" ||
+      parameterNode.type === "ObjectPattern" ||
+      parameterNode.type === "ArrayPattern"
+    ) {
+      count++;
+    } else {
+      break;
+    }
+  }
+
+  return count;
+}

package/src/util/random.ts

@@ -8,11 +8,24 @@ import {
   ArrayExpression,
 } from "./gen";
 
+/**
+ * Returns a random element from the given array
+ * @param choices Array of items
+ * @returns One of the items in the array at random
+ */
 export function choice<T>(choices: T[]): T {
   var index = Math.floor(Math.random() * choices.length);
   return choices[index];
 }
 
+/**
+ * Returns a true/false based on the percent chance (0%-100%)
+ * @param percentChance AS A PERCENTAGE 0 - 100%
+ */
+export function chance(percentChance: number): boolean {
+  return Math.random() < percentChance / 100;
+}
+
 /**
  * **Mutates the given array**
  * @param array

package/test/code/Cash.test.ts

@@ -4,7 +4,7 @@ import JsConfuser from "../../src/index";
 
 var CASH_JS = readFileSync(join(__dirname, "./Cash.src.js"), "utf-8");
 
-it("works with Cash.js on High Preset", async () => {
+test("Variant #1: Cash.js on High Preset (Strict Mode)", async () => {
   var output = await JsConfuser(CASH_JS, {
     target: "browser",
     preset: "high",