tor-browser

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

test_dns_service.js (4557B)

      1 "use strict";
      2 
      3 const defaultOriginAttributes = {};
      4 const mainThread = Services.tm.currentThread;
      5 
      6 const overrideService = Cc[
      7  "@mozilla.org/network/native-dns-override;1"
      8 ].getService(Ci.nsINativeDNSResolverOverride);
      9 
     10 class Listener {
     11  constructor() {
     12    this.promise = new Promise(resolve => {
     13      this.resolve = resolve;
     14    });
     15  }
     16 
     17  onLookupComplete(inRequest, inRecord, inStatus) {
     18    this.resolve([inRequest, inRecord, inStatus]);
     19  }
     20 
     21  then() {
     22    return this.promise.then.apply(this.promise, arguments);
     23  }
     24 }
     25 
     26 Listener.prototype.QueryInterface = ChromeUtils.generateQI(["nsIDNSListener"]);
     27 
     28 // This domain used to resolve. We fake the response to avoid
     29 // depending on the network for automated tests.
     30 overrideService.addIPOverride("xn--bcher-kva.org", "127.0.0.1");
     31 
     32 const DOMAIN_IDN = "bücher.org";
     33 const ACE_IDN = "xn--bcher-kva.org";
     34 
     35 const ADDR1 = "127.0.0.1";
     36 const ADDR2 = "::1";
     37 
     38 add_task(async function test_dns_localhost() {
     39  let listener = new Listener();
     40  Services.dns.asyncResolve(
     41    "localhost",
     42    Ci.nsIDNSService.RESOLVE_TYPE_DEFAULT,
     43    0,
     44    null, // resolverInfo
     45    listener,
     46    mainThread,
     47    defaultOriginAttributes
     48  );
     49  let [, inRecord] = await listener;
     50  inRecord.QueryInterface(Ci.nsIDNSAddrRecord);
     51  let answer = inRecord.getNextAddrAsString();
     52  Assert.ok(answer == ADDR1 || answer == ADDR2);
     53 });
     54 
     55 add_task(async function test_idn_cname() {
     56  let listener = new Listener();
     57  Services.dns.asyncResolve(
     58    DOMAIN_IDN,
     59    Ci.nsIDNSService.RESOLVE_TYPE_DEFAULT,
     60    Ci.nsIDNSService.RESOLVE_CANONICAL_NAME,
     61    null, // resolverInfo
     62    listener,
     63    mainThread,
     64    defaultOriginAttributes
     65  );
     66  let [, inRecord] = await listener;
     67  inRecord.QueryInterface(Ci.nsIDNSAddrRecord);
     68  Assert.equal(inRecord.canonicalName, ACE_IDN, "IDN is returned as punycode");
     69 });
     70 
     71 add_task(
     72  {
     73    skip_if: () =>
     74      Services.appinfo.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT,
     75  },
     76  async function test_long_domain() {
     77    let listener = new Listener();
     78    let domain = "a".repeat(253);
     79    overrideService.addIPOverride(domain, "1.2.3.4");
     80    Services.dns.asyncResolve(
     81      domain,
     82      Ci.nsIDNSService.RESOLVE_TYPE_DEFAULT,
     83      Ci.nsIDNSService.RESOLVE_CANONICAL_NAME,
     84      null, // resolverInfo
     85      listener,
     86      mainThread,
     87      defaultOriginAttributes
     88    );
     89    let [, , inStatus] = await listener;
     90    Assert.equal(inStatus, Cr.NS_OK);
     91 
     92    listener = new Listener();
     93    domain = "a".repeat(254);
     94    overrideService.addIPOverride(domain, "1.2.3.4");
     95 
     96    if (mozinfo.socketprocess_networking) {
     97      // When using the socket process, the call fails asynchronously.
     98      Services.dns.asyncResolve(
     99        domain,
    100        Ci.nsIDNSService.RESOLVE_TYPE_DEFAULT,
    101        Ci.nsIDNSService.RESOLVE_CANONICAL_NAME,
    102        null, // resolverInfo
    103        listener,
    104        mainThread,
    105        defaultOriginAttributes
    106      );
    107      let [, , inStatus1] = await listener;
    108      Assert.equal(inStatus1, Cr.NS_ERROR_UNKNOWN_HOST);
    109    } else {
    110      Assert.throws(
    111        () => {
    112          Services.dns.asyncResolve(
    113            domain,
    114            Ci.nsIDNSService.RESOLVE_TYPE_DEFAULT,
    115            Ci.nsIDNSService.RESOLVE_CANONICAL_NAME,
    116            null, // resolverInfo
    117            listener,
    118            mainThread,
    119            defaultOriginAttributes
    120          );
    121        },
    122        /NS_ERROR_UNKNOWN_HOST/,
    123        "Should throw for large domains"
    124      );
    125    }
    126  }
    127 );
    128 
    129 add_task(
    130  {
    131    skip_if: () =>
    132      Services.appinfo.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT,
    133  },
    134  async function test_sort_family() {
    135    Services.prefs.setBoolPref("network.dns.preferIPv6", true);
    136    overrideService.clearOverrides();
    137    overrideService.addIPOverride("example.com", "1.2.3.4");
    138    overrideService.addIPOverride("example.com", "3.4.5.6");
    139    overrideService.addIPOverride("example.com", "::1");
    140    overrideService.addIPOverride("example.com", "::2");
    141 
    142    let listener = new Listener();
    143    Services.dns.asyncResolve(
    144      "example.com",
    145      Ci.nsIDNSService.RESOLVE_TYPE_DEFAULT,
    146      Ci.nsIDNSService.RESOLVE_CANONICAL_NAME,
    147      null, // resolverInfo
    148      listener,
    149      mainThread,
    150      defaultOriginAttributes
    151    );
    152 
    153    let [, inRecord] = await listener;
    154    inRecord.QueryInterface(Ci.nsIDNSAddrRecord);
    155    Assert.equal(inRecord.getNextAddrAsString(), "::1");
    156    Assert.equal(inRecord.getNextAddrAsString(), "::2");
    157    Assert.equal(inRecord.getNextAddrAsString(), "1.2.3.4");
    158    Assert.equal(inRecord.getNextAddrAsString(), "3.4.5.6");
    159  }
    160 );