js-confuser 1.2.1 → 1.4.1

package/src/transforms/string/stringConcealing.ts

@@ -1,111 +1,30 @@
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
 import Template from "../../templates/template";
+import { isBlock } from "../../traverse";
 import { isDirective } from "../../util/compare";
 import {
   ArrayExpression,
   CallExpression,
+  ConditionalExpression,
   FunctionDeclaration,
+  FunctionExpression,
   Identifier,
+  IfStatement,
   Literal,
   MemberExpression,
   Node,
   ReturnStatement,
+  SequenceExpression,
+  ThisExpression,
+  UpdateExpression,
   VariableDeclaration,
   VariableDeclarator,
 } from "../../util/gen";
-import { append, prepend } from "../../util/insert";
+import { append, isLexContext, isVarContext, prepend } from "../../util/insert";
+import { choice, getRandomInteger, getRandomString } from "../../util/random";
 import Transform from "../transform";
-
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-function encode_ascii85(a) {
-  var b, c, d, e, f, g, h, i, j, k;
-  // @ts-ignore
-  for (
-    // @ts-ignore
-    !/[^\x00-\xFF]/.test(a),
-      b = "\x00\x00\x00\x00".slice(a.length % 4 || 4),
-      a += b,
-      c = [],
-      d = 0,
-      e = a.length;
-    e > d;
-    d += 4
-  )
-    (f =
-      (a.charCodeAt(d) << 24) +
-      (a.charCodeAt(d + 1) << 16) +
-      (a.charCodeAt(d + 2) << 8) +
-      a.charCodeAt(d + 3)),
-      0 !== f
-        ? ((k = f % 85),
-          (f = (f - k) / 85),
-          (j = f % 85),
-          (f = (f - j) / 85),
-          (i = f % 85),
-          (f = (f - i) / 85),
-          (h = f % 85),
-          (f = (f - h) / 85),
-          (g = f % 85),
-          c.push(g + 33, h + 33, i + 33, j + 33, k + 33))
-        : c.push(122);
-  return (
-    (function (a, b) {
-      for (var c = b; c > 0; c--) a.pop();
-    })(c, b.length),
-    "<~" + String.fromCharCode.apply(String, c) + "~>"
-  );
-}
-
-function decode_ascii85(a) {
-  var c,
-    d,
-    e,
-    f,
-    g,
-    h = String,
-    l = "length",
-    w = 255,
-    x = "charCodeAt",
-    y = "slice",
-    z = "replace";
-  for (
-    "<~" === a[y](0, 2) && "~>" === a[y](-2),
-      a = a[y](2, -2)[z](/s/g, "")[z]("z", "!!!!!"),
-      c = "uuuuu"[y](a[l] % 5 || 5),
-      a += c,
-      e = [],
-      f = 0,
-      g = a[l];
-    g > f;
-    f += 5
-  )
-    (d =
-      52200625 * (a[x](f) - 33) +
-      614125 * (a[x](f + 1) - 33) +
-      7225 * (a[x](f + 2) - 33) +
-      85 * (a[x](f + 3) - 33) +
-      (a[x](f + 4) - 33)),
-      e.push(w & (d >> 24), w & (d >> 16), w & (d >> 8), w & d);
-  return (
-    (function (a, b) {
-      for (var c = b; c > 0; c--) a.pop();
-    })(e, c[l]),
-    h.fromCharCode.apply(h, e)
-  );
-}
-
-var Ascii85Template = Template(`
-function {name}(a, LL = ["fromCharCode", "apply"]) {
-  var c, d, e, f, g, h = String, l = "length", w = 255, x = "charCodeAt", y = "slice", z = "replace";
-  for ("<~" === a[y](0, 2) && "~>" === a[y](-2), a = a[y](2, -2)[z](/\s/g, "")[z]("z", "!!!!!"), 
-  c = "uuuuu"[y](a[l] % 5 || 5), a += c, e = [], f = 0, g = a[l]; g > f; f += 5) d = 52200625 * (a[x](f) - 33) + 614125 * (a[x](f + 1) - 33) + 7225 * (a[x](f + 2) - 33) + 85 * (a[x](f + 3) - 33) + (a[x](f + 4) - 33), 
-  e.push(w & d >> 24, w & d >> 16, w & d >> 8, w & d);
-  return function(a, b) {
-    for (var c = b; c > 0; c--) a.pop();
-  }(e, c[l]), h[LL[0]][LL[1]](h, e);
-}
-`);
+import Encoding from "./encoding";
 
 export function isModuleSource(object: Node, parents: Node[]) {
   if (!parents[0]) {
@@ -140,83 +59,135 @@ export function isModuleSource(object: Node, parents: Node[]) {
 export default class StringConcealing extends Transform {
   arrayExpression: Node;
   set: Set<string>;
-  index: { [str: string]: number };
+  index: { [str: string]: [number, string] };
 
-  getterName = this.getPlaceholder();
   arrayName = this.getPlaceholder();
-  decodeFn = this.getPlaceholder();
+  ignore = new Set<string>();
+  variablesMade = 1;
+  encoding: { [type: string]: string } = Object.create(null);
 
-  decodeNode: Node;
+  hasAllEncodings: boolean;
 
   constructor(o) {
     super(o, ObfuscateOrder.StringConcealing);
 
     this.set = new Set();
     this.index = Object.create(null);
-  }
+    this.arrayExpression = ArrayExpression([]);
+    this.hasAllEncodings = false;
 
-  match(object, parents) {
-    return (
-      object.type == "Program" ||
-      (object.type == "Literal" &&
-        typeof object.value === "string" &&
-        !isModuleSource(object, parents) &&
-        !isDirective(object, parents)) //&&
-      /*!parents.find((x) => x.$dispatcherSkip)*/
-    );
+    // Pad array with useless strings
+    var dead = getRandomInteger(4, 10);
+    for (var i = 0; i < dead; i++) {
+      var str = getRandomString(getRandomInteger(4, 20));
+      var fn = this.transform(Literal(str), []);
+      if (fn) {
+        fn();
+      }
+    }
   }
 
-  transform(object, parents) {
-    if (object.type == "Program") {
-      this.arrayExpression = ArrayExpression([]);
+  apply(tree) {
+    super.apply(tree);
+
+    var cacheName = this.getPlaceholder();
 
-      return () => {
-        var cacheName = this.getPlaceholder();
+    Object.keys(this.encoding).forEach((type) => {
+      var { template } = Encoding[type];
+      var decodeFn = this.getPlaceholder();
+      var getterFn = this.encoding[type];
 
-        append(
-          object,
-          Template(`
-          
-          function ${this.getterName}(x, y, z){
-            if ( z ) {
-              return y[${cacheName}[z]] = x;
+      append(tree, template.single({ name: decodeFn }));
+
+      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]))
             }
-            return y ? x[${cacheName}[y]] : ${cacheName}[x] || (${cacheName}[x] = ${this.decodeFn}(${this.arrayName}[x]))
-          }
+  
+            `).single()
+      );
+    });
 
-          `).single()
-        );
+    var flowIntegrity = this.getPlaceholder();
 
-        prepend(
-          object,
-          VariableDeclaration([
-            VariableDeclarator(cacheName, ArrayExpression([])),
-            VariableDeclarator(this.arrayName, this.arrayExpression),
-          ])
-        );
+    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(),
+              ]
+            ),
+            []
+          )
+        ),
+      ])
+    );
+  }
 
-        append(
-          object,
-          (this.decodeNode = Ascii85Template.single({
-            name: this.decodeFn,
-          }))
-        );
-      };
-    }
+  match(object, parents) {
+    return (
+      object.type == "Literal" &&
+      typeof object.value === "string" &&
+      object.value.length >= 3 &&
+      !isModuleSource(object, parents) &&
+      !isDirective(object, parents) //&&
+      /*!parents.find((x) => x.$dispatcherSkip)*/
+    );
+  }
 
+  transform(object: Node, parents: Node[]) {
     return () => {
-      // No string concealing in the decoder function
-      if (parents.find((x) => x == this.decodeNode)) {
+      // Empty strings are discarded
+      if (!object.value || this.ignore.has(object.value)) {
         return;
       }
 
-      // Empty strings are discarded
-      if (!object.value) {
-        return;
+      var types = Object.keys(this.encoding);
+
+      var type = choice(types);
+      if (!type || (!this.hasAllEncodings && Math.random() > 0.9)) {
+        var allowed = Object.keys(Encoding).filter(
+          (type) => !this.encoding[type]
+        );
+
+        if (!allowed.length) {
+          this.hasAllEncodings = true;
+        } else {
+          var random = choice(allowed);
+          type = random;
+
+          this.encoding[random] = this.getPlaceholder();
+        }
       }
 
+      var fnName = this.encoding[type];
+      var encoder = Encoding[type];
+
       // The decode function must return correct result
-      if (decode_ascii85(encode_ascii85(object.value)) != object.value) {
+      var encoded = encoder.encode(object.value);
+      if (encoder.decode(encoded) != object.value) {
+        this.ignore.add(object.value);
         this.warn(object.value.slice(0, 100));
         return;
       }
@@ -225,33 +196,59 @@ export default class StringConcealing extends Transform {
       if (object.value && object.value.length > 0) {
         var index = -1;
         if (!this.set.has(object.value)) {
-          this.arrayExpression.elements.push(
-            Literal(encode_ascii85(object.value))
-          );
+          this.arrayExpression.elements.push(Literal(encoded));
           index = this.arrayExpression.elements.length - 1;
-          this.index[object.value] = index;
+          this.index[object.value] = [index, fnName];
 
           this.set.add(object.value);
         } else {
-          index = this.index[object.value];
+          [index, fnName] = this.index[object.value];
           ok(typeof index === "number");
         }
 
         ok(index != -1, "index == -1");
-        this.replace(
-          object,
-          CallExpression(Identifier(this.getterName), [Literal(index)])
-        );
 
-        // Fix 2. Make parent property key computed
-        if (
-          parents[0] &&
-          (parents[0].type == "Property" ||
-            parents[0].type == "MethodDefinition") &&
-          parents[0].key == object
-        ) {
-          parents[0].computed = true;
-          parents[0].shorthand = false;
+        var callExpr = CallExpression(Identifier(fnName), [Literal(index)]);
+
+        // use `.apply` to fool automated de-obfuscators
+        if (Math.random() > 0.5) {
+          callExpr = CallExpression(
+            MemberExpression(Identifier(fnName), Identifier("apply"), false),
+            [ThisExpression(), ArrayExpression([Literal(index)])]
+          );
+        }
+
+        // use `.call`
+        else if (Math.random() > 0.5) {
+          callExpr = CallExpression(
+            MemberExpression(Identifier(fnName), Identifier("call"), false),
+            [ThisExpression(), Literal(index)]
+          );
+        }
+
+        var constantReference =
+          parents.length && Math.random() > 0.5 / this.variablesMade;
+
+        if (constantReference) {
+          // Define the string earlier, reference the name here
+
+          var name = this.getPlaceholder();
+
+          var place = choice(parents.filter((node) => isBlock(node)));
+          if (!place) {
+            this.error(Error("No lexical block to insert code"));
+          }
+
+          place.body.unshift(
+            VariableDeclaration(VariableDeclarator(name, callExpr))
+          );
+
+          this.replaceIdentifierOrLiteral(object, Identifier(name), parents);
+
+          this.variablesMade++;
+        } else {
+          // Direct call to the getter function
+          this.replaceIdentifierOrLiteral(object, callExpr, parents);
         }
       }
     };

package/src/transforms/string/stringSplitting.ts

@@ -6,6 +6,7 @@ import { ObfuscateOrder } from "../../order";
 import { isModuleSource } from "./stringConcealing";
 import { isDirective } from "../../util/compare";
 import { ok } from "assert";
+import { ComputeProbabilityMap } from "../../probability";
 
 export default class StringSplitting extends Transform {
   joinPrototype: string;
@@ -59,13 +60,6 @@ export default class StringSplitting extends Transform {
 
   transform(object: Node, parents: Node[]) {
     return () => {
-      var propIndex = parents.findIndex(
-        (x) => x.type == "Property" || x.type == "MethodDefinition"
-      );
-      if (propIndex !== -1 && parents[propIndex].key == object) {
-        parents[propIndex].computed = true;
-      }
-
       var size = Math.round(
         Math.max(6, object.value.length / getRandomInteger(3, 8))
       );
@@ -78,6 +72,16 @@ export default class StringSplitting extends Transform {
         return;
       }
 
+      if (
+        !ComputeProbabilityMap(
+          this.options.stringSplitting,
+          (x) => x,
+          object.value
+        )
+      ) {
+        return;
+      }
+
       var binaryExpression;
       var parent;
       var last = chunks.pop();
@@ -101,7 +105,7 @@ export default class StringSplitting extends Transform {
 
       parent.right = Literal(last);
 
-      this.replace(object, parent);
+      this.replaceIdentifierOrLiteral(object, parent, parents);
     };
   }
 }

package/src/transforms/transform.ts

@@ -1,4 +1,4 @@
-import traverse, { getDepth, getBlock, ExitCallback } from "../traverse";
+import traverse, { ExitCallback } from "../traverse";
 import { AddComment, Node } from "../util/gen";
 import {
   alphabeticalGenerator,
@@ -6,7 +6,6 @@ import {
   getRandomInteger,
 } from "../util/random";
 import { ok } from "assert";
-import { isValidIdentifier } from "../util/compare";
 import Obfuscator from "../obfuscator";
 import { ObfuscateOptions } from "../options";
 import { ComputeProbabilityMap } from "../probability";
@@ -353,6 +352,20 @@ export default class Transform {
     this.objectAssign(node1, node2);
   }
 
+  replaceIdentifierOrLiteral(node1: Node, node2: Node, parents: Node[]) {
+    // Fix 2. Make parent property key computed
+    if (
+      parents[0] &&
+      (parents[0].type == "Property" ||
+        parents[0].type == "MethodDefinition") &&
+      parents[0].key == node1
+    ) {
+      parents[0].computed = true;
+      parents[0].shorthand = false;
+    }
+    this.replace(node1, node2);
+  }
+
   /**
    * Smartly merges two Nodes.
    * - Null checking

package/src/traverse.ts

@@ -1,16 +1,6 @@
 import { Node } from "./util/gen";
 import { validateChain } from "./util/identifiers";
 
-/**
- * Returns all the scopes given parents array.
- * - `[object, ...parents]` is recommended.
- *
- * @param parents
- */
-export function getBlocks(parents: any[]): any[] {
-  return parents.filter((x) => isBlock(x));
-}
-
 /**
  * A block refers to any object that has a **`.body`** property where code is nested.
  *
@@ -23,7 +13,7 @@ export function getBlock(object: any, parents: any[]) {
   if (!Array.isArray(parents)) {
     throw new Error("parents must be an array");
   }
-  return getBlocks([object, ...parents])[0];
+  return [object, ...parents].find((node) => isBlock(node));
 }
 
 /**
@@ -40,26 +30,6 @@ export function isBlock(object: any) {
   );
 }
 
-/**
- * Returns a numerical representation of the depth.
- * - Depth is how many blocks nested.
- * - Program = 1 depth
- * -    First Fn = 2 depth
- * -        Nested Fn = 3 depth
- * -    Second Fn = 2 depth
- * -        etc...
- * @param object
- * @param parents
- */
-export function getDepth(object: any, parents: any[]) {
-  if (!Array.isArray(parents)) {
-    throw new Error("parents should be an array");
-  }
-  var scopes = getBlocks([object, ...parents].filter((x) => x));
-
-  return scopes.length;
-}
-
 export type EnterCallback = (
   object: Node,
   parents: Node[]

package/src/util/gen.ts

@@ -134,7 +134,9 @@ export function ThisExpression() {
   return { type: "ThisExpression" };
 }
 
-export function SwitchCase(test: any, consequent: any[]) {
+export function SwitchCase(test: any, consequent: Node[]) {
+  ok(test === null || test);
+  ok(Array.isArray(consequent));
   return {
     type: "SwitchCase",
     test,
@@ -142,7 +144,7 @@ export function SwitchCase(test: any, consequent: any[]) {
   };
 }
 
-export function SwitchDefaultCase(consequent: any[]) {
+export function SwitchDefaultCase(consequent: Node[]) {
   return SwitchCase(null, consequent);
 }
 
@@ -496,7 +498,7 @@ export function AssignmentPattern(left: Node, right: Node) {
   ok(left);
   ok(right);
   return {
-    type: "AssignmentExpression",
+    type: "AssignmentPattern",
     left: left,
     right: right,
   };

package/src/util/identifiers.ts

@@ -30,17 +30,6 @@ export function validateChain(object: Node, parents: Node[]) {
   }
 }
 
-export function isWithinClass(object: Node, parents: Node[]) {
-  return (
-    isWithin(object, parents, "ClassDeclaration") ||
-    isWithin(object, parents, "ClassExpression")
-  );
-}
-
-export function isWithin(object: Node, parents: Node[], type: string): boolean {
-  return [object, ...parents].some((x) => x.type == type);
-}
-
 /**
  * Returns detailed information about the given Identifier node.
  * @param object
@@ -117,15 +106,22 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
 
   var isFunctionCall = parent.callee == object; // NewExpression and CallExpression
 
+  var assignmentIndex = parents.findIndex(
+    (p) => p.type === "AssignmentExpression"
+  );
+
   var isAssignmentLeft =
-    parent.type == "AssignmentExpression" && parent.left == object;
+    assignmentIndex !== -1 &&
+    parents[assignmentIndex].left === (parents[assignmentIndex - 1] || object);
   var isAssignmentValue =
-    parent.type == "AssignmentExpression" && parent.right == object;
+    assignmentIndex !== -1 &&
+    parents[assignmentIndex].right === (parents[assignmentIndex - 1] || object);
 
   var isUpdateExpression = parent.type == "UpdateExpression";
 
   var isClassDeclaration =
-    parent.type == "ClassDeclaration" && parent.id == object;
+    (parent.type == "ClassDeclaration" || parent.type == "ClassExpression") &&
+    parent.id == object;
   var isMethodDefinition =
     parent.type == "MethodDefinition" &&
     parent.key == object &&
@@ -352,7 +348,7 @@ export function getDefiningIdentifier(object: Node, parents: Node[]): Location {
   }
 }
 
-export function isFunctionParameter(o: Node, p: Node[]) {
+export function isFunctionParameter(o: Node, p: Node[], c?: Node) {
   ok(o);
   ok(p);
   validateChain(o, p);
@@ -365,7 +361,7 @@ export function isFunctionParameter(o: Node, p: Node[]) {
     return false;
   }
 
-  var c = getVarContext(o, p);
+  c = c || getVarContext(o, p);
   if (c === object) {
     var pIndex = p.indexOf(object.params);
     if (pIndex == -1) {
@@ -376,8 +372,7 @@ export function isFunctionParameter(o: Node, p: Node[]) {
     var paramIndex = object.params.indexOf(param);
     ok(paramIndex !== -1);
 
-    var sliced = p.slice(p.indexOf(paramIndex));
-    ok(!sliced.includes(o));
+    var sliced = p.slice(0, pIndex);
 
     var isReferenced = true;
     var i = 0;
@@ -391,7 +386,12 @@ export function isFunctionParameter(o: Node, p: Node[]) {
           break;
         }
 
-        if (node.type == "ObjectPattern" && node.key === down) {
+        if (
+          node.type == "Property" &&
+          node.key === down &&
+          sliced[i + 2] &&
+          sliced[i + 2].type == "ObjectPattern"
+        ) {
           isReferenced = false;
           break;
         }
@@ -419,7 +419,7 @@ export function getFunctionParameters(
 
   walk(object.params, [object, ...parents], (o, p) => {
     if (o.type == "Identifier") {
-      if (isFunctionParameter(o, p)) {
+      if (isFunctionParameter(o, p, object)) {
         locations.push([o, p]);
       }
     }