netwerk/test/unit/test_ip_space_glean.js

   1 "use strict";
   2
   3 const override = Cc["@mozilla.org/network/native-dns-override;1"].getService(
   4   Ci.nsINativeDNSResolverOverride
   5 );
   6 const mockNetwork = Cc[
   7   "@mozilla.org/network/mock-network-controller;1"
   8 ].getService(Ci.nsIMockNetworkLayerController);
   9 const certOverrideService = Cc[
  10   "@mozilla.org/security/certoverride;1"
  11 ].getService(Ci.nsICertOverrideService);
  12
  13 const DOMAIN = "example.org";
  14
  15 function makeChan(url) {
  16   let chan = NetUtil.newChannel({
  17     uri: url,
  18     loadUsingSystemPrincipal: true,
  19     contentPolicyType: Ci.nsIContentPolicy.TYPE_DOCUMENT,
  20   }).QueryInterface(Ci.nsIHttpChannel);
  21   return chan;
  22 }
  23
  24 function channelOpenPromise(chan, flags) {
  25   return new Promise(resolve => {
  26     function finish(req, buffer) {
  27       resolve([req, buffer]);
  28       certOverrideService.setDisableAllSecurityChecksAndLetAttackersInterceptMyData(
  29         false
  30       );
  31     }
  32     certOverrideService.setDisableAllSecurityChecksAndLetAttackersInterceptMyData(
  33       true
  34     );
  35     chan.asyncOpen(new ChannelListener(finish, null, flags));
  36   });
  37 }
  38
  39 let server;
  40
  41 add_setup(async function setup() {
  42   Services.prefs.setBoolPref("network.socket.attach_mock_network_layer", true);
  43
  44   Services.fog.initializeFOG();
  45
  46   server = new NodeHTTPServer();
  47   await server.start();
  48   registerCleanupFunction(async () => {
  49     Services.prefs.clearUserPref("network.disable-localhost-when-offline");
  50     Services.prefs.clearUserPref("network.dns.use_override_as_peer_address");
  51     Services.prefs.clearUserPref("dom.security.https_only_mode");
  52     Services.prefs.clearUserPref("dom.security.https_first");
  53     Services.prefs.clearUserPref("dom.security.https_first_schemeless");
  54     Services.prefs.clearUserPref("network.socket.attach_mock_network_layer");
  55     await server.stop();
  56   });
  57 });
  58
  59 function verifyGleanValues(aDescription, aExpected) {
  60   info(aDescription);
  61
  62   let loadIsHttps = aExpected.loadIsHttps || null;
  63   let loadIsHttp = aExpected.loadIsHttp || null;
  64   let loadIsHttpForLocalDomain = aExpected.loadIsHttpForLocalDomain || null;
  65
  66   let glean = Glean.networking.httpsHttpOrLocal;
  67   Assert.equal(
  68     glean.load_is_https.testGetValue(),
  69     loadIsHttps,
  70     "verify load_is_https"
  71   );
  72   Assert.equal(
  73     glean.load_is_http.testGetValue(),
  74     loadIsHttp,
  75     "verify load_is_http"
  76   );
  77   Assert.equal(
  78     glean.load_is_http_for_local_domain.testGetValue(),
  79     loadIsHttpForLocalDomain,
  80     "verify load_is_http_for_local_domain"
  81   );
  82 }
  83
  84 async function do_test(ip, expected, srcPort, dstPort) {
  85   Services.fog.testResetFOG();
  86
  87   override.addIPOverride(DOMAIN, ip);
  88   let fromAddr = mockNetwork.createScriptableNetAddr(ip, srcPort ?? 80);
  89   let toAddr = mockNetwork.createScriptableNetAddr(
  90     fromAddr.family == Ci.nsINetAddr.FAMILY_INET ? "127.0.0.1" : "::1",
  91     dstPort ?? server.port()
  92   );
  93
  94   mockNetwork.addNetAddrOverride(fromAddr, toAddr);
  95
  96   let chan = makeChan(`http://${DOMAIN}`);
  97   let [req] = await channelOpenPromise(chan);
  98   info(
  99     "req.remoteAddress=" +
 100       req.QueryInterface(Ci.nsIHttpChannelInternal).remoteAddress
 101   );
 102   verifyGleanValues(`test ip=${ip}`, expected);
 103
 104   Services.dns.clearCache(false);
 105   override.clearOverrides();
 106   mockNetwork.clearNetAddrOverrides();
 107   Services.obs.notifyObservers(null, "net:prune-all-connections");
 108 }
 109
 110 add_task(async function test_ipv4_local() {
 111   Services.prefs.setBoolPref("dom.security.https_only_mode", false);
 112   Services.prefs.setBoolPref("dom.security.https_first", false);
 113   Services.prefs.setBoolPref("dom.security.https_first_schemeless", false);
 114
 115   await do_test("10.0.0.1", { loadIsHttpForLocalDomain: 1 });
 116   await do_test("172.16.0.1", { loadIsHttpForLocalDomain: 1 });
 117   await do_test("192.168.0.1", { loadIsHttpForLocalDomain: 1 });
 118   await do_test("169.254.0.1", { loadIsHttpForLocalDomain: 1 });
 119   await do_test("127.0.0.1", { loadIsHttpForLocalDomain: 1 });
 120 });
 121
 122 add_task(async function test_ipv6_local() {
 123   await do_test("::1", { loadIsHttpForLocalDomain: 1 });
 124   await do_test("fc00::1", { loadIsHttpForLocalDomain: 1 });
 125   await do_test("fe80::1", { loadIsHttpForLocalDomain: 1 });
 126 });
 127
 128 add_task(async function test_http() {
 129   await do_test("1.1.1.1", { loadIsHttp: 1 });
 130 });
 131
 132 add_task(async function test_https() {
 133   Services.prefs.setBoolPref("dom.security.https_only_mode", true);
 134   let httpsServer = new NodeHTTPSServer();
 135   await httpsServer.start();
 136   registerCleanupFunction(async () => {
 137     await httpsServer.stop();
 138   });
 139   await do_test("1.1.1.1", { loadIsHttps: 1 }, 443, httpsServer.port());
 140 });