mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 08:02:59 +00:00
fix(dom): enforce native Window agent-cluster boundaries
This commit is contained in:
@@ -0,0 +1,70 @@
|
||||
use crate::{resource_owner::ResourceOwnerId, runtime::RendererStoragePartitionIdentity};
|
||||
use std::sync::Arc;
|
||||
|
||||
/// Native identity shared by Window access checks and shared-memory cloning.
|
||||
/// Permissions Policy controls API exposure separately from this identity.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub(crate) struct AgentClusterIdentity(Arc<AgentClusterKey>);
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
enum AgentClusterKey {
|
||||
Window {
|
||||
partition: RendererStoragePartitionIdentity,
|
||||
origin: String,
|
||||
isolation: WindowAgentClusterIsolation,
|
||||
},
|
||||
Worker(ResourceOwnerId),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub(crate) enum WindowAgentClusterIsolation {
|
||||
CoopCoep { isolation_origin: String },
|
||||
DocumentIsolation,
|
||||
}
|
||||
|
||||
impl AgentClusterIdentity {
|
||||
pub(crate) fn window(
|
||||
partition: RendererStoragePartitionIdentity,
|
||||
origin: String,
|
||||
isolation: WindowAgentClusterIsolation,
|
||||
) -> Self {
|
||||
Self(Arc::new(AgentClusterKey::Window {
|
||||
partition,
|
||||
origin,
|
||||
isolation,
|
||||
}))
|
||||
}
|
||||
|
||||
pub(crate) fn worker(owner: ResourceOwnerId) -> Self {
|
||||
Self(Arc::new(AgentClusterKey::Worker(owner)))
|
||||
}
|
||||
|
||||
pub(crate) fn window_security_token_key(&self, prefix: &str) -> Option<String> {
|
||||
let AgentClusterKey::Window {
|
||||
partition,
|
||||
origin,
|
||||
isolation,
|
||||
} = self.0.as_ref()
|
||||
else {
|
||||
return None;
|
||||
};
|
||||
let (kind, common_origin) = match isolation {
|
||||
WindowAgentClusterIsolation::CoopCoep { isolation_origin } => {
|
||||
("coop-coep", isolation_origin.as_str())
|
||||
}
|
||||
WindowAgentClusterIsolation::DocumentIsolation => ("document", origin.as_str()),
|
||||
};
|
||||
let browser = partition.browser_context_id();
|
||||
let profile = partition.profile_partition_id();
|
||||
// Lengths make the representation injective even for arbitrary native
|
||||
// partition identifiers. The caller supplies a distinct world namespace.
|
||||
Some(format!(
|
||||
"{prefix}{}:{browser}{}:{profile}{}:{origin}{}:{kind}{}:{common_origin}",
|
||||
browser.len(),
|
||||
profile.len(),
|
||||
origin.len(),
|
||||
kind.len(),
|
||||
common_origin.len(),
|
||||
))
|
||||
}
|
||||
}
|
||||
@@ -35,9 +35,18 @@ pub(super) fn refresh_from_current_context<'s>(
|
||||
location: v8::Local<'s, v8::Object>,
|
||||
) {
|
||||
let location = location_target(scope, location);
|
||||
if location.get_creation_context(scope) != Some(scope.get_current_context()) {
|
||||
// A replacement Window may still be adopting its proxy. Its old
|
||||
// Location belongs to the retired realm and must keep that snapshot.
|
||||
return;
|
||||
}
|
||||
let Some(origin) = WindowSecurityOrigin::for_context(scope.get_current_context()) else {
|
||||
return;
|
||||
};
|
||||
if for_target(scope, location).is_none() {
|
||||
install(scope, location);
|
||||
return;
|
||||
}
|
||||
let Some(value) = location.get_internal_field(scope, SECURITY_ORIGIN_FIELD) else {
|
||||
return;
|
||||
};
|
||||
|
||||
@@ -29,6 +29,7 @@ pub use app_manifest::{
|
||||
mod abort_signal_route;
|
||||
#[cfg(feature = "ace-protocol")]
|
||||
pub mod ace_page_task;
|
||||
mod agent_cluster;
|
||||
mod app_manifest;
|
||||
mod blob;
|
||||
mod broadcast_channel_runtime;
|
||||
|
||||
@@ -99,6 +99,12 @@ impl PageScriptHost {
|
||||
.is_some();
|
||||
let security_origin_allows_reuse = creation_kind != DocumentCreationKind::Error
|
||||
&& !current_document_domain_was_set
|
||||
&& self.window_agent_cluster(OwnerDispatchScope::Child(handle))
|
||||
== self.window_agent_cluster_for_policy(
|
||||
OwnerDispatchScope::Child(handle),
|
||||
&snapshot.policy_container,
|
||||
origin.clone(),
|
||||
)
|
||||
&& preflight
|
||||
.current_access_origin
|
||||
.as_ref()
|
||||
|
||||
@@ -85,7 +85,13 @@ impl PageScriptHost {
|
||||
};
|
||||
crate::frame_owner_model::FrameDocumentLocalWindowTransition::for_document_commit(
|
||||
self.initial_empty_main_document,
|
||||
same_origin,
|
||||
same_origin
|
||||
&& self.window_agent_cluster(OwnerDispatchScope::Top)
|
||||
== self.window_agent_cluster_for_policy(
|
||||
OwnerDispatchScope::Top,
|
||||
policy,
|
||||
origin.to_owned(),
|
||||
),
|
||||
self.document_policy_container(),
|
||||
policy,
|
||||
)
|
||||
|
||||
@@ -1136,6 +1136,11 @@ impl PageScriptHost {
|
||||
None
|
||||
}
|
||||
.unwrap_or_default();
|
||||
let initial_agent_cluster = self.window_agent_cluster_for_policy(
|
||||
OwnerDispatchScope::LightweightPopup(popup_id),
|
||||
&initial_document_state.policy_container,
|
||||
initial_origin.serialized_origin(),
|
||||
);
|
||||
let session_storage_store = match opener {
|
||||
Some(opener) => self.cloned_lightweight_popup_session_storage_store(
|
||||
scope,
|
||||
@@ -1169,6 +1174,7 @@ impl PageScriptHost {
|
||||
super::window_security_tokens::PopupWindowSecurityOrigin {
|
||||
origin: initial_origin,
|
||||
domain: initial_domain,
|
||||
agent_cluster: initial_agent_cluster,
|
||||
},
|
||||
)),
|
||||
secure_context,
|
||||
@@ -2427,6 +2433,11 @@ impl PageScriptHost {
|
||||
};
|
||||
let retained_access_origin = current_document.access_origin.borrow().current_origin();
|
||||
let retained_origin_state = current_document.access_origin.clone();
|
||||
let retained_agent_cluster = current_document
|
||||
.access_origin
|
||||
.borrow()
|
||||
.agent_cluster
|
||||
.clone();
|
||||
let domain = if matches!(
|
||||
commit.origin,
|
||||
LightweightPopupDocumentCommitOrigin::RetainCurrent
|
||||
@@ -2469,11 +2480,17 @@ impl PageScriptHost {
|
||||
}
|
||||
}
|
||||
};
|
||||
let agent_cluster = self.window_agent_cluster_for_policy(
|
||||
OwnerDispatchScope::LightweightPopup(popup_id),
|
||||
&commit.state.policy_container,
|
||||
access_origin.serialized_origin(),
|
||||
);
|
||||
// The first same-origin navigation can reuse the initial Window even
|
||||
// though it commits a new Document and its own resource authority.
|
||||
let reuse_initial_window = changed_document
|
||||
&& was_initial_empty
|
||||
&& !document_domain_was_set
|
||||
&& retained_agent_cluster == agent_cluster
|
||||
&& retained_access_origin.can_access(&access_origin);
|
||||
if reuse_initial_window {
|
||||
current_local_window_id = previous_local_window_id;
|
||||
@@ -2490,6 +2507,7 @@ impl PageScriptHost {
|
||||
let access_origin = super::window_security_tokens::PopupWindowSecurityOrigin {
|
||||
origin: access_origin,
|
||||
domain,
|
||||
agent_cluster,
|
||||
};
|
||||
let access_origin = if changed_window {
|
||||
Rc::new(RefCell::new(access_origin))
|
||||
|
||||
@@ -927,11 +927,13 @@ impl PageScriptHost {
|
||||
if !policy
|
||||
.cross_origin_embedder_policy
|
||||
.enables_cross_origin_isolation()
|
||||
&& !policy.credentialless
|
||||
{
|
||||
return false;
|
||||
}
|
||||
// COOP chooses the top-level group's mode. A COEP-only child joins it;
|
||||
// a child's own COOP header cannot isolate an otherwise ordinary group.
|
||||
// COOP chooses the top-level group's mode. A COEP child, or a
|
||||
// credentialless Document exempt from COEP embedding checks, joins it.
|
||||
// A child's own COOP cannot isolate an otherwise ordinary group.
|
||||
match self.child_browsing_context_root_scope(handle) {
|
||||
Some(OwnerDispatchScope::Top) => self.document_policy_container().coop_coep_isolation,
|
||||
Some(OwnerDispatchScope::LightweightPopup(id)) => self
|
||||
@@ -948,38 +950,52 @@ impl PageScriptHost {
|
||||
if !self.window_cross_origin_isolated(owner) {
|
||||
return None;
|
||||
}
|
||||
let dip = match owner {
|
||||
OwnerDispatchScope::Top => self.document_isolation_policy(),
|
||||
OwnerDispatchScope::Child(handle) => {
|
||||
let policy = self.child_browsing_context_policy_container_snapshot(handle)?;
|
||||
policy.document_isolation_policy
|
||||
}
|
||||
OwnerDispatchScope::LightweightPopup(id) => {
|
||||
let policy = self.lightweight_popup_policy_container(id)?;
|
||||
policy.document_isolation_policy
|
||||
}
|
||||
};
|
||||
self.window_agent_cluster(owner)
|
||||
}
|
||||
|
||||
pub(super) fn window_agent_cluster(
|
||||
&self,
|
||||
owner: OwnerDispatchScope,
|
||||
) -> Option<crate::agent_cluster::AgentClusterIdentity> {
|
||||
let policy = self.window_policy_container(owner)?;
|
||||
let origin = self.window_document_origin(owner)?;
|
||||
// DIP supplies its own isolation origin; otherwise the top-level
|
||||
// isolation origin is inherited, independently from the document origin.
|
||||
let isolation_origin = if dip.enables_cross_origin_isolation() {
|
||||
origin.clone()
|
||||
} else {
|
||||
let root = match owner {
|
||||
OwnerDispatchScope::Child(handle) => {
|
||||
self.child_browsing_context_root_scope(handle)?
|
||||
}
|
||||
root => root,
|
||||
};
|
||||
self.window_document_origin(root)?
|
||||
};
|
||||
if origin == "null" || isolation_origin == "null" {
|
||||
self.window_agent_cluster_for_policy(owner, &policy, origin)
|
||||
}
|
||||
|
||||
pub(super) fn window_agent_cluster_for_policy(
|
||||
&self,
|
||||
owner: OwnerDispatchScope,
|
||||
policy: &DocumentPolicyContainer,
|
||||
origin: String,
|
||||
) -> Option<crate::agent_cluster::AgentClusterIdentity> {
|
||||
use crate::agent_cluster::{AgentClusterIdentity, WindowAgentClusterIsolation};
|
||||
|
||||
if origin == "null"
|
||||
|| !self.window_agent_cluster_is_cross_origin_isolated_with_policy(owner, policy)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
Some(crate::structured_clone::SharedMemoryAgentCluster::window(
|
||||
let isolation = if policy
|
||||
.document_isolation_policy
|
||||
.enables_cross_origin_isolation()
|
||||
{
|
||||
WindowAgentClusterIsolation::DocumentIsolation
|
||||
} else {
|
||||
let isolation_origin = match owner {
|
||||
OwnerDispatchScope::Child(handle) => {
|
||||
self.window_document_origin(self.child_browsing_context_root_scope(handle)?)?
|
||||
}
|
||||
OwnerDispatchScope::Top | OwnerDispatchScope::LightweightPopup(_) => origin.clone(),
|
||||
};
|
||||
if isolation_origin == "null" {
|
||||
return None;
|
||||
}
|
||||
WindowAgentClusterIsolation::CoopCoep { isolation_origin }
|
||||
};
|
||||
Some(AgentClusterIdentity::window(
|
||||
self.browser_context_runtime().storage_partition_identity(),
|
||||
origin,
|
||||
isolation_origin,
|
||||
isolation,
|
||||
))
|
||||
}
|
||||
|
||||
|
||||
@@ -21,6 +21,7 @@ pub(crate) struct WindowEnvironmentSettings {
|
||||
access_origin: WindowAccessOrigin,
|
||||
domain_owner_document: DomHandle,
|
||||
execution_identity: WindowExecutionContextIdentity,
|
||||
agent_cluster: Option<crate::agent_cluster::AgentClusterIdentity>,
|
||||
}
|
||||
|
||||
impl WindowEnvironmentSettings {
|
||||
@@ -52,6 +53,7 @@ impl WindowEnvironmentSettings {
|
||||
access_origin,
|
||||
domain_owner_document,
|
||||
execution_identity,
|
||||
agent_cluster: host.window_agent_cluster(OwnerDispatchScope::Child(child_handle)),
|
||||
}));
|
||||
Some(())
|
||||
}
|
||||
@@ -80,6 +82,7 @@ impl WindowEnvironmentSettings {
|
||||
access_origin,
|
||||
domain_owner_document: host.document_handle(),
|
||||
execution_identity,
|
||||
agent_cluster: host.window_agent_cluster(OwnerDispatchScope::Top),
|
||||
}));
|
||||
Some(())
|
||||
}
|
||||
@@ -98,6 +101,9 @@ impl WindowEnvironmentSettings {
|
||||
if self.execution_identity.grants_universal_access() {
|
||||
return true;
|
||||
}
|
||||
if self.agent_cluster != target_host.window_agent_cluster(target.dispatch_scope()) {
|
||||
return false;
|
||||
}
|
||||
// Retiring a resource loader must not turn an inherited origin into
|
||||
// the origin of its about:blank URL. Keep that origin, while observing
|
||||
// domain changes on the exact Document that owns the shared origin.
|
||||
|
||||
@@ -4,11 +4,15 @@ use super::{
|
||||
WindowExecutionContextOwner,
|
||||
child_frames::{ChildAncestorOriginsReferrerPolicy, ChildBrowsingContextEntry},
|
||||
};
|
||||
use crate::agent_cluster::AgentClusterIdentity;
|
||||
use crate::document_runtime::DomHandle;
|
||||
use std::{cell::RefCell, rc::Rc};
|
||||
|
||||
const WINDOW_SECURITY_TOKEN_PREFIX: &str = "moli-window-origin-v1:";
|
||||
const WINDOW_ISOLATED_WORLD_SECURITY_TOKEN_PREFIX: &str = "moli-window-isolated-origin-v1:";
|
||||
const WINDOW_CLUSTER_SECURITY_TOKEN_PREFIX: &str = "moli-window-agent-cluster-v1:";
|
||||
const WINDOW_ISOLATED_CLUSTER_SECURITY_TOKEN_PREFIX: &str =
|
||||
"moli-window-isolated-agent-cluster-v1:";
|
||||
|
||||
pub(crate) fn window_contexts_allow_access(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
@@ -137,6 +141,7 @@ struct WindowContextSecurityOrigin {
|
||||
origin: WindowAccessOrigin,
|
||||
domain: Option<DocumentDomainState>,
|
||||
access_policy: WindowExecutionContextAccessPolicy,
|
||||
agent_cluster: Option<AgentClusterIdentity>,
|
||||
}
|
||||
|
||||
/// The origin of a particular LocalWindow, including virtual popup realms.
|
||||
@@ -166,6 +171,7 @@ enum WindowSecurityOriginSource {
|
||||
pub(super) struct PopupWindowSecurityOrigin {
|
||||
pub(super) origin: WindowAccessOrigin,
|
||||
pub(super) domain: DocumentDomainState,
|
||||
pub(super) agent_cluster: Option<AgentClusterIdentity>,
|
||||
}
|
||||
|
||||
impl PopupWindowSecurityOrigin {
|
||||
@@ -206,7 +212,15 @@ impl WindowSecurityOrigin {
|
||||
pub(crate) fn can_access(&self, target: &Self) -> bool {
|
||||
matches!(&self.0, WindowSecurityOriginSource::Context(origin)
|
||||
if origin.access_policy == WindowExecutionContextAccessPolicy::Universal)
|
||||
|| self.current_origin().can_access(&target.current_origin())
|
||||
|| (self.agent_cluster() == target.agent_cluster()
|
||||
&& self.current_origin().can_access(&target.current_origin()))
|
||||
}
|
||||
|
||||
fn agent_cluster(&self) -> Option<AgentClusterIdentity> {
|
||||
match &self.0 {
|
||||
WindowSecurityOriginSource::Context(origin) => origin.agent_cluster.clone(),
|
||||
WindowSecurityOriginSource::Popup(origin) => origin.borrow().agent_cluster.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -420,8 +434,11 @@ impl PageScriptHost {
|
||||
origin,
|
||||
domain,
|
||||
access_policy,
|
||||
agent_cluster: self.window_agent_cluster(dispatch_scope),
|
||||
}));
|
||||
self.retain_window_global_csp_context(context);
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
crate::context_bootstrap::refresh_global_location_security_origin(scope);
|
||||
}
|
||||
|
||||
pub(in crate::native_bridge::context_host) fn window_context_origins_allow_access(
|
||||
@@ -436,9 +453,10 @@ impl PageScriptHost {
|
||||
return false;
|
||||
};
|
||||
accessing.access_policy == WindowExecutionContextAccessPolicy::Universal
|
||||
|| accessing
|
||||
.current_origin()
|
||||
.can_access(&accessed.current_origin())
|
||||
|| (accessing.agent_cluster == accessed.agent_cluster
|
||||
&& accessing
|
||||
.current_origin()
|
||||
.can_access(&accessed.current_origin()))
|
||||
}
|
||||
|
||||
pub(in crate::native_bridge::context_host) fn child_ancestor_origins_referrer_policy_from_owner_attribute(
|
||||
@@ -522,7 +540,7 @@ impl PageScriptHost {
|
||||
if self.document_domain_override.get().is_some() {
|
||||
return None;
|
||||
}
|
||||
window_security_token_key(origin)
|
||||
self.window_default_world_token_for_agent_cluster(OwnerDispatchScope::Top, origin)
|
||||
}
|
||||
|
||||
pub(crate) fn popup_default_world_security_token_key(&self, popup_id: u64) -> Option<String> {
|
||||
@@ -534,7 +552,10 @@ impl PageScriptHost {
|
||||
{
|
||||
return None;
|
||||
}
|
||||
window_security_token_key(origin.serialized_origin())
|
||||
self.window_default_world_token_for_agent_cluster(
|
||||
OwnerDispatchScope::LightweightPopup(popup_id),
|
||||
origin.serialized_origin(),
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn child_default_world_security_token_key(
|
||||
@@ -551,7 +572,20 @@ impl PageScriptHost {
|
||||
{
|
||||
return None;
|
||||
}
|
||||
window_security_token_key(origin)
|
||||
self.window_default_world_token_for_agent_cluster(OwnerDispatchScope::Child(handle), origin)
|
||||
}
|
||||
|
||||
fn window_default_world_token_for_agent_cluster(
|
||||
&self,
|
||||
owner: OwnerDispatchScope,
|
||||
origin: String,
|
||||
) -> Option<String> {
|
||||
match self.window_agent_cluster(owner) {
|
||||
Some(cluster) => {
|
||||
cluster.window_security_token_key(WINDOW_CLUSTER_SECURITY_TOKEN_PREFIX)
|
||||
}
|
||||
None => window_security_token_key(origin),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn install_child_default_world_security_token(
|
||||
@@ -584,7 +618,8 @@ impl PageScriptHost {
|
||||
if self.document_sandbox_policy().forces_opaque_origin {
|
||||
return None;
|
||||
}
|
||||
window_isolated_world_security_token_key(
|
||||
self.window_isolated_world_token_for_agent_cluster(
|
||||
OwnerDispatchScope::Top,
|
||||
self.main_document_origin(),
|
||||
self.document_domain_override.get().is_some(),
|
||||
)
|
||||
@@ -598,13 +633,29 @@ impl PageScriptHost {
|
||||
return None;
|
||||
}
|
||||
let origin = self.child_browsing_context_window_origin(handle)?;
|
||||
window_isolated_world_security_token_key(
|
||||
self.window_isolated_world_token_for_agent_cluster(
|
||||
OwnerDispatchScope::Child(handle),
|
||||
origin,
|
||||
self.child_browsing_context_document_domain_override(handle)
|
||||
.is_some(),
|
||||
)
|
||||
}
|
||||
|
||||
fn window_isolated_world_token_for_agent_cluster(
|
||||
&self,
|
||||
owner: OwnerDispatchScope,
|
||||
origin: String,
|
||||
document_domain_was_set: bool,
|
||||
) -> Option<String> {
|
||||
let origin_key = window_isolated_world_security_token_key(origin, document_domain_was_set)?;
|
||||
match self.window_agent_cluster(owner) {
|
||||
Some(cluster) => {
|
||||
cluster.window_security_token_key(WINDOW_ISOLATED_CLUSTER_SECURITY_TOKEN_PREFIX)
|
||||
}
|
||||
None => Some(origin_key),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn refresh_security_tokens_after_document_domain_mutation(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
@@ -790,7 +841,11 @@ impl PageScriptHost {
|
||||
let Some(child) = self.child_window_access_origin(handle) else {
|
||||
return false;
|
||||
};
|
||||
top.can_access(&child)
|
||||
self.window_agent_clusters_match(
|
||||
OwnerDispatchScope::Top,
|
||||
self,
|
||||
OwnerDispatchScope::Child(handle),
|
||||
) && top.can_access(&child)
|
||||
}
|
||||
|
||||
pub(crate) fn frame_owner_can_access_content_document(&self, handle: DomHandle) -> bool {
|
||||
@@ -808,12 +863,14 @@ impl PageScriptHost {
|
||||
} else {
|
||||
return false;
|
||||
};
|
||||
// HTML's content document algorithm compares the container's node
|
||||
// Document with the active child Document, using same origin-domain.
|
||||
// Neither the top-level Window nor the callback's realm is its owner.
|
||||
self.window_access_origin_for_dispatch_scope(owner_scope)
|
||||
.zip(self.child_window_access_origin(handle))
|
||||
.is_some_and(|(owner, child)| owner.can_access(&child))
|
||||
// The returned Document also passes the native Window agent-cluster
|
||||
// check. The container's node Document owns this access, independently
|
||||
// from the callback's realm or the top-level Window.
|
||||
self.window_agent_clusters_match(owner_scope, self, OwnerDispatchScope::Child(handle))
|
||||
&& self
|
||||
.window_access_origin_for_dispatch_scope(owner_scope)
|
||||
.zip(self.child_window_access_origin(handle))
|
||||
.is_some_and(|(owner, child)| owner.can_access(&child))
|
||||
}
|
||||
|
||||
pub(in crate::native_bridge::context_host) fn accessing_context_can_access_child_window(
|
||||
@@ -842,18 +899,19 @@ impl PageScriptHost {
|
||||
}
|
||||
// Opaque identities are host-local; only tuple origins can be compared
|
||||
// between hosts before the target has materialized a V8 Context.
|
||||
accessing_host
|
||||
.window_access_origin(identity)
|
||||
.zip(self.child_window_access_origin(handle))
|
||||
.is_some_and(|(origin, target)| {
|
||||
matches!(
|
||||
(&origin, &target),
|
||||
(
|
||||
WindowAccessOrigin::Tuple { .. },
|
||||
WindowAccessOrigin::Tuple { .. }
|
||||
)
|
||||
) && origin.can_access(&target)
|
||||
})
|
||||
accessing_host.window_agent_clusters_match(identity.dispatch_scope(), self, target)
|
||||
&& accessing_host
|
||||
.window_access_origin(identity)
|
||||
.zip(self.child_window_access_origin(handle))
|
||||
.is_some_and(|(origin, target)| {
|
||||
matches!(
|
||||
(&origin, &target),
|
||||
(
|
||||
WindowAccessOrigin::Tuple { .. },
|
||||
WindowAccessOrigin::Tuple { .. }
|
||||
)
|
||||
) && origin.can_access(&target)
|
||||
})
|
||||
}
|
||||
|
||||
/// Compares the Window's origin with its top-level origin without applying
|
||||
@@ -911,6 +969,13 @@ impl PageScriptHost {
|
||||
if accessing.grants_universal_access() {
|
||||
return true;
|
||||
}
|
||||
if !self.window_agent_clusters_match(
|
||||
accessing.dispatch_scope(),
|
||||
target_host,
|
||||
accessed.dispatch_scope(),
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
let Some(origin) = self.window_access_origin(accessing) else {
|
||||
return false;
|
||||
};
|
||||
@@ -954,6 +1019,9 @@ impl PageScriptHost {
|
||||
if accessing.owner() == accessed_owner {
|
||||
return true;
|
||||
}
|
||||
if !self.window_agent_clusters_match(accessing.dispatch_scope(), self, accessed_scope) {
|
||||
return false;
|
||||
}
|
||||
let Some(accessing_origin) = self.window_access_origin(accessing) else {
|
||||
return false;
|
||||
};
|
||||
@@ -964,6 +1032,15 @@ impl PageScriptHost {
|
||||
accessing_origin.can_access(&accessed_origin)
|
||||
}
|
||||
|
||||
fn window_agent_clusters_match(
|
||||
&self,
|
||||
source: OwnerDispatchScope,
|
||||
target_host: &Self,
|
||||
target: OwnerDispatchScope,
|
||||
) -> bool {
|
||||
self.window_agent_cluster(source) == target_host.window_agent_cluster(target)
|
||||
}
|
||||
|
||||
fn window_access_origin(
|
||||
&self,
|
||||
identity: WindowExecutionContextIdentity,
|
||||
|
||||
@@ -2635,6 +2635,7 @@ mod window_scheduling_receivers;
|
||||
|
||||
mod window_immutable_prototype_chain;
|
||||
|
||||
mod window_agent_clusters;
|
||||
mod window_getter_consolidation;
|
||||
mod window_node_events;
|
||||
#[cfg(feature = "devtools")]
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
use super::*;
|
||||
|
||||
const DIP: &str = "Document-Isolation-Policy: isolate-and-require-corp\r\n";
|
||||
const DIP_CREDENTIALLESS: &str = "Document-Isolation-Policy: isolate-and-credentialless\r\n";
|
||||
const COEP: &str = "Cross-Origin-Embedder-Policy: require-corp\r\n";
|
||||
const COOP_COEP: &str =
|
||||
"Cross-Origin-Opener-Policy: same-origin\r\nCross-Origin-Embedder-Policy: require-corp\r\n";
|
||||
const DIP_COEP: &str = "Document-Isolation-Policy: isolate-and-require-corp\r\nCross-Origin-Embedder-Policy: require-corp\r\n";
|
||||
const DENIED_COOP_COEP: &str = "Cross-Origin-Opener-Policy: same-origin\r\nCross-Origin-Embedder-Policy: require-corp\r\nPermissions-Policy: cross-origin-isolated=()\r\n";
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn window_access_and_shared_memory_follow_native_agent_clusters() {
|
||||
for (root_headers, child_headers, credentialless, allowed, shared, child_isolated) in [
|
||||
("", DIP, false, false, false, true),
|
||||
(DIP, "", false, false, false, false),
|
||||
(DIP, DIP_CREDENTIALLESS, false, true, true, true),
|
||||
(COOP_COEP, COEP, false, true, true, true),
|
||||
(DENIED_COOP_COEP, COEP, false, true, false, false),
|
||||
(COOP_COEP, DIP_COEP, false, false, true, true),
|
||||
("", COEP, false, true, false, false),
|
||||
(COOP_COEP, "", true, true, true, true),
|
||||
(DENIED_COOP_COEP, "", true, true, false, false),
|
||||
] {
|
||||
let server = StaticHttpServer::spawn_with_raw_responder(1, move |_, _| {
|
||||
let body = r#"<!doctype html><body><script>
|
||||
const attempt = callback => { try { return callback(); } catch (error) { return error.name; } };
|
||||
onmessage = event => {
|
||||
parent.postMessage({kind:'shared', value:event.data.byteLength === 4 ? 'shared' : 'wrong bytes'}, '*');
|
||||
};
|
||||
onmessageerror = () => parent.postMessage({kind:'shared', value:'messageerror'}, '*');
|
||||
parent.postMessage({kind:'ready', isolated:crossOriginIsolated,
|
||||
value:attempt(() => parent.document.nodeType === 9),
|
||||
location:attempt(() => new URL(parent.location.href).hostname === location.hostname),
|
||||
postMessage:typeof parent.postMessage, frames:typeof parent.frames}, '*');
|
||||
</script>"#;
|
||||
format!(
|
||||
"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n{child_headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
||||
body.len()
|
||||
)
|
||||
})
|
||||
.await;
|
||||
let loader = static_http_loader([server.resolve_entry("localhost")]);
|
||||
let root_url = server.url_for_host("localhost", "/root");
|
||||
let child_url = server.url_for_host("localhost", "/child");
|
||||
let mut vm = new_storage_page_task_executor_test_vm_with_loader(root_url.as_str(), &loader);
|
||||
let headers = root_headers
|
||||
.lines()
|
||||
.map(|line| {
|
||||
let (name, value) = line.split_once(':').unwrap();
|
||||
(name.to_owned(), value.trim().as_bytes().to_vec())
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
vm.set_main_navigation_policy_container(
|
||||
crate::document_runtime::DocumentPolicyContainer::from_navigation_response_headers(
|
||||
&headers, &root_url,
|
||||
),
|
||||
);
|
||||
vm.eval(&format!(
|
||||
r#"
|
||||
globalThis.clusterReady = null;
|
||||
globalThis.clusterShared = null;
|
||||
onmessage = event => {{
|
||||
if (event.data.kind === 'ready') clusterReady = event.data;
|
||||
if (event.data.kind === 'shared') clusterShared = event.data.value;
|
||||
}};
|
||||
const root = document.documentElement || document.appendChild(document.createElement('html'));
|
||||
const body = document.body || root.appendChild(document.createElement('body'));
|
||||
body.appendChild(Object.assign(document.createElement('iframe'), {{id:'target', credentialless:{credentialless}, src:{:?}}}));
|
||||
"#,
|
||||
child_url.as_str()
|
||||
))
|
||||
.unwrap();
|
||||
advance_page_task_executor_until_eval_equals(
|
||||
&mut vm,
|
||||
&loader,
|
||||
"String(clusterReady !== null)",
|
||||
"true",
|
||||
"the child agent must report through the cross-origin-allowed postMessage surface",
|
||||
)
|
||||
.await;
|
||||
let result = vm
|
||||
.eval(
|
||||
r#"JSON.stringify((() => {
|
||||
const frame = document.getElementById('target');
|
||||
const attempt = callback => { try { return callback(); } catch (error) { return error.name; } };
|
||||
return {contentDocument:frame.contentDocument !== null,
|
||||
read:attempt(() => frame.contentWindow.document.nodeType === 9),
|
||||
write:attempt(() => {frame.contentWindow.nativeProbe = true; return true;}),
|
||||
location:attempt(() => new URL(frame.contentWindow.location.href).hostname === location.hostname),
|
||||
child:clusterReady.value, childLocation:clusterReady.location, childIsolated:clusterReady.isolated,
|
||||
postMessage:clusterReady.postMessage, frames:clusterReady.frames};
|
||||
})())"#,
|
||||
)
|
||||
.unwrap();
|
||||
let expected_access = if allowed {
|
||||
serde_json::json!(true)
|
||||
} else {
|
||||
serde_json::json!("SecurityError")
|
||||
};
|
||||
assert_eq!(
|
||||
serde_json::from_str::<serde_json::Value>(&result).unwrap(),
|
||||
serde_json::json!({"contentDocument":allowed, "read":expected_access,
|
||||
"write":expected_access,"location":expected_access,"child":expected_access,
|
||||
"childLocation":expected_access,"childIsolated":child_isolated,
|
||||
"postMessage":"function","frames":"object"}),
|
||||
"root={root_headers:?}, child={child_headers:?}, credentialless={credentialless}"
|
||||
);
|
||||
for universal in [false, true] {
|
||||
let world = vm
|
||||
.create_isolated_world(
|
||||
if universal {
|
||||
"agent-cluster-universal"
|
||||
} else {
|
||||
"agent-cluster-restricted"
|
||||
},
|
||||
universal,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
vm.eval_in_isolated_context(
|
||||
world,
|
||||
r#"(() => {
|
||||
try { return String(document.getElementById('target').contentWindow.document.nodeType === 9); }
|
||||
catch (error) { return error.name; }
|
||||
})()"#
|
||||
)
|
||||
.unwrap(),
|
||||
if universal || allowed {
|
||||
"true"
|
||||
} else {
|
||||
"SecurityError"
|
||||
},
|
||||
"universal={universal}, root={root_headers:?}, child={child_headers:?}"
|
||||
);
|
||||
}
|
||||
if shared {
|
||||
vm.eval("document.getElementById('target').contentWindow.postMessage(new SharedArrayBuffer(4), '*')")
|
||||
.unwrap();
|
||||
advance_page_task_executor_until_eval_equals(
|
||||
&mut vm,
|
||||
&loader,
|
||||
"String(clusterShared)",
|
||||
if allowed { "shared" } else { "messageerror" },
|
||||
"shared memory must use the same cluster boundary as DOM access",
|
||||
)
|
||||
.await;
|
||||
}
|
||||
assert_eq!(server.finish_targets().await, ["/child"]);
|
||||
}
|
||||
}
|
||||
@@ -80,39 +80,7 @@ const GEOMETRY_KIND_DOM_MATRIX: u32 = 6;
|
||||
// Kind 4 remains readable for existing numeric Quad payloads.
|
||||
const GEOMETRY_KIND_DOM_QUAD_REFERENCES: u32 = 7;
|
||||
|
||||
/// Native shared-memory identity. Compatible isolated Window agents can share
|
||||
/// a cluster even across unrelated browsing contexts. Dedicated Workers inherit
|
||||
/// their creator's identity; top-level Worker agents receive a fresh identity.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub(crate) struct SharedMemoryAgentCluster(Arc<SharedMemoryAgentClusterKey>);
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
enum SharedMemoryAgentClusterKey {
|
||||
Window {
|
||||
partition: crate::runtime::RendererStoragePartitionIdentity,
|
||||
origin: String,
|
||||
isolation_origin: String,
|
||||
},
|
||||
Worker(crate::resource_owner::ResourceOwnerId),
|
||||
}
|
||||
|
||||
impl SharedMemoryAgentCluster {
|
||||
pub(crate) fn window(
|
||||
partition: crate::runtime::RendererStoragePartitionIdentity,
|
||||
origin: String,
|
||||
isolation_origin: String,
|
||||
) -> Self {
|
||||
Self(Arc::new(SharedMemoryAgentClusterKey::Window {
|
||||
partition,
|
||||
origin,
|
||||
isolation_origin,
|
||||
}))
|
||||
}
|
||||
|
||||
pub(crate) fn worker(owner: crate::resource_owner::ResourceOwnerId) -> Self {
|
||||
Self(Arc::new(SharedMemoryAgentClusterKey::Worker(owner)))
|
||||
}
|
||||
}
|
||||
pub(crate) use crate::agent_cluster::AgentClusterIdentity as SharedMemoryAgentCluster;
|
||||
|
||||
#[derive(Debug)]
|
||||
struct ClonedSharedMemory {
|
||||
|
||||
Reference in New Issue
Block a user