js-confuser 1.5.8 → 1.6.0

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/hideInitializingCode.test.ts

@@ -1,336 +0,0 @@
-import JsConfuser from "../../src/index";
-
-test("Variant #1: Do not apply with exported names", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    export function myFunction(){
-
-    }
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).not.toContain("__p_");
-});
-
-test("Variant #2: Add ternary expressions and wrap initializing code in a function and still work", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    var myNumber = 10;
-    input(myNumber)
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-  expect(output).toContain("?");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #3: Should work with other function declarations", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    var myNumber = myFunction();
-    input(myNumber)
-
-    function myFunction(){
-      return 10;
-    }
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #4: Should work when doubly obfuscated", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    var myNumber = myFunction();
-    input(myNumber)
-
-    function myFunction(){
-      return 10;
-    }
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-
-  var doublyObfuscated = await JsConfuser.obfuscate(output, {
-    target: "node",
-    hideInitializingCode: true,
-  });
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-  eval(doublyObfuscated);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #5: Should bring up variable declarations", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    var myNumber = 10;
-    function myFunction(){
-      return myNumber;
-    }
-    input(myFunction())
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-  expect(output).toContain("var myNumber;");
-  expect(output).toContain("myNumber=");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #6: Should not bring up variable declarations in nested contexts", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-    function myFunction(){
-      function myNestedFunction(){
-        var myNumber = 10;
-        return myNumber;
-      }
-      return myNestedFunction();
-    }
-    input(myFunction())
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-  expect(output).toContain("var myNumber=");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #7: Should bring up class declarations", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-
-    class MyClass {
-      static getNumber(){
-        return 10;
-      }
-    }
-
-    function myFunction(){    
-      return MyClass.getNumber();
-    }
-    input(myFunction())
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-  expect(output).toContain("var MyClass;");
-  expect(output).toContain("MyClass=class MyClass{");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #8: Should bring up variable declarations in for statements", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-
-    for(var i=0; i <= 9; i++){
-      
-    } // i ends as 10
-
-    function myFunction(){
-      return i;
-    }
-    input(myFunction())
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #9: Should bring up variable declarations in for in statements", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-
-    var myNumber = 0;
-    var myArray = [0,1,2,3,4,5,6,7,8,9,10];
-    for(var i in myArray){
-      if(i==10){
-        myNumber = 10;
-      }
-    } // i ends as "10"
-
-    function myFunction(){
-      return parseInt(i);
-    }
-    input(myFunction())
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #10: Should work with multiple variable declarations", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-
-    var myNumber1 = 3, myNumber2 = 2;
-
-    function myFunction(){
-      return myNumber1*2 + myNumber2*2;
-    }
-    input(myFunction())
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});
-
-test("Variant #11: Should bring up variable declaration but not default values function expression's variables", async () => {
-  var output = await JsConfuser.obfuscate(
-    `
-
-    var [myNumber1 = function(){
-      var myNumber = 2;
-    }] = [10];
-
-    function myFunction(){
-      return myNumber1;
-    }
-    input(myFunction())
-    `,
-    {
-      target: "node",
-      hideInitializingCode: true,
-    }
-  );
-
-  expect(output).toContain("__p_");
-  expect(output).toContain("function ");
-  expect(output).toContain("var myNumber1;");
-  expect(output).toContain("[myNumber1");
-  expect(output).toContain("=[");
-
-  expect(output).toContain("var myNumber=");
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(10);
-});