js-confuser 1.2.1 → 1.4.1

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)];
 }
@@ -314,11 +297,11 @@ export function isForInitialize(o, p): "initializer" | "left-hand" | false {
   );
   if (forIndex !== -1) {
     if (p[forIndex].type == "ForStatement") {
-      if (p[forIndex].init == p[forIndex - 1] || o) {
+      if (p[forIndex].init == (p[forIndex - 1] || o)) {
         return "initializer";
       }
     } else {
-      if (p[forIndex].left == p[forIndex - 1] || o) {
+      if (p[forIndex].left == (p[forIndex - 1] || o)) {
         return "left-hand";
       }
     }
@@ -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

@@ -0,0 +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));
+}

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;
+  });
+});