tor-browser

custom_functions.js (5957B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

/* globals browser */

const replaceStringInRequest = (
 requestId,
 inString,
 outString,
 inEncoding = "utf-8"
) => {
 const filter = browser.webRequest.filterResponseData(requestId);
 const decoder = new TextDecoder(inEncoding);
 const encoder = new TextEncoder();
 const RE = new RegExp(inString, "g");
 const carryoverLength = inString.length;
 let carryover = "";

 filter.ondata = event => {
   const replaced = (
     carryover + decoder.decode(event.data, { stream: true })
   ).replace(RE, outString);
   filter.write(encoder.encode(replaced.slice(0, -carryoverLength)));
   carryover = replaced.slice(-carryoverLength);
 };

 filter.onstop = () => {
   if (carryover.length) {
     filter.write(encoder.encode(carryover));
   }
   filter.close();
 };
};

const interventionListeners = new Map();

function rememberListener(intervention, key, listener) {
 if (!interventionListeners.has(intervention)) {
   interventionListeners.set(intervention, new Map());
 }
 const map = interventionListeners.get(intervention);
 if (map.has(key)) {
   throw new Error(`multiple custom listeners have the same key ${key}`);
 }
 map.set(key, listener);
}

function forgetListener(intervention, key) {
 const map = interventionListeners.get(intervention);
 if (!map) {
   return undefined;
 }
 const listener = map.get(key);
 map.delete(key);
 return listener;
}

function makeHeaderAlterer(headerType, webRequestAPI) {
 return {
   details: ["headers", "replacement"],
   optionalDetails: ["fallback", "replace", "types", "urls"],
   getKey(config) {
     return `alter_${headerType}_headers:${JSON.stringify(config)}`;
   },
   enable(config, intervention) {
     let { fallback, headers, replace, replacement, types, urls } = config;
     if (!urls) {
       urls = Object.values(intervention.bugs)
         .map(bug => bug.matches)
         .flat()
         .filter(v => v !== undefined);
     }
     const regex =
       replace === null ? null : new RegExp(replace ?? "^.*$", "gi");
     const listener = evt => {
       let found = false;
       const finalHeaders = [];
       for (const header of evt[`${headerType}Headers`]) {
         if (headers.includes(header.name.toLowerCase())) {
           found = true;
           if (
             regex !== null &&
             replacement !== null &&
             replacement !== undefined
           ) {
             const value = header.value.replaceAll(regex, replacement);
             finalHeaders.push({ name: header.name, value });
           } else if (replacement !== null) {
             finalHeaders.push(header);
           }
         } else {
           finalHeaders.push(header);
         }
       }
       if (!found && (replace === undefined || typeof fallback === "string")) {
         const value = fallback ?? replacement;
         if (value !== null) {
           finalHeaders.push({
             name: headers[0],
             value,
           });
         }
       }
       const retval = {};
       retval[`${headerType}Headers`] = finalHeaders;
       return retval;
     };
     browser.webRequest[webRequestAPI].addListener(listener, { types, urls }, [
       "blocking",
       `${headerType}Headers`,
     ]);
     rememberListener(intervention, this.getKey(config), listener);
   },
   disable(config, intervention) {
     const listener = forgetListener(intervention, this.getKey(config));
     if (listener) {
       browser.webRequest[webRequestAPI].removeListener(listener);
     }
   },
 };
}

var CUSTOM_FUNCTIONS = {
 alter_request_headers: makeHeaderAlterer("request", "onBeforeSendHeaders"),
 alter_response_headers: makeHeaderAlterer("response", "onHeadersReceived"),
 replace_string_in_request: {
   details: ["find", "replace", "urls"],
   optionalDetails: ["types"],
   enable(details) {
     const { find, replace, urls, types } = details;
     const listener = (details.listener = ({ requestId }) => {
       replaceStringInRequest(requestId, find, replace);
       return {};
     });
     browser.webRequest.onBeforeRequest.addListener(
       listener,
       { urls, types },
       ["blocking"]
     );
   },
   disable(details) {
     const { listener } = details;
     browser.webRequest.onBeforeRequest.removeListener(listener);
     delete details.listener;
   },
 },
 run_script_before_request: {
   details: ["message", "urls", "script"],
   optionalDetails: ["types"],
   enable(details, intervention) {
     const { bug } = intervention;
     const { message, script, types, urls } = details;
     const warning = `${message} See https://bugzilla.mozilla.org/show_bug.cgi?id=${bug} for details.`;

     const listener = (details.listener = evt => {
       const { tabId, frameId } = evt;
       return browser.tabs
         .executeScript(tabId, {
           file: script,
           frameId,
           runAt: "document_start",
         })
         .then(() => {
           browser.tabs.executeScript(tabId, {
             code: `console.warn(${JSON.stringify(warning)})`,
             runAt: "document_start",
           });
         })
         .catch(err => {
           console.error(
             "Error running script before request for webcompat intervention for bug",
             bug,
             err
           );
         });
     });

     browser.webRequest.onBeforeRequest.addListener(
       listener,
       { urls, types: types || ["script"] },
       ["blocking"]
     );
   },
   disable(details) {
     const { listener } = details;
     browser.webRequest.onBeforeRequest.removeListener(listener);
     delete details.listener;
   },
 },
};