js-confuser 1.5.9 → 1.7.0

package/src/transforms/label.ts

@@ -1,64 +0,0 @@
-import Transform from "./transform";
-import { Identifier, LabeledStatement } from "../util/gen";
-import { walk } from "../traverse";
-import { clone } from "../util/insert";
-import { isLoop } from "../util/compare";
-
-/**
- * Ensures every break; statement has a label to point to.
- *
- * This is because Control Flow Flattening adds For Loops which label-less break statements point to the nearest,
- * when they actually need to point to the original statement.
- */
-export default class Label extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return (
-      isLoop(object) ||
-      (object.type == "BlockStatement" &&
-        parents[0] &&
-        parents[0].type == "LabeledStatement" &&
-        parents[0].body === object)
-    );
-  }
-
-  transform(object, parents) {
-    return () => {
-      var currentLabel =
-        parents[0].type == "LabeledStatement" && parents[0].label.name;
-
-      var label = currentLabel || this.getPlaceholder();
-
-      walk(object, parents, (o, p) => {
-        if (o.type == "BreakStatement" || o.type == "ContinueStatement") {
-          function isContinuableStatement(x) {
-            return isLoop(x) && x.type !== "SwitchStatement";
-          }
-          function isBreakableStatement(x) {
-            return isLoop(x) || (o.label && x.type == "BlockStatement");
-          }
-
-          var fn =
-            o.type == "ContinueStatement"
-              ? isContinuableStatement
-              : isBreakableStatement;
-
-          var loop = p.find(fn);
-          if (object == loop) {
-            if (!o.label) {
-              o.label = Identifier(label);
-            }
-          }
-        }
-      });
-
-      // Append label statement as this loop has none
-      if (!currentLabel) {
-        this.replace(object, LabeledStatement(label, { ...object }));
-      }
-    };
-  }
-}

package/src/transforms/preparation/nameConflicts.ts

@@ -1,102 +0,0 @@
-import { reservedIdentifiers } from "../../constants";
-import { Node } from "../../util/gen";
-import {
-  getDefiningIdentifier,
-  getIdentifierInfo,
-} from "../../util/identifiers";
-import Transform from "../transform";
-
-export class NameMappingAnalysis extends Transform {
-  names: Map<string, Set<Node>>;
-
-  constructor(o) {
-    super(o);
-
-    this.names = new Map();
-  }
-
-  match(object, parents) {
-    return object.type == "Identifier" && !reservedIdentifiers.has(object.name);
-  }
-
-  transform(object, parents) {
-    var info = getIdentifierInfo(object, parents);
-
-    if (info.spec.isReferenced && !info.spec.isDefined) {
-      object.$definedAt = getDefiningIdentifier(object, parents);
-    }
-
-    if (info.spec.isDefined) {
-      if (!this.names.has(object.name)) {
-        this.names.set(object.name, new Set([object]));
-      } else {
-        this.names.get(object.name).add(object);
-      }
-    }
-  }
-}
-
-/**
- * Renames variables & removes conflicts.
- *
- * - This helps transformations like `Dispatcher` not replace re-declared identifiers.
- */
-export default class NameConflicts extends Transform {
-  nameMappingAnalysis: NameMappingAnalysis;
-
-  changes: Map<Node, string>;
-  references: Map<Node, Set<Node>>;
-
-  constructor(o) {
-    super(o);
-
-    this.before.push((this.nameMappingAnalysis = new NameMappingAnalysis(o)));
-    this.changes = new Map();
-    this.references = new Map();
-  }
-
-  match(object, parents) {
-    return (
-      object.type == "Identifier" &&
-      !reservedIdentifiers.has(object.name) &&
-      !this.options.globalVariables.has(object.name)
-    );
-  }
-
-  transform(object: Node, parents: Node[]) {
-    var info = getIdentifierInfo(object, parents);
-
-    if (info.isMethodDefinition) {
-      return;
-    }
-
-    if (object.$definedAt) {
-      object.name = this.changes.get(object.$definedAt[0]) || object.name;
-
-      if (!this.references.has(object.$definedAt[0])) {
-        this.references.set(object.$definedAt[0], new Set([object]));
-      } else {
-        this.references.get(object.$definedAt[0]).add(object);
-      }
-    } else if (info.spec.isDefined) {
-      var set = this.nameMappingAnalysis.names.get(object.name);
-      if (set && set.size > 1) {
-        var index = Array.from(set).indexOf(object);
-
-        var newName = "_".repeat(index) + object.name;
-
-        if (index > 4 || this.nameMappingAnalysis.names.has(newName)) {
-          newName = this.getPlaceholder() + "_" + object.name;
-        }
-
-        object.name = newName;
-        this.changes.set(object, newName);
-        if (this.references.has(object)) {
-          this.references.get(object).forEach((ref) => {
-            ref.name = newName;
-          });
-        }
-      }
-    }
-  }
-}

package/src/transforms/preparation/preparation.ts

@@ -1,176 +0,0 @@
-/**
- * The file contains all preparation transformations
- */
-import Transform from "../transform";
-
-import { BlockStatement, Literal, ReturnStatement } from "../../util/gen";
-import { ObfuscateOrder } from "../../order";
-import { clone, getFunction } from "../../util/insert";
-import { getIdentifierInfo } from "../../util/identifiers";
-import Label from "../label";
-import { isLoop } from "../../util/compare";
-
-/**
- * People use shortcuts and its harder to parse.
- *
- * - `if (a) b()` -> `if (a) { b() }`
- * - Ensures all bodies are `BlockStatement`, not individual expression statements
- */
-class Block extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return !Array.isArray(object);
-  }
-
-  transform(object, parents) {
-    switch (object.type) {
-      case "IfStatement":
-        if (object.consequent.type != "BlockStatement") {
-          object.consequent = BlockStatement([clone(object.consequent)]);
-        }
-        if (object.alternate && object.alternate.type != "BlockStatement") {
-          object.alternate = BlockStatement([clone(object.alternate)]);
-        }
-        break;
-
-      case "WhileStatement":
-      case "WithStatement":
-      case "ForStatement":
-      case "ForOfStatement":
-      case "ForInStatement":
-        if (object.body.type != "BlockStatement") {
-          object.body = BlockStatement([clone(object.body)]);
-        }
-        break;
-
-      case "ArrowFunctionExpression":
-        if (object.body.type !== "BlockStatement" && object.expression) {
-          object.body = BlockStatement([ReturnStatement(clone(object.body))]);
-          object.expression = false;
-        }
-        break;
-    }
-  }
-}
-
-class ExplicitIdentifiers extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return object.type == "Identifier";
-  }
-
-  transform(object, parents) {
-    if (object.name === "eval") {
-      var fn = getFunction(object, parents);
-      if (fn) {
-        fn.$requiresEval = true;
-      }
-    }
-
-    var info = getIdentifierInfo(object, parents);
-    if (info.isPropertyKey || info.isAccessor) {
-      var propIndex = parents.findIndex(
-        (x) => x.type == "MethodDefinition" || x.type == "Property"
-      );
-      if (propIndex !== -1) {
-        if (
-          parents[propIndex].type == "MethodDefinition" &&
-          parents[propIndex].kind == "constructor"
-        ) {
-          return;
-        }
-      }
-
-      this.log(object.name, "->", `'${object.name}'`);
-
-      this.replace(object, Literal(object.name));
-      parents[0].computed = true;
-      parents[0].shorthand = false;
-    }
-  }
-}
-
-class ExplicitDeclarations extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return object.type == "VariableDeclaration";
-  }
-
-  transform(object, parents) {
-    // for ( var x in ... ) {...}
-    var forIndex = parents.findIndex(
-      (x) => x.type == "ForInStatement" || x.type == "ForOfStatement"
-    );
-    if (
-      forIndex != -1 &&
-      parents[forIndex].left == (parents[forIndex - 1] || object)
-    ) {
-      object.declarations.forEach((x) => {
-        x.init = null;
-      });
-      return;
-    }
-
-    var body = parents[0];
-    if (isLoop(body) || body.type == "LabeledStatement") {
-      return;
-    }
-
-    if (body.type == "ExportNamedDeclaration") {
-      return;
-    }
-
-    if (!Array.isArray(body)) {
-      this.error(new Error("body is " + body.type));
-    }
-
-    if (object.declarations.length > 1) {
-      // Make singular
-
-      var index = body.indexOf(object);
-      if (index == -1) {
-        this.error(new Error("index is -1"));
-      }
-
-      var after = object.declarations.slice(1);
-
-      body.splice(
-        index + 1,
-        0,
-        ...after.map((x) => {
-          return {
-            type: "VariableDeclaration",
-            declarations: [clone(x)],
-            kind: object.kind,
-          };
-        })
-      );
-
-      object.declarations.length = 1;
-    }
-  }
-}
-
-export default class Preparation extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.Preparation);
-
-    this.before.push(new Block(o));
-    this.before.push(new Label(o));
-    this.before.push(new ExplicitIdentifiers(o));
-    this.before.push(new ExplicitDeclarations(o));
-  }
-
-  match() {
-    return false;
-  }
-}

package/test/transforms/controlFlowFlattening/controlFlowObfuscation.test.ts

@@ -1,101 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-it("should obfuscate for loops (ControlFlowObfuscation)", async () => {
-  var code = `
-    var array = [];
-
-    for ( var i = 1; i <= 10; i++ ) {
-      array.push(i);
-    }
-
-    input(array);
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    controlFlowFlattening: true,
-  });
-
-  expect(output).toContain("switch");
-
-  function input(array) {
-    expect(array).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  }
-
-  eval(output);
-});
-
-it("should obfuscate while loops (ControlFlowObfuscation)", async () => {
-  var code = `
-    var array = [];
-    var i = 1;
-
-    while ( i <= 10 ) {
-      array.push(i);
-      i++
-    }
-
-    input(array);
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    controlFlowFlattening: true,
-  });
-
-  expect(output).toContain("switch");
-
-  function input(array) {
-    expect(array).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  }
-
-  eval(output);
-});
-
-it("should work with break statements (ControlFlowObfuscation)", async () => {
-  var code = `
-
-    var TEST_ARRAY = [];
-
-    for ( var i =1; true; i++ ) {
-      if ( i == 11 ) {
-        break;
-      }
-      TEST_ARRAY.push(i);
-    }
-
-    input(TEST_ARRAY);
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    controlFlowFlattening: true,
-  });
-
-  expect(output).toContain("switch");
-  expect(output).toContain("while");
-
-  function input(array) {
-    expect(array).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  }
-
-  eval(output);
-});
-
-it("should not obfuscate code with `let` (Lexically bound variables, ControlFlowObfuscation)", async () => {
-  var code = `
-  var array=[];
-  for ( let i =1; i <= 10; i++ ) {
-    array.push(i);
-  }
-
-    input(array);
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    controlFlowFlattening: true,
-  });
-
-  expect(output).not.toContain("switch");
-});

package/test/transforms/controlFlowFlattening/switchCaseObfuscation.test.ts

@@ -1,120 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-it("should obfuscate numbered switch statements (SwitchCaseObfuscation)", async () => {
-  var code = `
-    var array = [];
-
-    function runOnce(stateParam){
-      switch(stateParam){
-        case 1: array.push(1, 2, 3); break;
-        case 2: array.push(4, 5, 6); break;
-        case 3: array.push(7, 8, 9); break;
-        case 4: array.push(10); break;
-      }
-    }
-
-    runOnce(1);
-    runOnce(2);
-    runOnce(3);
-    runOnce(4);
-
-    input(array);
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    controlFlowFlattening: true,
-  });
-
-  expect(
-    output.includes("case 1:") &&
-      output.includes("case 2:") &&
-      output.includes("case 3:") &&
-      output.includes("case 4:")
-  ).toStrictEqual(false);
-
-  function input(array) {
-    expect(array).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  }
-
-  eval(output);
-});
-
-it("should not obfuscate switch statements with complex discriminants (SwitchCaseObfuscation)", async () => {
-  var code = `
-    var array = [];
-
-    function runOnce(stateParam){
-      switch(stateParam || 0){
-        case 1: array.push(1, 2, 3); break;
-        case 2: array.push(4, 5, 6); break;
-        case 3: array.push(7, 8, 9); break;
-        case 4: array.push(10); break;
-      }
-    }
-
-    runOnce(1);
-    runOnce(2);
-    runOnce(3);
-    runOnce(4);
-
-    input(array);
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    controlFlowFlattening: true,
-  });
-
-  expect(output).toContain("stateParam||0");
-
-  function input(array) {
-    expect(array).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  }
-
-  eval(output);
-});
-
-// https://github.com/MichaelXF/js-confuser/issues/41
-it("Not apply to switch statements with default cases", async ()=>{
-
-    var code = `
-    var array = [];
-
-    function runOnce(stateParam){
-      switch(stateParam){
-        case 1: array.push(1, 2, 3); break;
-        case 2: array.push(4, 5, 6); break;
-        case 3: array.push(7, 8, 9); break;
-        default: array.push(10); break;
-      }
-    }
-
-    runOnce(1);
-    runOnce(2);
-    runOnce(3);
-    runOnce(-1); // default case
-
-    input(array);
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    controlFlowFlattening: true,
-  });
-
-  expect(
-    output.includes("case 1:") &&
-      output.includes("case 2:") &&
-      output.includes("case 3:") 
-  ).toStrictEqual(true);
-
-  function input(array) {
-    expect(array).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  }
-
-  eval(output);
-
-
-
-});

package/test/transforms/eval.test.ts

@@ -1,131 +0,0 @@
-import JsConfuser from "../../src/index";
-
-it("should put functions into eval statements", async () => {
-  var code = `
-    function TEST_FUNCTION(){
-    }
-  `;
-
-  var output = await JsConfuser(code, { target: "node", eval: true });
-
-  expect(output).toContain("eval(");
-});
-
-it("should put functions into eval statements and have same result", async () => {
-  var code = `
-    function TEST_FUNCTION(){
-      input(100)
-    }
-    TEST_FUNCTION();
-  `;
-
-  var output = await JsConfuser(code, { target: "node", eval: true });
-
-  expect(output).toContain("eval(");
-
-  var value = "never_called",
-    input = (valueIn) => (value = valueIn);
-  eval(output);
-
-  expect(value).toStrictEqual(100);
-});
-
-it("should move function declarations to the top of the block", async () => {
-  var code = `
-    TEST_FUNCTION();
-    function TEST_FUNCTION(){
-      input(100)
-    }
-  `;
-
-  var output = await JsConfuser(code, { target: "node", eval: true });
-
-  expect(output).toContain("eval(");
-
-  var value = "never_called",
-    input = (valueIn) => (value = valueIn);
-  eval(output);
-
-  expect(value).toStrictEqual(100);
-});
-
-it("should work with Integrity also enabled", async () => {
-  var code = `
-    input("Hello World")
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    compact: false,
-    eval: true,
-    lock: {
-      integrity: true,
-    },
-  });
-
-  expect(output).toContain("eval(");
-
-  var value = "never_called",
-    input = (valueIn) => (value = valueIn);
-
-  try {
-    eval(output);
-  } catch (e) {
-    expect(e).toStrictEqual(undefined);
-  }
-
-  expect(value).toStrictEqual("Hello World");
-});
-
-it("should work on async functions", async () => {
-  var output = await JsConfuser(
-    `
-  async function myFunction(){
-    return "Correct Value";
-  }
-
-  (async ()=>{
-    TEST_FUNCTION( await myFunction() );
-  })();
-  `,
-    { target: "node", eval: true }
-  );
-
-  expect(output).toContain("eval");
-
-  var wasCalled = false;
-
-  function TEST_FUNCTION(value) {
-    wasCalled = true;
-    expect(value).toStrictEqual("Correct Value");
-  }
-
-  eval(output);
-
-  setTimeout(() => {
-    expect(wasCalled).toStrictEqual(true);
-  }, 1000);
-});
-
-it("should work on generator functions", async () => {
-  var output = await JsConfuser(
-    `
-  function* myFunction(){
-    yield "Correct Value";
-  }
-  
-  const gen = myFunction();
-
-  TEST_OUTPUT = gen.next().value;
-  `,
-    { target: "node", eval: true }
-  );
-
-  expect(output).toContain("eval");
-
-  var TEST_OUTPUT;
-
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
-});