Merge branch 'modules-proxy-patches' into immediate-finds-modules-proxy

scripts/generateReport.ts

@@ -465,6 +465,12 @@ async function runtime(token: string) {
             }
         }));
 
+        // Call the getter for all the values in the modules object
+        // So modules that were not required get patched by our proxy
+        for (const id in wreq!.m) {
+            wreq!.m[id];
+        }
+
         console.log("[PUP_DEBUG]", "Finished loading all chunks!");
 
         for (const patch of Vencord.Plugins.patches) {

src/utils/constants.ts

@@ -16,7 +16,6 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-export const WEBPACK_CHUNK = "webpackChunkdiscord_app";
 export const REACT_GLOBAL = "Vencord.Webpack.Common.React";
 export const SUPPORT_CHANNEL_ID = "1026515880080842772";
 

src/utils/lazy.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
+import { UNCONFIGURABLE_PROPERTIES } from "./misc";
 import { AnyObject } from "./types";
 
 export type ProxyLazy<T = AnyObject> = T & {
@@ -35,23 +36,19 @@ export function makeLazy<T>(factory: () => T, attempts = 5, { isIndirect = false
     return getter;
 }
 
-// Proxies demand that these properties be unmodified, so proxyLazy
-// will always return the function default for them.
-const unconfigurable = ["arguments", "caller", "prototype"];
-
 const handler: ProxyHandler<any> = {
     ...Object.fromEntries(Object.getOwnPropertyNames(Reflect).map(propName =>
         [propName, (target: any, ...args: any[]) => Reflect[propName](target[proxyLazyGet](), ...args)]
     )),
     ownKeys: target => {
         const keys = Reflect.ownKeys(target[proxyLazyGet]());
-        for (const key of unconfigurable) {
+        for (const key of UNCONFIGURABLE_PROPERTIES) {
             if (!keys.includes(key)) keys.push(key);
         }
         return keys;
     },
     getOwnPropertyDescriptor: (target, p) => {
-        if (typeof p === "string" && unconfigurable.includes(p))
+        if (typeof p === "string" && UNCONFIGURABLE_PROPERTIES.includes(p))
             return Reflect.getOwnPropertyDescriptor(target, p);
 
         const descriptor = Reflect.getOwnPropertyDescriptor(target[proxyLazyGet](), p);

src/utils/misc.tsx

@@ -99,3 +99,6 @@ export const isPluginDev = (id: string) => Object.hasOwn(DevsById, id);
 export function pluralise(amount: number, singular: string, plural = singular + "s") {
     return amount === 1 ? `${amount} ${singular}` : `${amount} ${plural}`;
 }
+
+/** Unconfigurable properties for proxies */
+export const UNCONFIGURABLE_PROPERTIES = ["arguments", "caller", "prototype"];

src/utils/proxyInner.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
+import { UNCONFIGURABLE_PROPERTIES } from "./misc";
 import { AnyObject } from "./types";
 
 export type ProxyInner<T = AnyObject> = T & {
@@ -14,23 +15,19 @@ export type ProxyInner<T = AnyObject> = T & {
 export const proxyInnerGet = Symbol.for("vencord.proxyInner.get");
 export const proxyInnerValue = Symbol.for("vencord.proxyInner.innerValue");
 
-// Proxies demand that these properties be unmodified, so proxyInner
-// will always return the function default for them.
-const unconfigurable = ["arguments", "caller", "prototype"];
-
 const handler: ProxyHandler<any> = {
     ...Object.fromEntries(Object.getOwnPropertyNames(Reflect).map(propName =>
         [propName, (target: any, ...args: any[]) => Reflect[propName](target[proxyInnerGet](), ...args)]
     )),
     ownKeys: target => {
         const keys = Reflect.ownKeys(target[proxyInnerGet]());
-        for (const key of unconfigurable) {
+        for (const key of UNCONFIGURABLE_PROPERTIES) {
             if (!keys.includes(key)) keys.push(key);
         }
         return keys;
     },
     getOwnPropertyDescriptor: (target, p) => {
-        if (typeof p === "string" && unconfigurable.includes(p))
+        if (typeof p === "string" && UNCONFIGURABLE_PROPERTIES.includes(p))
             return Reflect.getOwnPropertyDescriptor(target, p);
 
         const descriptor = Reflect.getOwnPropertyDescriptor(target[proxyInnerGet](), p);

src/webpack/patchWebpack.ts

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-import { WEBPACK_CHUNK } from "@utils/constants";
 import { Logger } from "@utils/Logger";
+import { UNCONFIGURABLE_PROPERTIES } from "@utils/misc";
 import { canonicalizeMatch, canonicalizeReplacement } from "@utils/patches";
 import { PatchReplacement } from "@utils/types";
 import { WebpackInstance } from "discord-types/other";
@@ -17,29 +17,30 @@ import { _initWebpack, beforeInitListeners, factoryListeners, moduleListeners, w
 const logger = new Logger("WebpackInterceptor", "#8caaee");
 const initCallbackRegex = canonicalizeMatch(/{return \i\(".+?"\)}/);
 
-let webpackChunk: any[];
+const modulesProxyhandler: ProxyHandler<any> = {
+    ...Object.fromEntries(Object.getOwnPropertyNames(Reflect).map(propName =>
+        [propName, (target: any, ...args: any[]) => Reflect[propName](target, ...args)]
+    )),
+    get: (target, p: string) => {
+        const mod = Reflect.get(target, p);
 
-// Patch the window webpack chunk setter to monkey patch the push method before any chunks are pushed
+        // If the property is not a module id, return the value of it without trying to patch
-// This way we can patch the factory of everything being pushed to the modules array
+        if (mod == null || mod.$$vencordOriginal != null || Number.isNaN(Number(p))) return mod;
-Object.defineProperty(window, WEBPACK_CHUNK, {
-    configurable: true,
 
-    get: () => webpackChunk,
+        const patchedMod = patchFactory(p, mod);
-    set: v => {
+        Reflect.set(target, p, patchedMod);
-        if (v?.push) {
-            if (!v.push.$$vencordOriginal) {
-                logger.info(`Patching ${WEBPACK_CHUNK}.push`);
-                patchPush(v);
 
-                // @ts-ignore
+        return patchedMod;
-                delete window[WEBPACK_CHUNK];
+    },
-                window[WEBPACK_CHUNK] = v;
+    set: (target, p, newValue) => Reflect.set(target, p, newValue),
+    ownKeys: target => {
+        const keys = Reflect.ownKeys(target);
+        for (const key of UNCONFIGURABLE_PROPERTIES) {
+            if (!keys.includes(key)) keys.push(key);
         }
+        return keys;
     }
-
+};
-        webpackChunk = v;
-    }
-});
 
 // wreq.O is the webpack onChunksLoaded function
 // Discord uses it to await for all the chunks to be loaded before initializing the app
@@ -96,141 +97,51 @@ Object.defineProperty(Function.prototype, "O", {
     }
 });
 
-// wreq.m is the webpack module factory.
+// wreq.m is the webpack object containing module factories.
-// normally, this is populated via webpackGlobal.push, which we patch below.
+// This is pre-populated with modules, and is also populated via webpackGlobal.push
-// However, Discord has their .m prepopulated.
+// We replace its prototype with our proxy, which is responsible for returning patched module factories containing our patches
-// Thus, we use this hack to immediately access their wreq.m and patch all already existing factories
-//
-// Update: Discord now has TWO webpack instances. Their normal one and sentry
-// Sentry does not push chunks to the global at all, so this same patch now also handles their sentry modules
 Object.defineProperty(Function.prototype, "m", {
     configurable: true,
 
-    set(v: any) {
+    set(originalModules: any) {
         // When using react devtools or other extensions, we may also catch their webpack here.
         // This ensures we actually got the right one
         const { stack } = new Error();
         if (stack?.includes("discord.com") || stack?.includes("discordapp.com")) {
             logger.info("Found Webpack module factory", stack.match(/\/assets\/(.+?\.js)/)?.[1] ?? "");
-            patchFactories(v);
+
+            // The new object which will contain the factories
+            const modules = Object.assign({}, originalModules);
+
+            // Clear the original object so pre-populated factories are patched
+            for (const propName in originalModules) {
+                delete originalModules[propName];
+            }
+
+            Object.setPrototypeOf(originalModules, new Proxy(modules, modulesProxyhandler));
         }
 
         Object.defineProperty(this, "m", {
-            value: v,
+            value: originalModules,
             configurable: true
         });
     }
 });
 
-function patchPush(webpackGlobal: any) {
-    function handlePush(chunk: any) {
-        try {
-            patchFactories(chunk[1]);
-        } catch (err) {
-            logger.error("Error in handlePush", err);
-        }
-
-        return handlePush.$$vencordOriginal.call(webpackGlobal, chunk);
-    }
-
-    handlePush.$$vencordOriginal = webpackGlobal.push;
-    handlePush.toString = handlePush.$$vencordOriginal.toString.bind(handlePush.$$vencordOriginal);
-    // Webpack overwrites .push with its own push like so: `d.push = n.bind(null, d.push.bind(d));`
-    // it wraps the old push (`d.push.bind(d)`). this old push is in this case our handlePush.
-    // If we then repatched the new push, we would end up with recursive patching, which leads to our patches
-    // being applied multiple times.
-    // Thus, override bind to use the original push
-    handlePush.bind = (...args: unknown[]) => handlePush.$$vencordOriginal.bind(...args);
-
-    Object.defineProperty(webpackGlobal, "push", {
-        configurable: true,
-
-        get: () => handlePush,
-        set(v) {
-            handlePush.$$vencordOriginal = v;
-        }
-    });
-}
-
 let webpackNotInitializedLogged = false;
 
-function patchFactories(factories: Record<string, (module: any, exports: any, require: WebpackInstance) => void>) {
+function patchFactory(id: string, mod: (module: any, exports: any, require: WebpackInstance) => void) {
-    for (const id in factories) {
-        let mod = factories[id];
-
-        const originalMod = mod;
-        const patchedBy = new Set();
-
-        const factory = factories[id] = function (module: any, exports: any, require: WebpackInstance) {
-            if (wreq == null && IS_DEV) {
-                if (!webpackNotInitializedLogged) {
-                    webpackNotInitializedLogged = true;
-                    logger.error("WebpackRequire was not initialized, running modules without patches instead.");
-                }
-
-                return void originalMod(module, exports, require);
-            }
-
-            try {
-                mod(module, exports, require);
-            } catch (err) {
-                // Just rethrow discord errors
-                if (mod === originalMod) throw err;
-
-                logger.error("Error in patched module", err);
-                return void originalMod(module, exports, require);
-            }
-
-            exports = module.exports;
-
-            if (!exports) return;
-
-            // There are (at the time of writing) 11 modules exporting the window
-            // Make these non enumerable to improve webpack search performance
-            if (exports === window && require.c) {
-                Object.defineProperty(require.c, id, {
-                    value: require.c[id],
-                    enumerable: false,
-                    configurable: true,
-                    writable: true
-                });
-                return;
-            }
-
-            for (const callback of moduleListeners) {
-                try {
-                    callback(exports, id);
-                } catch (err) {
-                    logger.error("Error in Webpack module listener:\n", err, callback);
-                }
-            }
-
-            for (const [filter, callback] of waitForSubscriptions) {
-                try {
-                    if (filter(exports)) {
-                        waitForSubscriptions.delete(filter);
-                        callback(exports);
-                    } else if (exports.default && filter(exports.default)) {
-                        waitForSubscriptions.delete(filter);
-                        callback(exports.default);
-                    }
-                } catch (err) {
-                    logger.error("Error while firing callback for Webpack waitFor subscription:\n", err, filter, callback);
-                }
-            }
-        } as any as { toString: () => string, original: any, (...args: any[]): void; };
-
-        factory.toString = originalMod.toString.bind(originalMod);
-        factory.original = originalMod;
-
     for (const factoryListener of factoryListeners) {
         try {
-                factoryListener(originalMod);
+            factoryListener(mod);
         } catch (err) {
             logger.error("Error in Webpack factory listener:\n", err, factoryListener);
         }
     }
 
+    const originalMod = mod;
+    const patchedBy = new Set();
+
     // Discords Webpack chunks for some ungodly reason contain random
     // newlines. Cyn recommended this workaround and it seems to work fine,
     // however this could potentially break code, so if anything goes weird,
@@ -342,5 +253,69 @@ function patchFactories(factories: Record<string, (module: any, exports: any, re
 
         if (!patch.all) patches.splice(i--, 1);
     }
+
+    function patchedFactory(module: any, exports: any, require: WebpackInstance) {
+        if (wreq == null && IS_DEV) {
+            if (!webpackNotInitializedLogged) {
+                webpackNotInitializedLogged = true;
+                logger.error("WebpackRequire was not initialized, running modules without patches instead.");
+            }
+
+            return void originalMod(module, exports, require);
+        }
+
+        try {
+            mod(module, exports, require);
+        } catch (err) {
+            // Just rethrow Discord errors
+            if (mod === originalMod) throw err;
+
+            logger.error("Error in patched module", err);
+            return void originalMod(module, exports, require);
+        }
+
+        // Webpack sometimes sets the value of module.exports directly, so assign exports to it to make sure we properly handle it
+        exports = module.exports;
+        if (exports == null) return;
+
+        // There are (at the time of writing) 11 modules exporting the window
+        // Make these non enumerable to improve webpack search performance
+        if (exports === window && require.c) {
+            Object.defineProperty(require.c, id, {
+                value: require.c[id],
+                configurable: true,
+                writable: true,
+                enumerable: false
+            });
+            return;
+        }
+
+        for (const callback of moduleListeners) {
+            try {
+                callback(exports, id);
+            } catch (err) {
+                logger.error("Error in Webpack module listener:\n", err, callback);
             }
         }
+
+        for (const [filter, callback] of waitForSubscriptions) {
+            try {
+                if (filter(exports)) {
+                    waitForSubscriptions.delete(filter);
+                    callback(exports);
+                } else if (exports.default && filter(exports.default)) {
+                    waitForSubscriptions.delete(filter);
+                    callback(exports.default);
+                }
+            } catch (err) {
+                logger.error("Error while firing callback for Webpack waitFor subscription:\n", err, filter, callback);
+            }
+        }
+    }
+
+    patchedFactory.toString = originalMod.toString.bind(originalMod);
+    // @ts-ignore
+    patchedFactory.$$vencordOriginal = originalMod;
+
+    return patchedFactory;
+}