From d6325b3c3ecb4e976117ad1a38b5ba6869969bf2 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sun, 8 Nov 2026 06:18:39 +0800 Subject: [PATCH] fix(navigation): retain auxiliary sandbox across document commits Apply the sandbox flags stored on an auxiliary browsing context to each new document environment before parsing and realm bootstrap. Network responses must retain inherited origin, storage and script restrictions while keeping their own CSP constraints. Cover direct window.open, hyperlink activation and an initial blank popup followed by network navigation. Check successive documents, opaque origins, cookie, localStorage and sessionStorage access, request Origin headers, script blocking, noscript parsing and explicit sandbox escape. --- .../popup_network_navigation.rs | 1 + .../popup_network_navigation/sandbox.rs | 304 ++++++++++++++++++ .../src/document_runtime/security_policy.rs | 6 +- .../src/native_bridge/context_host/popups.rs | 4 +- moli-renderer-v8/src/runtime/page_vm/mod.rs | 20 +- .../src/runtime/phase_one/bootstrap.rs | 8 +- moli-renderer-v8/src/runtime/phase_one/mod.rs | 1 + .../src/runtime/phase_one/streaming.rs | 1 + moli-renderer-v8/src/script_vm.rs | 62 +++- 9 files changed, 389 insertions(+), 18 deletions(-) create mode 100644 moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation/sandbox.rs diff --git a/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation.rs b/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation.rs index 6a4a3226920..c6e77cfe3ea 100644 --- a/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation.rs +++ b/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation.rs @@ -9,6 +9,7 @@ mod document_open; mod history_traversal; mod lifecycle; mod policy_inheritance; +mod sandbox; async fn gated_page() -> (SameDocumentPage, Arc) { let gate = Arc::new(ResponseGate { diff --git a/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation/sandbox.rs b/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation/sandbox.rs new file mode 100644 index 00000000000..082e9643311 --- /dev/null +++ b/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation/sandbox.rs @@ -0,0 +1,304 @@ +use super::*; + +const SANDBOX_DOCUMENT: &str = r#""#; + +#[tokio::test(flavor = "multi_thread")] +async fn auxiliary_windows_keep_inherited_sandbox_across_network_documents() { + run_history_test(async { + for kind in ["direct", "link", "blank"] { + for (sandbox, opaque) in [ + ("allow-scripts allow-popups", true), + ( + "allow-scripts allow-popups allow-popups-to-escape-sandbox", + false, + ), + ("allow-scripts allow-popups allow-same-origin", false), + ] { + let routes = axum::Router::new() + .route( + "/sandbox-creator", + axum::routing::get(|| async { axum::response::Html(SANDBOX_DOCUMENT) }), + ) + .route( + "/sandbox-successor", + axum::routing::get(|| async { axum::response::Html(SANDBOX_DOCUMENT) }), + ) + .route( + "/sandbox-origin-check", + axum::routing::post(|headers: axum::http::HeaderMap| async move { + ( + [(axum::http::header::ACCESS_CONTROL_ALLOW_ORIGIN, "*")], + headers + .get(axum::http::header::ORIGIN) + .and_then(|value| value.to_str().ok()) + .unwrap_or("") + .to_owned(), + ) + }), + ); + let mut page = SameDocumentPage::with_routes(routes).await; + let origin = url::Url::parse(&page.base_url) + .unwrap() + .origin() + .ascii_serialization(); + let result = page + .evaluate(&format!( + r#"(async () => {{ + const messages = []; + let finish; + const complete = new Promise(resolve => finish = resolve); + const frame = document.createElement('iframe'); + let ready; + const frameReady = new Promise(resolve => ready = resolve); + addEventListener('message', event => {{ + if (event.data === 'sandbox-frame-ready' && event.source === frame.contentWindow) {{ + ready(); + return; + }} + if (!event.data?.facts) return; + messages.push({{outerOrigin:event.origin, ...event.data}}); + if (messages.length === 2) finish(messages); + }}); + frame.sandbox = {sandbox:?}; + frame.src = '/sandbox-creator?kind={kind}'; + document.body.append(frame); + if ({kind:?} !== 'direct') {{ + await frameReady; + frame.contentWindow.postMessage('start', '*'); + }} + return complete; + }})()"# + )) + .await; + let frame_origin = if sandbox.contains("allow-same-origin") { + origin.as_str() + } else { + "null" + }; + let popup_origin = if opaque { "null" } else { origin.as_str() }; + let access = if opaque { "SecurityError" } else { "allowed" }; + let expected = ["/sandbox-creator", "/sandbox-successor"].map(|phase| { + json!({ + "outerOrigin":frame_origin, + "frameOrigin":frame_origin, + "messageOrigin":popup_origin, + "facts": {"phase":phase, "origin":popup_origin, + "cookie":access, "storage":access, "sessionStorage":access, + "fetchOrigin":popup_origin}, + }) + }); + assert_eq!(result, json!(expected), "{kind}/{sandbox}"); + page.ctx + .process_and_wait_for_response_async(json!({ + "id":1003, "method":"Target.getTargets", "params":{}, + })) + .await; + let targets = take_response_by_id(&mut page.ctx, 1003); + assert!(targets["error"].is_null(), "{targets}"); + let target = targets["result"]["targetInfos"] + .as_array() + .unwrap() + .iter() + .find(|target| { + target["url"] + .as_str() + .is_some_and(|url| url.ends_with("/sandbox-successor")) + }) + .expect("successor popup should remain open for its protocol identity check") + ["targetId"] + .as_str() + .unwrap() + .to_owned(); + page.ctx + .process_and_wait_for_response_async(json!({ + "id":1004, "method":"Target.attachToTarget", + "params":{"targetId":target,"flatten":true}, + })) + .await; + let attached = take_response_by_id(&mut page.ctx, 1004); + assert!(attached["error"].is_null(), "{attached}"); + let session = attached["result"]["sessionId"].as_str().unwrap(); + let tree = page + .command_in_session(session, "Page.getFrameTree", json!({})) + .await; + // Blink projects Page.Frame.securityOrigin from the loader URL. + // The sandboxed origin is checked above through script and fetch. + assert_eq!( + tree["frameTree"]["frame"]["securityOrigin"], + origin.as_str(), + "{kind}/{sandbox}: {tree}" + ); + page.ctx + .process_and_wait_for_response_async(json!({ + "id":1005, "method":"Target.closeTarget", + "params":{"targetId":target}, + })) + .await; + let closed = take_response_by_id(&mut page.ctx, 1005); + assert!(closed["error"].is_null(), "{closed}"); + } + } + }) + .await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn auxiliary_sandbox_script_restrictions_apply_before_parsing_network_documents() { + run_history_test(async { + for (sandbox, csp, scripts_allowed) in [ + ("allow-same-origin allow-popups", false, false), + ("allow-same-origin allow-popups allow-scripts", false, true), + ( + "allow-same-origin allow-popups allow-popups-to-escape-sandbox", + false, + true, + ), + ("allow-same-origin allow-popups allow-scripts", true, false), + ] { + let routes = axum::Router::new().route( + "/sandbox-script-check", + axum::routing::get(move || async move { + let mut headers = axum::http::HeaderMap::new(); + headers.insert( + axum::http::header::CONTENT_TYPE, + axum::http::HeaderValue::from_static("text/html"), + ); + if csp { + headers.insert( + axum::http::header::CONTENT_SECURITY_POLICY, + axum::http::HeaderValue::from_static("sandbox allow-same-origin"), + ); + } + (headers, "") + }), + ); + let mut page = SameDocumentPage::with_routes(routes).await; + page.evaluate(&format!(r#"(async () => {{ + const frame = document.createElement('iframe'); + frame.sandbox = {sandbox:?}; + frame.srcdoc = '

Creator

'; + const loaded = new Promise(resolve => frame.onload = () => {{ + if (frame.contentDocument.URL === 'about:srcdoc') resolve(); + }}); + document.body.append(frame); + await loaded; + const link = frame.contentDocument.createElement('a'); + link.href = '/sandbox-script-check'; + link.target = '_blank'; + link.rel = 'opener'; + frame.contentDocument.body.append(link); + link.click(); + return true; + }})()"#)).await; + let target = page.ctx.sent.iter().rev().find(|message| { + message["method"] == "Target.targetCreated" + && message["params"]["targetInfo"]["url"].as_str() + .is_some_and(|url| url.ends_with("/sandbox-script-check")) + }).expect("sandboxed hyperlink should create an auxiliary target") + ["params"]["targetInfo"]["targetId"].as_str().unwrap().to_owned(); + page.ctx.process_and_wait_for_response_async(json!({ + "id":1003, "method":"Target.attachToTarget", + "params":{"targetId":target,"flatten":true}, + })).await; + let attached = take_response_by_id(&mut page.ctx, 1003); + assert!(attached["error"].is_null(), "{attached}"); + let session = attached["result"]["sessionId"].as_str().unwrap().to_owned(); + let first_url = url::Url::parse(&page.base_url).unwrap() + .join("/sandbox-script-check").unwrap().to_string(); + let first = sandbox_popup_snapshot(&mut page, &session, &first_url).await; + let second_url = format!("{first_url}?successor"); + page.command_in_session(&session, "Page.navigate", json!({"url":second_url})).await; + let second = sandbox_popup_snapshot(&mut page, &session, &second_url).await; + let result = json!([first, second]); + let expected = json!({"ran":scripts_allowed, "fallback":!scripts_allowed}); + assert_eq!(result, json!([expected, expected]), "{sandbox}/csp={csp}"); + } + }).await; +} + +async fn sandbox_popup_snapshot( + page: &mut SameDocumentPage, + session: &str, + expected_url: &str, +) -> serde_json::Value { + page.command_in_session(session, "Page.enable", json!({})) + .await; + let mut tree = page + .command_in_session(session, "Page.getFrameTree", json!({})) + .await; + if tree["frameTree"]["frame"]["url"] != expected_url { + crate::testing::wait_until_scheduler_message( + &mut page.ctx, + "sandbox popup document commit", + |message| { + message["sessionId"] == session + && message["method"] == "Page.frameNavigated" + && message["params"]["frame"]["url"] == expected_url + }, + ) + .await; + tree = page + .command_in_session(session, "Page.getFrameTree", json!({})) + .await; + } + let frame = &tree["frameTree"]["frame"]; + assert_eq!(frame["url"], expected_url, "{tree}"); + crate::testing::wait_until_renderer_document_load( + &mut page.ctx, + Some(session), + frame["id"].as_str().unwrap(), + frame["loaderId"].as_str().unwrap(), + ) + .await; + let result = page.command_in_session(session, "Runtime.evaluate", json!({ + "expression":"({url:document.URL, ready:document.readyState, ran:globalThis.sandboxScriptDidRun === true, fallback:!!document.getElementById('fallback')})", + "returnByValue":true, + })).await; + assert!(result["exceptionDetails"].is_null(), "{result}"); + let value = &result["result"]["value"]; + assert_eq!(value["url"], expected_url); + assert_eq!(value["ready"], "complete"); + json!({"ran":value["ran"],"fallback":value["fallback"]}) +} diff --git a/moli-renderer-v8/src/document_runtime/security_policy.rs b/moli-renderer-v8/src/document_runtime/security_policy.rs index 86b67ab1dc6..6c1d2d713a8 100644 --- a/moli-renderer-v8/src/document_runtime/security_policy.rs +++ b/moli-renderer-v8/src/document_runtime/security_policy.rs @@ -1095,8 +1095,10 @@ impl DocumentRuntime { &mut self, mut policy: DocumentPolicyContainer, ) { - policy.sandbox = DocumentSandboxPolicy::from_response_content_security_policies( - &policy.response_content_security_policies, + policy.sandbox = policy.sandbox.with_response_content_security_policy( + DocumentSandboxPolicy::from_response_content_security_policies( + &policy.response_content_security_policies, + ), ); self.policy_container = policy; self.sync_document_resource_client_policy(); diff --git a/moli-renderer-v8/src/native_bridge/context_host/popups.rs b/moli-renderer-v8/src/native_bridge/context_host/popups.rs index 0ab99d232d7..c3adc7ae368 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/popups.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/popups.rs @@ -1083,7 +1083,9 @@ impl PageScriptHost { }; browsing_context_name .set(trackable_lightweight_popup_window_name(target_name).unwrap_or_default()); - let auxiliary_window = self.browser_context_runtime.new_auxiliary_window(); + let auxiliary_window = self + .browser_context_runtime + .new_auxiliary_window_with_sandbox(initial_policy_container.sandbox); let popup_id = auxiliary_window.id(); let (window, facade_context) = self.bridge.bindings.instantiate_window_proxy_shell(scope); let initial_document_owner = self.allocate_lightweight_popup_document_owner(popup_id); diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rs index 597e669a764..28ef4e2f2b0 100644 --- a/moli-renderer-v8/src/runtime/page_vm/mod.rs +++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs @@ -1279,6 +1279,22 @@ struct PageVmRendererDocumentIsolateBootstrap { } impl PageVmRuntimeHooks { + pub(in crate::runtime) fn apply_auxiliary_sandbox(&self, env: &mut PageVmEnvConfig) { + let window = self + .renderer_page_script_environment + .as_ref() + .and_then(|environment| environment.window_identity().auxiliary_window()); + if let Some(window) = window { + // Auxiliary sandbox flags belong to the browsing context, so a + // network response cannot replace them with its own CSP policy. + // Apply them before parsing and before origin/storage bootstrap. + env.document_policy_container.sandbox = env + .document_policy_container + .sandbox + .with_response_content_security_policy(window.frame_sandbox()); + } + } + pub(in crate::runtime) fn with_web_mcp_navigation( mut self, id: Option, @@ -4492,7 +4508,9 @@ impl PageVm { env.document_policy_container = environment.policy_container.clone(); env }); - let env = inherited_env.as_ref().unwrap_or(env); + let mut document_env = inherited_env.as_ref().unwrap_or(env).clone(); + runtime_hooks.apply_auxiliary_sandbox(&mut document_env); + let env = &document_env; let backend_node_registry = new_shared_renderer_backend_node_registry(); let initial_document_loader_bootstrap = crate::network::context::DocumentResourceLoaderBootstrap::new( diff --git a/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs b/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs index 57601fac012..5dc429dcaf2 100644 --- a/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs +++ b/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs @@ -69,14 +69,16 @@ impl ConcurrentParseTimeRuntime { html: String, started: Instant, ) -> Result { + let mut env = env.clone(); + runtime_hooks.apply_auxiliary_sandbox(&mut env); let mut state = ParseTimeDriverState::new_with_scripting_enabled( final_url.clone(), - main_document_parser_scripting_enabled(env), + main_document_parser_scripting_enabled(&env), ); state .buffered_document_preloads .set_script_fetch_requires_owner_admission(script_preloads_require_owner_admission( - env, + &env, )); state .buffered_document_preloads @@ -117,7 +119,7 @@ impl ConcurrentParseTimeRuntime { page_id, local_executor.clone(), loader.clone(), - env.clone(), + env, runtime_hooks, state, started, diff --git a/moli-renderer-v8/src/runtime/phase_one/mod.rs b/moli-renderer-v8/src/runtime/phase_one/mod.rs index 73750d96ed2..8e9d8ff5728 100644 --- a/moli-renderer-v8/src/runtime/phase_one/mod.rs +++ b/moli-renderer-v8/src/runtime/phase_one/mod.rs @@ -116,6 +116,7 @@ fn script_preloads_require_owner_admission(env: &PageVmEnvConfig) -> bool { pub(in crate::runtime) fn main_document_parser_scripting_enabled(env: &PageVmEnvConfig) -> bool { !env.document_settings.script_execution_disabled + && env.document_policy_container.sandbox.allows_scripts && crate::content_security_policy::content_security_policy_sandbox_allows_scripts( &env.document_policy_container .response_content_security_policies, diff --git a/moli-renderer-v8/src/runtime/phase_one/streaming.rs b/moli-renderer-v8/src/runtime/phase_one/streaming.rs index 082a367414d..8f15040266e 100644 --- a/moli-renderer-v8/src/runtime/phase_one/streaming.rs +++ b/moli-renderer-v8/src/runtime/phase_one/streaming.rs @@ -281,6 +281,7 @@ impl ConcurrentParseTimeRuntime { debug_assert!(!response_headers_indicate_download(&response_headers)); let mut env = env.clone(); env.apply_navigation_response_metadata(&final_url, response_status, &response_headers); + runtime_hooks.apply_auxiliary_sandbox(&mut env); let content_type = content_type.or_else(|| { moli_web_mime::navigation_response_mime_type_from_headers(&response_headers) diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs index 33268e4ab42..92053695ebe 100644 --- a/moli-renderer-v8/src/script_vm.rs +++ b/moli-renderer-v8/src/script_vm.rs @@ -2058,10 +2058,6 @@ impl ScriptVmPageRealmBootstrap { { dom_host.set_document_fallback_base_url_for_handle(document_handle, Some(base)); } - let top_level_storage_key = initial_environment - .as_ref() - .and_then(|environment| environment.storage_key.clone()) - .or(top_level_storage_key); let document_url = dom_host .dom() .final_url() @@ -2070,14 +2066,55 @@ impl ScriptVmPageRealmBootstrap { let document_base_url = dom_host .document_base_url_for_handle(document_handle) .unwrap_or_else(|| document_url.clone()); - let initial_origin = initial_environment - .as_ref() - .map(|environment| environment.origin.clone()) - .unwrap_or_else(|| moli_url::origin_ascii_serialization(&document_url)); - let initial_policy = initial_environment + let creation_sandbox = initial_policy.sandbox; + let mut initial_policy = initial_environment .as_ref() .map(|environment| environment.policy_container.clone()) .unwrap_or(initial_policy); + initial_policy.sandbox = initial_policy + .sandbox + .with_response_content_security_policy(creation_sandbox); + let sandbox_forces_opaque_origin = initial_policy.sandbox.forces_opaque_origin; + let initial_origin = if sandbox_forces_opaque_origin { + "null".to_owned() + } else { + initial_environment + .as_ref() + .map(|environment| environment.origin.clone()) + .unwrap_or_else(|| moli_url::origin_ascii_serialization(&document_url)) + }; + let top_level_storage_key = initial_environment + .as_ref() + .and_then(|environment| environment.storage_key.clone()) + .or(top_level_storage_key); + let top_level_storage_key = if sandbox_forces_opaque_origin { + // Sandboxing creates a fresh opaque Document origin even for an + // HTTP URL. Use it before creating storage and service worker + // clients, preserving only the supplied partition metadata. + let top_level_site = top_level_storage_key + .as_ref() + .map(|key| key.top_level_site().to_owned()) + .unwrap_or_else(|| moli_storage_key::site_for_url(&document_url)); + let relation = moli_storage_key::StoragePartitionRelation::from_sites( + &moli_storage_key::site_for_url(&document_url), + &top_level_site, + ); + let mut key = moli_storage_key::MoliStorageKey::new( + initial_origin.clone(), + top_level_site, + Some(browser_context_runtime.next_web_storage_opaque_context_nonce()), + relation, + ); + if top_level_storage_key + .as_ref() + .is_some_and(|key| key.has_cross_site_ancestor()) + { + key = key.with_cross_site_ancestor(); + } + Some(key) + } else { + top_level_storage_key + }; let mut frame_owner_store = FrameOwnerStore::default(); frame_owner_store.ensure_main_frame( document_handle, @@ -2097,6 +2134,7 @@ impl ScriptVmPageRealmBootstrap { .expect("main Document must own a LocalWindow") .inherited_opaque_origin = initial_environment .as_ref() + .filter(|_| !sandbox_forces_opaque_origin) .and_then(|environment| environment.opaque_origin.clone()); let post_domcontentloaded_page_task_tx = page_task_tx.page_task_sender(); let page_runtime_wake_tx = page_task_tx.page_runtime_wake_sender(); @@ -2125,9 +2163,11 @@ impl ScriptVmPageRealmBootstrap { let inherited_document_domain = initial_environment .as_ref() + .filter(|_| !sandbox_forces_opaque_origin) .map(|environment| environment.document_domain_override.clone()); - let inherited_security_token = - initial_environment.and_then(|environment| environment.security_token); + let inherited_security_token = initial_environment + .filter(|_| !sandbox_forces_opaque_origin) + .and_then(|environment| environment.security_token); let RendererDocumentIsolateBootstrap { initial_document_environment: _, renderer_document_isolate,