netwerk/test/unit/test_trr_additional_section.js

   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 trr_test_setup();
   8 registerCleanupFunction(async () => {
   9   trr_clear_prefs();
  10 });
  11
  12 function makeChan(url) {
  13   let chan = NetUtil.newChannel({
  14     uri: url,
  15     loadUsingSystemPrincipal: true,
  16   }).QueryInterface(Ci.nsIHttpChannel);
  17   return chan;
  18 }
  19
  20 function channelOpenPromise(chan) {
  21   return new Promise(resolve => {
  22     function finish(req, buffer) {
  23       resolve([req, buffer]);
  24     }
  25     chan.asyncOpen(new ChannelListener(finish));
  26   });
  27 }
  28
  29 let trrServer = new TRRServer();
  30 registerCleanupFunction(async () => {
  31   await trrServer.stop();
  32 });
  33 add_task(async function setup_server() {
  34   await trrServer.start();
  35   dump(`port = ${trrServer.port()}\n`);
  36   let chan = makeChan(`https://localhost:${trrServer.port()}/test?bla=some`);
  37   let [, resp] = await channelOpenPromise(chan);
  38   equal(resp, "<h1> 404 Path not found: /test</h1>");
  39 });
  40
  41 add_task(async function test_parse_additional_section() {
  42   Services.dns.clearCache(true);
  43   Services.prefs.setIntPref("network.trr.mode", 3);
  44   Services.prefs.setCharPref(
  45     "network.trr.uri",
  46     `https://foo.example.com:${trrServer.port()}/dns-query`
  47   );
  48
  49   await trrServer.registerDoHAnswers("something.foo", "A", {
  50     answers: [
  51       {
  52         name: "something.foo",
  53         ttl: 55,
  54         type: "A",
  55         flush: false,
  56         data: "1.2.3.4",
  57       },
  58     ],
  59     additionals: [
  60       {
  61         name: "else.foo",
  62         ttl: 55,
  63         type: "A",
  64         flush: false,
  65         data: "2.3.4.5",
  66       },
  67     ],
  68   });
  69
  70   await new TRRDNSListener("something.foo", { expectedAnswer: "1.2.3.4" });
  71   await new TRRDNSListener("else.foo", { expectedAnswer: "2.3.4.5" });
  72
  73   await trrServer.registerDoHAnswers("a.foo", "A", {
  74     answers: [
  75       {
  76         name: "a.foo",
  77         ttl: 55,
  78         type: "A",
  79         flush: false,
  80         data: "1.2.3.4",
  81       },
  82     ],
  83     additionals: [
  84       {
  85         name: "b.foo",
  86         ttl: 55,
  87         type: "A",
  88         flush: false,
  89         data: "2.3.4.5",
  90       },
  91     ],
  92   });
  93   await trrServer.registerDoHAnswers("b.foo", "A", {
  94     answers: [
  95       {
  96         name: "b.foo",
  97         ttl: 55,
  98         type: "A",
  99         flush: false,
 100         data: "3.4.5.6",
 101       },
 102     ],
 103   });
 104
 105   let req1 = new TRRDNSListener("a.foo", { expectedAnswer: "1.2.3.4" });
 106
 107   // A request for b.foo will be in progress by the time we parse the additional
 108   // record. To keep things simple we don't end up saving the record, instead
 109   // we wait for the in-progress request to complete.
 110   // This check is also racy - if the response for a.foo completes before we make
 111   // this request, we'll put the other IP in the cache. But that is very unlikely.
 112   let req2 = new TRRDNSListener("b.foo", { expectedAnswer: "3.4.5.6" });
 113
 114   await Promise.all([req1, req2]);
 115
 116   // IPv6 additional
 117   await trrServer.registerDoHAnswers("xyz.foo", "A", {
 118     answers: [
 119       {
 120         name: "xyz.foo",
 121         ttl: 55,
 122         type: "A",
 123         flush: false,
 124         data: "1.2.3.4",
 125       },
 126     ],
 127     additionals: [
 128       {
 129         name: "abc.foo",
 130         ttl: 55,
 131         type: "AAAA",
 132         flush: false,
 133         data: "::1:2:3:4",
 134       },
 135     ],
 136   });
 137
 138   await new TRRDNSListener("xyz.foo", { expectedAnswer: "1.2.3.4" });
 139   await new TRRDNSListener("abc.foo", { expectedAnswer: "::1:2:3:4" });
 140
 141   // IPv6 additional
 142   await trrServer.registerDoHAnswers("ipv6.foo", "AAAA", {
 143     answers: [
 144       {
 145         name: "ipv6.foo",
 146         ttl: 55,
 147         type: "AAAA",
 148         flush: false,
 149         data: "2001::a:b:c:d",
 150       },
 151     ],
 152     additionals: [
 153       {
 154         name: "def.foo",
 155         ttl: 55,
 156         type: "AAAA",
 157         flush: false,
 158         data: "::a:b:c:d",
 159       },
 160     ],
 161   });
 162
 163   await new TRRDNSListener("ipv6.foo", { expectedAnswer: "2001::a:b:c:d" });
 164   await new TRRDNSListener("def.foo", { expectedAnswer: "::a:b:c:d" });
 165
 166   // IPv6 additional
 167   await trrServer.registerDoHAnswers("ipv6b.foo", "AAAA", {
 168     answers: [
 169       {
 170         name: "ipv6b.foo",
 171         ttl: 55,
 172         type: "AAAA",
 173         flush: false,
 174         data: "2001::a:b:c:d",
 175       },
 176     ],
 177     additionals: [
 178       {
 179         name: "qqqq.foo",
 180         ttl: 55,
 181         type: "A",
 182         flush: false,
 183         data: "9.8.7.6",
 184       },
 185     ],
 186   });
 187
 188   await new TRRDNSListener("ipv6b.foo", { expectedAnswer: "2001::a:b:c:d" });
 189   await new TRRDNSListener("qqqq.foo", { expectedAnswer: "9.8.7.6" });
 190
 191   // Multiple IPs and multiple additional records
 192   await trrServer.registerDoHAnswers("multiple.foo", "A", {
 193     answers: [
 194       {
 195         name: "multiple.foo",
 196         ttl: 55,
 197         type: "A",
 198         flush: false,
 199         data: "9.9.9.9",
 200       },
 201     ],
 202     additionals: [
 203       {
 204         // Should be ignored, because it should be in the answer section
 205         name: "multiple.foo",
 206         ttl: 55,
 207         type: "A",
 208         flush: false,
 209         data: "1.1.1.1",
 210       },
 211       {
 212         // Is ignored, because it should be in the answer section
 213         name: "multiple.foo",
 214         ttl: 55,
 215         type: "AAAA",
 216         flush: false,
 217         data: "2001::a:b:c:d",
 218       },
 219       {
 220         name: "yuiop.foo",
 221         ttl: 55,
 222         type: "AAAA",
 223         flush: false,
 224         data: "2001::a:b:c:d",
 225       },
 226       {
 227         name: "yuiop.foo",
 228         ttl: 55,
 229         type: "A",
 230         flush: false,
 231         data: "1.2.3.4",
 232       },
 233     ],
 234   });
 235
 236   let { inRecord } = await new TRRDNSListener("multiple.foo", {
 237     expectedAnswer: "9.9.9.9",
 238   });
 239   let IPs = [];
 240   inRecord.QueryInterface(Ci.nsIDNSAddrRecord);
 241   inRecord.rewind();
 242   while (inRecord.hasMore()) {
 243     IPs.push(inRecord.getNextAddrAsString());
 244   }
 245   equal(IPs.length, 1);
 246   equal(IPs[0], "9.9.9.9");
 247   IPs = [];
 248   ({ inRecord } = await new TRRDNSListener("yuiop.foo", {
 249     expectedSuccess: false,
 250   }));
 251   inRecord.QueryInterface(Ci.nsIDNSAddrRecord);
 252   inRecord.rewind();
 253   while (inRecord.hasMore()) {
 254     IPs.push(inRecord.getNextAddrAsString());
 255   }
 256   equal(IPs.length, 2);
 257   equal(IPs[0], "2001::a:b:c:d");
 258   equal(IPs[1], "1.2.3.4");
 259 });
 260
 261 add_task(async function test_additional_after_resolve() {
 262   await trrServer.registerDoHAnswers("first.foo", "A", {
 263     answers: [
 264       {
 265         name: "first.foo",
 266         ttl: 55,
 267         type: "A",
 268         flush: false,
 269         data: "3.4.5.6",
 270       },
 271     ],
 272   });
 273   await new TRRDNSListener("first.foo", { expectedAnswer: "3.4.5.6" });
 274
 275   await trrServer.registerDoHAnswers("second.foo", "A", {
 276     answers: [
 277       {
 278         name: "second.foo",
 279         ttl: 55,
 280         type: "A",
 281         flush: false,
 282         data: "1.2.3.4",
 283       },
 284     ],
 285     additionals: [
 286       {
 287         name: "first.foo",
 288         ttl: 55,
 289         type: "A",
 290         flush: false,
 291         data: "2.3.4.5",
 292       },
 293     ],
 294   });
 295
 296   await new TRRDNSListener("second.foo", { expectedAnswer: "1.2.3.4" });
 297   await new TRRDNSListener("first.foo", { expectedAnswer: "2.3.4.5" });
 298 });
 299
 300 // test for Bug - 1790075
 301 // Crash was observed when a DNS (using TRR) reply contains an additional
 302 // record field and this addditional record was previously unsuccessfully
 303 // resolved
 304 add_task(async function test_additional_cached_record_override() {
 305   Services.dns.clearCache(true);
 306   Services.prefs.setIntPref("network.trr.mode", 2);
 307   Services.prefs.setCharPref(
 308     "network.trr.uri",
 309     `https://foo.example.com:${trrServer.port()}/dns-query`
 310   );
 311
 312   await new TRRDNSListener("else.foo", { expectedAnswer: "127.0.0.1" });
 313
 314   await trrServer.registerDoHAnswers("something.foo", "A", {
 315     answers: [
 316       {
 317         name: "something.foo",
 318         ttl: 55,
 319         type: "A",
 320         flush: false,
 321         data: "1.2.3.4",
 322       },
 323     ],
 324     additionals: [
 325       {
 326         name: "else.foo",
 327         ttl: 55,
 328         type: "A",
 329         flush: false,
 330         data: "2.3.4.5",
 331       },
 332     ],
 333   });
 334
 335   await new TRRDNSListener("something.foo", { expectedAnswer: "1.2.3.4" });
 336   await new TRRDNSListener("else.foo", { expectedAnswer: "2.3.4.5" });
 337 });
 338
 339 add_task(async function test_ipv6_disabled() {
 340   Services.prefs.setBoolPref("network.dns.disableIPv6", true);
 341   await trrServer.registerDoHAnswers("ipv6.foo", "A", {
 342     answers: [
 343       {
 344         name: "ipv6.foo",
 345         ttl: 55,
 346         type: "A",
 347         flush: false,
 348         data: "1.2.3.4",
 349       },
 350     ],
 351     additionals: [
 352       {
 353         name: "sub.ipv6.foo",
 354         ttl: 55,
 355         type: "AAAA",
 356         flush: false,
 357         data: "::1:2:3:4",
 358       },
 359     ],
 360   });
 361
 362   await new TRRDNSListener("ipv6.foo", { expectedAnswer: "1.2.3.4" });
 363   await new TRRDNSListener("sub.ipv6.foo", { expectedSuccess: false });
 364
 365   await trrServer.registerDoHAnswers("direct.ipv6.foo", "AAAA", {
 366     answers: [
 367       {
 368         name: "direct.ipv6.foo",
 369         ttl: 55,
 370         type: "AAAA",
 371         flush: false,
 372         data: "2001::a:b:c:d",
 373       },
 374     ],
 375   });
 376
 377   await new TRRDNSListener("direct.ipv6.foo", { expectedSuccess: false });
 378
 379   Services.prefs.setBoolPref("network.dns.disableIPv6", false);
 380 });