js-confuser 1.5.8 → 1.5.9

package/src/transforms/string/stringConcealing.ts

@@ -214,7 +214,7 @@ export default class StringConcealing extends Transform {
       if (Math.random() > 0.5) {
         callExpr = CallExpression(
           MemberExpression(Identifier(fnName), Identifier("apply"), false),
-          [ThisExpression(), ArrayExpression([Literal(index)])]
+          [Identifier("undefined"), ArrayExpression([Literal(index)])]
         );
       }
 
@@ -222,7 +222,7 @@ export default class StringConcealing extends Transform {
       else if (Math.random() > 0.5) {
         callExpr = CallExpression(
           MemberExpression(Identifier(fnName), Identifier("call"), false),
-          [ThisExpression(), Literal(index)]
+          [Identifier("undefined"), Literal(index)]
         );
       }
 

package/src/traverse.ts

@@ -39,16 +39,9 @@ export type ExitCallback = () => void;
 export function walk(
   object: Node | Node[],
   parents: Node[],
-  onEnter: EnterCallback,
-  seen = new Set<Node>()
+  onEnter: EnterCallback
 ): "EXIT" | void {
   if (typeof object === "object" && object) {
-    if (seen.has(object as any)) {
-      console.log(object);
-      throw new Error("Already seen: " + (object as any).type);
-    }
-    seen.add(object as any);
-
     var newParents: Node[] = [object as Node, ...parents];
 
     if (!Array.isArray(object)) {

package/src/types.ts

@@ -119,4 +119,12 @@ export type IJsConfuserDebugObfuscation = (
   code: string,
   options: ObfuscateOptions,
   callback: (name: string, complete: number, totalTransforms: number) => void
-) => Promise<string>;
+) => Promise<{
+  obfuscated: string;
+  transformationTimes: { [transformName: string]: number };
+  parseTime: number;
+  compileTime: number;
+  obfuscationTime: number;
+  totalTransforms: number;
+  totalPossibleTransforms: number;
+}>;

package/src/util/compare.ts

@@ -53,8 +53,8 @@ export function isValidIdentifier(name: string): boolean {
     return false;
   }
 
-  var x = name.match(/^[A-z$_][A-z0-9$_]*/);
-  return x && x[0] == name;
+  var x = name.match(/^[A-Za-z$_][A-Za-z0-9$_]*/);
+  return !!(x && x[0] == name);
 }
 
 export function isInsideType(

package/src/util/insert.ts

@@ -113,8 +113,14 @@ export function getDefiningContext(o: Node, p: Node[]): Node {
     var variableDeclaration = p.find((x) => x.type == "VariableDeclaration");
     ok(variableDeclaration);
 
-    if (variableDeclaration.kind === "let") {
-      return getLexContext(o, p);
+    if (
+      variableDeclaration.kind === "let" ||
+      variableDeclaration.kind === "const"
+    ) {
+      var context = getVarContext(o, p);
+      if (context && context.type === "Program") {
+        return getLexContext(o, p);
+      }
     }
   }
 
@@ -178,7 +184,7 @@ export function getBlockBody(block: Node): Node[] {
   return getBlockBody(block.body);
 }
 
-export function getIndexDirect(object: Node, parent: Node[]): string {
+export function getIndexDirect(object: Node, parent: Node): string {
   return Object.keys(parent).find((x) => parent[x] == object);
 }
 
@@ -255,16 +261,25 @@ export function prepend(block: Node, ...nodes: Node[]) {
   ok(!Array.isArray(block), "block should not be array");
 
   if (block.type == "Program") {
-    var decs = 0;
+    var moveBy = 0;
     block.body.forEach((stmt, i) => {
       if (stmt.type == "ImportDeclaration") {
-        if (decs == i) {
-          decs++;
+        if (moveBy == i) {
+          moveBy++;
+        }
+      }
+
+      if (
+        stmt.type === "ExpressionStatement" &&
+        typeof stmt.directive === "string"
+      ) {
+        if (moveBy == i) {
+          moveBy++;
         }
       }
     });
 
-    block.body.splice(decs, 0, ...nodes);
+    block.body.splice(moveBy, 0, ...nodes);
   } else {
     getBlockBody(block).unshift(...nodes);
   }
@@ -313,7 +328,10 @@ export function clone<T>(object: T): T {
  * @param p
  * @returns
  */
-export function isForInitialize(o, p): "initializer" | "left-hand" | false {
+export function isForInitialize(
+  o: Node,
+  p: Node[]
+): "initializer" | "left-hand" | false {
   validateChain(o, p);
 
   var forIndex = p.findIndex(
@@ -322,6 +340,17 @@ export function isForInitialize(o, p): "initializer" | "left-hand" | false {
       x.type == "ForInStatement" ||
       x.type == "ForOfStatement"
   );
+
+  if (
+    p
+      .slice(0, forIndex)
+      .find((x) =>
+        ["ArrowFunctionExpression", "BlockStatement"].includes(x.type)
+      )
+  ) {
+    return false;
+  }
+
   if (forIndex !== -1) {
     if (p[forIndex].type == "ForStatement") {
       if (p[forIndex].init == (p[forIndex - 1] || o)) {

package/test/code/ES6.src.js

@@ -73,3 +73,17 @@ for (var x of [3, 3, 5]) {
   sum += x;
 }
 expect(sum).toStrictEqual(11);
+
+// Variant #12 More complex for-loop initializer
+var outside = 12;
+for (
+  var myFunction = function () {
+    return outside;
+  };
+  false;
+
+) {}
+
+var TEST_OUTPUT = myFunction();
+
+expect(TEST_OUTPUT).toStrictEqual(12);

package/test/code/NewFeatures.test.ts

@@ -0,0 +1,19 @@
+import JsConfuser from "../../src/index";
+
+// https://github.com/MichaelXF/js-confuser/issues/79
+test("Variant #1: Support BigInt Literals (1n)", async () => {
+  var code = `
+  TEST_OUTPUT = 1n;
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    renameVariables: true,
+  });
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(typeof TEST_OUTPUT).toStrictEqual("bigint");
+  expect(TEST_OUTPUT).toStrictEqual(1n);
+});

package/test/index.test.ts

@@ -230,7 +230,19 @@ describe("debugObfuscation", () => {
       callback
     );
 
-    expect(typeof output).toStrictEqual("string");
+    expect(typeof output).toStrictEqual("object");
+    expect(typeof output.obfuscated).toStrictEqual("string");
+    expect(typeof output.obfuscationTime).toStrictEqual("number");
+    expect(typeof output.compileTime).toStrictEqual("number");
+    expect(typeof output.parseTime).toStrictEqual("number");
+    expect(typeof output.totalPossibleTransforms).toStrictEqual("number");
+    expect(typeof output.totalTransforms).toStrictEqual("number");
+    expect(typeof output.transformationTimes).toStrictEqual("object");
+    expect(typeof output.transformationTimes.RenameVariables).toStrictEqual(
+      "number"
+    );
+
+    eval(output.obfuscated);
     expect(called).toStrictEqual(true);
   });
 });

package/test/transforms/antiTooling.test.ts

@@ -0,0 +1,30 @@
+import JsConfuser from "../../src/index";
+
+// https://github.com/MichaelXF/js-confuser/issues/74
+test("Variant #1: Don't break Symbols", async () => {
+  if (typeof Symbol !== "undefined") {
+    for (var i = 0; i < 6; i++) {
+      var output = await JsConfuser(
+        `
+  
+      var sym1 = Symbol();
+    
+      if (true) {
+        sym1;
+        sym1;
+        sym1;
+      }
+  
+      TEST_OUTPUT = sym1;
+    
+      `,
+        { target: "node", renameVariables: true }
+      );
+
+      var TEST_OUTPUT;
+
+      eval(output);
+      expect(typeof TEST_OUTPUT).toStrictEqual("symbol");
+    }
+  }
+});

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

@@ -708,3 +708,25 @@ test("Variant #21: Don't move Import Declarations", async () => {
     "1cac63f39fd68d8c531f27b807610fb3d50f0fc3f186995767fb6316e7200a3e"
   );
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/81
+test("Variant #22: Don't break typeof expression", async () => {
+  var output = await JsConfuser(
+    `
+    TEST_OUTPUT = false;
+    if(typeof nonExistentVariable === "undefined") {
+      TEST_OUTPUT = true;
+    }
+    `,
+    {
+      target: "node",
+      controlFlowFlattening: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});

package/test/transforms/dispatcher.test.ts

@@ -330,3 +330,27 @@ it("should apply to every level of the code", async () => {
 
   expect(value).toStrictEqual(100);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/77
+it("should work with code that uses toString() function", async () => {
+  var output = await JsConfuser(
+    `
+  function myFunction(){
+    
+  }
+  
+  TEST_OUTPUT = toString();
+  `,
+    {
+      target: "node",
+      dispatcher: true,
+    }
+  );
+
+  var toString = () => "Correct Value";
+  var TEST_OUTPUT;
+
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

package/test/transforms/es5/antiClass.test.ts

@@ -392,3 +392,36 @@ it("should work with stringConcealing and hide method names", async () => {
 
   expect(TEST_VALUE).toStrictEqual(100);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/72
+it("should support class fields", async () => {
+  var output = await JsConfuser(
+    `
+  class MyClass {
+    myField = 1;
+    ["myComputedField"] = 2;
+    
+    static myStaticField = 3;
+    static ["myComputedStaticField"] = 4;
+  }
+
+  var myObject = new MyClass();
+  TEST_OUTPUT_1 = myObject.myField;
+  TEST_OUTPUT_2 = myObject.myComputedField;
+  TEST_OUTPUT_3 = MyClass.myStaticField;
+  TEST_OUTPUT_4 = MyClass.myComputedStaticField;
+  `,
+    {
+      target: "node",
+      es5: true,
+    }
+  );
+
+  var TEST_OUTPUT_1, TEST_OUTPUT_2, TEST_OUTPUT_3, TEST_OUTPUT_4;
+
+  eval(output);
+  expect(TEST_OUTPUT_1).toStrictEqual(1);
+  expect(TEST_OUTPUT_2).toStrictEqual(2);
+  expect(TEST_OUTPUT_3).toStrictEqual(3);
+  expect(TEST_OUTPUT_4).toStrictEqual(4);
+});

package/test/transforms/eval.test.ts

@@ -76,3 +76,56 @@ it("should work with Integrity also enabled", async () => {
 
   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");
+});

package/test/transforms/extraction/objectExtraction.test.ts

@@ -446,3 +446,24 @@ it("should not apply to objects with non-init properties (method, set, get)", as
   expect(output).toContain("TEST_OBJECT");
   expect(output).toContain("set ");
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/78
+it("should handle objects with spread elements", async () => {
+  var output = await JsConfuser(
+    `
+    var x = { firstName: "John", lastName: "Doe" }
+    var y = { ...x };
+
+    TEST_OUTPUT = y;
+`,
+    {
+      target: "node",
+      objectExtraction: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual({ firstName: "John", lastName: "Doe" });
+});

package/test/transforms/flatten.test.ts

@@ -4,7 +4,7 @@ it("should bring independent to the global level", async () => {
   var output = await JsConfuser.obfuscate(
     `
     function container(){
-      function nested(){
+      function nested(param){
 
       }
 
@@ -17,7 +17,8 @@ it("should bring independent to the global level", async () => {
     }
   );
 
-  expect(output).toContain("set");
+  // Ensure flatten was applied
+  expect(output).toContain("[param]");
 });
 
 it("should have correct return values", async () => {
@@ -255,7 +256,8 @@ it("should work when pattern-based assignment expressions are involved", async (
     }
   );
 
-  expect(output).toContain("set");
+  // Ensure flatten was applied
+  expect(output).toContain("[i],[]");
 
   var value = "never_called",
     input = (x) => (value = x);
@@ -263,3 +265,144 @@ it("should work when pattern-based assignment expressions are involved", async (
   eval(output);
   expect(value).toStrictEqual(1);
 });
+
+it("should work on async functions", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+    async function timeout(ms){
+      return await new Promise((resolve, reject)=>{
+        setTimeout(()=>{
+          resolve();
+        }, ms);
+      });
+    }
+
+    (async ()=>{
+      var startTime = Date.now();
+
+      await timeout(1000);
+
+      var endTime = Date.now();
+
+      var duration = endTime - startTime;
+
+      TEST_CALLBACK(duration);
+    })();
+    `,
+    {
+      target: "node",
+      flatten: true,
+    }
+  );
+
+  expect(output).toContain("_flat_timeout");
+
+  var wasCalled = false;
+  var TEST_CALLBACK = (time) => {
+    expect(time).toBeGreaterThan(500);
+    wasCalled = true;
+  };
+
+  eval(output);
+
+  setTimeout(() => {
+    expect(wasCalled).toStrictEqual(true);
+  }, 2000);
+});
+
+it("should work on Function Expressions", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+    var outsideVar = "Correct Value";
+
+    var myFunctionExpression = function(){
+      return outsideVar;
+    }
+
+    TEST_OUTPUT = myFunctionExpression();
+    `,
+    {
+      target: "node",
+      flatten: true,
+    }
+  );
+
+  // Ensure flatten applied
+  expect(output).toContain("_flat_myFunctionExpression");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+it("should work on Properties", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+    var outsideVar = "Incorrect Value";
+
+    var myObject = {
+      myInitProperty: function(){
+        return outsideVar;
+      },
+
+      myMethodProperty(){
+        return;
+      },
+
+      get myGetProperty(){
+        return;  
+      },
+
+      set mySetProperty(val){
+        outsideVar = val;
+      }
+    }
+
+    myObject.mySetProperty = "Correct Value";
+    TEST_OUTPUT = myObject.myInitProperty();
+    `,
+    {
+      target: "node",
+      flatten: true,
+    }
+  );
+
+  // Ensure flatten applied
+  expect(output).toContain("_flat_myInitProperty");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+it("should work with RGF enabled", async () => {
+  var output = await JsConfuser.obfuscate(
+    `
+  var outsideVar = "Correct Value";
+
+  function myFunction(){
+    return outsideVar;
+  }
+
+  TEST_OUTPUT = myFunction();
+  `,
+    {
+      target: "node",
+      flatten: true,
+      rgf: true,
+    }
+  );
+
+  // Ensure flatten applied
+  expect(output).toContain("_flat_myFunction");
+
+  // Ensure RGF applied
+  expect(output).toContain("new Function");
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

package/test/transforms/identifier/renameVariables.test.ts

@@ -474,3 +474,29 @@ test("Variant #19: Don't break Import Declarations", async () => {
     "1cac63f39fd68d8c531f27b807610fb3d50f0fc3f186995767fb6316e7200a3e"
   );
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/80
+test("Variant #20: Don't break code with var and let variables in same scope", async () => {
+  var output = await JsConfuser(
+    `
+  function log(param) {
+    let message = param;
+    var isWarning = false;
+    var isError = false;
+  
+    TEST_OUTPUT = message;
+  };
+
+  log("Correct Value");
+  `,
+    {
+      target: "node",
+      renameVariables: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

package/test/transforms/minify.test.ts

@@ -269,6 +269,7 @@ test("Variant #15: Removing implied 'return'", async () => {
   function MyFunction(){ 
     var output = "Hello World";
     console.log(output);
+    this; // Stop arrow function conversion
     return;
   } 
   
@@ -366,3 +367,68 @@ test("Variant #19: Remove unreachable code following a throw statement", async (
 
   expect(output).not.toContain("unreachableStmt");
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/76
+test("Variant #20: Properly handle objects with `, ^, [, ] as keys", async () => {
+  var output = await JsConfuser(
+    `
+  TEST_OBJECT = {
+    "\`": true,
+    "^": true,
+    "]": true,
+    "[": true
+  };
+  `,
+    {
+      target: "node",
+      minify: true,
+    }
+  );
+
+  var TEST_OBJECT;
+  eval(output);
+
+  expect(TEST_OBJECT).toStrictEqual({
+    "`": true,
+    "^": true,
+    "]": true,
+    "[": true,
+  });
+});
+
+// https://github.com/MichaelXF/js-confuser/issues/75
+test("Variant #21: Properly handle Object constructor (Function Declaration)", async () => {
+  var output = await JsConfuser(
+    `
+  function MyClass() {};
+
+  var myObject = new MyClass();
+
+  TEST_OUTPUT = myObject instanceof MyClass;
+  `,
+    { target: "node", minify: true }
+  );
+
+  var TEST_OUTPUT = false;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});
+
+test("Variant #22: Properly handle Object constructor (Function Expression)", async () => {
+  var output = await JsConfuser(
+    `
+  var MyClass = function() {};
+
+  var myObject = new MyClass();
+
+  TEST_OUTPUT = myObject instanceof MyClass;
+  `,
+    { target: "node", minify: true }
+  );
+
+  var TEST_OUTPUT = false;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});