Intercept webview requests (#23)

* intercept requests

* better logic

* keep the data parsed

* remove log import

* change payload structure

* change payload structure

* add log import

* check clone func

---------

Co-authored-by: Lukas <[email protected]>

Author: LukasOgunfeitimi

OpacityCore/src/main/assets/interceptExtension/background.js

@@ -0,0 +1,12 @@
+browser.runtime.onMessage.addListener(function (message, sender, _) {
+  if (message.type === "intercepted_request") {
+    try {
+      browser.runtime.sendNativeMessage("gecko", {
+        event: "intercepted_request",
+        data: message.data,
+      });
+    } catch (err) {
+      // Silently handle errors to prevent crashes
+    }
+  }
+});

OpacityCore/src/main/assets/interceptExtension/content.js

@@ -0,0 +1,107 @@
+const script = document.createElement("script");
+script.textContent = `
+  (function() {
+    const log = (request_type, data) => {
+        try {
+            window.postMessage({
+                type: "intercepted_request",
+                payload: {
+                    request_type,
+                    data
+                }
+            }, "*");
+        } catch (e) {}
+    };
+    const originalFetch = window.fetch;
+    window.fetch = async function(input, init) {
+        try {
+            const method = (init && init.method) || (typeof input === "string" ? "GET" : input.method || "GET");
+            const url = typeof input === "string" ? input : input.url;
+            let requestHeaders = init?.headers || {};
+            if (requestHeaders instanceof Headers) {
+                requestHeaders = Object.fromEntries(requestHeaders.entries());
+            }
+            log("fetch_request", {
+                url,
+                method,
+                headers: requestHeaders,
+                body: init?.body,
+            });
+            const response = await originalFetch.apply(this, arguments);
+            if (!response || !response.clone) {
+                return response;
+            }
+            const clonedResponse = response.clone();
+            let responseHeaders = clonedResponse.headers || {};
+            if (responseHeaders instanceof Headers) {
+                responseHeaders = Object.fromEntries(responseHeaders.entries());
+            }
+            log("fetch_response", {
+                url,
+                method,
+                headers: responseHeaders,
+                body: await clonedResponse.text(),
+                status: clonedResponse.status,
+            });
+            return response;
+        } catch (err) {
+            log("fetch_error", err.toString());
+        }
+    };
+    const OriginalXHR = window.XMLHttpRequest;
+
+    function PatchedXHR() {
+        const xhr = new OriginalXHR();
+        let _method = "";
+        let _url = "";
+        let headers = {};
+        xhr.open = new Proxy(xhr.open, {
+            apply(t, thisArg, args) {
+                _method = args[0];
+                _url = args[1];
+                return Reflect.apply(t, thisArg, args);
+            },
+        });
+        const setRequestHeader = xhr.setRequestHeader;
+        xhr.setRequestHeader = function(name, value) {
+            headers[name] = value;
+            return setRequestHeader.apply(xhr, arguments);
+        };
+        xhr.send = new Proxy(xhr.send, {
+            apply(t, thisArg, args) {
+                log("xhr_request", {
+                    method: _method,
+                    url: _url,
+                    headers,
+                    body: args[0],
+                });
+                xhr.addEventListener("loadend", function() {
+                    log("xhr_response", {
+                        method: _method,
+                        url: _url,
+                        headers,
+                        body: xhr.responseText || xhr.response,
+                        status: xhr.status,
+                    });
+                });
+                return Reflect.apply(t, thisArg, args);
+            },
+        });
+        return xhr;
+    }
+    window.XMLHttpRequest = PatchedXHR;
+})();
+`;
+(document.head || document.documentElement).appendChild(script);
+
+window.addEventListener("message", (event) => {
+  if (event.source !== window) return;
+  if (event.data?.type === "intercepted_request") {
+    try {
+      browser.runtime.sendMessage({
+        type: "intercepted_request",
+        data: event.data.payload,
+      });
+    } catch (err) {}
+  }
+});

OpacityCore/src/main/assets/interceptExtension/manifest.json

@@ -0,0 +1,39 @@
+{
+  "manifest_version": 2,
+  "name": "Opacity Extension for Intercepting Requests",
+  "version": "1.0",
+  "description": "Opacity extension for GeckoView for intercepting requests",
+  "applications": {
+    "gecko": {
+      "id": "[email protected]",
+      "strict_min_version": "68.0"
+    }
+  },
+  "background": {
+    "scripts": [
+      "background.js"
+    ]
+  },
+  "content_scripts": [
+    {
+      "matches": ["<all_urls>"],
+      "js": ["content.js"],
+      "run_at": "document_start",
+      "all_frames": true
+    }
+  ],
+  "permissions": [
+    "webRequest",
+    "activeTab",
+    "tabs",
+    "webRequestBlocking",
+    "cookies",
+    "*://*/*",
+    "<all_urls>",
+    "nativeMessaging",
+    "nativeMessagingFromContent",
+    "geckoViewAddons",
+    "webNavigation",
+    "scripting"
+  ]
+}

OpacityCore/src/main/cpp/OpacityCore.cpp

@@ -136,16 +136,17 @@ extern "C" void android_set_request_header(const char *key, const char *value) {
   env->CallVoidMethod(java_object, method, jkey, jvalue);
 }
 
-extern "C" void android_present_webview() {
+extern "C" void android_present_webview(bool shouldIntercept) {
   JNIEnv *env = GetJniEnv();
   // Get the Kotlin class
   jclass jOpacityCore = env->GetObjectClass(java_object);
 
   // Get the method ID for the method you want to call
-  jmethodID method = env->GetMethodID(jOpacityCore, "presentBrowser", "()V");
+  jmethodID method = env->GetMethodID(jOpacityCore, "presentBrowser", "(Z)V");
 
   // Call the method with the necessary parameters
-  env->CallVoidMethod(java_object, method);
+  jboolean jshouldIntercept = shouldIntercept ? JNI_TRUE : JNI_FALSE;
+  env->CallVoidMethod(java_object, method, jshouldIntercept);
 }
 
 extern "C" const char *get_ip_address() {

OpacityCore/src/main/jni/include/sdk.h

@@ -247,7 +247,7 @@ extern void android_prepare_request(const char *url);
 
 extern void android_set_request_header(const char *key, const char *value);
 
-extern void android_present_webview(void);
+extern void android_present_webview(bool intercept_requests);
 
 extern void android_close_webview(void);