From 2d20fee93768bedef9cc2129d2d63067029f6151 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Thu, 12 Nov 2026 05:20:18 +0800 Subject: [PATCH] fix(policy): preserve header bounds when delegating opaque sources --- moli-renderer-v8/src/permissions_policy.rs | 189 +++++++++++++----- .../permissions_policy/document_feature.rs | 135 +++++++++++++ .../src/runtime/page_vm/tests/mod.rs | 2 + .../tests/opaque_permissions_policy.rs | 112 +++++++++++ .../fixtures/opaque-permissions-policy.js | 35 ++++ 5 files changed, 427 insertions(+), 46 deletions(-) create mode 100644 moli-renderer-v8/src/permissions_policy/document_feature.rs create mode 100644 moli-renderer-v8/src/runtime/page_vm/tests/opaque_permissions_policy.rs create mode 100644 moli-renderer-v8/tests/fixtures/opaque-permissions-policy.js diff --git a/moli-renderer-v8/src/permissions_policy.rs b/moli-renderer-v8/src/permissions_policy.rs index a2a6435d168..56ae4ad6168 100644 --- a/moli-renderer-v8/src/permissions_policy.rs +++ b/moli-renderer-v8/src/permissions_policy.rs @@ -2,8 +2,10 @@ use std::sync::Arc; use url::Url; mod cross_origin_isolation; +mod document_feature; mod sensors; use cross_origin_isolation::CrossOriginIsolationPermission; +use document_feature::DocumentFeaturePolicy; pub(crate) use sensors::SensorPermission; use sensors::SensorPermissionsPolicy; @@ -13,17 +15,17 @@ use sensors::SensorPermissionsPolicy; /// container cannot delegate tools to an origin excluded by its parent header. #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct DocumentPermissionsPolicy { - fullscreen: bool, - gamepad: bool, - midi: bool, + fullscreen: DocumentFeaturePolicy, + gamepad: DocumentFeaturePolicy, + midi: DocumentFeaturePolicy, encrypted_media: bool, encrypted_media_allowlists: Vec<(url::Origin, OriginAllowlist)>, payment: bool, payment_allowlists: Vec<(url::Origin, OriginAllowlist)>, tools: bool, tools_allowlist: Option, - synchronous_xhr: bool, - focus_without_user_activation: bool, + synchronous_xhr: DocumentFeaturePolicy, + focus_without_user_activation: DocumentFeaturePolicy, sensors: SensorPermissionsPolicy, cross_origin_isolation: CrossOriginIsolationPermission, } @@ -31,17 +33,17 @@ pub(crate) struct DocumentPermissionsPolicy { impl Default for DocumentPermissionsPolicy { fn default() -> Self { Self { - fullscreen: true, - gamepad: true, - midi: true, + fullscreen: DocumentFeaturePolicy::default(), + gamepad: DocumentFeaturePolicy::default(), + midi: DocumentFeaturePolicy::default(), encrypted_media: true, encrypted_media_allowlists: Vec::new(), payment: true, payment_allowlists: Vec::new(), tools: true, tools_allowlist: None, - synchronous_xhr: true, - focus_without_user_activation: true, + synchronous_xhr: DocumentFeaturePolicy::default(), + focus_without_user_activation: DocumentFeaturePolicy::default(), sensors: SensorPermissionsPolicy::default(), cross_origin_isolation: CrossOriginIsolationPermission::default(), } @@ -57,24 +59,24 @@ impl DocumentPermissionsPolicy { self.sensors.enabled(sensor) } - pub(crate) const fn fullscreen_enabled(&self) -> bool { - self.fullscreen + pub(crate) fn fullscreen_enabled(&self) -> bool { + self.fullscreen.enabled() } - pub(crate) const fn synchronous_xhr_enabled(&self) -> bool { - self.synchronous_xhr + pub(crate) fn synchronous_xhr_enabled(&self) -> bool { + self.synchronous_xhr.enabled() } - pub(crate) const fn gamepad_enabled(&self) -> bool { - self.gamepad + pub(crate) fn gamepad_enabled(&self) -> bool { + self.gamepad.enabled() } - pub(crate) const fn focus_without_user_activation_enabled(&self) -> bool { - self.focus_without_user_activation + pub(crate) fn focus_without_user_activation_enabled(&self) -> bool { + self.focus_without_user_activation.enabled() } - pub(crate) const fn midi_enabled(&self) -> bool { - self.midi + pub(crate) fn midi_enabled(&self) -> bool { + self.midi.enabled() } pub(crate) const fn encrypted_media_enabled(&self) -> bool { @@ -91,9 +93,9 @@ impl DocumentPermissionsPolicy { pub(crate) fn intersect(&self, other: &Self) -> Self { Self { - fullscreen: self.fullscreen && other.fullscreen, - gamepad: self.gamepad && other.gamepad, - midi: self.midi && other.midi, + fullscreen: self.fullscreen.intersect(&other.fullscreen), + gamepad: self.gamepad.intersect(&other.gamepad), + midi: self.midi.intersect(&other.midi), encrypted_media: self.encrypted_media && other.encrypted_media, encrypted_media_allowlists: self .encrypted_media_allowlists @@ -110,9 +112,10 @@ impl DocumentPermissionsPolicy { .collect(), tools: self.tools && other.tools, tools_allowlist: other.tools_allowlist.clone(), - synchronous_xhr: self.synchronous_xhr && other.synchronous_xhr, - focus_without_user_activation: self.focus_without_user_activation - && other.focus_without_user_activation, + synchronous_xhr: self.synchronous_xhr.intersect(&other.synchronous_xhr), + focus_without_user_activation: self + .focus_without_user_activation + .intersect(&other.focus_without_user_activation), sensors: self.sensors.intersect(&other.sensors), cross_origin_isolation: self .cross_origin_isolation @@ -138,18 +141,20 @@ impl DocumentPermissionsPolicy { policy.sensors.declare(sensor, allowlist, document_url); } if feature.trim().eq_ignore_ascii_case("fullscreen") { - policy.fullscreen = allowed; + policy.fullscreen.declare(allowlist, document_url); } else if feature.trim().eq_ignore_ascii_case("gamepad") { - policy.gamepad = allowed; + policy.gamepad.declare(allowlist, document_url); } else if feature.trim().eq_ignore_ascii_case("midi") { - policy.midi = allowed; + policy.midi.declare(allowlist, document_url); } else if feature.trim().eq_ignore_ascii_case("sync-xhr") { - policy.synchronous_xhr = allowed; + policy.synchronous_xhr.declare(allowlist, document_url); } else if feature .trim() .eq_ignore_ascii_case("focus-without-user-activation") { - policy.focus_without_user_activation = allowed; + policy + .focus_without_user_activation + .declare(allowlist, document_url); } if feature.trim().eq_ignore_ascii_case("payment") { policy.payment = allowed; @@ -254,9 +259,15 @@ impl DocumentPermissionsPolicy { ) .unwrap_or(same_origin); Self { - fullscreen: self.fullscreen && fullscreen, - gamepad: self.gamepad && gamepad, - midi: self.midi && midi, + fullscreen: self + .fullscreen + .delegated_to_child(parent_origin, child_origin, fullscreen), + gamepad: self + .gamepad + .delegated_to_child(parent_origin, child_origin, gamepad), + midi: self + .midi + .delegated_to_child(parent_origin, child_origin, midi), encrypted_media: self.encrypted_media && self.encrypted_media_allows_origin(child_origin) && encrypted_media, @@ -268,9 +279,16 @@ impl DocumentPermissionsPolicy { && self.tools_allows_origin(child_origin, parent_origin) && tools, tools_allowlist: None, - synchronous_xhr: self.synchronous_xhr && synchronous_xhr, - focus_without_user_activation: self.focus_without_user_activation - && focus_without_user_activation, + synchronous_xhr: self.synchronous_xhr.delegated_to_child( + parent_origin, + child_origin, + synchronous_xhr, + ), + focus_without_user_activation: self.focus_without_user_activation.delegated_to_child( + parent_origin, + child_origin, + focus_without_user_activation, + ), sensors: self.sensors.delegated_to_child( parent_origin, child_origin, @@ -288,6 +306,13 @@ impl DocumentPermissionsPolicy { pub(crate) fn for_document_origin(&self, origin: &url::Origin) -> Self { Self { + fullscreen: self.fullscreen.for_document_origin(origin), + gamepad: self.gamepad.for_document_origin(origin), + midi: self.midi.for_document_origin(origin), + synchronous_xhr: self.synchronous_xhr.for_document_origin(origin), + focus_without_user_activation: self + .focus_without_user_activation + .for_document_origin(origin), tools: self.tools && self.tools_allows_origin(origin, origin), payment: self.payment && self.payment_allows_origin(origin), encrypted_media: self.encrypted_media && self.encrypted_media_allows_origin(origin), @@ -392,7 +417,7 @@ fn iframe_allow_feature( } let allowlist = tokens.collect::>(); if allowlist.is_empty() { - return Some(child_origin == source_origin); + return Some(iframe_src_origin_matches(child_origin, source_origin)); } if allowlist .iter() @@ -402,7 +427,8 @@ fn iframe_allow_feature( } Some(allowlist.into_iter().any(|token| { token == "*" - || (token.eq_ignore_ascii_case("'src'") && child_origin == source_origin) + || (token.eq_ignore_ascii_case("'src'") + && iframe_src_origin_matches(child_origin, source_origin)) || (token.eq_ignore_ascii_case("'self'") && child_origin == parent_origin) || Url::parse(token.trim_matches(['\'', '"'])) .ok() @@ -414,6 +440,16 @@ fn iframe_allow_feature( }) } +// 'src' may designate an opaque document. That allowlist permission does not +// change origin identity or make unrelated opaque origins match 'self'. +fn iframe_src_origin_matches(child: &url::Origin, source: &url::Origin) -> bool { + child == source + || matches!( + (child, source), + (url::Origin::Opaque(_), url::Origin::Opaque(_)) + ) +} + fn token_origin_matches(token: &str, url: &Url) -> bool { let token = token.trim_matches(['\'', '"']); Url::parse(token) @@ -425,6 +461,66 @@ fn token_origin_matches(token: &str, url: &Url) -> bool { mod tests { use super::*; + #[test] + fn opaque_src_permissions_do_not_override_parent_feature_declarations() { + let parent_url = url("https://parent.test/"); + let parent = parent_url.origin(); + let child = url::Origin::new_opaque(); + let declared = url::Origin::new_opaque(); + assert_ne!(child, declared); + let features: [(&str, fn(&DocumentPermissionsPolicy) -> bool); 5] = [ + ("fullscreen", DocumentPermissionsPolicy::fullscreen_enabled), + ("gamepad", DocumentPermissionsPolicy::gamepad_enabled), + ("midi", DocumentPermissionsPolicy::midi_enabled), + ( + "sync-xhr", + DocumentPermissionsPolicy::synchronous_xhr_enabled, + ), + ( + "focus-without-user-activation", + DocumentPermissionsPolicy::focus_without_user_activation_enabled, + ), + ]; + for (feature, enabled) in features { + for allow in [ + feature.to_owned(), + format!("{feature} 'src'"), + format!("{feature} *"), + ] { + let delegate = |policy: &DocumentPermissionsPolicy| { + policy.delegated_to_child(&parent, &child, &declared, Some(&allow), false) + }; + assert!( + enabled(&delegate(&DocumentPermissionsPolicy::default())), + "{allow}" + ); + for restriction in ["()", "(self)"] { + let policy = DocumentPermissionsPolicy::from_navigation_response_headers( + &[( + "Permissions-Policy".to_owned(), + format!("{feature}={restriction}").into_bytes(), + )], + &parent_url, + ); + assert!( + !enabled(&delegate(&policy)), + "{feature}={restriction}; {allow}" + ); + } + } + let allow = format!("{feature} 'self'"); + assert!(!enabled( + &DocumentPermissionsPolicy::default().delegated_to_child( + &parent, + &child, + &declared, + Some(&allow), + false, + ) + )); + } + } + impl DocumentPermissionsPolicy { fn delegated_to_child_urls( &self, @@ -793,13 +889,14 @@ mod tests { assert!(!denied.synchronous_xhr_enabled()); assert!(!denied.focus_without_user_activation_enabled()); - let parent_denied = DocumentPermissionsPolicy { - fullscreen: false, - gamepad: false, - synchronous_xhr: false, - focus_without_user_activation: false, - ..Default::default() - }; + let parent_denied = DocumentPermissionsPolicy::from_navigation_response_headers( + &[( + "Permissions-Policy".to_owned(), + b"fullscreen=(), gamepad=(), sync-xhr=(), focus-without-user-activation=()" + .to_vec(), + )], + &parent, + ); let delegated = parent_denied.delegated_to_child_urls_with_fullscreen( &parent, &url("https://other.test/child"), diff --git a/moli-renderer-v8/src/permissions_policy/document_feature.rs b/moli-renderer-v8/src/permissions_policy/document_feature.rs new file mode 100644 index 00000000000..b98351dce21 --- /dev/null +++ b/moli-renderer-v8/src/permissions_policy/document_feature.rs @@ -0,0 +1,135 @@ +use super::{OriginAllowlist, response_origin_allowlist}; +use url::{Origin, Url}; + +/// A Document's own declarations remain separate from its inherited decision. +/// A child receives the evaluated decision, rather than its parent's header. +#[derive(Clone, Debug, PartialEq, Eq)] +pub(super) struct DocumentFeaturePolicy { + inherited: bool, + origin: Option, + declarations: Vec, +} + +impl Default for DocumentFeaturePolicy { + fn default() -> Self { + Self { + inherited: true, + origin: None, + declarations: Vec::new(), + } + } +} + +impl DocumentFeaturePolicy { + pub(super) fn enabled(&self) -> bool { + self.origin + .as_ref() + .map_or(self.inherited, |origin| self.allows_origin(origin, origin)) + } + + fn allows_origin(&self, declaring_origin: &Origin, origin: &Origin) -> bool { + self.inherited + && self.declarations.iter().all(|allowed| { + allowed.matches_self && origin == declaring_origin + || allowed.origins.contains(origin) + }) + } + + pub(super) fn declare(&mut self, allowlist: &str, url: &Url) { + self.declarations = response_origin_allowlist(allowlist).into_iter().collect(); + self.origin = (!self.declarations.is_empty()).then(|| url.origin()); + } + + pub(super) fn for_document_origin(&self, origin: &Origin) -> Self { + Self { + origin: (!self.declarations.is_empty()).then(|| origin.clone()), + ..self.clone() + } + } + + pub(super) fn intersect(&self, other: &Self) -> Self { + Self { + inherited: self.inherited && other.inherited, + origin: other.origin.clone().or_else(|| self.origin.clone()), + declarations: self + .declarations + .iter() + .chain(&other.declarations) + .cloned() + .collect(), + } + } + + pub(super) fn delegated_to_child( + &self, + parent: &Origin, + child: &Origin, + container_allows: bool, + ) -> Self { + Self { + inherited: self.allows_origin(parent, parent) + && self.allows_origin(parent, child) + && container_allows, + ..Self::default() + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn declarations_constrain_parent_and_child_before_container_delegation() { + let url = Url::parse("https://parent.test/").unwrap(); + let parent = url.origin(); + let other = Url::parse("https://other.test/").unwrap().origin(); + let opaque = Origin::new_opaque(); + for (header, same, cross, data) in [ + ("()", false, false, false), + ("(self)", true, false, false), + ("*", true, true, true), + ("(self \"https://other.test\")", true, true, false), + ("(\"https://other.test\")", false, false, false), + ] { + let mut policy = DocumentFeaturePolicy::default(); + policy.declare(header, &url); + for (child, expected) in [(&parent, same), (&other, cross), (&opaque, data)] { + assert_eq!( + policy.delegated_to_child(&parent, child, true).enabled(), + expected, + "{header}: {child:?}" + ); + assert!(!policy.delegated_to_child(&parent, child, false).enabled()); + } + } + } + + #[test] + fn self_refers_to_its_document_and_does_not_merge_distinct_opaque_origins() { + let url = Url::parse("https://parent.test/").unwrap(); + let parent = Origin::new_opaque(); + let different = Origin::new_opaque(); + let mut declared = DocumentFeaturePolicy::default(); + declared.declare("(self)", &url); + let policy = declared.for_document_origin(&parent); + assert!(policy.enabled()); + assert!(policy.delegated_to_child(&parent, &parent, true).enabled()); + assert!( + !policy + .delegated_to_child(&parent, &different, true) + .enabled() + ); + assert_eq!( + DocumentFeaturePolicy::default().for_document_origin(&parent), + DocumentFeaturePolicy::default() + ); + let denied = policy.delegated_to_child(&parent, &different, true); + assert!(denied.declarations.is_empty()); + assert!( + !denied + .intersect(&DocumentFeaturePolicy::default()) + .enabled() + ); + } +} diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs index 35867926cf3..df51bd3d7be 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs @@ -2456,3 +2456,5 @@ mod rtc_data_channel_init; mod rtc_data_channel_send; mod rtc_stats; mod rtp_transceivers; + +mod opaque_permissions_policy; diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/opaque_permissions_policy.rs b/moli-renderer-v8/src/runtime/page_vm/tests/opaque_permissions_policy.rs new file mode 100644 index 00000000000..407adae0b5c --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/tests/opaque_permissions_policy.rs @@ -0,0 +1,112 @@ +use super::*; + +const PROBE: &str = include_str!("../../../../tests/fixtures/opaque-permissions-policy.js"); +const CHILD: &str = ""; + +#[tokio::test] +async fn iframe_src_delegation_preserves_parent_headers_for_opaque_and_tuple_origins() { + run_page_vm_async_test(async move { + let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + listener.set_nonblocking(true).unwrap(); + let origin = format!("http://{}", listener.local_addr().unwrap()); + let server_origin = origin.clone(); + let (stop, mut stopped) = tokio::sync::oneshot::channel::<()>(); + let server = std::thread::spawn(move || { + tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .unwrap() + .block_on(async move { + let listener = TcpListener::from_std(listener).unwrap(); + let mut connections = tokio::task::JoinSet::new(); + loop { + let accepted = tokio::select! { + result = listener.accept() => result.ok(), + _ = &mut stopped => None, + _ = tokio::time::sleep(Duration::from_secs(30)) => None, + }; + let Some((mut stream, _)) = accepted else { break }; + let server_origin = server_origin.clone(); + connections.spawn(async move { + let request = read_http_request_with_body(&mut stream).await.unwrap(); + let path = request.lines().next().unwrap().split_whitespace().nth(1).unwrap(); + let url = Url::parse(&format!("{server_origin}{path}")).unwrap(); + let header = url.query_pairs().find(|(key, _)| key == "policy").map(|(_, value)| value.into_owned()).unwrap_or_default(); + assert!(["", "fullscreen=()", "fullscreen=(self)", "fullscreen=*"].contains(&header.as_str())); + let body = if url.path() == "/child" { + CHILD.to_owned() + } else { + assert_eq!(url.path(), "/page"); + let probe = PROBE.replace("", "<\\/script>"); + format!("") + }; + let extra = if header.is_empty() { String::new() } else { format!("Permissions-Policy: {header}\r\n") }; + let response = format!("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\n{extra}\r\n{body}", body.len()); + let _ = stream.write_all(response.as_bytes()).await; + }); + } + connections.abort_all(); + while connections.join_next().await.is_some() {} + }); + }); + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let mut hooks = PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(); + hooks.resource_task_runner = Some(loader.browser_resource_runtime().resource_task_runner()); + let mut page = test_page_vm_with_loader_document_url_and_hooks( + &loader, + Vec::new(), + Url::parse(&format!("{origin}/root")).unwrap(), + hooks, + ); + page.retain_standalone_request_client_owner_for_test(loader); + let local = page.local_executor.clone(); + local.run(async move { + page.vm_mut().eval(r#" +globalThis.policyResult=null; +(async()=>{ + const html=document.documentElement||document.appendChild(document.createElement('html')); + const body=document.body||html.appendChild(document.createElement('body')); + const rows=[]; + for(const header of ['', 'fullscreen=()', 'fullscreen=(self)', 'fullscreen=*']) { + const frame=document.createElement('iframe'); + const response=new Promise(resolve=>{ + const listener=event=>{ + if(event.source!==frame.contentWindow)return; + removeEventListener('message',listener);resolve(event.data); + };addEventListener('message',listener); + }); + frame.src='/page?policy='+encodeURIComponent(header);body.appendChild(frame); + const value=await response; + if(value.error!==null)throw Error(value.error); + for(const row of value.rows)rows.push({header,...row}); + frame.remove(); + } + policyResult={rows}; +})().catch(error=>policyResult={error:String(error)}); +void 0; + "#)?; + drive_page_work_until_done_with_explicit_producer_admission( + &mut page, + "String(globalThis.policyResult !== null)", + "Real iframe permission reports must finish", + |_| {}, + ).await?; + let result: serde_json::Value = serde_json::from_str(&page.vm_mut().eval("JSON.stringify(policyResult)")?)?; + assert_eq!(result["error"], serde_json::Value::Null, "{result}"); + let rows = result["rows"].as_array().unwrap(); + assert_eq!(rows.len(), 64); + for row in rows { + let allow = row["allow"].as_str(); + let parent_allows = matches!(row["header"].as_str().unwrap(), "" | "fullscreen=*"); + let container_allows = row["fullscreenAttribute"] == true + || matches!(allow, Some("fullscreen" | "fullscreen 'src'" | "fullscreen *" | "payment;fullscreen")); + assert_eq!(row["observed"]["enabled"], parent_allows && container_allows, "{row}"); + assert_eq!(row["sourceMatches"], true); + assert_eq!(row["observed"]["origin"], if row["source"] == "data" { "null".to_owned() } else { origin.replace("127.0.0.1", "localhost") }); + } + anyhow::Ok(()) + }).await.unwrap(); + let _ = stop.send(()); + server.join().unwrap(); + }).await; +} diff --git a/moli-renderer-v8/tests/fixtures/opaque-permissions-policy.js b/moli-renderer-v8/tests/fixtures/opaque-permissions-policy.js new file mode 100644 index 00000000000..5bf1426ed21 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/opaque-permissions-policy.js @@ -0,0 +1,35 @@ + +globalThis.policyRows=[];globalThis.policyError=null;globalThis.policyDone=false; +(async()=>{ + const childSource=''; + for(const source of ['data','tuple']) { + for(const allow of [null, "fullscreen", "fullscreen 'src'", "fullscreen 'self'", "fullscreen 'none'", "fullscreen *", "payment;fullscreen"]) { + const frame=document.createElement('iframe'); + if(allow!==null)frame.setAttribute('allow',allow); + const result=new Promise((resolve,reject)=>{ + const listener=event=>{ + if(event.source!==frame.contentWindow)return; + removeEventListener('message',listener); + resolve({source,allow,fullscreenAttribute:false,observed:event.data,sourceMatches:true}); + }; + addEventListener('message',listener); + frame.onerror=()=>reject(Error('frame loading failed')); + }); + frame.onload=()=>frame.contentWindow.postMessage('inspect','*'); + frame.src=source==='tuple'?location.origin.replace('127.0.0.1','localhost')+'/child':'data:text/html,'+encodeURIComponent(childSource); + document.body.appendChild(frame); + policyRows.push(await result);frame.remove(); + } + const frame=document.createElement('iframe');frame.setAttribute('allowfullscreen',''); + const result=new Promise(resolve=>{ + const listener=event=>{ + if(event.source!==frame.contentWindow)return; + removeEventListener('message',listener); + resolve({source,allow:null,fullscreenAttribute:true,observed:event.data,sourceMatches:true}); + };addEventListener('message',listener); + }); + frame.onload=()=>frame.contentWindow.postMessage('inspect','*'); + frame.src=source==='tuple'?location.origin.replace('127.0.0.1','localhost')+'/child':'data:text/html,'+encodeURIComponent(childSource);document.body.appendChild(frame); + policyRows.push(await result);frame.remove();} + policyDone=true; +})().catch(error=>{policyError=String(error);policyDone=true;});