js-confuser 1.5.8 → 1.5.9

package/src/transforms/flatten.ts

@@ -1,3 +1,4 @@
+import { ok } from "assert";
 import { reservedIdentifiers } from "../constants";
 import { ObfuscateOrder } from "../order";
 import traverse, { walk } from "../traverse";
@@ -24,6 +25,8 @@ import {
   IfStatement,
   ThrowStatement,
   NewExpression,
+  AwaitExpression,
+  UnaryExpression,
 } from "../util/gen";
 import { getIdentifierInfo } from "../util/identifiers";
 import {
@@ -46,20 +49,19 @@ import Transform from "./transform";
  *   return [ref1, ref2, refN, returnValue];
  * }
  * ```
+ *
+ * Flatten is used to make functions eligible for the RGF transformation.
  */
 export default class Flatten extends Transform {
   definedNames: Map<Node, Set<string>>;
-
-  flatMapName: string;
-  flatNode: Node;
-  gen: any;
+  flattenedFns: Node[];
+  gen: ReturnType<Transform["getGenerator"]>;
 
   constructor(o) {
     super(o, ObfuscateOrder.Flatten);
 
     this.definedNames = new Map();
-    this.flatMapName = null;
-    this.flatNode = null;
+    this.flattenedFns = [];
     this.gen = this.getGenerator();
   }
 
@@ -87,33 +89,64 @@ export default class Flatten extends Transform {
     });
 
     super.apply(tree);
+
+    if (this.flattenedFns.length) {
+      prepend(tree, VariableDeclaration(this.flattenedFns));
+    }
   }
 
   match(object: Node, parents: Node[]) {
     return (
-      object.type == "FunctionDeclaration" &&
+      (object.type == "FunctionDeclaration" ||
+        object.type === "FunctionExpression") &&
       object.body.type == "BlockStatement" &&
       !object.generator &&
-      !object.async &&
       !object.params.find((x) => x.type !== "Identifier")
     );
   }
 
   transform(object: Node, parents: Node[]) {
     return () => {
-      //
+      if (parents[0]) {
+        // Don't change class methods
+        if (
+          parents[0].type === "MethodDefinition" &&
+          parents[0].value === object
+        ) {
+          return;
+        }
 
-      if (
-        parents.find(
-          (x) =>
-            x.type == "ClassExpression" ||
-            x.type == "ClassDeclaration" ||
-            x.type == "MethodDefinition"
-        )
-      ) {
-        return;
+        // Don't change getter/setter methods
+        if (
+          parents[0].type === "Property" &&
+          parents[0].value === object &&
+          parents[0].kind !== "init"
+        ) {
+          return;
+        }
       }
 
+      ok(
+        object.type === "FunctionDeclaration" ||
+          object.type === "FunctionExpression"
+      );
+
+      // The name is purely for debugging purposes
+      var currentFnName =
+        object.type === "FunctionDeclaration"
+          ? object.id?.name
+          : parents[0]?.type === "VariableDeclarator" &&
+            parents[0].id?.type === "Identifier" &&
+            parents[0].id?.name;
+
+      if (parents[0]?.type === "Property" && parents[0]?.key) {
+        currentFnName =
+          currentFnName ||
+          String(parents[0]?.key?.name || parents[0]?.key?.value);
+      }
+
+      if (!currentFnName) currentFnName = "unnamed";
+
       var defined = new Set<string>();
       var references = new Set<string>();
       var modified = new Set<string>();
@@ -147,9 +180,7 @@ export default class Flatten extends Transform {
 
           if (o.hidden) {
             illegal.add(o.name);
-          }
-
-          if (info.spec.isDefined) {
+          } else if (info.spec.isDefined) {
             defined.add(o.name);
           } else if (info.spec.isModified) {
             modified.add(o.name);
@@ -198,9 +229,6 @@ export default class Flatten extends Transform {
         return;
       }
 
-      illegal.forEach((name) => {
-        defined.delete(name);
-      });
       defined.forEach((name) => {
         references.delete(name);
         modified.delete(name);
@@ -216,16 +244,35 @@ export default class Flatten extends Transform {
 
       var output = Array.from(modified);
 
-      var newName = this.gen.generate();
-      var valName = this.getPlaceholder();
+      var newName = this.getPlaceholder() + "_flat_" + currentFnName;
       var resultName = this.getPlaceholder();
       var propName = this.gen.generate();
 
+      var newOutputNames: { [originalName: string]: string } =
+        Object.create(null);
+      output.forEach((name) => {
+        newOutputNames[name] = this.gen.generate();
+      });
+      var returnOutputName = this.gen.generate();
+
       getBlockBody(object.body).push(ReturnStatement());
       walk(object.body, [object, ...parents], (o, p) => {
         return () => {
+          // Change return statements from
+          // return (argument)
+          // to
+          // return [ [modifiedRefs],  ]
           if (o.type == "ReturnStatement" && getVarContext(o, p) === object) {
-            var elements = output.map(Identifier);
+            var returnObject = ObjectExpression(
+              output.map((outputName) =>
+                Property(
+                  Literal(newOutputNames[outputName]),
+                  Identifier(outputName),
+                  true
+                )
+              )
+            );
+
             if (
               o.argument &&
               !(
@@ -233,11 +280,11 @@ export default class Flatten extends Transform {
                 o.argument.name == "undefined"
               )
             ) {
-              elements.unshift(clone(o.argument));
+              returnObject.properties.push(
+                Property(Literal(returnOutputName), clone(o.argument), true)
+              );
             }
 
-            o.argument = ArrayExpression(elements);
-
             o.argument = AssignmentExpression(
               "=",
               MemberExpression(
@@ -245,7 +292,7 @@ export default class Flatten extends Transform {
                 Identifier(propName),
                 false
               ),
-              o.argument
+              returnObject
             );
           }
         };
@@ -253,35 +300,12 @@ export default class Flatten extends Transform {
 
       var newBody = getBlockBody(object.body);
 
-      newBody.unshift(
-        VariableDeclaration(
-          VariableDeclarator(
-            ArrayPattern([
-              ArrayPattern(input.map(Identifier)),
-              ArrayPattern(clone(object.params)),
-              Identifier(resultName),
-            ]),
-
-            Identifier(valName)
-          )
-        )
-      );
-
-      if (!this.flatMapName) {
-        this.flatMapName = this.getPlaceholder();
-        prepend(
-          parents[parents.length - 1],
-          VariableDeclaration(
-            VariableDeclarator(
-              this.flatMapName,
-              (this.flatNode = ObjectExpression([]))
-            )
-          )
-        );
-      }
-
       var newFunctionExpression = FunctionExpression(
-        [Identifier(valName)],
+        [
+          ArrayPattern(input.map(Identifier)),
+          ArrayPattern(clone(object.params)),
+          Identifier(resultName),
+        ],
         newBody
       );
 
@@ -295,134 +319,163 @@ export default class Flatten extends Transform {
       );
       property.kind = "set";
 
-      this.flatNode.properties.push(property);
-
-      var identifier = MemberExpression(
-        Identifier(this.flatMapName),
-        Identifier(newName),
-        false
+      this.flattenedFns.push(
+        VariableDeclarator(newName, newFunctionExpression)
       );
 
       var newParamNodes = object.params.map(() =>
         Identifier(this.getPlaceholder())
       );
 
-      // var result = newFn.call([...refs], ...arguments)
-      var call = VariableDeclaration([
-        VariableDeclarator(resultName, ArrayExpression([])),
-        VariableDeclarator(
-          "_",
-          AssignmentExpression(
-            "=",
-            identifier,
-            ArrayExpression([
-              ArrayExpression(input.map(Identifier)),
-              ArrayExpression([...newParamNodes]),
-              Identifier(resultName),
-            ])
-          )
-        ),
-      ]);
-
       // result.pop()
-      var pop = CallExpression(
+      var getOutputMemberExpression = (outputName) =>
         MemberExpression(
-          MemberExpression(Identifier(resultName), Identifier(propName), false),
-          Literal("pop"),
+          MemberExpression(Identifier(resultName), Literal(propName), true),
+          Literal(outputName),
           true
-        ),
-        []
-      );
+        );
 
-      // var result = newFn.call([...refs], ...arguments)
-      // modified1 = result.pop();
-      // modified2 = result.pop();
-      // ...modifiedN = result.pop();...
-      //
-      // return result.pop()
+      // newFn.call([...refs], ...arguments, resultObject)
+      var callExpression = CallExpression(Identifier(newName), [
+        ArrayExpression(input.map(Identifier)),
+        ArrayExpression([...newParamNodes]),
+        Identifier(resultName),
+      ]);
+
+      var newObjectBody: Node[] = [
+        // var resultObject = {};
+        VariableDeclaration([
+          VariableDeclarator(resultName, ObjectExpression([])),
+        ]),
+
+        ExpressionStatement(
+          newFunctionExpression.async
+            ? AwaitExpression(callExpression)
+            : callExpression
+        ),
+      ];
 
-      var newObjectBody: Node[] = [call];
       var outputReversed = [...output].reverse();
 
+      // realVar
+      outputReversed.forEach((outputName) => {
+        newObjectBody.push(
+          ExpressionStatement(
+            AssignmentExpression(
+              "=",
+              Identifier(outputName),
+              getOutputMemberExpression(newOutputNames[outputName])
+            )
+          )
+        );
+      });
+
       // DECOY STATEMENTS
       var decoyKey = this.gen.generate();
       var decoyNodes = [
+        // if (result.random) throw result.prop.random
         IfStatement(
           MemberExpression(
             Identifier(resultName),
-            Identifier(this.gen.generate()),
-            false
+            Literal(this.gen.generate()),
+            true
           ),
           [
             ThrowStatement(
               NewExpression(Identifier("Error"), [
-                Literal(this.getPlaceholder()),
+                getOutputMemberExpression(this.gen.generate()),
               ])
             ),
           ]
         ),
+        // if (result.random) return true;
         IfStatement(
           MemberExpression(
             Identifier(resultName),
-            Identifier(this.gen.generate()),
-            false
+            Literal(this.gen.generate()),
+            true
           ),
-          [ReturnStatement(Identifier(resultName))]
+          [ReturnStatement(Literal(true))]
         ),
+        // if (result.random) return result;
         IfStatement(
           MemberExpression(
             Identifier(resultName),
-            Identifier(this.gen.generate()),
-            false
+            Literal(this.gen.generate()),
+            true
           ),
           [ReturnStatement(Identifier(resultName))]
         ),
+        // if (result.random) return result.random;
         IfStatement(
-          MemberExpression(Identifier(resultName), Identifier(decoyKey), false),
+          MemberExpression(Identifier(resultName), Literal(decoyKey), true),
           [
             ReturnStatement(
-              MemberExpression(
-                Identifier(resultName),
-                Identifier(decoyKey),
-                false
-              )
+              MemberExpression(Identifier(resultName), Literal(decoyKey), true)
             ),
           ]
         ),
+        // if(result.random1) return result.random2;
         IfStatement(
           MemberExpression(
             Identifier(resultName),
-            Identifier(this.gen.generate()),
-            false
+            Literal(this.gen.generate()),
+            true
           ),
           [
             ReturnStatement(
               MemberExpression(
                 Identifier(resultName),
-                Identifier(this.gen.generate()),
-                false
+                Literal(this.gen.generate()),
+                true
               )
             ),
           ]
         ),
-      ];
+        // if(result.random) return flatFn;
+        IfStatement(
+          MemberExpression(
+            Identifier(resultName),
+            Literal(this.gen.generate()),
+            true
+          ),
+          [ReturnStatement(Identifier(newName))]
+        ),
+        // if(result.random) flatFn = undefined;
+        IfStatement(
+          MemberExpression(
+            Identifier(resultName),
+            Literal(this.gen.generate()),
+            true
+          ),
+          [
+            ExpressionStatement(
+              AssignmentExpression(
+                "=",
+                Identifier(newName),
+                Identifier("undefined")
+              )
+            ),
+          ]
+        ),
+        // if(!result) return;
+        IfStatement(UnaryExpression("!", Identifier(resultName)), [
+          ReturnStatement(),
+        ]),
+      ].filter(() => Math.random() > 0.25);
+
+      // if (result.output) return result.output.returnValue;
+      // this is the real return statement, it is always added
+      decoyNodes.push(
+        IfStatement(
+          MemberExpression(Identifier(resultName), Literal(propName), true),
+          [ReturnStatement(getOutputMemberExpression(returnOutputName))]
+        )
+      );
 
       shuffle(decoyNodes);
-      decoyNodes.forEach((decoyNode) => {
-        if (Math.random() < 0.5) {
-          newObjectBody.push(decoyNode);
-        }
-      });
 
-      newObjectBody.push(
-        ...outputReversed.map((name) => {
-          return ExpressionStatement(
-            AssignmentExpression("=", Identifier(name), clone(pop))
-          );
-        }),
-
-        ReturnStatement(clone(pop))
-      );
+      newObjectBody.push(...decoyNodes);
 
       object.body = BlockStatement(newObjectBody);
 

package/src/transforms/hexadecimalNumbers.ts

@@ -3,12 +3,19 @@ import { ObfuscateOrder } from "../order";
 import { ExitCallback } from "../traverse";
 import { Identifier, Node } from "../util/gen";
 
+/**
+ * The HexadecimalNumbers transformation converts number literals into the hexadecimal form.
+ *
+ * This is done by replacing the number literal with an Identifier to ensure escodegen properly outputs it as such
+ *
+ * This transformation also handles BigInt support, so its always enabled for this reason.
+ */
 export default class HexadecimalNumbers extends Transform {
   constructor(o) {
     super(o, ObfuscateOrder.HexadecimalNumbers);
   }
 
-  match(object: Node, parents: Node[]): boolean {
+  isNumberLiteral(object: Node) {
     return (
       object.type === "Literal" &&
       typeof object.value === "number" &&
@@ -16,16 +23,37 @@ export default class HexadecimalNumbers extends Transform {
     );
   }
 
+  isBigIntLiteral(object: Node) {
+    return object.type === "Literal" && typeof object.value === "bigint";
+  }
+
+  match(object: Node, parents: Node[]): boolean {
+    return (
+      (this.options.hexadecimalNumbers && this.isNumberLiteral(object)) ||
+      this.isBigIntLiteral(object)
+    );
+  }
+
   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);
+    if (this.isNumberLiteral(object)) {
+      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;
 
-      var newStr = (isNegative ? "-" : "") + "0x" + hex;
+        this.replace(object, Identifier(newStr));
+      };
+    }
 
-      this.replace(object, Identifier(newStr));
-    };
+    // https://github.com/MichaelXF/js-confuser/issues/79
+    if (this.isBigIntLiteral(object)) {
+      return () => {
+        // Use an Identifier with the raw string
+        this.replace(object, Identifier(object.raw));
+      };
+    }
   }
 }

package/src/transforms/identifier/movedDeclarations.ts

@@ -46,7 +46,7 @@ export default class MovedDeclarations extends Transform {
 
       walk(object, parents, (o, p) => {
         if (o.type == "Identifier") {
-          if (getLexicalScope(o, p) !== object) {
+          if (o.hidden || getLexicalScope(o, p) !== object) {
             illegal.add(o.name);
           } else {
             var info = getIdentifierInfo(o, p);

package/src/transforms/minify.ts

@@ -15,6 +15,7 @@ import {
   AssignmentExpression,
   VariableDeclarator,
   Identifier,
+  CallExpression,
 } from "../util/gen";
 import {
   getBlockBody,
@@ -22,11 +23,14 @@ import {
   isForInitialize,
   isLexContext,
   getFunction,
+  prepend,
+  append,
 } from "../util/insert";
 import { isValidIdentifier, isEquivalent } from "../util/compare";
 import { walk, isBlock } from "../traverse";
 import { ok } from "assert";
 import { isLexicalScope } from "../util/scope";
+import Template from "../templates/template";
 
 /**
  * Basic transformations to reduce code size.
@@ -37,12 +41,13 @@ import { isLexicalScope } from "../util/scope";
  * - `x['y']` **->** `x.y`
  */
 export default class Minify extends Transform {
-  variables: Map<Node, Location[]>;
+  /**
+   * A helper function that is introduced preserve function semantics
+   */
+  arrowFunctionName: string;
 
   constructor(o) {
     super(o, ObfuscateOrder.Minify);
-
-    this.variables = new Map();
   }
 
   match(object: Node, parents: Node[]) {
@@ -239,17 +244,42 @@ export default class Minify extends Transform {
         });
 
         if (canTransform) {
+          if (!this.arrowFunctionName) {
+            this.arrowFunctionName = this.getPlaceholder();
+
+            append(
+              parents[parents.length - 1] || object,
+              Template(`
+            function ${this.arrowFunctionName}(arrowFn){
+              return function(){ return arrowFn(...arguments) }
+            }
+            `).single()
+            );
+          }
+
+          const wrap = (object: Node) => {
+            return CallExpression(Identifier(this.arrowFunctionName), [
+              clone(object),
+            ]);
+          };
+
           if (object.type == "FunctionExpression") {
             object.type = "ArrowFunctionExpression";
+
+            this.replace(object, wrap(clone(object)));
           } else {
             var arrow = { ...clone(object), type: "ArrowFunctionExpression" };
             this.replace(
               object,
-              VariableDeclaration(VariableDeclarator(object.id.name, arrow))
+              VariableDeclaration(
+                VariableDeclarator(object.id.name, wrap(arrow))
+              )
             );
 
             var x = this.transform(arrow, []);
-            x();
+            if (typeof x === "function") {
+              x();
+            }
           }
         }
       };
@@ -442,6 +472,8 @@ export default class Minify extends Transform {
         }
 
         if (
+          object.consequent &&
+          object.consequent.body &&
           object.consequent.body.length == 1 &&
           object.alternate &&
           object.alternate.body.length == 1

package/src/transforms/rgf.ts

@@ -31,6 +31,7 @@ import {
   isFunction,
   prepend,
   getDefiningContext,
+  clone,
 } from "../util/insert";
 import { getRandomString } from "../util/random";
 import Transform from "./transform";
@@ -300,7 +301,8 @@ export default class RGF extends Transform {
                         [],
                         [
                           ReturnStatement(
-                            CallExpression(memberExpression, [
+                            // clone() is required!
+                            CallExpression(clone(memberExpression), [
                               Identifier(referenceArray),
                               SpreadElement(Identifier("arguments")),
                             ])
@@ -328,8 +330,6 @@ export default class RGF extends Transform {
 
       queue.forEach(([object, parents]) => {
         var name = object?.id?.name;
-        var hasName = !!name;
-        var params = object.params.map((x) => x.name) || [];
         var signature = referenceSignatures[names.get(name)];
 
         var embeddedName = name || this.getPlaceholder();
@@ -349,6 +349,7 @@ export default class RGF extends Transform {
           },
           eval: false,
           hideInitializingCode: false,
+          stringEncoding: false,
         });
         var transforms = Object.values(obfuscator.transforms).filter(
           (x) => x.priority > this.priority

package/src/transforms/stack.ts

@@ -55,7 +55,9 @@ export default class Stack extends Transform {
     return () => {
       // Uncaught SyntaxError: Getter must not have any formal parameters.
       // Uncaught SyntaxError: Setter must have exactly one formal parameter
-      var propIndex = parents.findIndex((x) => x.type == "Property");
+      var propIndex = parents.findIndex(
+        (x) => x.type === "Property" || x.type === "MethodDefinition"
+      );
       if (propIndex !== -1) {
         if (parents[propIndex].value === (parents[propIndex - 1] || object)) {
           if (parents[propIndex].kind !== "init" || parents[propIndex].method) {