tor-browser

browser_wpi_base.js (8402B)

---

// This test is fission-only! Make that clear before continuing, to avoid
// confusing failures.
ok(
 Services.appinfo.fissionAutostart,
 "this test requires fission to function!"
);

requestLongerTimeout(2);

const WebContentIsolationStrategy = {
 IsolateNothing: 0,
 IsolateEverything: 1,
 IsolateHighValue: 2,
};

const COM_ORIGIN = "https://example.com";
const ORG_ORIGIN = "https://example.org";
const MOZ_ORIGIN = "https://www.mozilla.org";

// Helper for building document-builder.sjs URLs which have specific headers &
// HTML content.
function documentURL(origin, headers, html) {
 let params = new URLSearchParams();
 params.append("html", html.trim());
 for (const [key, value] of Object.entries(headers)) {
   params.append("headers", `${key}:${value}`);
 }
 return `${origin}/document-builder.sjs?${params.toString()}`;
}

async function testTreeRemoteTypes(name, testpage) {
 // Use document-builder.sjs to build up the expected document tree.
 function buildURL(path, page) {
   let html = `<h1>${path}</h1>`;
   for (let i = 0; i < page.children.length; ++i) {
     const inner = buildURL(`${path}[${i}]`, page.children[i]);
     html += `<iframe src=${JSON.stringify(inner)}></iframe>`;
   }
   return documentURL(page.origin, page.headers, html);
 }
 const url = buildURL(name, testpage);

 // Load the tab and confirm that properties of the loaded documents match
 // expectation.
 await BrowserTestUtils.withNewTab(url, async browser => {
   let stack = [
     {
       path: name,
       bc: browser.browsingContext,
       ...testpage,
     },
   ];

   while (stack.length) {
     const { path, bc, remoteType, children, origin } = stack.pop();
     is(
       Services.scriptSecurityManager.createContentPrincipal(
         bc.currentWindowGlobal.documentURI,
         {}
       ).originNoSuffix,
       origin,
       `Frame ${path} has expected originNoSuffix`
     );
     is(
       bc.currentWindowGlobal.domProcess.remoteType,
       remoteType,
       `Frame ${path} has expected remote type`
     );
     is(
       bc.children.length,
       children.length,
       `Frame ${path} has the expected number of children`
     );
     for (let i = 0; i < bc.children.length; ++i) {
       stack.push({
         path: `${path}[${i}]`,
         bc: bc.children[i],
         ...children[i],
       });
     }
   }
 });
}

function mkTestPage({
 comRemoteType,
 orgRemoteType,
 mozRemoteType,
 topOrigin,
 topHeaders = {},
 frameHeaders = {},
}) {
 const topRemoteType = {
   [COM_ORIGIN]: comRemoteType,
   [ORG_ORIGIN]: orgRemoteType,
   [MOZ_ORIGIN]: mozRemoteType,
 }[topOrigin];

 const innerChildren = [
   {
     origin: COM_ORIGIN,
     headers: frameHeaders,
     remoteType: comRemoteType,
     children: [],
   },
   {
     origin: ORG_ORIGIN,
     headers: frameHeaders,
     remoteType: orgRemoteType,
     children: [],
   },
   {
     origin: MOZ_ORIGIN,
     headers: frameHeaders,
     remoteType: mozRemoteType,
     children: [],
   },
 ];

 return {
   origin: topOrigin,
   headers: topHeaders,
   remoteType: topRemoteType,
   children: [
     {
       origin: COM_ORIGIN,
       headers: frameHeaders,
       remoteType: comRemoteType,
       children: [...innerChildren],
     },
     {
       origin: ORG_ORIGIN,
       headers: frameHeaders,
       remoteType: orgRemoteType,
       children: [...innerChildren],
     },
     {
       origin: MOZ_ORIGIN,
       headers: frameHeaders,
       remoteType: mozRemoteType,
       children: [...innerChildren],
     },
   ],
 };
}

const heuristics = [
 {
   name: "coop",
   setup_com: async expected => {
     // Set the COOP header, and load
     await testTreeRemoteTypes(
       "com_set_coop",
       mkTestPage({
         topOrigin: COM_ORIGIN,
         topHeaders: { "Cross-Origin-Opener-Policy": "same-origin" },
         comRemoteType: expected.com_high,
         orgRemoteType: expected.org_normal,
         mozRemoteType: expected.moz_normal,
       })
     );
   },
   run_extra_test: async expected => {
     // Load with both the COOP and COEP headers set.
     await testTreeRemoteTypes(
       "com_coop_coep",
       mkTestPage({
         topOrigin: COM_ORIGIN,
         topHeaders: {
           "Cross-Origin-Opener-Policy": "same-origin",
           "Cross-Origin-Embedder-Policy": "require-corp",
         },
         frameHeaders: {
           "Cross-Origin-Embedder-Policy": "require-corp",
           "Cross-Origin-Resource-Policy": "cross-origin",
         },
         comRemoteType: expected.com_coop_coep,
         orgRemoteType: expected.org_coop_coep,
         mozRemoteType: expected.moz_coop_coep,
       })
     );
   },
 },
 {
   name: "hasSavedLogin",
   setup_com: async () => {
     // add .com to the password manager
     let LoginInfo = new Components.Constructor(
       "@mozilla.org/login-manager/loginInfo;1",
       Ci.nsILoginInfo,
       "init"
     );
     await Services.logins.addLoginAsync(
       new LoginInfo(COM_ORIGIN, "", null, "username", "password", "", "")
     );

     // Init login detection service to trigger fetching logins
     let loginDetection = Cc[
       "@mozilla.org/login-detection-service;1"
     ].createInstance(Ci.nsILoginDetectionService);
     loginDetection.init();

     await TestUtils.waitForCondition(() => {
       let x = loginDetection.isLoginsLoaded();
       return x;
     }, "waiting for loading logins from the password manager");
   },
 },
 {
   name: "isLoggedIn",
   setup_com: async () => {
     let p = new Promise(resolve => {
       Services.obs.addObserver(function obs() {
         Services.obs.removeObserver(
           obs,
           "passwordmgr-form-submission-detected"
         );
         resolve();
       }, "passwordmgr-form-submission-detected");
     });

     const TEST_URL = documentURL(
       COM_ORIGIN,
       {},
       `<form>
         <input value="username">
         <input type="password" value="password">
         <input type="submit">
       </form>`
     );

     // submit the form to simulate the login behavior
     await BrowserTestUtils.withNewTab(TEST_URL, async browser => {
       await SpecialPowers.spawn(browser, [], async () => {
         content.document.querySelector("form").submit();
       });
     });
     await p;
   },
 },
];

async function do_tests(expected) {
 for (let heuristic of heuristics) {
   info(`Starting ${heuristic.name} test`);
   // Clear all site-specific data, as we don't want to have any high-value site
   // permissions from any previous iterations.
   Services.logins.removeAllLogins();
   await new Promise(resolve =>
     Services.clearData.deleteData(Ci.nsIClearDataService.CLEAR_ALL, resolve)
   );

   // Loads for basic URLs with no special headers set.
   await testTreeRemoteTypes(
     "basic_com",
     mkTestPage({
       topOrigin: COM_ORIGIN,
       comRemoteType: expected.com_normal,
       orgRemoteType: expected.org_normal,
       mozRemoteType: expected.moz_normal,
     })
   );

   await testTreeRemoteTypes(
     "basic_org",
     mkTestPage({
       topOrigin: ORG_ORIGIN,
       comRemoteType: expected.com_normal,
       orgRemoteType: expected.org_normal,
       mozRemoteType: expected.moz_normal,
     })
   );

   info(`Setting up ${heuristic.name} test`);
   await heuristic.setup_com(expected);

   // Load again after the heuristic is triggered
   info(`Running ${heuristic.name} tests after setup`);
   await testTreeRemoteTypes(
     `com_after_${heuristic.name}`,
     mkTestPage({
       topOrigin: COM_ORIGIN,
       comRemoteType: expected.com_high,
       orgRemoteType: expected.org_normal,
       mozRemoteType: expected.moz_normal,
     })
   );

   // Load again with a .org toplevel
   await testTreeRemoteTypes(
     `org_after_${heuristic.name}`,
     mkTestPage({
       topOrigin: ORG_ORIGIN,
       comRemoteType: expected.com_high,
       orgRemoteType: expected.org_normal,
       mozRemoteType: expected.moz_normal,
     })
   );

   // Run heuristic dependent tests
   if (heuristic.run_extra_test) {
     info(`Running extra tests for ${heuristic.name}`);
     await heuristic.run_extra_test(expected);
   }
 }
}