tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

test_URIFixup_check_host.js (5387B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 "use strict";
      6 
      7 const lazy = {};
      8 
      9 // Ensure DNS lookups don't hit the server
     10 XPCOMUtils.defineLazyServiceGetter(
     11  lazy,
     12  "gDNSOverride",
     13  "@mozilla.org/network/native-dns-override;1",
     14  Ci.nsINativeDNSResolverOverride
     15 );
     16 
     17 add_task(async function setup() {
     18  Services.prefs.setStringPref("browser.fixup.alternate.prefix", "www.");
     19  Services.prefs.setStringPref("browser.fixup.alternate.suffix", ".com");
     20  Services.prefs.setStringPref("browser.fixup.alternate.protocol", "https");
     21  Services.prefs.setBoolPref(
     22    "browser.urlbar.dnsResolveFullyQualifiedNames",
     23    true
     24  );
     25  registerCleanupFunction(function () {
     26    Services.prefs.clearUserPref("browser.fixup.alternate.prefix");
     27    Services.prefs.clearUserPref("browser.fixup.alternate.suffix");
     28    Services.prefs.clearUserPref("browser.fixup.alternate.protocol");
     29    Services.prefs.clearUserPref(
     30      "browser.urlbar.dnsResolveFullyQualifiedNames"
     31    );
     32  });
     33 });
     34 
     35 // TODO: Export Listener from test_dns_override instead of duping
     36 class Listener {
     37  constructor() {
     38    this.promise = new Promise(resolve => {
     39      this.resolve = resolve;
     40    });
     41  }
     42 
     43  onLookupComplete(inRequest, inRecord, inStatus) {
     44    this.resolve([inRequest, inRecord, inStatus]);
     45  }
     46 
     47  async firstAddress() {
     48    let all = await this.addresses();
     49    if (all.length) {
     50      return all[0];
     51    }
     52    return undefined;
     53  }
     54 
     55  async addresses() {
     56    let [, inRecord] = await this.promise;
     57    let addresses = [];
     58    if (!inRecord) {
     59      return addresses; // returns []
     60    }
     61    inRecord.QueryInterface(Ci.nsIDNSAddrRecord);
     62    while (inRecord.hasMore()) {
     63      addresses.push(inRecord.getNextAddrAsString());
     64    }
     65    return addresses;
     66  }
     67 
     68  then() {
     69    return this.promise.then.apply(this.promise, arguments);
     70  }
     71 }
     72 
     73 const FAKE_IP = "::1";
     74 const FAKE_INTRANET_IP = "::2";
     75 const ORIGIN_ATTRIBUTE = {};
     76 
     77 add_task(async function test_uri_with_force_fixup() {
     78  let listener = new Listener();
     79  let { fixedURI } = Services.uriFixup.forceHttpFixup("http://www.example.com");
     80 
     81  lazy.gDNSOverride.addIPOverride(fixedURI.displayHost, FAKE_IP);
     82 
     83  Services.uriFixup.checkHost(fixedURI, listener, ORIGIN_ATTRIBUTE);
     84  Assert.equal(
     85    await listener.firstAddress(),
     86    FAKE_IP,
     87    "Should've received fake IP"
     88  );
     89 
     90  lazy.gDNSOverride.clearHostOverride(fixedURI.displayHost);
     91  Services.dns.clearCache(false);
     92 });
     93 
     94 add_task(async function test_uri_with_get_fixup() {
     95  let listener = new Listener();
     96  let uri = Services.io.newURI("http://www.example.com");
     97 
     98  lazy.gDNSOverride.addIPOverride(uri.displayHost, FAKE_IP);
     99 
    100  Services.uriFixup.checkHost(uri, listener, ORIGIN_ATTRIBUTE);
    101  Assert.equal(
    102    await listener.firstAddress(),
    103    FAKE_IP,
    104    "Should've received fake IP"
    105  );
    106 
    107  lazy.gDNSOverride.clearHostOverride(uri.displayHost);
    108  Services.dns.clearCache(false);
    109 });
    110 
    111 add_task(async function test_intranet_like_uri() {
    112  let listener = new Listener();
    113  let uri = Services.io.newURI("http://someintranet");
    114 
    115  lazy.gDNSOverride.addIPOverride(uri.displayHost, FAKE_IP);
    116  // Hosts without periods should end with a period to make them FQN
    117  lazy.gDNSOverride.addIPOverride(uri.displayHost + ".", FAKE_INTRANET_IP);
    118 
    119  Services.uriFixup.checkHost(uri, listener, ORIGIN_ATTRIBUTE);
    120  Assert.deepEqual(
    121    await listener.addresses(),
    122    FAKE_INTRANET_IP,
    123    "Should've received fake intranet IP"
    124  );
    125 
    126  lazy.gDNSOverride.clearHostOverride(uri.displayHost);
    127  lazy.gDNSOverride.clearHostOverride(uri.displayHost + ".");
    128  Services.dns.clearCache(false);
    129 });
    130 
    131 add_task(async function test_intranet_like_uri_without_fixup() {
    132  let listener = new Listener();
    133  let uri = Services.io.newURI("http://someintranet");
    134  Services.prefs.setBoolPref(
    135    "browser.urlbar.dnsResolveFullyQualifiedNames",
    136    false
    137  );
    138 
    139  lazy.gDNSOverride.addIPOverride(uri.displayHost, FAKE_IP);
    140  // Hosts without periods should end with a period to make them FQN
    141  lazy.gDNSOverride.addIPOverride(uri.displayHost + ".", FAKE_INTRANET_IP);
    142 
    143  Services.uriFixup.checkHost(uri, listener, ORIGIN_ATTRIBUTE);
    144  Assert.deepEqual(
    145    await listener.addresses(),
    146    FAKE_IP,
    147    "Should've received non-fixed up IP"
    148  );
    149 
    150  lazy.gDNSOverride.clearHostOverride(uri.displayHost);
    151  lazy.gDNSOverride.clearHostOverride(uri.displayHost + ".");
    152  Services.dns.clearCache(false);
    153 });
    154 
    155 add_task(async function test_ip_address() {
    156  let listener = new Listener();
    157  let uri = Services.io.newURI("http://192.168.0.1");
    158 
    159  // Testing IP address being passed into the method
    160  // requires observing if the asyncResolve method gets called
    161  let didResolve = false;
    162  let topic = "uri-fixup-check-dns";
    163  let observer = {
    164    observe(aSubject, aTopicInner) {
    165      if (aTopicInner == topic) {
    166        didResolve = true;
    167      }
    168    },
    169  };
    170  Services.obs.addObserver(observer, topic);
    171  lazy.gDNSOverride.addIPOverride(uri.displayHost, FAKE_IP);
    172 
    173  Services.uriFixup.checkHost(uri, listener, ORIGIN_ATTRIBUTE);
    174  Assert.equal(
    175    didResolve,
    176    false,
    177    "Passing an IP address should not conduct a host lookup"
    178  );
    179 
    180  lazy.gDNSOverride.clearHostOverride(uri.displayHost);
    181  Services.dns.clearCache(false);
    182  Services.obs.removeObserver(observer, topic);
    183 });