tor-browser

util.sub.js (6156B)

---

function loadSharedStorageImage(data) {
 let {key, value, hasSharedStorageWritableAttribute, isSameOrigin} = data;
 const encodedKey = encodeURIComponent(key);
 const encodedValue = encodeURIComponent(value);
 const sameOriginSrc = `/shared-storage/resources/` +
     `shared-storage-writable-pixel.png?key=${encodedKey}&value=${encodedValue}`;
 const crossOriginSrc =
     'https://{{domains[www]}}:{{ports[https][0]}}' + sameOriginSrc;

 let image = document.createElement('img');
 image.src = isSameOrigin ? sameOriginSrc : crossOriginSrc;
 if (hasSharedStorageWritableAttribute) {
   image.sharedStorageWritable = true;
 }

 const promise = new Promise((resolve, reject) => {
   image.addEventListener('load', () => {
     resolve(image);
   });
   image.addEventListener('error', () => {
     reject(new Error('Image load failed'));
   });
 });

 document.body.appendChild(image);
 return promise;
}

function navigateSharedStorageIframe(data) {
 let {
   hasSharedStorageWritableAttribute,
   rawWriteHeader,
   isSameOrigin,
   expectSharedStorageWritableHeader
 } = data;
 const writeHeader = encodeURIComponent(rawWriteHeader);
 const sameOriginSrc =
     `/shared-storage/resources/shared-storage-write-notify-parent.py` +
     `?write=${writeHeader}`;
 const crossOriginSrc =
     'https://{{domains[www]}}:{{ports[https][0]}}' + sameOriginSrc;

 let frame = document.createElement('iframe');
 frame.src = isSameOrigin ? sameOriginSrc : crossOriginSrc;
 if (hasSharedStorageWritableAttribute) {
   frame.sharedStorageWritable = true;
 }

 const expectedResult = expectSharedStorageWritableHeader ?
     '?1' :
     'NO_SHARED_STORAGE_WRITABLE_HEADER';

 function checkExpectedResult(data) {
   assert_equals(data.sharedStorageWritableHeader, expectedResult);
 }

 const promise = new Promise((resolve, reject) => {
   window.addEventListener('message', async function handler(evt) {
     if (evt.source === frame.contentWindow) {
       checkExpectedResult(evt.data);
       document.body.removeChild(frame);
       window.removeEventListener('message', handler);
       resolve();
     }
   });
   window.addEventListener('error', () => {
     reject(new Error('Navigation error'));
   });
 });

 document.body.appendChild(frame);
 return promise;
}

async function loadNestedSharedStorageFrameInNewFrame(data) {
 const SCOPE = '/shared-storage/resources/shared-storage-writ';
 const INTERMEDIATE_FRAME_SUFFIX =
     'able-fetch-request-fallback-to-network-iframe.https.html'
 const CROSS_ORIGIN = 'https://{{domains[www]}}:{{ports[https][0]}}';

 let {key, value, hasSharedStorageWritableAttribute, isSameOrigin} = data;

 const windowPromise = new Promise((resolve, reject) => {
   window.addEventListener('message', async function handler(evt) {
     if (evt.data.msg && evt.data.msg === 'iframe loaded') {
       window.removeEventListener('message', handler);
       resolve();
     }
   });
   window.addEventListener('error', () => {
     reject(new Error('Navigation error'));
   });
 });

 const framePromise = new Promise((resolve, reject) => {
   let frame = document.createElement('iframe');
   frame.src = SCOPE + INTERMEDIATE_FRAME_SUFFIX;
   frame.onload = function() {
     resolve(frame);
   };
   frame.onerror = function() {
     reject(new Error('Iframe load failed'));
   };
   document.body.appendChild(frame);
 });
 let frame = await framePromise;

 let rawWriteHeader = `set;key=${key};value=${value}`;
 let writeHeader = encodeURIComponent(rawWriteHeader);
 const sameOriginNestedSrc = `/shared-storage/resources/` +
     `shared-storage-write.py?write=${writeHeader}`;
 const nestedSrc =
     isSameOrigin ? sameOriginNestedSrc : CROSS_ORIGIN + sameOriginNestedSrc;

 let nestedFrame = frame.contentWindow.loadFrame(
     nestedSrc, hasSharedStorageWritableAttribute);
 await windowPromise;
 return {frame: frame, nestedFrame: nestedFrame, nestedFrameUrl: nestedSrc};
}

async function createWorkletAndVerifyDataOrigin(
   t, data_origin, script_origin, expect_success, error_type) {
 if (error_type) {
   assert_false(expect_success);
 }
 const key = 'key0';
 const value = 'value0';
 const sameOrigin = location.origin;
 const sameOriginScriptUrl = `/shared-storage/resources/simple-module.js`;
 const scriptUrl = (script_origin === location.origin) ?
     sameOriginScriptUrl :
     script_origin + sameOriginScriptUrl;
 let dataOrigin = sameOrigin;
 if (data_origin === 'script-origin') {
   dataOrigin = script_origin;
 } else if (data_origin !== '' && data_origin !== 'context-origin') {
   try {
     dataOrigin = new URL(data_origin).origin;
   } catch (e) {
     if (e.message !== 'Failed to construct \'URL\': Invalid URL') {
       throw e;
     }
     assert_false(expect_success);
   }
 }
 const options = (data_origin === '') ?
     {credentials: 'omit'} :
     {credentials: 'omit', dataOrigin: data_origin};
 let success = false;
 let error = null;

 try {
   const worklet = await sharedStorage.createWorklet(scriptUrl, options);

   const ancestor_key = token();
   let url0 =
       generateURL('/shared-storage/resources/frame0.html', [ancestor_key]);

   let select_url_result =
       await worklet.selectURL('test-url-selection-operation', [{url: url0}], {
         data: {'mockResult': 0, 'setKey': key, 'setValue': value},
         resolveToConfig: true,
         keepAlive: true
       });

   assert_true(validateSelectURLResult(select_url_result, true));
   attachFencedFrame(select_url_result, 'opaque-ads');
   const result0 = await nextValueFromServer(ancestor_key);
   assert_equals(result0, 'frame0_loaded');

   await verifyKeyValueForOrigin(key, value, dataOrigin);
   await deleteKeyForOrigin(key, dataOrigin);
   success = true;
 } catch (e) {
   error = e;
   assert_equals(e.name, error_type, e.message);
 } finally {
   assert_equals(
       expect_success, success,
       error ? 'expected success but error thrown: ' + error.toString() :
               'no error caught even though one was expected');
   t.done();
 }
}