Merge pull request #65 from MichaelXF/dev

MichaelXF · web-flow · commit 2ec449ae1a3b · 2023-05-08T22:59:16.000-04:00
1.5.6
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,8 +1,26 @@
+# `1.5.6`
+Website changed and RGF fixes
+
+The website is back at a different domain now: [https://master--hungry-shannon-c1ce6b.netlify.app/](https://master--hungry-shannon-c1ce6b.netlify.app/)
+
+This update focuses on fixing RGF bugs
+
+- Fixed [#64](https://github.com/MichaelXF/js-confuser/issues/64)
+- - RGF to properly handle Arrow functions and function expressions
+
+- RGF will no longer change getter/setter methods
+
+- RGF will no longer change class methods
+
+- RGF now works when using `mangled` variable names
+
+- Minify will remove unreachable code following a Throw statement
+
 # `1.5.5`
 Updates
 
 - Fixed [#53](https://github.com/MichaelXF/js-confuser/issues/53)
-- - Shuffle to not use common varialbe names like `x`
+- - Shuffle to not use common variable names like `x`
 
 - Fixed [#60](https://github.com/MichaelXF/js-confuser/issues/60)
 - - Rename Variables to properly handle function parameters
@@ -447,7 +465,7 @@ Available now on NPM: https://www.npmjs.com/package/js-confuser
 # `1.1.7`
 Website is Live
 
-- [JsConfuser.com](https://jsconfuser.com) is live!
+- [https://master--hungry-shannon-c1ce6b.netlify.app/](https://master--hungry-shannon-c1ce6b.netlify.app/) is live!
 - Check out the [js-confuser-website](https://github.com/MichaelXF/js-confuser-website) repo for more info
 
 - **⚠️ Breaking change**: `Rename Globals` is now enabled by default
diff --git a/README.md b/README.md
@@ -1,8 +1,8 @@
 # JS Confuser
 
-JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_ to read. [Try the web version](https://jsconfuser.com).
+JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_ to read. [Try the web version](https://master--hungry-shannon-c1ce6b.netlify.app/).
 
-  [![NPM](https://img.shields.io/badge/NPM-%23000000.svg?style=for-the-badge&logo=npm&logoColor=white)](https://npmjs.com/package/js-confuser) [![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/MichaelXF/js-confuser) [![Netlify](https://img.shields.io/badge/netlify-%23000000.svg?style=for-the-badge&logo=netlify&logoColor=#00C7B7)](https://jsconfuser.com)
+  [![NPM](https://img.shields.io/badge/NPM-%23000000.svg?style=for-the-badge&logo=npm&logoColor=white)](https://npmjs.com/package/js-confuser) [![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/MichaelXF/js-confuser) [![Netlify](https://img.shields.io/badge/netlify-%23000000.svg?style=for-the-badge&logo=netlify&logoColor=#00C7B7)](https://master--hungry-shannon-c1ce6b.netlify.app/)
 
 ## Key features
 
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "js-confuser",
-  "version": "1.5.5",
+  "version": "1.5.6",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",
@@ -45,7 +45,7 @@
   "bugs": {
     "url": "https://github.com/MichaelXF/js-confuser/issues"
   },
-  "homepage": "https://jsconfuser.com",
+  "homepage": "https://master--hungry-shannon-c1ce6b.netlify.app/",
   "jest": {
     "coverageReporters": [
       "html"
diff --git a/src/transforms/flatten.ts b/src/transforms/flatten.ts
@@ -328,8 +328,8 @@ export default class Flatten extends Transform {
       var pop = CallExpression(
         MemberExpression(
           MemberExpression(Identifier(resultName), Identifier(propName), false),
-          Identifier("pop"),
-          false
+          Literal("pop"),
+          true
         ),
         []
       );
diff --git a/src/transforms/identifier/variableAnalysis.ts b/src/transforms/identifier/variableAnalysis.ts
@@ -93,10 +93,10 @@ export default class VariableAnalysis extends Transform {
         ok(definingContexts.length);
 
         definingContexts.forEach((definingContext) => {
-          ok(
-            isContext(definingContext),
-            `${definingContext.type} is not a context`
-          );
+          // ok(
+          //   isContext(definingContext),
+          //   `${definingContext.type} is not a context`
+          // );
 
           if (isDefined) {
             // Add to defined Map
diff --git a/src/transforms/minify.ts b/src/transforms/minify.ts
@@ -61,9 +61,10 @@ export default class Minify extends Transform {
 
         body.forEach((stmt, i) => {
           if (
-            stmt.type == "ReturnStatement" ||
-            stmt.type == "BreakStatement" ||
-            stmt.type == "ContinueStatement"
+            stmt.type === "ReturnStatement" ||
+            stmt.type === "BreakStatement" ||
+            stmt.type === "ContinueStatement" ||
+            stmt.type === "ThrowStatement"
           ) {
             if (earlyReturn > i + 1) {
               earlyReturn = i + 1;
@@ -156,7 +157,7 @@ export default class Minify extends Transform {
               ) {
                 lastDec = x;
               } else {
-                lastDec.declarations.push(...x.declarations);
+                lastDec.declarations.push(...clone(x.declarations));
                 remove.unshift(i);
               }
             } else {
diff --git a/src/transforms/rgf.ts b/src/transforms/rgf.ts
@@ -7,7 +7,10 @@ import Template from "../templates/template";
 import traverse, { walk } from "../traverse";
 import {
   ArrayExpression,
+  AssignmentExpression,
   CallExpression,
+  ConditionalExpression,
+  ExpressionStatement,
   FunctionExpression,
   Identifier,
   Literal,
@@ -28,6 +31,7 @@ import {
   isFunction,
   prepend,
 } from "../util/insert";
+import { getRandomString } from "../util/random";
 import Transform from "./transform";
 
 /**
@@ -70,6 +74,8 @@ export default class RGF extends Transform {
       }[] = [];
       var queue: Location[] = [];
       var names = new Map<string, number>();
+      var referenceSignatures: { [name: string]: string } = {};
+
       var definingNodes = new Map<string, Node>();
 
       walk(contextObject, contextParents, (object, parents) => {
@@ -81,6 +87,25 @@ export default class RGF extends Transform {
           !object.generator &&
           getVarContext(parents[0], parents.slice(1)) === contextObject
         ) {
+          // Discard getter/setter methods
+          if (parents[0].type === "Property" && parents[0].value === object) {
+            if (
+              parents[0].method ||
+              parents[0].kind === "get" ||
+              parents[0].kind === "set"
+            ) {
+              return;
+            }
+          }
+
+          // Discard class methods
+          if (
+            parents[0].type === "MethodDefinition" &&
+            parents[0].value === object
+          ) {
+            return;
+          }
+
           var defined = new Set<string>(),
             referenced = new Set<string>();
 
@@ -177,6 +202,8 @@ export default class RGF extends Transform {
             var index = names.size;
 
             names.set(object.id.name, index);
+            referenceSignatures[index] = getRandomString(10);
+
             definingNodes.set(object.id.name, object.id);
           }
         }
@@ -186,7 +213,8 @@ export default class RGF extends Transform {
         return;
       }
 
-      var referenceArray = this.generateIdentifier();
+      // An array containing all the function declarations
+      var referenceArray = "_" + getRandomString(10);
 
       walk(contextObject, contextParents, (o, p) => {
         if (o.type == "Identifier" && !reservedIdentifiers.has(o.name)) {
@@ -204,27 +232,50 @@ export default class RGF extends Transform {
                 if (pointingTo == shouldBe) {
                   this.log(o.name, "->", `${referenceArray}[${index}]`);
 
-                  this.replace(
-                    o,
-                    FunctionExpression(
-                      [],
-                      [
-                        ReturnStatement(
-                          CallExpression(
-                            MemberExpression(
-                              Identifier(referenceArray),
-                              Literal(index),
-                              true
-                            ),
-                            [
+                  var memberExpression = MemberExpression(
+                    Identifier(referenceArray),
+                    Literal(index),
+                    true
+                  );
+
+                  // Allow re-assignment to the RGF function
+                  if (
+                    p[0] &&
+                    p[0].type === "AssignmentExpression" &&
+                    p[0].left === o
+                  ) {
+                    // fn = ...
+
+                    this.replace(o, memberExpression);
+                  } else {
+                    // fn()
+                    // fn
+
+                    // In most cases the identifier is being used like this (call expression, or referenced to be called later)
+                    // Replace it with a simple wrapper function that will pass on the reference array
+
+                    var conditionalExpression = ConditionalExpression(
+                      Template(
+                        `typeof ${referenceArray}[${index}] === "function" && ${referenceArray}[${index}]["${
+                          referenceSignatures[index] || "_"
+                        }"]`
+                      ).single().expression,
+                      FunctionExpression(
+                        [],
+                        [
+                          ReturnStatement(
+                            CallExpression(memberExpression, [
                               Identifier(referenceArray),
                               SpreadElement(Identifier("arguments")),
-                            ]
-                          )
-                        ),
-                      ]
-                    )
-                  );
+                            ])
+                          ),
+                        ]
+                      ),
+                      memberExpression
+                    );
+
+                    this.replace(o, conditionalExpression);
+                  }
                 }
               }
             }
@@ -243,6 +294,7 @@ export default class RGF extends Transform {
         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();
 
@@ -280,11 +332,11 @@ export default class RGF extends Transform {
               CallExpression(
                 MemberExpression(
                   Identifier(embeddedName),
-                  Identifier("call"),
-                  false
+                  Literal("call"),
+                  true
                 ),
                 [
-                  ThisExpression(),
+                  Identifier("undefined"),
                   SpreadElement(
                     Template(
                       `Array.prototype.slice.call(arguments, 1)`
@@ -322,8 +374,38 @@ export default class RGF extends Transform {
           Literal(toString),
         ]);
 
-        if (hasName) {
-          arrayExpression.elements[names.get(name)] = newFunction;
+        function applySignature(fn) {
+          if (!signature) {
+            return fn;
+          }
+
+          // This code marks the function object with a unique property
+          return CallExpression(
+            FunctionExpression(
+              [],
+              [
+                VariableDeclaration(VariableDeclarator("fn", fn)),
+                ExpressionStatement(
+                  AssignmentExpression(
+                    "=",
+                    MemberExpression(
+                      Identifier("fn"),
+                      Literal(signature),
+                      true
+                    ),
+                    Literal(true)
+                  )
+                ),
+                ReturnStatement(Identifier("fn")),
+              ]
+            ),
+            []
+          );
+        }
+
+        if (object.type === "FunctionDeclaration") {
+          arrayExpression.elements[names.get(name)] =
+            applySignature(newFunction);
 
           if (Array.isArray(parents[0])) {
             parents[0].splice(parents[0].indexOf(object), 1);
@@ -336,7 +418,24 @@ export default class RGF extends Transform {
             );
           }
         } else {
-          this.replace(object, newFunction);
+          // The wrapper function passes the reference array around
+          var wrapperFunction = FunctionExpression(
+            [],
+            [
+              ReturnStatement(
+                CallExpression(
+                  MemberExpression(newFunction, Literal("call"), true),
+                  [
+                    Identifier("undefined"),
+                    Identifier(referenceArray),
+                    SpreadElement(Identifier("arguments")),
+                  ]
+                )
+              ),
+            ]
+          );
+
+          this.replace(object, applySignature(wrapperFunction));
         }
       });
     };
diff --git a/src/transforms/string/stringSplitting.ts b/src/transforms/string/stringSplitting.ts
@@ -25,34 +25,11 @@ export default class StringSplitting extends Transform {
     this.vars = [];
   }
 
-  apply(tree) {
-    super.apply(tree);
-
-    if (this.vars.length) {
-      shuffle(this.adders);
-      shuffle(this.vars);
-
-      var body: Node[] = tree.body;
-
-      this.adders.forEach((nodes) => {
-        nodes.forEach((x) => body.unshift(x));
-      });
-
-      var variableDeclaration = {
-        type: "VariableDeclaration",
-        declarations: [],
-        kind: "var",
-      };
-      this.vars.forEach((node) => variableDeclaration.declarations.push(node));
-
-      body.unshift(variableDeclaration);
-    }
-  }
-
   match(object: Node, parents: Node[]) {
     return (
       object.type == "Literal" &&
       typeof object.value === "string" &&
+      object.value.length >= 8 &&
       !isModuleSource(object, parents) &&
       !isDirective(object, parents)
     );
@@ -87,7 +64,6 @@ export default class StringSplitting extends Transform {
       var last = chunks.pop();
       chunks.forEach((chunk, i) => {
         if (i == 0) {
-          ok(i == 0);
           parent = binaryExpression = BinaryExpression(
             "+",
             Literal(chunk),
diff --git a/test/transforms/minify.test.ts b/test/transforms/minify.test.ts
diff --git a/test/transforms/rgf.test.ts b/test/transforms/rgf.test.ts
