Translation updates

[torbutton.git] / chrome / content / tor-circuit-display.js

// A script that automatically displays the Tor Circuit used for the
// current domain for the currently selected tab.
//
// This file is written in call stack order (later functions
// call earlier functions). The file can be processed
// with docco.js to produce pretty documentation.
//
// This script is to be embedded in torbutton.xhtml. It defines a single global
// function, createTorCircuitDisplay(), which activates the automatic Tor
// circuit display for the current tab and any future tabs.
//
// See https://trac.torproject.org/8641

/* jshint esnext: true */
/* global document, gBrowser, Components */

// ### Main function
// __createTorCircuitDisplay(enablePrefName)__.
// The single function that prepares tor circuit display. Connects to a tor
// control port using information provided to the control port module via
// a previous call to configureControlPortModule(), and binds to a named
// bool pref whose value determines whether the circuit display is enabled
// or disabled.
let createTorCircuitDisplay = (function() {
  "use strict";

  // Mozilla utilities
  const { Services } = ChromeUtils.import(
    "resource://gre/modules/Services.jsm"
  );

  // Import the controller code.
  const { wait_for_controller } = ChromeUtils.import(
    "resource://torbutton/modules/tor-control-port.js"
  );

  // Utility functions
  let {
    bindPrefAndInit,
    observe,
    getLocale,
    getDomainForBrowser,
    torbutton_get_property_string,
  } = ChromeUtils.import("resource://torbutton/modules/utils.js");

  // Make the TorButton logger available.
  let logger = Cc["@torproject.org/torbutton-logger;1"].getService(
    Ci.nsISupports
  ).wrappedJSObject;

  // ## Circuit/stream credentials and node monitoring

  // A mutable map that stores the current nodes for each
  // SOCKS username/password pair.
  let credentialsToNodeDataMap = new Map(),
    // A mutable map that reports `true` for IDs of "mature" circuits
    // (those that have conveyed a stream).
    knownCircuitIDs = new Map(),
    // A mutable map that records the SOCKS credentials for the
    // latest channels for each browser + domain.
    browserToCredentialsMap = new Map();

  // __trimQuotes(s)__.
  // Removes quotation marks around a quoted string.
  let trimQuotes = s => (s ? s.match(/^"(.*)"$/)[1] : undefined);

  // __getBridge(id)__.
  // Gets the bridge parameters for a given node ID. If the node
  // is not currently used as a bridge, returns null.
  let getBridge = async function(controller, id) {
    let bridges = await controller.getConf("bridge");
    if (bridges) {
      for (let bridge of bridges) {
        if (bridge.ID && bridge.ID.toUpperCase() === id.toUpperCase()) {
          return bridge;
        }
      }
    }
    return null;
  };

  // nodeDataForID(controller, id)__.
  // Returns the type, IP addresses and country code of a node with given ID.
  // Example: `nodeDataForID(controller, "20BC91DC525C3DC9974B29FBEAB51230DE024C44")`
  // => `{ type: "default", ipAddrs: ["12.23.34.45", "2001:db8::"], countryCode: "fr" }`
  let nodeDataForID = async function(controller, id) {
    let result = { ipAddrs: [] };
    const bridge = await getBridge(controller, id); // type, ip, countryCode;
    const addrRe = /^\[?([^\]]+)\]?:\d+$/;
    if (bridge) {
      result.type = "bridge";
      result.bridgeType = bridge.type;
      // Attempt to get an IP address from bridge address string.
      try {
        const ip = bridge.address.match(addrRe)[1];
        if (!ip.startsWith("0.")) {
          result.ipAddrs = [ip];
        }
      } catch (e) {}
    } else {
      // either dealing with a relay, or a bridge whose fingerprint is not saved in torrc
      try {
        const statusMap = await controller.getInfo("ns/id/" + id);
        result.type = "default";
        if (!statusMap.IP.startsWith("0.")) {
          result.ipAddrs.push(statusMap.IP);
        }
        try {
          result.ipAddrs.push(statusMap.IPv6.match(addrRe)[1]);
        } catch (e) {}
      } catch (e) {
        // getInfo will throw if the given id is not a relay
        // this probably means we are dealing with a user-provided bridge with no fingerprint
        result.type = "bridge";
        // we don't know the ip/ipv6 or type, so leave blank
        result.ipAddrs = [];
        result.bridgeType = "";
      }
    }
    if (result.ipAddrs.length) {
      // Get the country code for the node's IP address.
      try {
        const countryCode = await controller.getInfo(
          "ip-to-country/" + result.ipAddrs[0]
        );
        result.countryCode = countryCode === "??" ? null : countryCode;
      } catch (e) {}
    }
    return result;
  };

  // __nodeDataForCircuit(controller, circuitEvent)__.
  // Gets the information for a circuit.
  let nodeDataForCircuit = async function(controller, circuitEvent) {
    let rawIDs = circuitEvent.circuit.map(circ => circ[0]),
      // Remove the leading '$' if present.
      ids = rawIDs.map(id => (id[0] === "$" ? id.substring(1) : id));
    // Get the node data for all IDs in circuit.
    return Promise.all(ids.map(id => nodeDataForID(controller, id)));
  };

  // __getCircuitStatusByID(aController, circuitID)__
  // Returns the circuit status for the circuit with the given ID.
  let getCircuitStatusByID = async function(aController, circuitID) {
    let circuitStatuses = await aController.getInfo("circuit-status");
    if (circuitStatuses) {
      for (let circuitStatus of circuitStatuses) {
        if (circuitStatus.id === circuitID) {
          return circuitStatus;
        }
      }
    }
    return null;
  };

  // __collectIsolationData(aController, updateUI)__.
  // Watches for STREAM SENTCONNECT events. When a SENTCONNECT event occurs, then
  // we assume isolation settings (SOCKS username+password) are now fixed for the
  // corresponding circuit. Whenever the first stream on a new circuit is seen,
  // looks up u+p and records the node data in the credentialsToNodeDataMap.
  // We need to update the circuit display immediately after any new node data
  // is received. So the `updateUI` callback will be called at that point.
  // See https://trac.torproject.org/projects/tor/ticket/15493
  let collectIsolationData = function(aController, updateUI) {
    return aController.watchEvent(
      "STREAM",
      streamEvent => streamEvent.StreamStatus === "SENTCONNECT",
      async streamEvent => {
        if (!knownCircuitIDs.get(streamEvent.CircuitID)) {
          logger.eclog(3, "streamEvent.CircuitID: " + streamEvent.CircuitID);
          knownCircuitIDs.set(streamEvent.CircuitID, true);
          let circuitStatus = await getCircuitStatusByID(
              aController,
              streamEvent.CircuitID
            ),
            credentials = circuitStatus
              ? trimQuotes(circuitStatus.SOCKS_USERNAME) +
                "|" +
                trimQuotes(circuitStatus.SOCKS_PASSWORD)
              : null;
          if (credentials) {
            let nodeData = await nodeDataForCircuit(aController, circuitStatus);
            credentialsToNodeDataMap.set(credentials, nodeData);
            updateUI();
          }
        }
      }
    );
  };

  // __browserForChannel(channel)__.
  // Returns the browser that loaded a given channel.
  let browserForChannel = function(channel) {
    if (!channel) {
      return null;
    }
    let chan = channel.QueryInterface(Ci.nsIChannel);
    let callbacks = chan.notificationCallbacks;
    if (!callbacks) {
      return null;
    }
    let loadContext;
    try {
      loadContext = callbacks.getInterface(Ci.nsILoadContext);
    } catch (e) {
      // Ignore
      return null;
    }
    if (!loadContext) {
      return null;
    }
    return loadContext.topFrameElement;
  };

  // __collectBrowserCredentials()__.
  // Starts observing http channels. Each channel's proxyInfo
  // username and password is recorded for the channel's browser.
  let collectBrowserCredentials = function() {
    return observe("http-on-modify-request", chan => {
      try {
        let proxyInfo = chan.QueryInterface(Ci.nsIProxiedChannel).proxyInfo;
        let browser = browserForChannel(chan);
        if (browser && proxyInfo) {
          if (!browserToCredentialsMap.has(browser)) {
            browserToCredentialsMap.set(browser, new Map());
          }
          let domainMap = browserToCredentialsMap.get(browser);
          domainMap.set(proxyInfo.username, [
            proxyInfo.username,
            proxyInfo.password,
          ]);
        }
      } catch (e) {
        logger.eclog(
          3,
          `Error collecting browser credentials: ${e.message}, ${chan.URI.spec}`
        );
      }
    });
  };

  // ## User interface

  // __uiString__.
  // Read the localized strings for this UI.
  let uiString = function(shortName) {
    return torbutton_get_property_string(
      "torbutton.circuit_display." + shortName
    );
  };

  // __localizedCountryNameFromCode(countryCode)__.
  // Convert a country code to a localized country name.
  // Example: `'de'` -> `'Deutschland'` in German locale.
  let localizedCountryNameFromCode = function(countryCode) {
    if (!countryCode) {
      return uiString("unknown_country");
    }
    try {
      return Services.intl.getRegionDisplayNames(undefined, [countryCode])[0];
    } catch (e) {
      return countryCode.toUpperCase();
    }
  };

  // __showCircuitDisplay(show)__.
  // If show === true, makes the circuit display visible.
  let showCircuitDisplay = function(show) {
    document.getElementById("circuit-display-container").hidden = !show;
  };

  // __xmlTree(ns, data)__.
  // Takes an xml namespace, ns, and a
  // data structure representing xml elements like
  // [tag, { attr-key: attr-value }, ...xml-children]
  // and returns nested xml element objects.
  let xmlTree = function xmlTree(ns, data) {
    let [type, attrs, ...children] = data;
    let element = type.startsWith("html:")
      ? document.createXULElement(type)
      : document.createElementNS(ns, type);
    for (let [key, val] of Object.entries(attrs)) {
      element.setAttribute(key, val);
    }
    for (let child of children) {
      if (child !== null && child !== undefined) {
        element.append(typeof child === "string" ? child : xmlTree(ns, child));
      }
    }
    return element;
  };

  // __htmlTree(data)__.
  // Takes a data structure representing html elements like
  // [tag, { attr-key: attr-value }, ...html-children]
  // and returns nested html element objects.
  let htmlTree = data => xmlTree("http://www.w3.org/1999/xhtml", data);

  // __appendHtml(parent, data)__.
  // Takes a data structure representing html elements like
  // [tag, { attr-key: attr-value }, ...html-children]
  // and appends nested html element objects to the parent element.
  let appendHtml = (parent, data) => parent.appendChild(htmlTree(data));

  // __circuitCircuitData()__.
  // Obtains the circuit used by the given browser.
  let currentCircuitData = function(browser) {
    if (browser) {
      let firstPartyDomain = getDomainForBrowser(browser);
      let domain = firstPartyDomain || "--unknown--";
      let domainMap = browserToCredentialsMap.get(browser);
      let credentials = domainMap && domainMap.get(domain);
      if (credentials) {
        let [SOCKS_username, SOCKS_password] = credentials;
        let nodeData = credentialsToNodeDataMap.get(
          `${SOCKS_username}|${SOCKS_password}`
        );
        let domain = SOCKS_username;
        if (browser.documentURI.host.endsWith(".tor.onion")) {
          const service = Cc[
            "@torproject.org/onion-alias-service;1"
          ].getService(Ci.IOnionAliasService);
          domain = service.getOnionAlias(browser.documentURI.host);
        }
        return { domain, nodeData };
      }
    }
    return { domain: null, nodeData: null };
  };

  // __updateCircuitDisplay()__.
  // Updates the Tor circuit display, showing the current domain
  // and the relay nodes for that domain.
  let updateCircuitDisplay = function() {
    let { domain, nodeData } = currentCircuitData(gBrowser.selectedBrowser);
    if (domain && nodeData) {
      // Update the displayed information for the relay nodes.
      let nodeHtmlList = document.getElementById("circuit-display-nodes");
      let li = (...data) => appendHtml(nodeHtmlList, ["li", {}, ...data]);
      nodeHtmlList.innerHTML = "";
      li(uiString("this_browser"));
      for (let i = 0; i < nodeData.length; ++i) {
        let relayText;
        if (nodeData[i].type === "bridge") {
          relayText = uiString("tor_bridge");
          let bridgeType = nodeData[i].bridgeType;
          if (bridgeType === "meek_lite") {
            relayText += ": meek";
          } else if (bridgeType !== "vanilla" && bridgeType !== "") {
            relayText += ": " + bridgeType;
          }
        } else if (nodeData[i].type == "default") {
          relayText = localizedCountryNameFromCode(nodeData[i].countryCode);
        }
        const ipAddrs = nodeData[i].ipAddrs.join(", ");
        li(
          relayText,
          " ",
          ["span", { class: "circuit-ip-address" }, ipAddrs],
          " ",
          i === 0 && nodeData[0].type !== "bridge"
            ? ["span", { class: "circuit-guard-info" }, uiString("guard")]
            : null
        );
      }

      let domainParts = [];
      if (domain.endsWith(".onion")) {
        for (let i = 0; i < 3; ++i) {
          li(uiString("relay"));
        }
        if (domain.length > 22) {
          domainParts.push(domain.slice(0, 7), "…", domain.slice(-12));
        } else {
          domainParts.push(domain);
        }
      } else {
        domainParts.push(domain);
      }

      // We use a XUL html:span element so that the tooltiptext is displayed.
      li([
        "html:span",
        {
          class: "circuit-onion",
          onclick: `
          this.classList.add("circuit-onion-copied");
          Cc[
            "@mozilla.org/widget/clipboardhelper;1"
          ].getService(Ci.nsIClipboardHelper).copyString(this.getAttribute("data-onion"))
        `,
          "data-onion": domain,
          "data-text-clicktocopy": torbutton_get_property_string(
            "torbutton.circuit_display.click_to_copy"
          ),
          "data-text-copied": torbutton_get_property_string(
            "torbutton.circuit_display.copied"
          ),
          tooltiptext: domain,
        },
        ...domainParts,
      ]);

      // Hide the note about guards if we are using a bridge.
      document.getElementById("circuit-guard-note-container").hidden =
        nodeData[0].type === "bridge";
    } else {
      // Only show the Tor circuit if we have credentials and node data.
      logger.eclog(4, "no SOCKS credentials found for current document.");
    }
    showCircuitDisplay(domain && nodeData);
  };

  // __syncDisplayWithSelectedTab(syncOn)__.
  // Whenever the user starts to open the popup menu, make sure the display
  // is the correct one for this tab. It's also possible that a new site
  // can be loaded while the popup menu is open.
  // Update the display if this happens.
  let syncDisplayWithSelectedTab = (function() {
    let listener = {
      onLocationChange(aBrowser) {
        if (aBrowser === gBrowser.selectedBrowser) {
          updateCircuitDisplay();
        }
      },
    };
    return function(syncOn) {
      let popupMenu = document.getElementById("identity-popup");
      if (syncOn) {
        // Update the circuit display just before the popup menu is shown.
        popupMenu.addEventListener("popupshowing", updateCircuitDisplay);
        // If the currently selected tab has been sent to a new location,
        // update the circuit to reflect that.
        gBrowser.addTabsProgressListener(listener);
      } else {
        // Stop syncing.
        gBrowser.removeTabsProgressListener(listener);
        popupMenu.removeEventListener("popupshowing", updateCircuitDisplay);
        // Hide the display.
        showCircuitDisplay(false);
      }
    };
  })();

  // __setupGuardNote()__.
  // Call once to show the Guard note as intended.
  let setupGuardNote = function() {
    let guardNote = document.getElementById("circuit-guard-note-container");
    let guardNoteString = uiString("guard_note");
    let learnMoreString = uiString("learn_more");
    let [noteBefore, name, noteAfter] = guardNoteString.split(/[\[\]]/);
    let localeCode = getLocale();
    appendHtml(guardNote, [
      "div",
      {},
      noteBefore,
      ["span", { class: "circuit-guard-name" }, name],
      noteAfter,
      " ",
      [
        "span",
        {
          onclick: `gBrowser.selectedTab = gBrowser.addWebTab('https://support.torproject.org/${localeCode}/tbb/tbb-2/');`,
          class: "circuit-link",
        },
        learnMoreString,
      ],
    ]);
  };

  // __ensureCorrectPopupDimensions()__.
  // Make sure the identity popup always displays with the correct height.
  let ensureCorrectPopupDimensions = function() {
    // FIXME: This is hacking with the internals of the panel view, which also
    // sets the width and height for transitions (see PanelMultiView.jsm), so
    // this fix is fragile.
    // Ideally the panel view would start using a non-XUL CSS layout, which
    // would work regardless of the content.
    let popupMenu = document.getElementById("identity-popup");
    let setDimensions = event => {
      if (event.target !== popupMenu) {
        return;
      }
      setTimeout(() => {
        let view = document.querySelector(
          "#identity-popup-multiView .panel-viewcontainer"
        );
        let stack = document.querySelector(
          "#identity-popup-multiView .panel-viewstack"
        );
        let view2 = document.getElementById("identity-popup-mainView");
        if (view && stack && view2) {
          let newWidth = Math.max(
            ...[...view2.children].map(el => el.clientWidth)
          );
          let newHeight = stack.clientHeight;
          stack.setAttribute("width", newWidth);
          view2.style.minWidth = view2.style.maxWidth = newWidth + "px";
          view.setAttribute("width", newWidth);
          view.setAttribute("height", newHeight);
        }
      });
    };
    let removeDimensions = event => {
      if (event.target !== popupMenu) {
        return;
      }
      let view = document.querySelector(
        "#identity-popup-multiView .panel-viewcontainer"
      );
      let stack = document.querySelector(
        "#identity-popup-multiView .panel-viewstack"
      );
      let view2 = document.getElementById("identity-popup-mainView");
      if (view && stack && view2) {
        view.removeAttribute("width");
        view.removeAttribute("height");
        stack.removeAttribute("width");
        view2.style.minWidth = view2.style.maxWidth = "";
      }
    };
    popupMenu.addEventListener("popupshowing", setDimensions);
    popupMenu.addEventListener("popuphiding", removeDimensions);
    return () => {
      popupMenu.removeEventListener("popupshowing", setDimensions);
      popupMenu.removeEventListener("popuphiding", removeDimensions);
    };
  };

  // ## Main function

  // __setupDisplay(enablePrefName)__.
  // Once called, the Tor circuit display will be started whenever
  // the "enablePref" is set to true, and stopped when it is set to false.
  // A reference to this function (called createTorCircuitDisplay) is exported as a global.
  let setupDisplay = function(enablePrefName) {
    // From 79 on the identity popup is initialized lazily
    if (gIdentityHandler._initializePopup) {
      gIdentityHandler._initializePopup();
    }
    setupGuardNote();
    let myController = null,
      stopCollectingIsolationData = null,
      stopCollectingBrowserCredentials = null,
      stopEnsuringCorrectPopupDimensions = null,
      stop = function() {
        syncDisplayWithSelectedTab(false);
        if (myController) {
          if (stopCollectingIsolationData) {
            stopCollectingIsolationData();
          }
          if (stopCollectingBrowserCredentials) {
            stopCollectingBrowserCredentials();
          }
          if (stopEnsuringCorrectPopupDimensions) {
            stopEnsuringCorrectPopupDimensions();
          }
          myController = null;
        }
      },
      start = async function() {
        if (!myController) {
          try {
            myController = await wait_for_controller();
            syncDisplayWithSelectedTab(true);
            stopCollectingIsolationData = collectIsolationData(
              myController,
              updateCircuitDisplay
            );
            stopCollectingBrowserCredentials = collectBrowserCredentials();
            stopEnsuringCorrectPopupDimensions = ensureCorrectPopupDimensions();
          } catch (err) {
            logger.eclog(5, err);
            logger.eclog(
              5,
              "Disabling tor display circuit because of an error."
            );
            myController.close();
            stop();
          }
        }
      };
    try {
      let unbindPref = bindPrefAndInit(enablePrefName, on => {
        if (on) {
          start();
        } else {
          stop();
        }
      });
      // When this chrome window is unloaded, we need to unbind the pref.
      window.addEventListener("unload", function() {
        unbindPref();
        stop();
      });
    } catch (e) {
      logger.eclog(5, "Error: " + e.message + "\n" + e.stack);
    }
  };

  return setupDisplay;

  // Finish createTorCircuitDisplay()
})();