tor-browser

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

cache-storage.https.window.js (4333B)

      1 // META: timeout=long
      2 // META: variant=?document
      3 // META: variant=?dedicated_worker
      4 // META: variant=?shared_worker
      5 // META: variant=?service_worker
      6 // META: script=/common/get-host-info.sub.js
      7 // META: script=/common/utils.js
      8 // META: script=/common/dispatcher/dispatcher.js
      9 // META: script=./resources/common.js
     10 
     11 // Fetch a resource and store it into CacheStorage from |storer| context. Then
     12 // check if it can be retrieved via CacheStorage.match from |retriever| context.
     13 const cacheStorageTest = (
     14  description,
     15  storer,
     16  retriever,
     17  resource_headers,
     18  request_credential_mode,
     19  expectation
     20 ) => {
     21  promise_test_parallel(async test => {
     22    const cross_origin = get_host_info().HTTPS_REMOTE_ORIGIN;
     23    const url = cross_origin + "/common/square.png?pipe=" + resource_headers +
     24      `&${token()}`;
     25    const this_token = token();
     26 
     27    // Fetch a request from |stored|. Store the opaque response into
     28    // CacheStorage.
     29    send(storer, `
     30      const cache = await caches.open("v1");
     31      const fetch_request = new Request("${url}", {
     32        mode: 'no-cors',
     33        credentials: '${request_credential_mode}'
     34      });
     35      const fetch_response = await fetch(fetch_request);
     36      await cache.put(fetch_request, fetch_response);
     37      send("${this_token}", "stored");
     38    `);
     39    assert_equals(await receive(this_token), "stored");
     40 
     41    // Retrieved it from |retriever|.
     42    send(retriever, `
     43      const cache = await caches.open("v1");
     44      try {
     45        const response = await cache.match("${url}");
     46        send("${this_token}", "retrieved");
     47      } catch (error) {
     48        send("${this_token}", "error");
     49      }
     50    `);
     51    assert_equals(await receive(this_token), expectation);
     52  }, description);
     53 };
     54 
     55 // Execute the same set of tests for every type of execution contexts:
     56 // Documents, DedicatedWorkers, SharedWorkers, and ServiceWorkers. The results
     57 // should be independent of the context.
     58 const environment = location.search.substr(1);
     59 const constructor = environments[environment];
     60 
     61 const context_none = constructor(coep_none)[0];
     62 const context_credentialless = constructor(coep_credentialless)[0];
     63 const context_require_corp = constructor(coep_require_corp)[0];
     64 
     65 cacheStorageTest(`[${environment}] unsafe-none => unsafe-none`,
     66  context_none,
     67  context_none,
     68  "",
     69  "include",
     70  "retrieved");
     71 cacheStorageTest(`[${environment}] unsafe-none => credentialless`,
     72  context_none,
     73  context_credentialless,
     74  "",
     75  "include",
     76  "error");
     77 cacheStorageTest(`[${environment}] unsafe-none => credentialless (omit)`,
     78  context_none,
     79  context_credentialless,
     80  "",
     81  "omit",
     82  "retrieved");
     83 cacheStorageTest(`[${environment}] unsafe-none => credentialless + CORP`,
     84  context_none,
     85  context_credentialless,
     86  corp_cross_origin,
     87  "include",
     88  "retrieved");
     89 cacheStorageTest(`[${environment}] unsafe-none => require-corp`,
     90  context_none,
     91  context_require_corp,
     92  "",
     93  "include",
     94  "error");
     95 cacheStorageTest(`[${environment}] unsafe-none => require-corp (omit)`,
     96  context_none,
     97  context_require_corp,
     98  "",
     99  "include",
    100  "error");
    101 cacheStorageTest(`[${environment}] unsafe-none => require-corp + CORP`,
    102  context_none,
    103  context_require_corp,
    104  corp_cross_origin,
    105  "include",
    106  "retrieved");
    107 
    108 cacheStorageTest(`[${environment}] credentialless => unsafe-none`,
    109  context_credentialless,
    110  context_none,
    111  "",
    112  "include",
    113  "retrieved");
    114 cacheStorageTest(`[${environment}] credentialless => credentialless`,
    115  context_credentialless,
    116  context_credentialless,
    117  "",
    118  "include",
    119  "retrieved");
    120 cacheStorageTest(`[${environment}] credentialless => require-corp`,
    121  context_credentialless,
    122  context_require_corp,
    123  "",
    124  "include",
    125  "error");
    126 cacheStorageTest(`[${environment}] credentialless => require-corp + CORP`,
    127  context_credentialless,
    128  context_require_corp,
    129  corp_cross_origin,
    130  "include",
    131  "retrieved");
    132 
    133 cacheStorageTest(`[${environment}] require_corp => unsafe-none`,
    134  context_require_corp,
    135  context_none,
    136  corp_cross_origin,
    137  "include",
    138  "retrieved");
    139 cacheStorageTest(`[${environment}] require_corp => credentialless`,
    140  context_require_corp,
    141  context_credentialless,
    142  corp_cross_origin,
    143  "include",
    144  "retrieved");
    145 cacheStorageTest(`[${environment}] require_corp => require-corp`,
    146  context_require_corp,
    147  context_require_corp,
    148  corp_cross_origin,
    149  "include",
    150  "retrieved");