tor-browser

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

test_cookiejars.js (5096B)

      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 /*
      6 *  Test that channels with different LoadInfo
      7 *  are stored in separate namespaces ("cookie jars")
      8 */
      9 
     10 "use strict";
     11 
     12 ChromeUtils.defineLazyGetter(this, "URL", function () {
     13  return "http://localhost:" + httpserver.identity.primaryPort;
     14 });
     15 
     16 const { HttpServer } = ChromeUtils.importESModule(
     17  "resource://testing-common/httpd.sys.mjs"
     18 );
     19 
     20 var httpserver = new HttpServer();
     21 
     22 var cookieSetPath = "/setcookie";
     23 var cookieCheckPath = "/checkcookie";
     24 
     25 function inChildProcess() {
     26  return Services.appinfo.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
     27 }
     28 
     29 // Test array:
     30 //  - element 0: name for cookie, used both to set and later to check
     31 //  - element 1: loadInfo (determines cookie namespace)
     32 //
     33 // TODO: bug 722850: make private browsing work per-app, and add tests.  For now
     34 // all values are 'false' for PB.
     35 
     36 var tests = [
     37  {
     38    cookieName: "LCC_App0_BrowF_PrivF",
     39    originAttributes: new OriginAttributes(0),
     40  },
     41  {
     42    cookieName: "LCC_App1_BrowF_PrivF",
     43    originAttributes: new OriginAttributes(1),
     44  },
     45 ];
     46 
     47 // test number: index into 'tests' array
     48 var i = 0;
     49 
     50 function setupChannel(path) {
     51  var chan = NetUtil.newChannel({
     52    uri: URL + path,
     53    loadUsingSystemPrincipal: true,
     54  });
     55  chan.loadInfo.originAttributes = tests[i].originAttributes;
     56  chan.QueryInterface(Ci.nsIHttpChannel);
     57 
     58  let loadGroup = Cc["@mozilla.org/network/load-group;1"].createInstance(
     59    Ci.nsILoadGroup
     60  );
     61 
     62  if (chan.loadInfo.originAttributes.privateBrowsingId == 0) {
     63    loadGroup.notificationCallbacks = Cu.createLoadContext();
     64    chan.loadGroup = loadGroup;
     65 
     66    chan.notificationCallbacks = Cu.createLoadContext();
     67  } else {
     68    loadGroup.notificationCallbacks = Cu.createPrivateLoadContext();
     69    chan.loadGroup = loadGroup;
     70 
     71    chan.notificationCallbacks = Cu.createPrivateLoadContext();
     72  }
     73 
     74  return chan;
     75 }
     76 
     77 function setCookie() {
     78  var channel = setupChannel(cookieSetPath);
     79  channel.setRequestHeader("foo-set-cookie", tests[i].cookieName, false);
     80  channel.asyncOpen(new ChannelListener(setNextCookie, null));
     81 }
     82 
     83 function setNextCookie() {
     84  if (++i == tests.length) {
     85    // all cookies set: switch to checking them
     86    i = 0;
     87    checkCookie();
     88  } else {
     89    info("setNextCookie:i=" + i);
     90    setCookie();
     91  }
     92 }
     93 
     94 // Open channel that should send one and only one correct Cookie: header to
     95 // server, corresponding to it's namespace
     96 function checkCookie() {
     97  var channel = setupChannel(cookieCheckPath);
     98  channel.asyncOpen(new ChannelListener(completeCheckCookie, null));
     99 }
    100 
    101 function completeCheckCookie(request) {
    102  // Look for all cookies in what the server saw: fail if we see any besides the
    103  // one expected cookie for each namespace;
    104  var expectedCookie = tests[i].cookieName;
    105  request.QueryInterface(Ci.nsIHttpChannel);
    106  var cookiesSeen = request.getResponseHeader("foo-saw-cookies");
    107 
    108  var j;
    109  for (j = 0; j < tests.length; j++) {
    110    var cookieToCheck = tests[j].cookieName;
    111    let found = cookiesSeen.includes(cookieToCheck);
    112    if (found && expectedCookie != cookieToCheck) {
    113      do_throw(
    114        "test index " +
    115          i +
    116          ": found unexpected cookie '" +
    117          cookieToCheck +
    118          "': in '" +
    119          cookiesSeen +
    120          "'"
    121      );
    122    } else if (!found && expectedCookie == cookieToCheck) {
    123      do_throw(
    124        "test index " +
    125          i +
    126          ": missing expected cookie '" +
    127          expectedCookie +
    128          "': in '" +
    129          cookiesSeen +
    130          "'"
    131      );
    132    }
    133  }
    134  // If we get here we're good.
    135  info("Saw only correct cookie '" + expectedCookie + "'");
    136  Assert.ok(true);
    137 
    138  if (++i == tests.length) {
    139    // end of tests
    140    httpserver.stop(do_test_finished);
    141  } else {
    142    checkCookie();
    143  }
    144 }
    145 
    146 function run_test() {
    147  // Allow all cookies if the pref service is available in this process.
    148  if (!inChildProcess()) {
    149    Services.prefs.setIntPref("network.cookie.cookieBehavior", 0);
    150    Services.prefs.setBoolPref(
    151      "network.cookieJarSettings.unblocked_for_testing",
    152      true
    153    );
    154  }
    155 
    156  httpserver.registerPathHandler(cookieSetPath, cookieSetHandler);
    157  httpserver.registerPathHandler(cookieCheckPath, cookieCheckHandler);
    158  httpserver.start(-1);
    159 
    160  setCookie();
    161  do_test_pending();
    162 }
    163 
    164 function cookieSetHandler(metadata, response) {
    165  var cookieName = metadata.getHeader("foo-set-cookie");
    166 
    167  response.setStatusLine(metadata.httpVersion, 200, "Ok");
    168  response.setHeader("Set-Cookie", cookieName + "=1; Path=/", false);
    169  response.setHeader("Content-Type", "text/plain");
    170  response.bodyOutputStream.write("Ok", "Ok".length);
    171 }
    172 
    173 function cookieCheckHandler(metadata, response) {
    174  var cookies = metadata.getHeader("Cookie");
    175 
    176  response.setStatusLine(metadata.httpVersion, 200, "Ok");
    177  response.setHeader("foo-saw-cookies", cookies, false);
    178  response.setHeader("Content-Type", "text/plain");
    179  response.bodyOutputStream.write("Ok", "Ok".length);
    180 }