tor-browser

ProxyPerUserContextManager.sys.mjs (5040B)

---

/* 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/. */

import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";

const lazy = {};

ChromeUtils.defineESModuleGetters(lazy, {
 ProxyTypes: "chrome://remote/content/shared/webdriver/Capabilities.sys.mjs",
});

XPCOMUtils.defineLazyServiceGetter(
 lazy,
 "protocolProxyService",
 "@mozilla.org/network/protocol-proxy-service;1",
 Ci.nsIProtocolProxyService
);

const nsIProtocolProxyChannelFilter = ChromeUtils.generateQI([
 Ci.nsIProtocolProxyChannelFilter,
]);

// The maximum uint32 value.
const PR_UINT32_MAX = 4294967295;

/**
* A ProxyPerUserContextManager class keeps track of user contexts and their proxy configuration.
*/
export class ProxyPerUserContextManager {
 #channelProxyFilter;
 #proxyFilterRegistered;
 #userContextToProxyConfiguration;

 constructor() {
   this.#proxyFilterRegistered = false;

   // A map between internal user context ids and proxy configurations.
   this.#userContextToProxyConfiguration = new Map();
 }

 destroy() {
   this.#userContextToProxyConfiguration = new Map();

   this.#unregisterProxyFilter();
 }

 /**
  * Add proxy configuration for a provided user context id.
  *
  * @param {string} userContextId
  *     Internal user context id.
  * @param {Proxy} proxy
  *     Proxy configuration.
  */
 addConfiguration(userContextId, proxy) {
   this.#userContextToProxyConfiguration.set(userContextId, proxy);

   this.#registerProxyFilter();
 }

 /**
  * Delete proxy configuration for a provided user context id.
  *
  * @param {string} userContextId
  *     Internal user context id.
  */
 deleteConfiguration(userContextId) {
   this.#userContextToProxyConfiguration.delete(userContextId);

   this.#unregisterProxyFilter();
 }

 #addProxyFilter(proxyFilter, proxySettings) {
   const { host, port, type } = proxySettings;

   proxyFilter.onProxyFilterResult(
     lazy.protocolProxyService.newProxyInfo(
       type,
       host,
       port,
       "" /* aProxyAuthorizationHeader */,
       "" /* aConnectionIsolationKey */,
       Ci.nsIProxyInfo.TRANSPARENT_PROXY_RESOLVES_HOST /* aFlags */,
       PR_UINT32_MAX /* aFailoverTimeout */,
       null /* failover proxy */
     )
   );
 }

 #applyFilter = (channel, defaultProxyInfo, proxyFilter) => {
   const originAttributes =
     channel.loadInfo && channel.loadInfo.originAttributes;

   if (
     this.#userContextToProxyConfiguration.has(originAttributes.userContextId)
   ) {
     const proxyInfo = this.#userContextToProxyConfiguration.get(
       originAttributes.userContextId
     );

     if (proxyInfo.proxyType === lazy.ProxyTypes.Direct) {
       proxyFilter.onProxyFilterResult(null);

       return;
     }

     if (proxyInfo.proxyType === lazy.ProxyTypes.Manual) {
       const channelURI = channel.originalURI;
       for (const url of proxyInfo.noProxy ?? []) {
         if (
           (url.startsWith(".") && channelURI.host.endsWith(url)) ||
           (!url.startsWith(".") && channelURI.host === url)
         ) {
           proxyFilter.onProxyFilterResult(defaultProxyInfo);

           // If at least one element from noProxy matches the channel URL no need to check further.
           return;
         }
       }

       if (proxyInfo.httpProxy) {
         this.#addProxyFilter(proxyFilter, {
           host: proxyInfo.httpProxy,
           port: proxyInfo.httpProxyPort,
           type: "http",
         });
       }

       if (proxyInfo.sslProxy) {
         this.#addProxyFilter(proxyFilter, {
           host: proxyInfo.sslProxy,
           port: proxyInfo.sslProxyPort,
           type: "https",
         });
       }

       if (proxyInfo.socksProxy) {
         this.#addProxyFilter(proxyFilter, {
           host: proxyInfo.socksProxy,
           port: proxyInfo.socksProxyPort,
           type:
             proxyInfo.socksVersion === 5
               ? "socks"
               : `socks${proxyInfo.socksVersion}`,
         });
       }

       return;
     }
   }

   proxyFilter.onProxyFilterResult(defaultProxyInfo);
 };

 #registerProxyFilter() {
   if (!this.#proxyFilterRegistered) {
     this.#proxyFilterRegistered = true;

     this.#channelProxyFilter = {
       QueryInterface: nsIProtocolProxyChannelFilter,
       applyFilter: this.#applyFilter,
     };

     lazy.protocolProxyService.registerChannelFilter(
       this.#channelProxyFilter,
       0 /* set position `0` to override global filters */
     );
   }
 }

 #unregisterProxyFilter() {
   if (
     this.#proxyFilterRegistered &&
     this.#userContextToProxyConfiguration.size === 0
   ) {
     this.#proxyFilterRegistered = false;
     lazy.protocolProxyService.unregisterChannelFilter(
       this.#channelProxyFilter
     );
     this.#channelProxyFilter = null;
   }
 }
}