js-confuser 1.7.2 → 1.7.3

package/src/transforms/string/stringCompression.ts

@@ -4,12 +4,18 @@ import { ComputeProbabilityMap } from "../../probability";
 import Template from "../../templates/template";
 import { isDirective, isModuleSource } from "../../util/compare";
 import {
+  AssignmentExpression,
+  BinaryExpression,
   CallExpression,
+  ExpressionStatement,
   FunctionDeclaration,
   FunctionExpression,
   Identifier,
+  IfStatement,
   Literal,
   MemberExpression,
+  ObjectExpression,
+  Property,
   ReturnStatement,
   VariableDeclaration,
   VariableDeclarator,
@@ -17,6 +23,14 @@ import {
 import { append, prepend } from "../../util/insert";
 import Transform from "../transform";
 import { predictableFunctionTag } from "../../constants";
+import {
+  chance,
+  choice,
+  getRandomFalseExpression,
+  getRandomInteger,
+  getRandomString,
+  splitIntoChunks,
+} from "../../util/random";
 
 function LZ_encode(c) {
   ok(c);
@@ -58,7 +72,7 @@ function LZ_decode(b) {
   return g.join("");
 }
 
-const DecodeTemplate = Template(
+const DecodeTemplate = new Template(
   `function {name}(b){
     var o,
     f,
@@ -141,15 +155,72 @@ export default class StringCompression extends Transform {
       )
     );
 
-    append(
-      tree,
-      FunctionDeclaration(
-        getStringName,
-        [],
-        [ReturnStatement(Literal(encoded))]
-      )
+    var keys = new Set<string>();
+    var keysToMake = getRandomInteger(4, 14);
+    for (var i = 0; i < keysToMake; i++) {
+      keys.add(getRandomString(getRandomInteger(4, 14)));
+    }
+
+    var objectExpression = ObjectExpression(
+      Array.from(keys).map((key) => {
+        return Property(Literal(key), getRandomFalseExpression(), true);
+      })
+    );
+
+    // Get string function
+    var getStringBody = [];
+    var splits = splitIntoChunks(
+      encoded,
+      Math.floor(encoded.length / getRandomInteger(3, 6))
+    );
+
+    getStringBody.push(
+      VariableDeclaration(VariableDeclarator("str", Literal(splits.shift())))
+    );
+
+    getStringBody.push(
+      VariableDeclaration(VariableDeclarator("objectToTest", objectExpression))
     );
 
+    const addIfStatement = (testingFor, literalValueToBeAppended) => {
+      getStringBody.push(
+        IfStatement(
+          BinaryExpression(
+            "in",
+            Literal(testingFor),
+            Identifier("objectToTest")
+          ),
+          [
+            ExpressionStatement(
+              AssignmentExpression(
+                "+=",
+                Identifier("str"),
+                Literal(literalValueToBeAppended)
+              )
+            ),
+          ]
+        )
+      );
+    };
+
+    for (const split of splits) {
+      if (chance(50)) {
+        var fakeKey;
+        do {
+          fakeKey = getRandomString(getRandomInteger(4, 14));
+        } while (keys.has(fakeKey) || fakeKey in {});
+
+        addIfStatement(fakeKey, getRandomString(split.length));
+      }
+
+      addIfStatement(choice(Array.from(keys)), split);
+    }
+
+    // Return computed string
+    getStringBody.push(ReturnStatement(Identifier("str")));
+
+    append(tree, FunctionDeclaration(getStringName, [], getStringBody));
+
     append(
       tree,
       FunctionDeclaration(
@@ -176,7 +247,8 @@ export default class StringCompression extends Transform {
       object.value &&
       object.value.length > 3 &&
       !isDirective(object, parents) &&
-      !isModuleSource(object, parents)
+      !isModuleSource(object, parents) &&
+      !parents.find((x) => x.$multiTransformSkip)
     );
   }
 

package/src/transforms/string/stringConcealing.ts

@@ -31,7 +31,10 @@ import {
   hasAllEncodings,
 } from "./encoding";
 import { ComputeProbabilityMap } from "../../probability";
-import { BufferToStringTemplate } from "../../templates/bufferToString";
+import {
+  BufferToStringTemplate,
+  createGetGlobalTemplate,
+} from "../../templates/bufferToString";
 import { criticalFunctionTag, predictableFunctionTag } from "../../constants";
 
 interface FunctionObject {
@@ -65,7 +68,7 @@ export default class StringConcealing extends Transform {
     super.apply(tree);
 
     // Pad array with useless strings
-    var dead = getRandomInteger(5, 15);
+    var dead = getRandomInteger(50, 200);
     for (var i = 0; i < dead; i++) {
       var str = getRandomString(getRandomInteger(5, 40));
       var fn = this.transform(Literal(str), [tree]);
@@ -83,6 +86,7 @@ export default class StringConcealing extends Transform {
       ...BufferToStringTemplate.compile({
         name: bufferToStringName,
         getGlobalFnName: this.getPlaceholder() + predictableFunctionTag,
+        GetGlobalTemplate: createGetGlobalTemplate(this, tree, []),
       })
     );
 
@@ -104,7 +108,7 @@ export default class StringConcealing extends Transform {
         })
       );
       // All these are fake and never ran
-      var ifStatements = Template(`if ( z == x ) {
+      var ifStatements = new Template(`if ( z == x ) {
           return y[${cacheName}[z]] = ${getterFnName}(x, y);
         }
         if ( y ) {
@@ -132,7 +136,7 @@ export default class StringConcealing extends Transform {
 
       // This one is always used
       ifStatements.push(
-        Template(`
+        new Template(`
       if ( x !== y ) {
         return b[x] || (b[x] = a(${this.arrayName}[x]))
       }
@@ -141,7 +145,7 @@ export default class StringConcealing extends Transform {
 
       shuffle(ifStatements);
 
-      var varDeclaration = Template(`
+      var varDeclaration = new Template(`
       var ${getterFnName} = (x, y, z, a, b)=>{
         if(typeof a === "undefined") {
           a = ${decodeFn}
@@ -173,7 +177,7 @@ export default class StringConcealing extends Transform {
       object.value.length >= 3 &&
       !isModuleSource(object, parents) &&
       !isDirective(object, parents) //&&
-      /*!parents.find((x) => x.$dispatcherSkip)*/
+      /*!parents.find((x) => x.$multiTransformSkip)*/
     );
   }
 

package/src/transforms/transform.ts

@@ -8,11 +8,12 @@ import {
 import {
   alphabeticalGenerator,
   choice,
+  createZeroWidthGenerator,
   getRandomInteger,
+  shuffle,
 } from "../util/random";
 import { ok } from "assert";
 import Obfuscator from "../obfuscator";
-import { ObfuscateOptions } from "../options";
 import { ComputeProbabilityMap } from "../probability";
 import {
   placeholderVariablePrefix,
@@ -20,8 +21,9 @@ import {
   reservedKeywords,
 } from "../constants";
 import { ObfuscateOrder } from "../order";
-import { ITemplate } from "../templates/template";
 import { prepend } from "../util/insert";
+import Lock from "./lock/lock";
+import Template from "../templates/template";
 
 /**
  * Base-class for all transformations.
@@ -68,7 +70,7 @@ export default class Transform {
   /**
    * The user's options.
    */
-  options: ObfuscateOptions;
+  options: Obfuscator["options"];
 
   /**
    * Only required for top-level transformations.
@@ -87,6 +89,8 @@ export default class Transform {
 
   initVariables = new Map<string, string>();
 
+  zeroWidthGenerator = createZeroWidthGenerator();
+
   constructor(obfuscator, priority: number = -1) {
     ok(obfuscator instanceof Obfuscator, "obfuscator should be an Obfuscator");
 
@@ -108,6 +112,32 @@ export default class Transform {
     );
   }
 
+  /**
+   * Gets the `Lock` transformation.
+   */
+  get lockTransform(): Lock {
+    var transform = this.obfuscator.transforms["Lock"] as Lock;
+
+    ok(transform, "Lock transform not created");
+
+    return transform;
+  }
+
+  /**
+   * Wraps the given name with the `__JS_CONFUSER_VAR__` function call.
+   *
+   * If `Rename Variables` is disabled, the name is returned as-is.
+   * @param name
+   * @returns
+   */
+  jsConfuserVar(name: string) {
+    if (!this.obfuscator.transforms["RenameVariables"]) {
+      return `"${name}"`;
+    }
+
+    return `__JS_CONFUSER_VAR__(${name})`;
+  }
+
   /**
    * Run an AST through the transformation (including `pre` and `post` transforms)
    * @param tree
@@ -286,49 +316,7 @@ export default class Transform {
               return "var_" + count;
 
             case "zeroWidth":
-              var keyWords = [
-                "if",
-                "in",
-                "for",
-                "let",
-                "new",
-                "try",
-                "var",
-                "case",
-                "else",
-                "null",
-                "break",
-                "catch",
-                "class",
-                "const",
-                "super",
-                "throw",
-                "while",
-                "yield",
-                "delete",
-                "export",
-                "import",
-                "public",
-                "return",
-                "switch",
-                "default",
-                "finally",
-                "private",
-                "continue",
-                "debugger",
-                "function",
-                "arguments",
-                "protected",
-                "instanceof",
-                "function",
-                "await",
-                "async",
-              ];
-
-              var safe = "\u200C".repeat(count + 1);
-
-              var base = choice(keyWords) + safe;
-              return base;
+              return this.zeroWidthGenerator.generate();
           }
 
           throw new Error("Invalid 'identifierGenerator' mode: " + mode);
@@ -345,7 +333,7 @@ export default class Transform {
     return identifier;
   }
 
-  createInitVariable = (value: ITemplate, parents: Node[]) => {
+  createInitVariable = (value: Template, parents: Node[]) => {
     var key = value.templates[0];
     if (this.initVariables.has(key)) {
       return this.initVariables.get(key);

package/src/types.ts

@@ -1,5 +1,6 @@
 import Obfuscator from "./obfuscator";
 import { ObfuscateOptions } from "./options";
+import Template from "./templates/template";
 import Transform from "./transforms/transform";
 
 /**
@@ -21,6 +22,7 @@ export interface IJsConfuser {
 
   Transform: typeof Transform;
   Obfuscator: typeof Obfuscator;
+  Template: typeof Template;
 }
 
 /**

package/src/util/guard.ts

@@ -1,3 +1,4 @@
+import { variableFunctionName } from "../constants";
 import { Node } from "./gen";
 
 export function isStringLiteral(node: Node) {
@@ -5,3 +6,12 @@ export function isStringLiteral(node: Node) {
     node.type === "Literal" && typeof node.value === "string" && !node.regex
   );
 }
+
+export function isJSConfuserVar(p: Node[]) {
+  return p.find(
+    (x) =>
+      x.type === "CallExpression" &&
+      x.callee.type === "Identifier" &&
+      x.callee.name == variableFunctionName
+  );
+}

package/src/util/random.ts

@@ -63,7 +63,7 @@ export function splitIntoChunks(str: string, size: number) {
   ok(Math.floor(size) === size, "size must be integer");
 
   const numChunks = Math.ceil(str.length / size);
-  const chunks = new Array(numChunks);
+  const chunks: string[] = new Array(numChunks);
 
   for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
     chunks[i] = str.substr(o, size);
@@ -139,3 +139,83 @@ export function alphabeticalGenerator(index: number) {
   }
   return name;
 }
+
+export function createZeroWidthGenerator() {
+  var keywords = [
+    "if",
+    "in",
+    "for",
+    "let",
+    "new",
+    "try",
+    "var",
+    "case",
+    "else",
+    "null",
+    "break",
+    "catch",
+    "class",
+    "const",
+    "super",
+    "throw",
+    "while",
+    "yield",
+    "delete",
+    "export",
+    "import",
+    "public",
+    "return",
+    "switch",
+    "default",
+    "finally",
+    "private",
+    "continue",
+    "debugger",
+    "function",
+    "arguments",
+    "protected",
+    "instanceof",
+    "await",
+    "async",
+
+    // new key words and other fun stuff :P
+    "NaN",
+    "undefined",
+    "true",
+    "false",
+    "typeof",
+    "this",
+    "static",
+    "void",
+    "of",
+  ];
+
+  var maxSize = 0;
+  var currentKeyWordsArray: string[] = [];
+
+  function generateArray() {
+    var result = keywords
+      .map(
+        (keyWord) =>
+          keyWord + "\u200C".repeat(Math.max(maxSize - keyWord.length, 1))
+      )
+      .filter((craftedVariableName) => craftedVariableName.length == maxSize);
+
+    if (!result.length) {
+      ++maxSize;
+      return generateArray();
+    }
+
+    return shuffle(result);
+  }
+
+  function getNextVariable(): string {
+    if (!currentKeyWordsArray.length) {
+      ++maxSize;
+      currentKeyWordsArray = generateArray();
+    }
+    return currentKeyWordsArray.pop();
+  }
+
+  return { generate: getNextVariable };
+}

package/test/code/Cash.test.ts

@@ -6,7 +6,7 @@ var CASH_JS = readFileSync(join(__dirname, "./Cash.src.js"), "utf-8");
 
 test("Variant #1: Cash.js on High Preset (Strict Mode)", async () => {
   var output = await JsConfuser(CASH_JS, {
-    target: "browser",
+    target: "node",
     preset: "high",
   });
 
@@ -33,6 +33,9 @@ test("Variant #1: Cash.js on High Preset (Strict Mode)", async () => {
   } as any;
   window.window = window;
   global.window = window;
+  for (var key in window) {
+    global[key] = window[key];
+  }
 
   try {
     eval(output);
@@ -47,3 +50,83 @@ test("Variant #1: Cash.js on High Preset (Strict Mode)", async () => {
 
   expect(window).toHaveProperty("cash");
 });
+
+test("Variant #2: Cash.js on High Preset + Integrity + Self Defending + RGF + Tamper Protection", async () => {
+  // Make the required document variables for initialization
+  var document = {
+    documentElement: {},
+    createElement: () => {
+      return { style: {} };
+    },
+  } as any as Document;
+  var window = {
+    document,
+    Array,
+    Object,
+    Symbol,
+    Number,
+    parseInt,
+    JSON,
+    setTimeout,
+    encodeURIComponent,
+    RegExp,
+    String,
+    $: false,
+  } as any;
+  window.window = window;
+  global.window = window;
+  for (var key in window) {
+    global[key] = window[key];
+  }
+
+  var output = await JsConfuser(CASH_JS, {
+    target: "node",
+    preset: "high",
+    rgf: true,
+    lock: {
+      integrity: true,
+      selfDefending: true,
+      tamperProtection: true,
+    },
+  });
+
+  try {
+    // new Function() runs in non-strict mode
+    new Function(output)();
+  } catch (e) {
+    var helperCode = `var document = {
+    documentElement: {},
+    createElement: () => {
+      return { style: {} };
+    },
+  };
+  var window = {
+    document,
+    Array,
+    Object,
+    Symbol,
+    Number,
+    parseInt,
+    JSON,
+    setTimeout,
+    encodeURIComponent,
+    RegExp,
+    String,
+    $: false,
+  };
+  window.window = window;
+  global.window = window;
+  for (var key in window) {
+    global[key] = window[key];
+  }`;
+
+    console.error(e);
+    writeFileSync("dev.output.js", helperCode + "\n" + output, {
+      encoding: "utf-8",
+    });
+
+    expect(true).toStrictEqual(false);
+  }
+
+  expect(window).toHaveProperty("cash");
+});

package/test/compare.test.ts

@@ -46,7 +46,7 @@ describe("isIndependent", () => {
   it("various cases", () => {
     expect(
       isIndependent(
-        Template(`({
+        new Template(`({
       x: 1,
       y: 2,
       z: 3,
@@ -57,7 +57,7 @@ describe("isIndependent", () => {
 
     expect(
       isIndependent(
-        Template(`({
+        new Template(`({
       x: 1,
       y: 2,
       z: [3,4,5,6,7,"My String",undefined,null,NaN],
@@ -68,7 +68,7 @@ describe("isIndependent", () => {
 
     expect(
       isIndependent(
-        Template(`({
+        new Template(`({
       x: 1,
       y: 2,
       z: 3,
@@ -80,7 +80,7 @@ describe("isIndependent", () => {
 
     expect(
       isIndependent(
-        Template(`({
+        new Template(`({
       x: 1,
       y: 2,
       z: 3,
@@ -92,7 +92,7 @@ describe("isIndependent", () => {
 
     expect(
       isIndependent(
-        Template(`([
+        new Template(`([
           {
             x: value
           }

package/test/options.test.ts

@@ -75,6 +75,24 @@ describe("options", () => {
 
     expect(output).not.toContain("TEST_VARIABLE");
   });
+
+  test("Variant #7: Error on invalid lock option", async () => {
+    expect(
+      JsConfuser(`var TEST_VARIABLE;`, {
+        target: "node",
+        lock: "invalid",
+      } as any)
+    ).rejects.toThrow();
+
+    expect(
+      JsConfuser(`var TEST_VARIABLE;`, {
+        target: "node",
+        lock: {
+          invalidProperty: true,
+        },
+      } as any)
+    ).rejects.toThrow();
+  });
 });
 
 describe("options.preserveFunctionLength", () => {