mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
fix(navigation): validate child ancestor navigation permissions
This commit is contained in:
@@ -1,5 +1,6 @@
|
||||
use super::*;
|
||||
|
||||
mod ancestor_navigation;
|
||||
mod child_beforeunload;
|
||||
mod child_history_traversal;
|
||||
mod cross_origin_navigation;
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
function ancestorNavigationProbe(operation, targetName, destination) {
|
||||
const target = targetName === '_top' || targetName === 'ancestor-top' ? top : parent;
|
||||
let conversions = 0;
|
||||
const value = {toString() { ++conversions; return destination; }};
|
||||
const result = {operation, targetName, before: [navigator.userActivation.isActive, navigator.userActivation.hasBeenActive]};
|
||||
try {
|
||||
if (operation === 'location') target.location = value;
|
||||
else if (operation === 'href') target.location.href = value;
|
||||
else if (operation === 'replace') target.location.replace(value);
|
||||
else if (operation === 'open') result.returnedTarget = open(destination, targetName) === target;
|
||||
else if (operation === 'anchor') {
|
||||
const a = document.body.appendChild(document.createElement('a'));
|
||||
a.href = destination; a.target = targetName; a.click();
|
||||
} else if (operation === 'form' || operation === 'post') {
|
||||
const form = document.body.appendChild(document.createElement('form'));
|
||||
form.action = destination; form.target = targetName;
|
||||
if (operation === 'post') form.method = 'POST';
|
||||
form.submit();
|
||||
}
|
||||
result.outcome = 'returned';
|
||||
} catch (error) {
|
||||
result.outcome = error.name;
|
||||
result.localException = error instanceof DOMException;
|
||||
}
|
||||
result.conversions = conversions;
|
||||
return result;
|
||||
}
|
||||
@@ -0,0 +1,444 @@
|
||||
use super::*;
|
||||
use std::sync::{
|
||||
Arc,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
};
|
||||
|
||||
const PROBE: &str = include_str!("ancestor_navigation.js");
|
||||
const PARENT: &str = r#"<!doctype html><body><script>
|
||||
const params = new URLSearchParams(location.search);
|
||||
const frame = document.createElement('iframe');
|
||||
frame.id = 'source';
|
||||
if (params.has('sandbox')) frame.setAttribute('sandbox', params.get('sandbox'));
|
||||
frame.src = params.get('source');
|
||||
document.body.append(frame);
|
||||
</script>"#;
|
||||
|
||||
struct RemoteOrigin {
|
||||
base_url: String,
|
||||
server: tokio::task::JoinHandle<()>,
|
||||
}
|
||||
|
||||
impl Drop for RemoteOrigin {
|
||||
fn drop(&mut self) {
|
||||
self.server.abort();
|
||||
}
|
||||
}
|
||||
|
||||
impl RemoteOrigin {
|
||||
async fn new(routes: axum::Router) -> Self {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let base_url = format!("http://{}/history.html", listener.local_addr().unwrap());
|
||||
let server = tokio::spawn(async move { axum::serve(listener, routes).await.unwrap() });
|
||||
Self { base_url, server }
|
||||
}
|
||||
}
|
||||
|
||||
fn routes(requests: Arc<AtomicUsize>, request_received: Arc<tokio::sync::Notify>) -> axum::Router {
|
||||
axum::Router::new()
|
||||
.route(
|
||||
"/ancestor-source",
|
||||
axum::routing::get(|| async {
|
||||
axum::response::Html(format!(
|
||||
r#"<!doctype html><body><script>
|
||||
{PROBE}
|
||||
addEventListener('message', event => {{
|
||||
if (event.data.kind !== 'ancestor-probe') return;
|
||||
const {{operation, target, destination}} = event.data;
|
||||
event.source.postMessage({{
|
||||
kind: 'ancestor-result',
|
||||
value: ancestorNavigationProbe(operation, target, destination),
|
||||
}}, '*');
|
||||
}});
|
||||
</script>"#
|
||||
))
|
||||
}),
|
||||
)
|
||||
.route(
|
||||
"/ancestor-parent",
|
||||
axum::routing::get(|| async { axum::response::Html(PARENT) }),
|
||||
)
|
||||
.route(
|
||||
"/ancestor-destination",
|
||||
axum::routing::any(move || {
|
||||
requests.fetch_add(1, Ordering::SeqCst);
|
||||
request_received.notify_one();
|
||||
async { axum::http::StatusCode::NO_CONTENT }
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
struct Case {
|
||||
nested: bool,
|
||||
parent_cross_origin: bool,
|
||||
source_same_origin: bool,
|
||||
target_parent: bool,
|
||||
related_destination: bool,
|
||||
activation: &'static str,
|
||||
sandbox: Option<&'static str>,
|
||||
remove_sandbox: bool,
|
||||
popup: bool,
|
||||
named: bool,
|
||||
}
|
||||
|
||||
async fn check(operation: &str, case: Case, allowed: bool) {
|
||||
tokio::task::LocalSet::new()
|
||||
.run_until(check_in_local_set(operation, case, allowed))
|
||||
.await;
|
||||
}
|
||||
|
||||
async fn check_in_local_set(operation: &str, case: Case, allowed: bool) {
|
||||
let requests = Arc::new(AtomicUsize::new(0));
|
||||
let request_received = Arc::new(tokio::sync::Notify::new());
|
||||
let other = RemoteOrigin::new(routes(requests.clone(), request_received.clone())).await;
|
||||
let mut page =
|
||||
SameDocumentPage::with_routes(routes(requests.clone(), request_received.clone())).await;
|
||||
page.ctx.enable_background_navigation_scheduler_for_test();
|
||||
let source_base = if case.source_same_origin {
|
||||
&page.base_url
|
||||
} else {
|
||||
&other.base_url
|
||||
};
|
||||
let source_url = source_base.replace("/history.html", "/ancestor-source");
|
||||
let mut frame_url = url::Url::parse(&source_url).unwrap();
|
||||
if case.nested {
|
||||
let parent_base = if case.parent_cross_origin {
|
||||
&other.base_url
|
||||
} else {
|
||||
&page.base_url
|
||||
};
|
||||
frame_url =
|
||||
url::Url::parse(&parent_base.replace("/history.html", "/ancestor-parent")).unwrap();
|
||||
frame_url
|
||||
.query_pairs_mut()
|
||||
.append_pair("source", &source_url);
|
||||
if let Some(sandbox) = case.sandbox {
|
||||
frame_url.query_pairs_mut().append_pair("sandbox", sandbox);
|
||||
}
|
||||
}
|
||||
page.evaluate(&format!(
|
||||
r#"(async () => {{
|
||||
globalThis.ancestorContainer = {};
|
||||
ancestorContainer.beforeUnloadCount = 0;
|
||||
ancestorContainer.addEventListener('beforeunload', () => ++ancestorContainer.beforeUnloadCount);
|
||||
const frame = ancestorContainer.document.createElement('iframe');
|
||||
frame.id = 'source';
|
||||
frame.name = 'ancestor-parent';
|
||||
const sandbox = {};
|
||||
if (sandbox !== null) frame.setAttribute('sandbox', sandbox);
|
||||
frame.src = {};
|
||||
const loaded = new Promise(resolve => frame.onload = resolve);
|
||||
ancestorContainer.document.body.append(frame);
|
||||
await loaded;
|
||||
return true;
|
||||
}})()"#,
|
||||
if case.popup { "open('about:blank', 'ancestor-top')" } else { "window" },
|
||||
json!(if case.nested { None } else { case.sandbox }),
|
||||
json!(frame_url.as_str()),
|
||||
)).await;
|
||||
page.command("Runtime.enable", json!({})).await;
|
||||
let context =
|
||||
page.ctx
|
||||
.sent
|
||||
.iter()
|
||||
.rev()
|
||||
.find(|event| {
|
||||
event["method"] == "Runtime.executionContextCreated"
|
||||
&& event["params"]["context"]["name"] == source_url
|
||||
&& event["params"]["context"]["auxData"]["isDefault"] == true
|
||||
})
|
||||
.unwrap_or_else(|| panic!("missing source realm: {}", json!(page.ctx.sent)))["params"]
|
||||
["context"]["id"]
|
||||
.clone();
|
||||
if case.remove_sandbox {
|
||||
page.evaluate(
|
||||
"ancestorContainer.document.getElementById('source').removeAttribute('sandbox')",
|
||||
)
|
||||
.await;
|
||||
}
|
||||
if case.activation == "parent" {
|
||||
page.command(
|
||||
"Runtime.evaluate",
|
||||
json!({"expression": "navigator.userActivation.hasBeenActive", "userGesture": true}),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
if case.activation == "synthetic" {
|
||||
page.command(
|
||||
"Runtime.evaluate",
|
||||
json!({
|
||||
"expression": "document.body.appendChild(document.createElement('button')).click()",
|
||||
"contextId": context,
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
let destination_base = if case.related_destination {
|
||||
&page.base_url
|
||||
} else {
|
||||
&other.base_url
|
||||
};
|
||||
let destination = destination_base.replace("/history.html", "/ancestor-destination");
|
||||
let target = match (case.target_parent, case.named) {
|
||||
(true, false) => "_parent",
|
||||
(false, false) => "_top",
|
||||
(true, true) => "ancestor-parent",
|
||||
(false, true) => "ancestor-top",
|
||||
};
|
||||
if case.activation == "source" {
|
||||
page.command(
|
||||
"Runtime.evaluate",
|
||||
json!({
|
||||
"expression": "navigator.userActivation.hasBeenActive",
|
||||
"contextId": context,
|
||||
"userGesture": true,
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
let result = if case.popup {
|
||||
// Exercise the child realm directly for virtual popup windows, whose
|
||||
// message delivery is managed separately from the opener's page.
|
||||
let response = page
|
||||
.command(
|
||||
"Runtime.evaluate",
|
||||
json!({
|
||||
"expression": format!(
|
||||
"ancestorNavigationProbe({operation:?}, {target:?}, {destination:?})"
|
||||
),
|
||||
"contextId": context,
|
||||
"returnByValue": true,
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
assert!(response["exceptionDetails"].is_null(), "{response}");
|
||||
response["result"]["value"].clone()
|
||||
} else {
|
||||
page.evaluate(&format!(
|
||||
r#"new Promise(resolve => {{
|
||||
const receive = event => {{
|
||||
if (event.data.kind !== 'ancestor-result') return;
|
||||
removeEventListener('message', receive);
|
||||
resolve(event.data.value);
|
||||
}};
|
||||
addEventListener('message', receive);
|
||||
let source = ancestorContainer.document.getElementById('source').contentWindow;
|
||||
if ({}) source = source[0];
|
||||
source.postMessage({{
|
||||
kind: 'ancestor-probe', operation: {operation:?},
|
||||
target: {target:?}, destination: {destination:?},
|
||||
}}, '*');
|
||||
}})"#,
|
||||
case.nested
|
||||
))
|
||||
.await
|
||||
};
|
||||
let location = matches!(operation, "location" | "href" | "replace");
|
||||
assert_eq!(
|
||||
result["outcome"],
|
||||
if !allowed && location {
|
||||
"SecurityError"
|
||||
} else {
|
||||
"returned"
|
||||
},
|
||||
"{operation}/{case:?}: {result}"
|
||||
);
|
||||
assert_eq!(result["conversions"], usize::from(location));
|
||||
if !allowed && location {
|
||||
assert_eq!(result["localException"], true);
|
||||
}
|
||||
if operation == "open" {
|
||||
assert_eq!(result["returnedTarget"], allowed);
|
||||
}
|
||||
assert_eq!(result["before"][1], case.activation == "source", "{result}");
|
||||
if allowed {
|
||||
let description = format!("admitted ancestor navigation request: {operation}/{case:?}");
|
||||
// The HTTP server has its own wake source. A 204 response need not
|
||||
// publish another CDP event after the request counter changes.
|
||||
tokio::select! {
|
||||
() = page.ctx.wait_until_scheduler_state(
|
||||
&description,
|
||||
|_| requests.load(Ordering::SeqCst) == 1,
|
||||
) => {},
|
||||
() = request_received.notified() => {},
|
||||
}
|
||||
assert_eq!(requests.load(Ordering::SeqCst), 1, "{operation}/{case:?}");
|
||||
} else {
|
||||
page.evaluate("new Promise(resolve => setTimeout(resolve, 50))")
|
||||
.await;
|
||||
assert_eq!(requests.load(Ordering::SeqCst), 0, "{operation}");
|
||||
assert_eq!(
|
||||
page.evaluate("ancestorContainer.beforeUnloadCount").await,
|
||||
0
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn ancestor_navigation_rejects_cross_origin_sources_across_all_entry_points() {
|
||||
for operation in [
|
||||
"location", "href", "replace", "open", "anchor", "form", "post",
|
||||
] {
|
||||
check(operation, Case::default(), false).await;
|
||||
check(
|
||||
operation,
|
||||
Case {
|
||||
nested: true,
|
||||
target_parent: true,
|
||||
..Case::default()
|
||||
},
|
||||
false,
|
||||
)
|
||||
.await;
|
||||
check(
|
||||
operation,
|
||||
Case {
|
||||
popup: true,
|
||||
..Case::default()
|
||||
},
|
||||
false,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn ancestor_navigation_rejects_named_ancestor_targets() {
|
||||
for operation in ["open", "anchor", "form", "post"] {
|
||||
check(
|
||||
operation,
|
||||
Case {
|
||||
popup: true,
|
||||
named: true,
|
||||
..Case::default()
|
||||
},
|
||||
false,
|
||||
)
|
||||
.await;
|
||||
check(
|
||||
operation,
|
||||
Case {
|
||||
nested: true,
|
||||
target_parent: true,
|
||||
named: true,
|
||||
..Case::default()
|
||||
},
|
||||
false,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn ancestor_navigation_preserves_accessible_ancestors_activation_and_related_destinations() {
|
||||
for operation in ["href", "open", "anchor", "form", "post"] {
|
||||
check(
|
||||
operation,
|
||||
Case {
|
||||
activation: "source",
|
||||
..Case::default()
|
||||
},
|
||||
true,
|
||||
)
|
||||
.await;
|
||||
check(
|
||||
operation,
|
||||
Case {
|
||||
related_destination: true,
|
||||
..Case::default()
|
||||
},
|
||||
true,
|
||||
)
|
||||
.await;
|
||||
check(
|
||||
operation,
|
||||
Case {
|
||||
nested: true,
|
||||
parent_cross_origin: true,
|
||||
source_same_origin: true,
|
||||
target_parent: true,
|
||||
..Case::default()
|
||||
},
|
||||
true,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn ancestor_navigation_activation_belongs_to_the_source_and_only_unlocks_the_top() {
|
||||
for activation in ["parent", "synthetic"] {
|
||||
check(
|
||||
"href",
|
||||
Case {
|
||||
activation,
|
||||
..Case::default()
|
||||
},
|
||||
false,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
check(
|
||||
"href",
|
||||
Case {
|
||||
nested: true,
|
||||
target_parent: true,
|
||||
activation: "source",
|
||||
..Case::default()
|
||||
},
|
||||
false,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn ancestor_navigation_uses_committed_sandbox_flags_and_ancestor_delegation() {
|
||||
for (sandbox, needs_activation) in [
|
||||
("allow-scripts allow-same-origin", None),
|
||||
(
|
||||
"allow-scripts allow-same-origin allow-top-navigation",
|
||||
Some(false),
|
||||
),
|
||||
(
|
||||
"allow-scripts allow-same-origin allow-top-navigation-by-user-activation",
|
||||
Some(true),
|
||||
),
|
||||
] {
|
||||
for activation in ["none", "source"] {
|
||||
let allowed =
|
||||
needs_activation.is_some_and(|required| !required || activation == "source");
|
||||
check(
|
||||
"href",
|
||||
Case {
|
||||
sandbox: Some(sandbox),
|
||||
activation,
|
||||
..Case::default()
|
||||
},
|
||||
allowed,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
check(
|
||||
"href",
|
||||
Case {
|
||||
sandbox: Some("allow-scripts allow-same-origin"),
|
||||
remove_sandbox: true,
|
||||
..Case::default()
|
||||
},
|
||||
false,
|
||||
)
|
||||
.await;
|
||||
check(
|
||||
"href",
|
||||
Case {
|
||||
nested: true,
|
||||
parent_cross_origin: true,
|
||||
sandbox: Some("allow-scripts allow-same-origin allow-top-navigation"),
|
||||
..Case::default()
|
||||
},
|
||||
false,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
@@ -81,6 +81,7 @@ moli-script = { path = "../moli-script" }
|
||||
moli-site = { path = "../moli-site" }
|
||||
moli-session-history = { path = "../moli-session-history" }
|
||||
moli-history = { path = "../moli-history" }
|
||||
moli-site = { path = "../moli-site" }
|
||||
moli-stylesheet-blocking = { path = "../moli-stylesheet-blocking" }
|
||||
moli-sqlite = { path = "../moli-sqlite" }
|
||||
moli-web-storage = { path = "../moli-web-storage" }
|
||||
|
||||
@@ -214,7 +214,6 @@ pub(crate) use location_navigation::{
|
||||
navigate_location_object_for_hyperlink, navigate_location_object_with_child_navigate_event,
|
||||
navigate_location_object_with_source_element, navigate_top_level_meta_refresh,
|
||||
navigate_top_level_same_document_from_browser, resolve_cross_window_location_target,
|
||||
sandbox_blocks_ancestor_or_top_navigation_from_source,
|
||||
};
|
||||
pub(crate) use navigation_cancellation::{
|
||||
NavigationCancellationReason, inform_about_canceled_navigation_for_window,
|
||||
|
||||
@@ -37,8 +37,7 @@ use super::navigation_serialize::serialize_history_entries;
|
||||
use super::navigation_window::{
|
||||
child_browsing_context_handle_for_runtime_owner, navigation_document_has_disabled_entries,
|
||||
navigation_document_is_active, navigation_unload_event_active, runtime_window_is_global,
|
||||
runtime_window_owner, runtime_window_uses_top_level_history_model, window_history_for_holder,
|
||||
window_location_for_holder,
|
||||
runtime_window_owner, window_history_for_holder, window_location_for_holder,
|
||||
};
|
||||
use super::*;
|
||||
use crate::native_bridge::NavigationHistoryEntrySeed;
|
||||
@@ -440,14 +439,6 @@ fn navigate_location_object_with_source_element_and_child_navigate_event<'s>(
|
||||
}
|
||||
}
|
||||
let exact_same_href = current_href == resolved.as_str();
|
||||
if !matches!(kind, LocationNavigationKind::Reload)
|
||||
&& exact_same_href
|
||||
&& source_element.is_none()
|
||||
&& raw_target_is_fragment_only
|
||||
&& !force_exact_same_document_navigation
|
||||
{
|
||||
return;
|
||||
}
|
||||
let owner = runtime_window_owner(scope, location);
|
||||
let source_can_access_target = source_can_access_target.unwrap_or_else(|| {
|
||||
let Some(host_ptr) = context_host_ptr_for_navigation_owner(scope, owner) else {
|
||||
@@ -469,14 +460,22 @@ fn navigate_location_object_with_source_element_and_child_navigate_event<'s>(
|
||||
{
|
||||
return;
|
||||
}
|
||||
if sandbox_blocks_ancestor_or_top_location_navigation(scope, owner) {
|
||||
if blocks_ancestor_location_navigation(scope, owner, &resolved) {
|
||||
crate::context_bootstrap::throw_dom_exception_value(
|
||||
scope,
|
||||
"Blocked a sandboxed frame from navigating an ancestor browsing context.",
|
||||
"The source frame is not allowed to navigate this ancestor browsing context.",
|
||||
"SecurityError",
|
||||
);
|
||||
return;
|
||||
}
|
||||
if !matches!(kind, LocationNavigationKind::Reload)
|
||||
&& exact_same_href
|
||||
&& source_element.is_none()
|
||||
&& raw_target_is_fragment_only
|
||||
&& !force_exact_same_document_navigation
|
||||
{
|
||||
return;
|
||||
}
|
||||
if matches!(kind, LocationNavigationKind::Reload)
|
||||
&& matches!(
|
||||
navigation_reload_admission(scope, owner),
|
||||
@@ -1078,22 +1077,10 @@ fn capture_location_navigation_source<'s>(
|
||||
}
|
||||
}
|
||||
|
||||
fn sandbox_blocks_ancestor_or_top_location_navigation<'s>(
|
||||
fn blocks_ancestor_location_navigation<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> bool {
|
||||
let Some(source_handle) =
|
||||
crate::context_bootstrap::current_child_browsing_context_handle_for_runtime_scope(scope)
|
||||
else {
|
||||
return false;
|
||||
};
|
||||
sandbox_blocks_ancestor_or_top_navigation_from_source(scope, source_handle, owner)
|
||||
}
|
||||
|
||||
pub(crate) fn sandbox_blocks_ancestor_or_top_navigation_from_source<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
source_handle: crate::document_runtime::DomHandle,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
destination: &url::Url,
|
||||
) -> bool {
|
||||
let Some(host_ptr) = context_host_ptr_for_navigation_owner(scope, owner)
|
||||
.or_else(|| context_host_ptr_from_global_bridge(scope))
|
||||
@@ -1101,35 +1088,14 @@ pub(crate) fn sandbox_blocks_ancestor_or_top_navigation_from_source<'s>(
|
||||
return false;
|
||||
};
|
||||
let host = unsafe { &*host_ptr };
|
||||
if host.child_browsing_context_allows_top_navigation(source_handle) {
|
||||
let Some(target) = super::navigation_window::runtime_window_dispatch_scope(scope, owner) else {
|
||||
return false;
|
||||
}
|
||||
if let Some(popup_id) = crate::native_bridge::lightweight_popup_id_from_window(scope, owner)
|
||||
&& host.lightweight_popup_id_for_node_owner_document(source_handle) != Some(popup_id)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
match child_browsing_context_handle_for_runtime_owner(scope, owner) {
|
||||
Some(target_handle) => {
|
||||
child_browsing_context_is_ancestor(host, target_handle, source_handle)
|
||||
}
|
||||
None => runtime_window_uses_top_level_history_model(scope, owner),
|
||||
}
|
||||
}
|
||||
|
||||
fn child_browsing_context_is_ancestor(
|
||||
host: &PageScriptHost,
|
||||
ancestor: crate::document_runtime::DomHandle,
|
||||
child: crate::document_runtime::DomHandle,
|
||||
) -> bool {
|
||||
let mut current = host.child_browsing_context_parent_handle(child);
|
||||
while let Some(handle) = current {
|
||||
if handle == ancestor {
|
||||
return true;
|
||||
}
|
||||
current = host.child_browsing_context_parent_handle(handle);
|
||||
}
|
||||
false
|
||||
};
|
||||
host.blocks_ancestor_navigation(
|
||||
location_navigation_initiator_scope(scope, host),
|
||||
target,
|
||||
destination,
|
||||
)
|
||||
}
|
||||
|
||||
fn window_for_child_cross_document_location_navigation<'s>(
|
||||
@@ -1377,13 +1343,19 @@ fn location_navigation_initiator_scope(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host: &PageScriptHost,
|
||||
) -> crate::native_bridge::OwnerDispatchScope {
|
||||
let incumbent = scope
|
||||
.get_incumbent_context()
|
||||
.and_then(|context| host.window_execution_context_identity_for_access_check(context))
|
||||
.map(|identity| identity.dispatch_scope());
|
||||
// Popup callbacks share the main realm, but a real child realm keeps its
|
||||
// own source identity when it calls a popup ancestor's Location binding.
|
||||
if let Some(source @ crate::native_bridge::OwnerDispatchScope::Child(_)) = incumbent {
|
||||
return source;
|
||||
}
|
||||
if let Some(popup_id) = crate::native_bridge::active_lightweight_popup_id(scope) {
|
||||
return crate::native_bridge::OwnerDispatchScope::LightweightPopup(popup_id);
|
||||
}
|
||||
scope
|
||||
.get_incumbent_context()
|
||||
.and_then(|context| host.window_execution_context_identity_for_access_check(context))
|
||||
.map(|identity| identity.dispatch_scope())
|
||||
incumbent
|
||||
.or_else(|| {
|
||||
crate::context_bootstrap::current_child_browsing_context_handle_for_runtime_scope(scope)
|
||||
.map(crate::native_bridge::OwnerDispatchScope::Child)
|
||||
|
||||
@@ -292,14 +292,11 @@ pub(crate) fn window_open_callback<'s>(
|
||||
target @ (SpecialBrowsingContextTarget::Parent | SpecialBrowsingContextTarget::Top),
|
||||
) = special_target
|
||||
{
|
||||
let source_window = if window_receiver_child_handle(scope, args.this()).is_some() {
|
||||
args.this()
|
||||
} else {
|
||||
entered_window
|
||||
};
|
||||
let source = entered_window_dispatch_scope(scope, unsafe { &*host_ptr });
|
||||
match navigate_existing_browsing_context_target(
|
||||
scope,
|
||||
source_window,
|
||||
host_ptr,
|
||||
source,
|
||||
target,
|
||||
url.as_deref(),
|
||||
) {
|
||||
@@ -312,6 +309,22 @@ pub(crate) fn window_open_callback<'s>(
|
||||
existing_named_child_window_for_window_open(scope, host_ptr, &parsed.target_name)
|
||||
&& !suppress_opener
|
||||
{
|
||||
let host = unsafe { &*host_ptr };
|
||||
let source = entered_window_dispatch_scope(scope, host);
|
||||
if url
|
||||
.as_deref()
|
||||
.and_then(|url| Url::parse(url).ok())
|
||||
.is_some_and(|url| {
|
||||
host.blocks_ancestor_navigation(
|
||||
source,
|
||||
OwnerDispatchScope::Child(target_handle),
|
||||
&url,
|
||||
)
|
||||
})
|
||||
{
|
||||
rv.set(v8::null(scope).into());
|
||||
return;
|
||||
}
|
||||
let opener_child_handle = window_open_receiver_child_handle(scope, entered_window);
|
||||
let opener_endpoint = opener_child_handle
|
||||
.map(PendingWindowMessageEndpoint::ChildWindow)
|
||||
@@ -334,6 +347,17 @@ pub(crate) fn window_open_callback<'s>(
|
||||
}
|
||||
}
|
||||
let host = unsafe { &mut *host_ptr };
|
||||
if let Some(popup_id) = host.named_lightweight_popup_id(&parsed.target_name)
|
||||
&& let Some(destination) = url.as_deref().and_then(|url| Url::parse(url).ok())
|
||||
&& host.blocks_ancestor_navigation(
|
||||
entered_window_dispatch_scope(scope, host),
|
||||
OwnerDispatchScope::LightweightPopup(popup_id),
|
||||
&destination,
|
||||
)
|
||||
{
|
||||
rv.set(v8::null(scope).into());
|
||||
return;
|
||||
}
|
||||
// Only a newly selected browsing context defaults an omitted URL to
|
||||
// about:blank. Reusing a target must preserve its current document and any
|
||||
// navigation already in flight.
|
||||
|
||||
@@ -397,6 +397,7 @@ impl PageScriptHost {
|
||||
replaced_document_handle, expected_current_document_handle,
|
||||
"adapter document handle must change in the same owner commit"
|
||||
);
|
||||
self.capture_child_top_navigation_permission(handle);
|
||||
if let Some(loader_id) = loader_id {
|
||||
self.child_browsing_contexts
|
||||
.get_mut(&handle)
|
||||
|
||||
@@ -169,6 +169,7 @@ impl PageScriptHost {
|
||||
);
|
||||
|
||||
self.populate_initial_empty_child_html_document(document_handle);
|
||||
self.capture_child_top_navigation_permission(handle);
|
||||
self.dom_host_mut()
|
||||
.mark_subtree_connected_preserving_owner_document(document_handle);
|
||||
self.install_empty_child_classic_script_runner_for_current_document(
|
||||
|
||||
@@ -2473,6 +2473,12 @@ fn live_location_for_cross_origin_window<'s>(
|
||||
};
|
||||
let host_ptr = context_host_ptr_from_global_bridge(scope)?;
|
||||
let host = unsafe { &mut *host_ptr };
|
||||
if let super::super::OwnerDispatchScope::LightweightPopup(popup_id) = dispatch_scope {
|
||||
// Lightweight popups share a V8 realm with the opener. Its global is
|
||||
// not the popup's Window and must not supply this proxy's Location.
|
||||
let window = host.lightweight_popup_window(scope, popup_id)?;
|
||||
return crate::context_bootstrap::window_location_for_holder(scope, window);
|
||||
}
|
||||
let owner = host.current_window_execution_context_owner(dispatch_scope)?;
|
||||
let (_, context) = host.window_execution_context(scope, owner, dispatch_scope)?;
|
||||
crate::context_bootstrap::window_location_for_holder(scope, context.global(scope))
|
||||
|
||||
@@ -74,6 +74,9 @@ pub(super) struct ChildBrowsingContextEntry {
|
||||
srcdoc_history:
|
||||
HashMap<NavigationHistoryDocumentId, Arc<srcdoc_history::SrcdocHistoryResource>>,
|
||||
document_policy_container: ChildDocumentPolicyContainer,
|
||||
// Captured at Document commit; changing sandbox or document.domain must
|
||||
// not grant a descendant permission to navigate the top without activation.
|
||||
pub(super) can_navigate_top_without_user_gesture: bool,
|
||||
document_internal_ancestor_origins: Vec<WindowAccessOrigin>,
|
||||
ancestor_origins_referrer_policy_snapshot: ChildAncestorOriginsReferrerPolicy,
|
||||
completed_frame_owner_resource_timing: Option<CompletedFrameOwnerResourceTiming>,
|
||||
|
||||
@@ -593,6 +593,9 @@ impl PageScriptHost {
|
||||
.map(|entry| entry.srcdoc_history.clone())
|
||||
.unwrap_or_default(),
|
||||
document_policy_container,
|
||||
can_navigate_top_without_user_gesture: existing
|
||||
.as_ref()
|
||||
.is_some_and(|entry| entry.can_navigate_top_without_user_gesture),
|
||||
document_internal_ancestor_origins,
|
||||
ancestor_origins_referrer_policy_snapshot,
|
||||
completed_frame_owner_resource_timing: existing.as_ref().and_then(
|
||||
|
||||
@@ -924,36 +924,6 @@ impl PageScriptHost {
|
||||
(policy.sandboxes_document_domain && !policy.allows_popups_to_escape).then_some(policy)
|
||||
}
|
||||
|
||||
pub(crate) fn child_browsing_context_allows_top_navigation(&self, handle: DomHandle) -> bool {
|
||||
self.child_browsing_contexts
|
||||
.get(&handle)
|
||||
.is_some_and(|entry| entry.document_sandbox_policy().allows_top_navigation)
|
||||
}
|
||||
|
||||
pub(crate) fn sandbox_blocks_ancestor_navigation(
|
||||
&self,
|
||||
source: OwnerDispatchScope,
|
||||
target: OwnerDispatchScope,
|
||||
) -> bool {
|
||||
let OwnerDispatchScope::Child(source_handle) = source else {
|
||||
return false;
|
||||
};
|
||||
if self.child_browsing_context_allows_top_navigation(source_handle) {
|
||||
return false;
|
||||
}
|
||||
let mut ancestor = self.owner_dispatch_scope_for_node(source_handle);
|
||||
while let Some(owner) = ancestor {
|
||||
if owner == target {
|
||||
return true;
|
||||
}
|
||||
ancestor = match owner {
|
||||
OwnerDispatchScope::Child(handle) => self.owner_dispatch_scope_for_node(handle),
|
||||
OwnerDispatchScope::Top | OwnerDispatchScope::LightweightPopup(_) => None,
|
||||
};
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub(crate) fn sandbox_allows_history_traversal(
|
||||
&self,
|
||||
source: OwnerDispatchScope,
|
||||
|
||||
@@ -142,6 +142,7 @@ pub(crate) use mouse_click::MouseReleaseFollowUp;
|
||||
#[cfg(feature = "devtools")]
|
||||
pub(crate) use mouse_click::common_flat_tree_ancestor;
|
||||
mod navigation;
|
||||
mod navigation_permissions;
|
||||
mod navigator_overrides;
|
||||
mod opfs_tasks;
|
||||
mod permissions;
|
||||
|
||||
@@ -0,0 +1,163 @@
|
||||
use super::{OwnerDispatchScope, PageScriptHost, window_security_tokens::WindowAccessOrigin};
|
||||
use url::Url;
|
||||
|
||||
impl PageScriptHost {
|
||||
/// Admission for a child navigating one of its ancestors. Location,
|
||||
/// hyperlinks and forms must check the source before entering the target
|
||||
/// realm or publishing navigation work.
|
||||
pub(crate) fn blocks_ancestor_navigation(
|
||||
&self,
|
||||
source: OwnerDispatchScope,
|
||||
target: OwnerDispatchScope,
|
||||
destination: &Url,
|
||||
) -> bool {
|
||||
let OwnerDispatchScope::Child(source_handle) = source else {
|
||||
return false;
|
||||
};
|
||||
let mut ancestor = self.navigation_parent_scope(source);
|
||||
while let Some(owner) = ancestor {
|
||||
if owner == target {
|
||||
break;
|
||||
}
|
||||
ancestor = self.navigation_parent_scope(owner);
|
||||
}
|
||||
if ancestor.is_none() {
|
||||
return false;
|
||||
}
|
||||
let Some(entry) = self.child_browsing_contexts.get(&source_handle) else {
|
||||
return true;
|
||||
};
|
||||
let sandbox = entry.document_sandbox_policy();
|
||||
let target_is_top = !matches!(target, OwnerDispatchScope::Child(_));
|
||||
if destination.scheme() == "javascript"
|
||||
&& !self.window_scopes_have_same_origin_domain(source, target)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
// Consult the active Document's flags, including inherited/CSP flags.
|
||||
// Mutating the container's sandbox attribute does not change them.
|
||||
if sandbox.restricts_navigation {
|
||||
if !target_is_top {
|
||||
return true;
|
||||
}
|
||||
return if sandbox.allows_top_navigation {
|
||||
!entry.can_navigate_top_without_user_gesture
|
||||
&& !self.window_user_activation_state(source).1
|
||||
} else {
|
||||
!(sandbox.allows_top_navigation_by_user_activation
|
||||
&& self.window_has_transient_user_activation(source))
|
||||
};
|
||||
}
|
||||
let mut accessible_ancestor = Some(target);
|
||||
while let Some(owner) = accessible_ancestor {
|
||||
if self.window_scopes_have_same_origin_domain(source, owner) {
|
||||
return false;
|
||||
}
|
||||
accessible_ancestor = self.navigation_parent_scope(owner);
|
||||
}
|
||||
// An unrelated intermediate ancestor cannot be navigated, even with
|
||||
// activation. A top-level ancestor additionally permits sticky
|
||||
// activation and destinations related to its existing origin/site.
|
||||
!(target_is_top
|
||||
&& (self.window_user_activation_state(source).1
|
||||
|| self.ancestor_navigation_destination_is_related(target, destination)))
|
||||
}
|
||||
|
||||
pub(super) fn capture_child_top_navigation_permission(
|
||||
&mut self,
|
||||
handle: crate::document_runtime::DomHandle,
|
||||
) {
|
||||
let source = OwnerDispatchScope::Child(handle);
|
||||
let Some(parent) = self.navigation_parent_scope(source) else {
|
||||
return;
|
||||
};
|
||||
let mut top = parent;
|
||||
while let Some(ancestor) = self.navigation_parent_scope(top) {
|
||||
top = ancestor;
|
||||
}
|
||||
let parent_allows = match parent {
|
||||
OwnerDispatchScope::Child(parent) => self
|
||||
.child_browsing_contexts
|
||||
.get(&parent)
|
||||
.is_some_and(|entry| entry.can_navigate_top_without_user_gesture),
|
||||
OwnerDispatchScope::Top | OwnerDispatchScope::LightweightPopup(_) => true,
|
||||
};
|
||||
// A cross-origin parent cannot delegate a permission it does not have.
|
||||
// Unlike access checks, this committed grant ignores document.domain.
|
||||
let allowed = self.window_scopes_have_same_origin(source, top)
|
||||
|| (parent_allows
|
||||
&& self
|
||||
.dom_host()
|
||||
.get_attribute(handle, "sandbox")
|
||||
.is_some_and(|value| {
|
||||
value
|
||||
.split_ascii_whitespace()
|
||||
.any(|token| token.eq_ignore_ascii_case("allow-top-navigation"))
|
||||
}));
|
||||
if let Some(entry) = self.child_browsing_contexts.get_mut(&handle) {
|
||||
entry.can_navigate_top_without_user_gesture = allowed;
|
||||
}
|
||||
}
|
||||
|
||||
fn navigation_parent_scope(&self, owner: OwnerDispatchScope) -> Option<OwnerDispatchScope> {
|
||||
match owner {
|
||||
OwnerDispatchScope::Child(handle) => self.owner_dispatch_scope_for_node(handle),
|
||||
OwnerDispatchScope::Top | OwnerDispatchScope::LightweightPopup(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn ancestor_navigation_destination_is_related(
|
||||
&self,
|
||||
target: OwnerDispatchScope,
|
||||
destination: &Url,
|
||||
) -> bool {
|
||||
let Some(origin) = self.window_access_origin_for_dispatch_scope(target) else {
|
||||
return false;
|
||||
};
|
||||
if WindowAccessOrigin::from_serialized_origin(
|
||||
moli_url::origin_ascii_serialization(destination),
|
||||
None,
|
||||
)
|
||||
.is_some_and(|destination_origin| origin.can_access(&destination_origin))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
let WindowAccessOrigin::Tuple {
|
||||
serialized_origin,
|
||||
scheme,
|
||||
document_domain,
|
||||
} = origin
|
||||
else {
|
||||
return false;
|
||||
};
|
||||
if scheme != destination.scheme() {
|
||||
return false;
|
||||
}
|
||||
let target_host = document_domain.or_else(|| {
|
||||
Url::parse(&serialized_origin)
|
||||
.ok()?
|
||||
.host_str()
|
||||
.map(str::to_owned)
|
||||
});
|
||||
target_host
|
||||
.as_deref()
|
||||
.and_then(navigation_registrable_domain)
|
||||
.zip(
|
||||
destination
|
||||
.host_str()
|
||||
.and_then(navigation_registrable_domain),
|
||||
)
|
||||
.is_some_and(|(target, destination)| target == destination)
|
||||
}
|
||||
}
|
||||
|
||||
fn navigation_registrable_domain(host: &str) -> Option<&str> {
|
||||
let host = host.trim_start_matches('[').trim_end_matches(']');
|
||||
if host.parse::<std::net::IpAddr>().is_ok()
|
||||
|| !host.contains('.')
|
||||
|| moli_site::host_is_public_suffix(host)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
Some(moli_site::registrable_site_host(host))
|
||||
}
|
||||
@@ -438,6 +438,15 @@ pub(in crate::native_bridge) fn choose_form_navigation_target(
|
||||
return Some(OwnerDispatchScope::Child(handle));
|
||||
}
|
||||
}
|
||||
if let Some(popup_id) = runtime.named_lightweight_popup_id(target_name)
|
||||
&& runtime.blocks_ancestor_navigation(
|
||||
source,
|
||||
OwnerDispatchScope::LightweightPopup(popup_id),
|
||||
destination,
|
||||
)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let relations = element_popup_relations(unsafe { &*runtime_ptr }, form, target_name);
|
||||
let mut creator = element_popup_creator(scope, runtime_ptr, form)?;
|
||||
creator.policy_container.document_referrer = if relations.suppress_referrer {
|
||||
@@ -587,7 +596,8 @@ fn navigate_special_target_from_window<'s>(
|
||||
|
||||
pub(crate) fn navigate_existing_browsing_context_target<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
source_window: v8::Local<'s, v8::Object>,
|
||||
runtime_ptr: *mut PageScriptHost,
|
||||
navigation_source: crate::native_bridge::OwnerDispatchScope,
|
||||
target: SpecialBrowsingContextTarget,
|
||||
resolved_url: Option<&str>,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
@@ -596,6 +606,31 @@ pub(crate) fn navigate_existing_browsing_context_target<'s>(
|
||||
SpecialBrowsingContextTarget::Blank,
|
||||
"a new-context target cannot use existing-context navigation"
|
||||
);
|
||||
let runtime = unsafe { &*runtime_ptr };
|
||||
let dispatch_scope = runtime
|
||||
.window_execution_context_identity_for_access_check(scope.get_current_context())
|
||||
.map(|identity| identity.dispatch_scope())
|
||||
.filter(|owner| matches!(owner, crate::native_bridge::OwnerDispatchScope::Child(_)))
|
||||
.unwrap_or_else(|| runtime.entered_owner_dispatch_scope(scope));
|
||||
let mut destination_scope = dispatch_scope;
|
||||
while target != SpecialBrowsingContextTarget::Current
|
||||
&& let crate::native_bridge::OwnerDispatchScope::Child(handle) = destination_scope
|
||||
{
|
||||
destination_scope = runtime.owner_dispatch_scope_for_node(handle)?;
|
||||
if target == SpecialBrowsingContextTarget::Parent {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if resolved_url
|
||||
.and_then(|url| url::Url::parse(url).ok())
|
||||
.is_some_and(|url| {
|
||||
runtime.blocks_ancestor_navigation(navigation_source, destination_scope, &url)
|
||||
})
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let source_window =
|
||||
browsing_context_window_for_dispatch_scope(scope, runtime_ptr, dispatch_scope)?;
|
||||
navigate_special_target_from_window(scope, source_window, Some(target), resolved_url)
|
||||
}
|
||||
|
||||
@@ -671,7 +706,9 @@ pub(in crate::native_bridge) fn navigate_element_target_browsing_context(
|
||||
});
|
||||
};
|
||||
let runtime = unsafe { &mut *runtime_ptr };
|
||||
if runtime.sandbox_blocks_ancestor_navigation(source, target) {
|
||||
if url::Url::parse(resolved_url)
|
||||
.is_ok_and(|destination| runtime.blocks_ancestor_navigation(source, target, &destination))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
let Some(document) = runtime.dom_host().owner_document_handle(source_handle) else {
|
||||
|
||||
@@ -648,7 +648,7 @@ pub(in crate::native_bridge) fn submit_form_default_action(
|
||||
else {
|
||||
return false;
|
||||
};
|
||||
if runtime.sandbox_blocks_ancestor_navigation(source, destination) {
|
||||
if runtime.blocks_ancestor_navigation(source, destination, request.url()) {
|
||||
return false;
|
||||
}
|
||||
let mutation = runtime.form_navigation_history_mutation_for_scope(
|
||||
|
||||
Reference in New Issue
Block a user