js-confuser 1.2.2 → 1.4.2

package/src/transforms/string/encoding.ts

@@ -1,6 +1,12 @@
 import Template from "../../templates/template";
 
-const Encoding = {
+const Encoding: {
+  [encoding_name: string]: {
+    encode: (s) => string;
+    decode: (s) => string;
+    template: ReturnType<typeof Template>;
+  };
+} = {
   ascii85: {
     encode(a) {
       var b, c, d, e, f, g, h, i, j, k;
@@ -89,6 +95,7 @@ const Encoding = {
     }
     `),
   },
+
   base32: {
     encode: function (s) {
       var a = "!\"#$%&'()*+,-./0123456789:;<=>?@";
@@ -199,6 +206,105 @@ const Encoding = {
     }
     `),
   },
+
+  hexTable: {
+    encode: function (str) {
+      var output = "";
+
+      for (var j = 0; j < str.length; j += 3) {
+        var chunk = str.substring(j, j + 3);
+        if (!chunk) {
+          continue;
+        }
+
+        chunk = chunk + "~";
+
+        var uniqueChars = new Set([]);
+        for (var char of chunk) {
+          uniqueChars.add(char);
+        }
+
+        var keys = Array.from(uniqueChars).sort();
+        var table = {},
+          i = 0;
+        for (var key of keys) {
+          table[key] = i++;
+        }
+
+        var idx = [];
+        for (var char of chunk) {
+          idx.push(table[char]);
+        }
+
+        var table64 = "0x";
+        for (var i = keys.length - 1; i >= 0; i--) {
+          table64 += keys[i].charCodeAt(0).toString(16).toUpperCase();
+        }
+
+        var idxInt = 0;
+        for (var i = idx.length - 1; i >= 0; i--) {
+          idxInt = (idxInt << 3) | idx[i];
+        }
+
+        var idx64 = "0x" + idxInt.toString(16).toUpperCase();
+
+        // console.log(chunk, table, idx, table64, idx64);
+
+        output += table64 + "," + idx64 + ",";
+      }
+
+      if (output.endsWith(",")) {
+        output = output.substring(0, output.length - 1);
+      }
+
+      return "{" + output + "}";
+    },
+
+    decode: function (str) {
+      var output = "";
+
+      str = str.substring(1, str.length - 1);
+      var chunks = str.split(",");
+
+      for (var i = 0; i < chunks.length; i += 2) {
+        var arr = [chunks[i], chunks[i + 1]];
+
+        var [table, idx] = arr.map(Number);
+
+        // console.log(table, idx);
+        while (idx) {
+          output += String.fromCharCode((table >> (8 * (idx & 7))) & 0xff);
+          idx >>= 3;
+        }
+      }
+
+      return output.replace(/~/g, "");
+    },
+
+    template: Template(`
+      function {name}(str){
+        var output = "";
+    
+        str = str.substring(1, str.length - 1);
+        var chunks = str.split(",");
+      
+        for (var i = 0; i < chunks.length; i += 2) {
+          var arr = [chunks[i], chunks[i + 1]];
+      
+          var [table, idx] = arr.map(Number);
+      
+          // console.log(table, idx);
+          while (idx) {
+            output += String.fromCharCode((table >> (8 * (idx & 7))) & 0xff);
+            idx >>= 3;
+          }
+        }
+      
+        return output.replace(/~/g, "");
+      }
+    
+    `),
+  },
 };
 
 export default Encoding;

package/src/transforms/string/stringCompression.ts

@@ -6,6 +6,7 @@ import { isDirective } from "../../util/compare";
 import {
   CallExpression,
   FunctionDeclaration,
+  FunctionExpression,
   Identifier,
   Literal,
   MemberExpression,
@@ -105,19 +106,43 @@ export default class StringCompression extends Transform {
 
     var split = this.getPlaceholder();
     var decoder = this.getPlaceholder();
+    var getStringName = this.getPlaceholder();
 
     var encoded = LZ_encode(this.string);
     if (LZ_decode(encoded) !== this.string) {
       this.error(new Error("String failed to be decoded"));
     }
 
-    var callExpression = CallExpression(Identifier(decoder), [
-      Literal(encoded),
+    var getStringParamName = this.getPlaceholder();
+    var decoderParamName = this.getPlaceholder();
+
+    var callExpression = CallExpression(Identifier(decoderParamName), [
+      CallExpression(Identifier(getStringParamName), []),
     ]);
 
     prepend(
       tree,
-      VariableDeclaration(VariableDeclarator(split, callExpression))
+      VariableDeclaration(
+        VariableDeclarator(
+          split,
+          CallExpression(
+            FunctionExpression(
+              [Identifier(getStringParamName), Identifier(decoderParamName)],
+              [ReturnStatement(callExpression)]
+            ),
+            [Identifier(getStringName), Identifier(decoder)]
+          )
+        )
+      )
+    );
+
+    append(
+      tree,
+      FunctionDeclaration(
+        getStringName,
+        [],
+        [ReturnStatement(Literal(encoded))]
+      )
     );
 
     append(

package/src/transforms/string/stringConcealing.ts

@@ -106,6 +106,8 @@ export default class StringConcealing extends Transform {
             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]))

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;
@@ -71,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();

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";

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.
  *
@@ -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,10 +106,16 @@ 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";
 
@@ -353,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);
@@ -366,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) {
@@ -377,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;
@@ -392,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;
         }
@@ -420,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]);
       }
     }

package/src/util/insert.ts

@@ -1,6 +1,6 @@
 import { ok } from "assert";
-import { getBlock, isBlock, getBlocks } from "../traverse";
-import { Node, Location } from "./gen";
+import { getBlock, isBlock } from "../traverse";
+import { Node } from "./gen";
 import { getIdentifierInfo, validateChain } from "./identifiers";
 
 /**
@@ -125,35 +125,18 @@ export function getDefiningContext(o: Node, p: Node[]): Node {
   return getVarContext(o, p);
 }
 
-export function getReferencingContexts(o: Node, p: Node[]): Node[] {
+export function getReferencingContexts(
+  o: Node,
+  p: Node[],
+  info?: ReturnType<typeof getIdentifierInfo>
+): Node[] {
   validateChain(o, p);
   ok(o.type == "Identifier");
 
-  var info = getIdentifierInfo(o, p);
-  ok(info.spec.isReferenced);
-
-  var assignmentPatternIndex = p.findIndex(
-    (x) => x.type == "AssignmentPattern"
-  );
-  if (assignmentPatternIndex != -1) {
-    if (
-      p[assignmentPatternIndex].right == (p[assignmentPatternIndex - 1] || o)
-    ) {
-      var sliced = p.slice(assignmentPatternIndex);
-      var fnIndex = sliced.findIndex((x) => isFunction(x));
-      var associatedFn = sliced[fnIndex];
-      if (
-        fnIndex !== -1 &&
-        sliced[fnIndex].params == (sliced[fnIndex - 1] || o)
-      ) {
-        if (associatedFn == getVarContext(o, p)) {
-          return isLexContext(associatedFn.body)
-            ? [associatedFn, associatedFn.body]
-            : [associatedFn];
-        }
-      }
-    }
+  if (!info) {
+    info = getIdentifierInfo(o, p);
   }
+  ok(info.spec.isReferenced);
 
   return [getVarContext(o, p), getLexContext(o, p)];
 }
@@ -326,52 +309,3 @@ export function isForInitialize(o, p): "initializer" | "left-hand" | false {
 
   return false;
 }
-
-export function isInBranch(object: Node, parents: Node[], context: Node) {
-  ok(object);
-  ok(parents);
-  ok(context);
-
-  ok(parents.includes(context));
-
-  var definingContext =
-    parents[0].type == "FunctionDeclaration" && parents[0].id == object
-      ? getVarContext(parents[0], parents.slice(1))
-      : getVarContext(object, parents);
-
-  var contextIndex = parents.findIndex((x) => x === context);
-  var slicedParents = parents.slice(0, contextIndex);
-
-  ok(!slicedParents.includes(object), "slicedParents includes object");
-
-  var slicedTypes = new Set(slicedParents.map((x) => x.type));
-
-  var isBranch = definingContext !== context;
-  if (!isBranch) {
-    if (
-      [
-        "IfStatement",
-        "ForStatement",
-        "ForInStatement",
-        "ForOfStatement",
-        "WhileStatement",
-        "DoWhileStatement",
-        "SwitchStatement",
-        "ConditionalExpression",
-        "LogicalExpression",
-        "TryStatement",
-        "ChainExpression",
-        "BinaryExpression",
-        "FunctionExpression",
-        "FunctionDeclaration",
-        "ArrowFunctionExpression",
-        "ClassExpression",
-        "ClassDeclaration",
-      ].find((x) => slicedTypes.has(x))
-    ) {
-      isBranch = true;
-    }
-  }
-
-  return isBranch;
-}

package/src/util/scope.ts

@@ -1,9 +1,9 @@
-import { isBlock } from "../traverse";
-
-export function isLexicalScope(object) {
-  return isBlock(object) || object.type == "SwitchCase";
-}
-
-export function getLexicalScope(object, parents) {
-  return [object, ...parents].find((node) => isLexicalScope(node));
-}
+import { isBlock } from "../traverse";
+
+export function isLexicalScope(object) {
+  return isBlock(object) || object.type == "SwitchCase";
+}
+
+export function getLexicalScope(object, parents) {
+  return [object, ...parents].find((node) => isLexicalScope(node));
+}

package/test/{transforms/compare.test.ts → compare.test.ts}

@@ -1,10 +1,10 @@
-import { isIndependent } from "../../src/util/compare";
+import { isIndependent } from "../src/util/compare";
 import {
   ArrayExpression,
   FunctionExpression,
   Identifier,
   Literal,
-} from "../../src/util/gen";
+} from "../src/util/gen";
 
 describe("isIndependent", () => {
   it("should return true for literals", () => {

package/test/index.test.ts

@@ -1,4 +1,7 @@
-import JsConfuser from "../src/index";
+import JsConfuser, {
+  debugObfuscation,
+  debugTransformations,
+} from "../src/index";
 
 it("should be a function", async () => {
   expect(typeof JsConfuser).toBe("function");
@@ -126,3 +129,108 @@ it("should error when invalid endDate is passed in", async () => {
     return await JsConfuser("5+5", invalid);
   }).rejects.toThrow();
 });
+
+it("should error when source code is not a string", async () => {
+  await expect(async () => {
+    return await JsConfuser({} as any, {
+      target: "node",
+      preset: "low",
+    });
+  }).rejects.toThrow();
+});
+
+it("should error when invalid source code is passed in", async () => {
+  await expect(async () => {
+    return await JsConfuser("#?!if?//for:;1(function:class{))]][]", {
+      target: "node",
+      preset: "low",
+    });
+  }).rejects.toThrow();
+});
+
+describe("obfuscateAST", () => {
+  test("Variant #1: Mutate AST", async () => {
+    var AST = {
+      type: "Program",
+      body: [
+        {
+          type: "ExpressionStatement",
+          expression: { type: "Literal", value: true },
+        },
+      ],
+    };
+    var before = JSON.stringify(AST);
+
+    JsConfuser.obfuscateAST(AST, { target: "node", es5: true });
+
+    var after = JSON.stringify(AST);
+
+    // Same object reference
+    expect(AST === AST).toStrictEqual(true);
+
+    // Different string
+    expect(before !== after).toStrictEqual(false);
+  });
+
+  test("Variant #2: Error on invalid parameters", async () => {
+    await expect(async () => {
+      return await JsConfuser.obfuscateAST("string", {
+        target: "node",
+        preset: "low",
+      });
+    }).rejects.toThrow();
+  });
+
+  test("Variant #3: Error on invalid AST", async () => {
+    await expect(async () => {
+      var invalidAST = {
+        type: "NotProgram",
+      };
+
+      return await JsConfuser.obfuscateAST(invalidAST, {
+        target: "node",
+        preset: "low",
+      });
+    }).rejects.toThrow();
+  });
+});
+
+describe("debugTransformations", () => {
+  test("Variant #1: Return array of objects containing `name`, `code`, and `ms` properties", async () => {
+    var frames = await debugTransformations(`console.log(1)`, {
+      target: "node",
+      preset: "low",
+    });
+
+    expect(Array.isArray(frames)).toStrictEqual(true);
+    expect(frames.length).toBeTruthy();
+
+    frames.forEach((frame) => {
+      expect(typeof frame.name).toStrictEqual("string");
+      expect(typeof frame.code).toStrictEqual("string");
+      expect(typeof frame.ms).toStrictEqual("number");
+    });
+  });
+});
+
+describe("debugObfuscation", () => {
+  test("Variant #1: Return array of objects containing code, ms, and name properties", async () => {
+    var called = false;
+
+    var callback = (name, complete, totalTransforms) => {
+      expect(typeof name).toStrictEqual("string");
+      expect(typeof complete).toStrictEqual("number");
+      expect(typeof totalTransforms).toStrictEqual("number");
+
+      called = true;
+    };
+    var output = await debugObfuscation(
+      `console.log(1)`,
+      { target: "node", preset: "low" },
+      callback
+    );
+
+    expect(typeof output).toStrictEqual("string");
+    expect(called).toStrictEqual(true);
+  });
+});

package/test/templates/template.test.ts

@@ -0,0 +1,14 @@
+import Template from "../../src/templates/template";
+
+describe("Template", () => {
+  test("Variant #1: Error when invalid code passed in", () => {
+    var _consoleError = console.error;
+    console.error = null;
+
+    expect(() => {
+      Template(`#&!#Ylet{}class)--1]?|:!@#`).compile();
+    }).toThrow();
+
+    console.error = _consoleError;
+  });
+});