js-confuser 1.4.1 → 1.5.0

package/src/transforms/calculator.ts

@@ -10,19 +10,27 @@ import {
   LogicalExpression,
   SwitchCase,
   SwitchStatement,
+  SequenceExpression,
+  AssignmentExpression,
+  VariableDeclaration,
+  VariableDeclarator,
+  ExpressionStatement,
 } from "../util/gen";
 import { prepend } from "../util/insert";
 import { getBlock } from "../traverse";
-import { getRandomInteger } from "../util/random";
+import { choice, getRandomInteger } from "../util/random";
 import { ObfuscateOrder } from "../order";
 import { ok } from "assert";
 import { OPERATOR_PRECEDENCE } from "../precedence";
+import Template from "../templates/template";
 
 export default class Calculator extends Transform {
   gen: any;
   ops: { [operator: string]: number };
   statesUsed: Set<string>;
   calculatorFn: string;
+  calculatorOpVar: string;
+  calculatorSetOpFn: string;
 
   constructor(o) {
     super(o, ObfuscateOrder.Calculator);
@@ -30,6 +38,8 @@ export default class Calculator extends Transform {
     this.ops = Object.create(null);
     this.statesUsed = new Set();
     this.calculatorFn = this.getPlaceholder();
+    this.calculatorOpVar = this.getPlaceholder();
+    this.calculatorSetOpFn = this.getPlaceholder();
 
     this.gen = this.getGenerator();
   }
@@ -41,7 +51,6 @@ export default class Calculator extends Transform {
       return;
     }
 
-    var opArg = this.getPlaceholder();
     var leftArg = this.getPlaceholder();
     var rightArg = this.getPlaceholder();
     var switchCases = [];
@@ -65,8 +74,21 @@ export default class Calculator extends Transform {
 
     var func = FunctionDeclaration(
       this.calculatorFn,
-      [opArg, leftArg, rightArg].map((x) => Identifier(x)),
-      [SwitchStatement(Identifier(opArg), switchCases)]
+      [leftArg, rightArg].map((x) => Identifier(x)),
+      [SwitchStatement(Identifier(this.calculatorOpVar), switchCases)]
+    );
+
+    prepend(
+      tree,
+      VariableDeclaration(VariableDeclarator(this.calculatorOpVar))
+    );
+
+    prepend(
+      tree,
+      Template(`function {name}(a){
+        a = {b} + ({b}=a, 0);
+        return a;
+      }`).single({ name: this.calculatorSetOpFn, b: this.calculatorOpVar })
     );
 
     prepend(tree, func);
@@ -123,9 +145,18 @@ export default class Calculator extends Transform {
       this.replace(
         object,
         CallExpression(Identifier(this.calculatorFn), [
-          Literal(this.ops[operator]),
           object.left,
           object.right,
+          choice([
+            AssignmentExpression(
+              "=",
+              Identifier(this.calculatorOpVar),
+              Literal(this.ops[operator])
+            ),
+            CallExpression(Identifier(this.calculatorSetOpFn), [
+              Literal(this.ops[operator]),
+            ]),
+          ]),
         ])
       );
     };

package/src/transforms/controlFlowFlattening/controlFlowFlattening.ts

@@ -18,7 +18,10 @@ import {
   IfStatement,
   LabeledStatement,
   Literal,
+  MemberExpression,
   Node,
+  ObjectExpression,
+  Property,
   ReturnStatement,
   SequenceExpression,
   SwitchCase,
@@ -234,7 +237,16 @@ export default class ControlFlowFlattening extends Transform {
 
       var resultVar = this.getPlaceholder();
       var argVar = this.getPlaceholder();
+      var testVar = this.getPlaceholder();
+      var stringBankVar = this.getPlaceholder();
+      var stringBank: { [strValue: string]: string } = Object.create(null);
+      var stringBankByLabels: { [label: string]: Set<string> } =
+        Object.create(null);
+      let stringBankGen = this.getGenerator();
+
+      var needsTestVar = false;
       var needsResultAndArgVar = false;
+      var needsStringBankVar = false;
       var fnToLabel: { [fnName: string]: string } = Object.create(null);
 
       fnNames.forEach((fnName) => {
@@ -269,6 +281,38 @@ export default class ControlFlowFlattening extends Transform {
             body: [...currentBody],
           });
 
+          walk(currentBody, [], (o, p) => {
+            if (
+              o.type == "Literal" &&
+              typeof o.value == "string" &&
+              !o.regex &&
+              Math.random() / (Object.keys(stringBank).length / 2 + 1) > 0.5
+            ) {
+              needsStringBankVar = true;
+              if (!stringBankByLabels[currentLabel]) {
+                stringBankByLabels[currentLabel] = new Set();
+              }
+
+              stringBankByLabels[currentLabel].add(o.value);
+
+              if (typeof stringBank[o.value] === "undefined") {
+                stringBank[o.value] = stringBankGen.generate();
+              }
+
+              return () => {
+                this.replaceIdentifierOrLiteral(
+                  o,
+                  MemberExpression(
+                    Identifier(stringBankVar),
+                    Literal(stringBank[o.value]),
+                    true
+                  ),
+                  p
+                );
+              };
+            }
+          });
+
           currentLabel = newLabel;
           currentBody = [];
         };
@@ -478,7 +522,21 @@ export default class ControlFlowFlattening extends Transform {
                 finishCurrentChunk(isPostTest ? bodyPath : testPath, testPath);
 
                 currentBody.push(
-                  IfStatement(control.test || Literal(true), [
+                  ExpressionStatement(
+                    AssignmentExpression(
+                      "=",
+                      Identifier(testVar),
+                      control.test || Literal(true)
+                    )
+                  )
+                );
+
+                needsTestVar = true;
+
+                finishCurrentChunk();
+
+                currentBody.push(
+                  IfStatement(Identifier(testVar), [
                     {
                       type: "GotoStatement",
                       label: bodyPath,
@@ -522,6 +580,16 @@ export default class ControlFlowFlattening extends Transform {
           ) {
             finishCurrentChunk();
 
+            currentBody.push(
+              ExpressionStatement(
+                AssignmentExpression("=", Identifier(testVar), stmt.test)
+              )
+            );
+
+            needsTestVar = true;
+
+            finishCurrentChunk();
+
             var hasAlternate = !!stmt.alternate;
             ok(!(hasAlternate && stmt.alternate.type !== "BlockStatement"));
 
@@ -530,7 +598,7 @@ export default class ControlFlowFlattening extends Transform {
             var afterPath = this.getPlaceholder();
 
             currentBody.push(
-              IfStatement(stmt.test, [
+              IfStatement(Identifier(testVar), [
                 {
                   type: "GotoStatement",
                   label: yesPath,
@@ -845,6 +913,7 @@ export default class ControlFlowFlattening extends Transform {
 
         var breaksInsertion = [];
         var staticStateValues = [...labelToStates[chunk.label]];
+        var potentialBranches = new Set<string>();
 
         chunk.body.forEach((stmt, stmtIndex) => {
           var addBreak = false;
@@ -894,6 +963,8 @@ export default class ControlFlowFlattening extends Transform {
                   );
                 }
 
+                potentialBranches.add(o.label);
+
                 var mutatingStateValues = [...labelToStates[chunk.label]];
                 var nextStateValues = labelToStates[o.label];
                 ok(nextStateValues, o.label);
@@ -930,6 +1001,29 @@ export default class ControlFlowFlattening extends Transform {
           chunk.body.splice(index + 1, 0, BreakStatement(switchLabel));
         });
 
+        for (var branch of Array.from(potentialBranches)) {
+          var strings = stringBankByLabels[branch];
+          if (strings) {
+            chunk.body.unshift(
+              ExpressionStatement(
+                SequenceExpression(
+                  Array.from(strings).map((strValue) => {
+                    return AssignmentExpression(
+                      "=",
+                      MemberExpression(
+                        Identifier(stringBankVar),
+                        Literal(stringBank[strValue]),
+                        true
+                      ),
+                      Literal(strValue)
+                    );
+                  })
+                )
+              )
+            );
+          }
+        }
+
         // var c = Identifier("undefined");
         // this.addComment(c, stateValues.join(", "));
         // transitionStatements.push(c);
@@ -975,11 +1069,34 @@ export default class ControlFlowFlattening extends Transform {
 
       var declarations = [];
 
+      if (needsTestVar) {
+        declarations.push(VariableDeclarator(testVar));
+      }
+
       if (needsResultAndArgVar) {
         declarations.push(VariableDeclarator(resultVar));
         declarations.push(VariableDeclarator(argVar));
       }
 
+      if (needsStringBankVar) {
+        declarations.push(
+          VariableDeclarator(
+            stringBankVar,
+            ObjectExpression(
+              stringBankByLabels[startLabel]
+                ? Array.from(stringBankByLabels[startLabel]).map((strValue) =>
+                    Property(
+                      Literal(stringBank[strValue]),
+                      Literal(strValue),
+                      false
+                    )
+                  )
+                : []
+            )
+          )
+        );
+      }
+
       declarations.push(
         ...stateVars.map((stateVar, i) => {
           return VariableDeclarator(stateVar, Literal(initStateValues[i]));

package/src/transforms/deadCode.ts

@@ -124,6 +124,108 @@ function setCookie(cname, cvalue, exdays) {
 
     __.match(s + g);
   `),
+  Template(`
+  function vec_pack(vec) {
+    return vec[1] * 67108864 + (vec[0] < 0 ? 33554432 | vec[0] : vec[0]);
+  }
+  
+  function vec_unpack(number) {
+    switch (((number & 33554432) !== 0) * 1 + (number < 0) * 2) {
+      case 0:
+        return [number % 33554432, Math.trunc(number / 67108864)];
+      case 1:
+        return [
+          (number % 33554432) - 33554432,
+          Math.trunc(number / 67108864) + 1,
+        ];
+      case 2:
+        return [
+          (((number + 33554432) % 33554432) + 33554432) % 33554432,
+          Math.round(number / 67108864),
+        ];
+      case 3:
+        return [number % 33554432, Math.trunc(number / 67108864)];
+    }
+  }
+  
+  let a = vec_pack([2, 4]);
+  let b = vec_pack([1, 2]);
+  
+  let c = a + b; // Vector addition
+  let d = c - b; // Vector subtraction
+  let e = d * 2; // Scalar multiplication
+  let f = e / 2; // Scalar division
+  
+  console.log(vec_unpack(c)); // [3, 6]
+  console.log(vec_unpack(d)); // [2, 4]
+  console.log(vec_unpack(e)); // [4, 8]
+  console.log(vec_unpack(f)); // [2, 4]
+  `),
+  Template(`
+  function buildCharacterMap(str) {
+    const characterMap = {};
+  
+    for (let char of str.replace(/[^\w]/g, "").toLowerCase())
+      characterMap[char] = characterMap[char] + 1 || 1;
+  
+    return characterMap;
+  }
+  
+  function isAnagrams(stringA, stringB) {
+    const stringAMap = buildCharMap(stringA);
+    const stringBMap = buildCharMap(stringB);
+  
+    for (let char in stringAMap) {
+      if (stringAMap[char] !== stringBMap[char]) {
+        return false;
+      }
+    }
+  
+    if (Object.keys(stringAMap).length !== Object.keys(stringBMap).length) {
+      return false;
+    }
+  
+    return true;
+  }
+  
+  /**
+   * @param {TreeNode} root
+   * @return {boolean}
+   */
+  function isBalanced(root) {
+    const height = getHeightBalanced(root);
+    return height !== Infinity;
+  }
+  
+  function getHeightBalanced(node) {
+    if (!node) {
+      return -1;
+    }
+  
+    const leftTreeHeight = getHeightBalanced(node.left);
+    const rightTreeHeight = getHeightBalanced(node.right);
+  
+    const heightDiff = Math.abs(leftTreeHeight - rightTreeHeight);
+  
+    if (
+      leftTreeHeight === Infinity ||
+      rightTreeHeight === Infinity ||
+      heightDiff > 1
+    ) {
+      return Infinity;
+    }
+  
+    const currentHeight = Math.max(leftTreeHeight, rightTreeHeight) + 1;
+    return currentHeight;
+  }
+  
+  window["__GLOBAL__HELPERS__"] = {
+    buildCharacterMap,
+    isAnagrams,
+    isBalanced,
+    getHeightBalanced,
+  };
+  `),
 ];
 
 /**

package/src/transforms/eval.ts

@@ -22,7 +22,8 @@ export default class Eval extends Transform {
     return (
       isFunction(object) &&
       object.type != "ArrowFunctionExpression" &&
-      !object.$eval
+      !object.$eval &&
+      !object.$dispatcherSkip
     );
   }
 

package/src/transforms/hexadecimalNumbers.ts

@@ -0,0 +1,31 @@
+import Transform from "./transform";
+import { ObfuscateOrder } from "../order";
+import { ExitCallback } from "../traverse";
+import { Identifier, Node } from "../util/gen";
+
+export default class HexadecimalNumbers extends Transform {
+  constructor(o) {
+    super(o, ObfuscateOrder.HexadecimalNumbers);
+  }
+
+  match(object: Node, parents: Node[]): boolean {
+    return (
+      object.type === "Literal" &&
+      typeof object.value === "number" &&
+      Math.floor(object.value) === object.value
+    );
+  }
+
+  transform(object: Node, parents: Node[]): void | ExitCallback {
+    return () => {
+      // Technically, a Literal will never be negative because it's supposed to be inside a UnaryExpression with a "-" operator.
+      // This code handles it regardless
+      var isNegative = object.value < 0;
+      var hex = Math.abs(object.value).toString(16);
+
+      var newStr = (isNegative ? "-" : "") + "0x" + hex;
+
+      this.replace(object, Identifier(newStr));
+    };
+  }
+}

package/src/transforms/minify.ts

@@ -21,6 +21,7 @@ import {
   clone,
   isForInitialize,
   isLexContext,
+  getFunction,
 } from "../util/insert";
 import { isValidIdentifier, isEquivalent } from "../util/compare";
 import { walk, isBlock } from "../traverse";
@@ -126,9 +127,14 @@ export default class Minify extends Transform {
           // Unnecessary return
           if (body.length && body[body.length - 1]) {
             var last = body[body.length - 1];
-            var isUndefined = last.argument == null;
-            if (last.type == "ReturnStatement" && isUndefined) {
-              body.pop();
+            if (last.type == "ReturnStatement") {
+              var isUndefined = last.argument == null;
+
+              if (isUndefined) {
+                if (getFunction(object, parents).body == object) {
+                  body.pop();
+                }
+              }
             }
           }
 

package/src/transforms/transform.ts

@@ -196,10 +196,18 @@ export default class Transform {
    */
   getGenerator(offset = 0) {
     var count = offset;
+    var identifiers = new Set();
     return {
       generate: () => {
-        count++;
-        return this.generateIdentifier(-1, count);
+        var retValue;
+        do {
+          count++;
+          retValue = this.generateIdentifier(-1, count);
+        } while (identifiers.has(retValue));
+
+        identifiers.add(retValue);
+
+        return retValue;
       },
     };
   }

package/test/transforms/eval.test.ts

@@ -48,3 +48,31 @@ it("should move function declarations to the top of the block", async () => {
 
   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");
+});

package/test/transforms/hexadecimalNumbers.test.ts

@@ -0,0 +1,62 @@
+import JsConfuser from "../../src/index";
+
+test("Variant #1: Positive integer to hexadecimal", async () => {
+  var output = await JsConfuser.obfuscate(`TEST_VAR = 10;`, {
+    target: "node",
+    hexadecimalNumbers: true,
+  });
+
+  expect(output).toContain("0xa");
+  expect(output).not.toContain("10");
+
+  var TEST_VAR;
+
+  eval(output);
+
+  expect(TEST_VAR).toStrictEqual(10);
+});
+
+test("Variant #2: Negative integer to hexadecimal", async () => {
+  var output = await JsConfuser.obfuscate(`TEST_VAR = -10;`, {
+    target: "node",
+    hexadecimalNumbers: true,
+  });
+
+  expect(output).toContain("-0xa");
+  expect(output).not.toContain("-10");
+
+  var TEST_VAR;
+
+  eval(output);
+
+  expect(TEST_VAR).toStrictEqual(-10);
+});
+
+test("Variant #3: Don't change floats", async () => {
+  var output = await JsConfuser.obfuscate(`var TEST_VAR = [15.5, -75.9];`, {
+    target: "node",
+    hexadecimalNumbers: true,
+  });
+
+  expect(output).toContain("15.5");
+  expect(output).toContain("-75.9");
+  expect(output).not.toContain("0x");
+});
+
+test("Variant #4: Work even on large numbers", async () => {
+  var output = await JsConfuser.obfuscate(
+    `TEST_VAR = 10000000000000000000000000000;`,
+    {
+      target: "node",
+      hexadecimalNumbers: true,
+    }
+  );
+
+  expect(output).toContain("0x204fce5e3e25020000000000");
+
+  var TEST_VAR;
+
+  eval(output);
+
+  expect(TEST_VAR).toStrictEqual(10000000000000000000000000000);
+});

package/test/transforms/minify.test.ts

@@ -261,3 +261,41 @@ test("Variant #14: Shorten 'var x = undefined' to 'var x'", async () => {
   expect(output).toContain("var x");
   expect(output).not.toContain("var x=");
 });
+
+test("Variant #15: Removing implied 'return'", async () => {
+  // Valid
+  var output = await JsConfuser(
+    `
+  function MyFunction(){ 
+    var output = "Hello World";
+    console.log(output);
+    return;
+  } 
+  
+  MyFunction();
+  `,
+    { target: "node", minify: true }
+  );
+
+  expect(output).not.toContain("return");
+
+  // Invalid
+  // https://github.com/MichaelXF/js-confuser/issues/34
+  var output2 = await JsConfuser(
+    `
+  function greet(){ 
+    if(true){ 
+      console.log("return"); 
+      return; 
+    }
+
+    var output = "should not show!"; console.log(output); 
+  } 
+  
+  greet();
+  `,
+    { target: "browser", minify: true }
+  );
+
+  expect(output2).toContain("return");
+});