Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 353 insertions, 0 deletions

diff --git a/toolkit/actors/NetErrorParent.sys.mjs b/toolkit/actors/NetErrorParent.sys.mjs
new file mode 100644
index 0000000000..7d1f0f3f0f
--- /dev/null
+++ b/toolkit/actors/NetErrorParent.sys.mjs
@@ -0,0 +1,353 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* 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 { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+import { PrivateBrowsingUtils } from "resource://gre/modules/PrivateBrowsingUtils.sys.mjs";
+import { TelemetryController } from "resource://gre/modules/TelemetryController.sys.mjs";
+
+const PREF_SSL_IMPACT_ROOTS = [
+  "security.tls.version.",
+  "security.ssl3.",
+  "security.tls13.",
+];
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  BrowserUtils: "resource://gre/modules/BrowserUtils.sys.mjs",
+});
+
+ChromeUtils.defineModuleGetter(
+  lazy,
+  "HomePage",
+  "resource:///modules/HomePage.jsm"
+);
+
+class CaptivePortalObserver {
+  constructor(actor) {
+    this.actor = actor;
+    Services.obs.addObserver(this, "captive-portal-login-abort");
+    Services.obs.addObserver(this, "captive-portal-login-success");
+  }
+
+  stop() {
+    Services.obs.removeObserver(this, "captive-portal-login-abort");
+    Services.obs.removeObserver(this, "captive-portal-login-success");
+  }
+
+  observe(aSubject, aTopic, aData) {
+    switch (aTopic) {
+      case "captive-portal-login-abort":
+      case "captive-portal-login-success":
+        // Send a message to the content when a captive portal is freed
+        // so that error pages can refresh themselves.
+        this.actor.sendAsyncMessage("AboutNetErrorCaptivePortalFreed");
+        break;
+    }
+  }
+}
+
+export class NetErrorParent extends JSWindowActorParent {
+  constructor() {
+    super();
+    this.captivePortalObserver = new CaptivePortalObserver(this);
+  }
+
+  didDestroy() {
+    if (this.captivePortalObserver) {
+      this.captivePortalObserver.stop();
+    }
+  }
+
+  get browser() {
+    return this.browsingContext.top.embedderElement;
+  }
+
+  hasChangedCertPrefs() {
+    let prefSSLImpact = PREF_SSL_IMPACT_ROOTS.reduce((prefs, root) => {
+      return prefs.concat(Services.prefs.getChildList(root));
+    }, []);
+    for (let prefName of prefSSLImpact) {
+      if (Services.prefs.prefHasUserValue(prefName)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  async ReportBlockingError(bcID, scheme, host, port, path, xfoAndCspInfo) {
+    // For reporting X-Frame-Options error and CSP: frame-ancestors errors, We
+    // are collecting 4 pieces of information.
+    // 1. The X-Frame-Options in the response header.
+    // 2. The CSP: frame-ancestors in the response header.
+    // 3. The URI of the frame who triggers this error.
+    // 4. The top-level URI which loads the frame.
+    //
+    // We will exclude the query strings from the reporting URIs.
+    //
+    // More details about the data we send can be found in
+    // https://firefox-source-docs.mozilla.org/toolkit/components/telemetry/telemetry/data/xfocsp-error-report-ping.html
+    //
+
+    let topBC = BrowsingContext.get(bcID).top;
+    let topURI = topBC.currentWindowGlobal.documentURI;
+
+    // Get the URLs without query strings.
+    let frame_uri = `${scheme}://${host}${port == -1 ? "" : ":" + port}${path}`;
+    let top_uri = `${topURI.scheme}://${topURI.hostPort}${topURI.filePath}`;
+
+    TelemetryController.submitExternalPing(
+      "xfocsp-error-report",
+      {
+        ...xfoAndCspInfo,
+        frame_hostname: host,
+        top_hostname: topURI.host,
+        frame_uri,
+        top_uri,
+      },
+      { addClientId: false, addEnvironment: false }
+    );
+  }
+
+  /**
+   * Return the default start page for the cases when the user's own homepage is
+   * infected, so we can get them somewhere safe.
+   */
+  getDefaultHomePage(win) {
+    let url;
+    if (
+      !PrivateBrowsingUtils.isWindowPrivate(win) &&
+      AppConstants.MOZ_BUILD_APP == "browser"
+    ) {
+      url = lazy.HomePage.getDefault();
+    }
+    url ||= win.BROWSER_NEW_TAB_URL || "about:blank";
+
+    // If url is a pipe-delimited set of pages, just take the first one.
+    if (url.includes("|")) {
+      url = url.split("|")[0];
+    }
+    return url;
+  }
+
+  /**
+   * Re-direct the browser to the previous page or a known-safe page if no
+   * previous page is found in history.  This function is used when the user
+   * browses to a secure page with certificate issues and is presented with
+   * about:certerror.  The "Go Back" button should take the user to the previous
+   * or a default start page so that even when their own homepage is on a server
+   * that has certificate errors, we can get them somewhere safe.
+   */
+  goBackFromErrorPage(browser) {
+    if (!browser.canGoBack) {
+      // If the unsafe page is the first or the only one in history, go to the
+      // start page.
+      browser.fixupAndLoadURIString(
+        this.getDefaultHomePage(browser.ownerGlobal),
+        {
+          triggeringPrincipal:
+            Services.scriptSecurityManager.getSystemPrincipal(),
+        }
+      );
+    } else {
+      browser.goBack();
+    }
+  }
+
+  /**
+   * This function does a canary request to a reliable, maintained endpoint, in
+   * order to help network code detect a system-wide man-in-the-middle.
+   */
+  primeMitm(browser) {
+    // If we already have a mitm canary issuer stored, then don't bother with the
+    // extra request. This will be cleared on every update ping.
+    if (Services.prefs.getStringPref("security.pki.mitm_canary_issuer", null)) {
+      return;
+    }
+
+    let url = Services.prefs.getStringPref(
+      "security.certerrors.mitm.priming.endpoint"
+    );
+    let request = new XMLHttpRequest({ mozAnon: true });
+    request.open("HEAD", url);
+    request.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE;
+    request.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING;
+
+    request.addEventListener("error", event => {
+      // Make sure the user is still on the cert error page.
+      if (!browser.documentURI.spec.startsWith("about:certerror")) {
+        return;
+      }
+
+      let secInfo = request.channel.securityInfo;
+      if (secInfo.errorCodeString != "SEC_ERROR_UNKNOWN_ISSUER") {
+        return;
+      }
+
+      // When we get to this point there's already something deeply wrong, it's very likely
+      // that there is indeed a system-wide MitM.
+      if (secInfo.serverCert && secInfo.serverCert.issuerName) {
+        // Grab the issuer of the certificate used in the exchange and store it so that our
+        // network-level MitM detection code has a comparison baseline.
+        Services.prefs.setStringPref(
+          "security.pki.mitm_canary_issuer",
+          secInfo.serverCert.issuerName
+        );
+
+        // MitM issues are sometimes caused by software not registering their root certs in the
+        // Firefox root store. We might opt for using third party roots from the system root store.
+        if (
+          Services.prefs.getBoolPref(
+            "security.certerrors.mitm.auto_enable_enterprise_roots"
+          )
+        ) {
+          if (
+            !Services.prefs.getBoolPref("security.enterprise_roots.enabled")
+          ) {
+            // Loading enterprise roots happens on a background thread, so wait for import to finish.
+            lazy.BrowserUtils.promiseObserved(
+              "psm:enterprise-certs-imported"
+            ).then(() => {
+              if (browser.documentURI.spec.startsWith("about:certerror")) {
+                browser.reload();
+              }
+            });
+
+            Services.prefs.setBoolPref(
+              "security.enterprise_roots.enabled",
+              true
+            );
+            // Record that this pref was automatically set.
+            Services.prefs.setBoolPref(
+              "security.enterprise_roots.auto-enabled",
+              true
+            );
+          }
+        } else {
+          // Need to reload the page to make sure network code picks up the canary issuer pref.
+          browser.reload();
+        }
+      }
+    });
+
+    request.send(null);
+  }
+
+  displayOfflineSupportPage(supportPageSlug) {
+    const AVAILABLE_PAGES = ["connection-not-secure", "time-errors"];
+    if (!AVAILABLE_PAGES.includes(supportPageSlug)) {
+      console.log(
+        `[Not supported] Offline support is not yet available for ${supportPageSlug} errors.`
+      );
+      return;
+    }
+
+    let offlinePagePath = `chrome://global/content/neterror/supportpages/${supportPageSlug}.html`;
+    let triggeringPrincipal =
+      Services.scriptSecurityManager.getSystemPrincipal();
+    this.browser.loadURI(Services.io.newURI(offlinePagePath), {
+      triggeringPrincipal,
+    });
+  }
+
+  receiveMessage(message) {
+    switch (message.name) {
+      case "Browser:EnableOnlineMode":
+        // Reset network state and refresh the page.
+        Services.io.offline = false;
+        this.browser.reload();
+        break;
+      case "Browser:OpenCaptivePortalPage":
+        this.browser.ownerGlobal.CaptivePortalWatcher.ensureCaptivePortalTab();
+        break;
+      case "Browser:PrimeMitm":
+        this.primeMitm(this.browser);
+        break;
+      case "Browser:ResetEnterpriseRootsPref":
+        Services.prefs.clearUserPref("security.enterprise_roots.enabled");
+        Services.prefs.clearUserPref("security.enterprise_roots.auto-enabled");
+        break;
+      case "Browser:ResetSSLPreferences":
+        let prefSSLImpact = PREF_SSL_IMPACT_ROOTS.reduce((prefs, root) => {
+          return prefs.concat(Services.prefs.getChildList(root));
+        }, []);
+        for (let prefName of prefSSLImpact) {
+          Services.prefs.clearUserPref(prefName);
+        }
+        this.browser.reload();
+        break;
+      case "Browser:SSLErrorGoBack":
+        this.goBackFromErrorPage(this.browser);
+        break;
+      case "Browser:SSLErrorReportTelemetry":
+        let reportStatus = message.data.reportStatus;
+        Services.telemetry
+          .getHistogramById("TLS_ERROR_REPORT_UI")
+          .add(reportStatus);
+        break;
+      case "GetChangedCertPrefs":
+        let hasChangedCertPrefs = this.hasChangedCertPrefs();
+        this.sendAsyncMessage("HasChangedCertPrefs", {
+          hasChangedCertPrefs,
+        });
+        break;
+      case "ReportBlockingError":
+        this.ReportBlockingError(
+          this.browsingContext.id,
+          message.data.scheme,
+          message.data.host,
+          message.data.port,
+          message.data.path,
+          message.data.xfoAndCspInfo
+        );
+        break;
+      case "DisplayOfflineSupportPage":
+        this.displayOfflineSupportPage(message.data.supportPageSlug);
+        break;
+      case "Browser:CertExceptionError":
+        switch (message.data.elementId) {
+          case "viewCertificate": {
+            let certs = message.data.failedCertChain.map(certBase64 =>
+              encodeURIComponent(certBase64)
+            );
+            let certsStringURL = certs.map(elem => `cert=${elem}`);
+            certsStringURL = certsStringURL.join("&");
+            let url = `about:certificate?${certsStringURL}`;
+
+            let window = this.browser.ownerGlobal;
+            if (AppConstants.MOZ_BUILD_APP === "browser") {
+              window.switchToTabHavingURI(url, true, {});
+            } else {
+              window.open(url, "_blank");
+            }
+            break;
+          }
+        }
+        break;
+      case "Browser:AddTRRExcludedDomain":
+        let domain = message.data.hostname;
+        let excludedDomains = Services.prefs.getStringPref(
+          "network.trr.excluded-domains"
+        );
+        excludedDomains += `, ${domain}`;
+        Services.prefs.setStringPref(
+          "network.trr.excluded-domains",
+          excludedDomains
+        );
+        break;
+      case "OpenTRRPreferences":
+        let browser = this.browsingContext.top.embedderElement;
+        if (!browser) {
+          break;
+        }
+
+        let win = browser.ownerGlobal;
+        win.openPreferences("privacy-doh");
+        break;
+    }
+  }
+}