tor-browser

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

make_unknownFiles.js (4660B)

      1 /**
      2 * Any copyright is dedicated to the Public Domain.
      3 * http://creativecommons.org/publicdomain/zero/1.0/
      4 */
      5 
      6 loadScript("dom/quota/test/common/file.js");
      7 
      8 async function testSteps() {
      9  const principal = getPrincipal("http://example.com");
     10 
     11  const repoRelativePath = "storage/default";
     12  const originRelativePath = `${repoRelativePath}/http+++example.com`;
     13 
     14  let unknownFileCounter = 1;
     15  let unknownDirCounter = 1;
     16 
     17  function createUnknownFileIn(dirRelativePath, recursive) {
     18    const dir = getRelativeFile(dirRelativePath);
     19 
     20    let file = dir.clone();
     21    file.append("foo" + unknownFileCounter + ".bar");
     22 
     23    const ostream = Cc[
     24      "@mozilla.org/network/file-output-stream;1"
     25    ].createInstance(Ci.nsIFileOutputStream);
     26 
     27    ostream.init(file, -1, parseInt("0644", 8), 0);
     28 
     29    ostream.write("x".repeat(unknownFileCounter), unknownFileCounter);
     30 
     31    ostream.close();
     32 
     33    unknownFileCounter++;
     34 
     35    if (recursive) {
     36      const entries = dir.directoryEntries;
     37      while ((file = entries.nextFile)) {
     38        if (file.isDirectory()) {
     39          createUnknownFileIn(dirRelativePath + "/" + file.leafName);
     40        }
     41      }
     42    }
     43  }
     44 
     45  function createUnknownDirectoryIn(dirRelativePath) {
     46    createUnknownFileIn(dirRelativePath + "/foo" + unknownDirCounter++);
     47  }
     48 
     49  // storage.sqlite and storage/ls-archive.sqlite
     50  {
     51    const request = init();
     52    await requestFinished(request);
     53  }
     54 
     55  // Unknown file in the repository
     56  {
     57    createUnknownFileIn(repoRelativePath);
     58  }
     59 
     60  // Unknown file and unknown directory in the origin directory
     61  {
     62    let request = init();
     63    await requestFinished(request);
     64 
     65    request = initTemporaryStorage();
     66    await requestFinished(request);
     67 
     68    request = initTemporaryOrigin("default", principal);
     69    await requestFinished(request);
     70 
     71    Assert.strictEqual(
     72      request.result,
     73      true,
     74      "The origin directory was created"
     75    );
     76 
     77    createUnknownFileIn(originRelativePath);
     78    createUnknownDirectoryIn(originRelativePath);
     79  }
     80 
     81  // Unknown files in idb client directory and its subdirectories and unknown
     82  // directory in .files directory
     83  {
     84    const request = indexedDB.openForPrincipal(principal, "myIndexedDB");
     85    await openDBRequestUpgradeNeeded(request);
     86 
     87    const database = request.result;
     88 
     89    const objectStore = database.createObjectStore("Blobs", {});
     90 
     91    objectStore.add(getNullBlob(200), 42);
     92 
     93    await openDBRequestSucceeded(request);
     94 
     95    database.close();
     96 
     97    createUnknownFileIn(`${originRelativePath}/idb`);
     98    createUnknownFileIn(
     99      `${originRelativePath}/idb/2320029346mByDIdnedxe.files`
    100    );
    101    createUnknownDirectoryIn(
    102      `${originRelativePath}/idb/2320029346mByDIdnedxe.files`
    103    );
    104    createUnknownFileIn(
    105      `${originRelativePath}/idb/2320029346mByDIdnedxe.files/journals`
    106    );
    107  }
    108 
    109  // Unknown files in cache client directory and its subdirectories
    110  {
    111    async function sandboxScript() {
    112      const cache = await caches.open("myCache");
    113      const request = new Request("http://example.com/index.html");
    114      const response = new Response("hello world");
    115      await cache.put(request, response);
    116    }
    117 
    118    const sandbox = new Cu.Sandbox(principal, {
    119      wantGlobalProperties: ["caches", "fetch"],
    120    });
    121 
    122    const promise = new Promise(function (resolve, reject) {
    123      sandbox.resolve = resolve;
    124      sandbox.reject = reject;
    125    });
    126 
    127    Cu.evalInSandbox(
    128      sandboxScript.toSource() + " sandboxScript().then(resolve, reject);",
    129      sandbox
    130    );
    131    await promise;
    132 
    133    createUnknownFileIn(`${originRelativePath}/cache`);
    134    createUnknownFileIn(
    135      `${originRelativePath}/cache/morgue`,
    136      /* recursive */ true
    137    );
    138  }
    139 
    140  // Unknown file and unknown directory in sdb client directory
    141  {
    142    const database = getSimpleDatabase(principal);
    143 
    144    let request = database.open("mySimpleDB");
    145    await requestFinished(request);
    146 
    147    request = database.write(getBuffer(100));
    148    await requestFinished(request);
    149 
    150    request = database.close();
    151    await requestFinished(request);
    152 
    153    createUnknownFileIn(`${originRelativePath}/sdb`);
    154    createUnknownDirectoryIn(`${originRelativePath}/sdb`);
    155  }
    156 
    157  // Unknown file and unknown directory in ls client directory
    158  {
    159    Services.prefs.setBoolPref("dom.storage.testing", true);
    160    Services.prefs.setBoolPref("dom.storage.client_validation", false);
    161 
    162    const storage = Services.domStorageManager.createStorage(
    163      null,
    164      principal,
    165      principal,
    166      ""
    167    );
    168 
    169    storage.setItem("foo", "bar");
    170 
    171    storage.close();
    172 
    173    createUnknownFileIn(`${originRelativePath}/ls`);
    174    createUnknownDirectoryIn(`${originRelativePath}/ls`);
    175  }
    176 }