Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat(credentials): bind native CredentialsContainer entry points
ldm01356f248ff19
diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/finalize.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/finalize.rsindex 2c9e825c0..538dcc5d4 100644--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/finalize.rs+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/finalize.rs@@ -2,6 +2,7 @@ use anyhow::{Context, Result, anyhow};use crate::context_bootstrap::{crypto::finalize_crypto_realm_bindings, events::finalize_pointer_event_realm_bindings,+ navigator_runtime::finalize_navigator_credentials_realm_bindings,notification_runtime::finalize_notification_realm_bindings,performance_runtime::finalize_performance_observer_realm_bindings,web_audio_runtime::finalize_base_audio_context_realm_bindings,@@ -13,6 +14,7 @@ enum RealmDependentFinalizer {DocumentRealmBindings,NodeMixinUnscopables,GlobalEventHandlersSecureContextSurface,+ NavigatorCredentialsSecureContextSurface,CryptoSecureContextSurface,BaseAudioContextSecureContextSurface,XmlHttpRequestEventTargetState,@@ -40,6 +42,10 @@ const REALM_DEPENDENT_FINALIZER_ALLOWLIST: &[(&str, RealmDependentFinalizer)] =),// These entries install private realm state, context-conditional surface,// or constructor data whose JavaScript identity must be realm-local.+ (+ "Navigator",+ RealmDependentFinalizer::NavigatorCredentialsSecureContextSurface,+ ),("BaseAudioContext",RealmDependentFinalizer::BaseAudioContextSecureContextSurface,@@ -113,6 +119,9 @@ pub(super) fn finalize_materialized_interface<'s>(RealmDependentFinalizer::BaseAudioContextSecureContextSurface => {finalize_base_audio_context_realm_bindings(scope, prototype)}+ RealmDependentFinalizer::NavigatorCredentialsSecureContextSurface => {+ finalize_navigator_credentials_realm_bindings(scope, prototype)+ }RealmDependentFinalizer::GlobalEventHandlersSecureContextSurface => {crate::context_bootstrap::window_events::finalize_secure_global_event_handler_realm_bindings(scope, prototype,@@ -171,6 +180,7 @@ mod tests {"Element","DocumentType","CharacterData",+ "Navigator","BaseAudioContext","Crypto","XMLHttpRequestEventTarget",diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime.rsindex 1c2a9a602..85ed62a9f 100644--- a/moli-renderer-v8/src/context_bootstrap/navigator_runtime.rs+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime.rs@@ -21,7 +21,7 @@ pub(in crate::context_bootstrap) use self::navigator::{SERVICE_WORKER_OWNER_TOKEN_SLOT, STORAGE_BUCKET_MANAGER_CHILD_HANDLE_SLOT,STORAGE_BUCKET_MANAGER_POPUP_ID_SLOT, STORAGE_MANAGER_CHILD_HANDLE_SLOT,STORAGE_MANAGER_POPUP_ID_SLOT, build_storage_manager_worker_template,- current_protocol_user_gesture_activation,+ current_protocol_user_gesture_activation, finalize_navigator_credentials_realm_bindings,install_storage_manager_constructor_template_bindings, navigator_identity_profile,navigator_receiver_branded, service_worker_owner_token_value, set_navigator_identity_profile,};diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials.rsindex 8ee84ab2d..6fb35035c 100644--- a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials.rs+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials.rs@@ -7,9 +7,11 @@use moli_webapi_declare::WebApiFunctionTemplate;mod base64url;+mod container;mod json_options;mod schema;mod value;+pub(super) use container::build as build_container;use crate::{native_bridge::throw_dom_exception, util::v8str, web_api_interfaces};@@ -90,6 +92,7 @@ pub(super) fn install<'s>(// Static members are installed on the constructor template by the derive.let prototype = template.prototype_template(scope);match interface_name {+ "CredentialsContainer" => container::install(scope, prototype),"Credential" => {CredentialDeclaration::initialize_template(scope, template);CredentialDeclaration::initialize_prototype_template(scope, prototype);diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials/container.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials/container.rsnew file mode 100644index 000000000..e61e3125a--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials/container.rs@@ -0,0 +1,179 @@+//! Native credential-manager entry points without a credential-store backend.+//!+//! WebIDL conversion and fully-active/pre-aborted checks still apply when no+//! credential can be produced. The generated Promise adapter handles receiver+//! and conversion errors in the function realm. Do not manufacture credentials+//! or claim to persist them.++mod options;++use anyhow::Result;+use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};++use crate::{+ native_bridge::{OwnerDispatchScope, throw_dom_exception},+ util::context_host_ptr_from_context_slot,+ web_api_interfaces, webidl,+};++use options::{CreateArgs, GetArgs, StoreArgs};++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::CredentialsContainer)]+struct ContainerObject<'s> {+ #[webapi(prototype)]+ prototype: v8::Local<'s, v8::Object>,+}++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::CredentialsContainer, enumerable, receiver)]+struct ContainerPrototype {+ #[webapi(method, returns_promise, length = 0, callback = get)]+ get: (),+ #[webapi(method, returns_promise, length = 1, callback = store)]+ store: (),+ #[webapi(method, returns_promise, length = 0, callback = create)]+ create: (),+ #[webapi(method, returns_promise, length = 0, callback = prevent_silent_access)]+ prevent_silent_access: (),+}++pub(super) fn install<'s>(+ scope: &mut v8::PinScope<'s, '_, ()>,+ prototype: v8::Local<'s, v8::ObjectTemplate>,+) {+ ContainerPrototype::initialize_prototype_template(scope, prototype);+}++pub(in crate::context_bootstrap::navigator_runtime) fn build<'s>(+ scope: &mut v8::PinScope<'s, '_>,+) -> Result<v8::Local<'s, v8::Object>> {+ let prototype = crate::context_bootstrap::ensure_intrinsic_interface_prototype(+ scope,+ "CredentialsContainer",+ )?;+ ContainerObject::new(prototype)+ .bind(scope)+ .map_err(Into::into)+}++fn check_fully_active(scope: &mut v8::PinScope<'_, '_>) -> bool {+ // Current settings come from the function realm, never from an author+ // property such as window.document or a retained WindowProxy association.+ let context = scope.get_current_context();+ let fully_active = context_host_ptr_from_context_slot(context).is_some_and(|host_ptr| {+ let host = unsafe { &*host_ptr };+ let Some(identity) = host.window_execution_context_identity_for_access_check(context)+ else {+ return false;+ };+ if !host.window_execution_context_identity_is_current(identity) {+ return false;+ }+ let document = match identity.dispatch_scope() {+ OwnerDispatchScope::Top => Some(host.document_handle()),+ OwnerDispatchScope::Child(frame) => host.child_browsing_context_document_handle(frame),+ OwnerDispatchScope::LightweightPopup(id) => host.lightweight_popup_document_handle(id),+ };+ document.is_some_and(|document| host.document_is_fully_active(document))+ });+ if !fully_active {+ throw_dom_exception(+ scope,+ "InvalidStateError",+ 11,+ "The document is not fully active.",+ );+ }+ fully_active+}++fn check_aborted<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ signal: Option<options::Signal<'s>>,+) -> bool {+ if let Some(signal) = signal+ && signal.0.is_aborted(scope)+ {+ let reason = signal+ .0+ .reason(scope)+ .unwrap_or_else(|| v8::undefined(scope).into());+ scope.throw_exception(reason);+ return true;+ }+ false+}++fn backend_unavailable(scope: &mut v8::PinScope<'_, '_>) {+ throw_dom_exception(+ scope,+ "NotSupportedError",+ 9,+ "No supported credential backend is available.",+ );+}++fn get<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'s>,+) {+ let Some(parsed) = webidl::parse_args::<GetArgs>(scope, &args) else {+ return;+ };+ if !check_fully_active(scope) || check_aborted(scope, parsed.options.0.signal) {+ return;+ }+ backend_unavailable(scope);+}++fn create<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'s>,+) {+ let Some(parsed) = webidl::parse_args::<CreateArgs>(scope, &args) else {+ return;+ };+ if !check_fully_active(scope) {+ return;+ }+ let options = parsed.options.0;+ // Unlike get(), create() checks multiple credential types before abort.+ let types = usize::from(options.password.is_some())+ + usize::from(options.federated.is_some())+ + usize::from(options.public_key.is_some());+ if types > 1 {+ backend_unavailable(scope);+ return;+ }+ if !check_aborted(scope, options.signal) {+ backend_unavailable(scope);+ }+}++fn store<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'s>,+) {+ if webidl::parse_args::<StoreArgs>(scope, &args).is_some() && check_fully_active(scope) {+ backend_unavailable(scope);+ }+}++fn prevent_silent_access<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ _args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s>,+) {+ if !check_fully_active(scope) {+ return;+ }+ // The default prevent-silent-access flag is true. With no credential store+ // or automatic sign-in path, this cannot enable silent access or persist a+ // credential; its idempotent operation can complete normally.+ let value = v8::undefined(scope).into();+ crate::context_bootstrap::stream_adapter::set_resolved_promise(scope, &mut rv, value);+}diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials/container/options.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials/container/options.rsnew file mode 100644index 000000000..f92cd43de--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/credentials/container/options.rs@@ -0,0 +1,308 @@+//! Convert credential dictionaries before entering the backend algorithm.+//!+//! All dictionaries preserve WebIDL's inherited-then-lexical member order.+//! Underscored fields are converted even though the unavailable backend cannot+//! consume them. BufferSource validation uses native identity and never copies+//! authenticator input or reads an author-visible `.buffer` property.++use crate::{abort_signal_route::ResolvedAbortSignal, web_api_interfaces, webidl};++use super::super::{+ schema::{Entity, Parameters, RelyingParty, Selection},+ value::{Dictionary, Text},+};++#[derive(Clone, Copy, webidl::WebIdlEnum)]+#[webidl(name = "CredentialMediationRequirement")]+enum Mediation {+ Silent,+ Optional,+ Conditional,+ Required,+}++pub(super) struct Signal<'s>(pub(super) ResolvedAbortSignal<'s>);++impl<'s> webidl::WebIdlConverter<'s> for Signal<'s> {+ type Options = ();++ fn convert(+ scope: &mut v8::PinScope<'s, '_>,+ value: v8::Local<'s, v8::Value>,+ context: webidl::Context,+ _options: &Self::Options,+ ) -> Result<Self, webidl::WebIdlError> {+ let signal = v8::Local::<v8::Object>::try_from(value)+ .ok()+ .filter(|object| web_api_interfaces::AbortSignal::is_instance(scope, *object))+ .and_then(|object| moli_webapi_declare::web_api_object_target(scope, object))+ .and_then(|object| ResolvedAbortSignal::resolve(scope, object));+ signal+ .map(Self)+ .ok_or_else(|| webidl::WebIdlError::cannot_convert(context, "AbortSignal"))+ }+}++// This is validation for WebAuthn's BufferSource without AllowShared or+// AllowResizable. The existing byte-copy converter also accepts shared input,+// so it cannot be used for these dictionaries.+struct Buffer;++impl<'s> webidl::WebIdlConverter<'s> for Buffer {+ type Options = ();++ fn convert(+ _scope: &mut v8::PinScope<'s, '_>,+ value: v8::Local<'s, v8::Value>,+ context: webidl::Context,+ _options: &Self::Options,+ ) -> Result<Self, webidl::WebIdlError> {+ let binary = value.is_array_buffer() || value.is_array_buffer_view();+ if binary && !crate::blob::buffer_source_has_shared_or_resizable_backing_store(value) {+ Ok(Self)+ } else {+ Err(webidl::WebIdlError::cannot_convert(context, "BufferSource"))+ }+ }+}++pub(super) struct PasswordInit;++impl<'s> webidl::WebIdlConverter<'s> for PasswordInit {+ type Options = ();++ fn convert(+ scope: &mut v8::PinScope<'s, '_>,+ value: v8::Local<'s, v8::Value>,+ context: webidl::Context,+ _options: &Self::Options,+ ) -> Result<Self, webidl::WebIdlError> {+ if let Ok(object) = v8::Local::<v8::Object>::try_from(value)+ && web_api_interfaces::HTMLFormElement::is_instance(scope, object)+ {+ return Ok(Self);+ }+ webidl::convert::<Dictionary<PasswordData>>(scope, value, context)?;+ Ok(Self)+ }+}++#[derive(webidl::WebIdlArgs)]+#[webidl(prefix = "CredentialsContainer.get")]+pub(super) struct GetArgs<'s> {+ #[webidl(converter = "raw", default = Dictionary::empty(scope)?)]+ pub(super) options: Dictionary<Request<'s>>,+}++#[derive(webidl::WebIdlArgs)]+#[webidl(prefix = "CredentialsContainer.create")]+pub(super) struct CreateArgs<'s> {+ #[webidl(converter = "raw", default = Dictionary::empty(scope)?)]+ pub(super) options: Dictionary<Creation<'s>>,+}++#[derive(webidl::WebIdlArgs)]+#[webidl(prefix = "CredentialsContainer.store")]+pub(super) struct StoreArgs<'s> {+ #[webidl(required, interface = web_api_interfaces::Credential)]+ _credential: v8::Local<'s, v8::Object>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "CredentialRequestOptions")]+pub(super) struct Request<'s> {+ #[webidl(converter = "raw")]+ _federated: Option<Dictionary<FederatedRequest>>,+ #[webidl(converter = "enum", default = Mediation::Optional)]+ _mediation: Mediation,+ #[webidl(default = false)]+ _password: bool,+ #[webidl(converter = "raw")]+ _public_key: Option<Dictionary<PublicKeyRequest>>,+ #[webidl(converter = "raw")]+ pub(super) signal: Option<Signal<'s>>,+ #[webidl(converter = "raw")]+ _ui_mode: Option<Text>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "CredentialCreationOptions")]+pub(super) struct Creation<'s> {+ #[webidl(converter = "raw")]+ pub(super) federated: Option<Dictionary<FederatedInit>>,+ #[webidl(converter = "enum", default = Mediation::Optional)]+ _mediation: Mediation,+ #[webidl(converter = "raw")]+ pub(super) password: Option<PasswordInit>,+ #[webidl(converter = "raw")]+ pub(super) public_key: Option<Dictionary<PublicKeyCreation>>,+ #[webidl(converter = "raw")]+ pub(super) signal: Option<Signal<'s>>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "FederatedCredentialRequestOptions")]+struct FederatedRequest {+ #[webidl(converter = "raw")]+ _protocols: Option<webidl::Sequence<Text>>,+ #[webidl(converter = "raw")]+ _providers: Option<webidl::Sequence<webidl::UsvString>>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "CredentialData")]+struct CredentialData {+ #[webidl(required, converter = "usv_string")]+ _id: String,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "FederatedCredentialInit")]+pub(super) struct FederatedInit {+ #[webidl(inherit)]+ _base: CredentialData,+ #[webidl(name = "iconURL", converter = "usv_string")]+ _icon_url: Option<String>,+ #[webidl(converter = "usv_string")]+ _name: Option<String>,+ #[webidl(required, converter = "usv_string")]+ _origin: String,+ #[webidl(converter = "raw")]+ _protocol: Option<Text>,+ #[webidl(required, converter = "usv_string")]+ _provider: String,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "PasswordCredentialData")]+struct PasswordData {+ #[webidl(inherit)]+ _base: CredentialData,+ #[webidl(name = "iconURL", converter = "usv_string")]+ _icon_url: Option<String>,+ #[webidl(converter = "usv_string")]+ _name: Option<String>,+ #[webidl(required, converter = "usv_string")]+ _origin: String,+ #[webidl(required, converter = "usv_string")]+ _password: String,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "PublicKeyCredentialCreationOptions")]+pub(super) struct PublicKeyCreation {+ #[webidl(converter = "raw", default = Text::from("none"))]+ _attestation: Text,+ #[webidl(converter = "raw", default = webidl::Sequence(Vec::new()))]+ _attestation_formats: webidl::Sequence<Text>,+ #[webidl(converter = "raw")]+ _authenticator_selection: Option<Dictionary<Selection>>,+ #[webidl(required, converter = "raw")]+ _challenge: Buffer,+ #[webidl(converter = "raw", default = webidl::Sequence(Vec::new()))]+ _exclude_credentials: webidl::Sequence<Dictionary<Descriptor>>,+ #[webidl(converter = "raw")]+ _extensions: Option<Dictionary<Extensions>>,+ #[webidl(converter = "raw", default = webidl::Sequence(Vec::new()))]+ _hints: webidl::Sequence<Text>,+ #[webidl(required, converter = "raw")]+ _pub_key_cred_params: webidl::Sequence<Dictionary<Parameters>>,+ #[webidl(required, converter = "raw")]+ _rp: Dictionary<RelyingParty>,+ _timeout: Option<u32>,+ #[webidl(required, converter = "raw")]+ _user: Dictionary<User>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "PublicKeyCredentialRequestOptions")]+struct PublicKeyRequest {+ #[webidl(converter = "raw", default = webidl::Sequence(Vec::new()))]+ _allow_credentials: webidl::Sequence<Dictionary<Descriptor>>,+ #[webidl(required, converter = "raw")]+ _challenge: Buffer,+ #[webidl(converter = "raw")]+ _extensions: Option<Dictionary<Extensions>>,+ #[webidl(converter = "raw", default = webidl::Sequence(Vec::new()))]+ _hints: webidl::Sequence<Text>,+ #[webidl(converter = "raw")]+ _rp_id: Option<Text>,+ _timeout: Option<u32>,+ #[webidl(converter = "raw", default = Text::from("preferred"))]+ _user_verification: Text,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "PublicKeyCredentialUserEntity")]+struct User {+ #[webidl(inherit)]+ _base: Entity,+ #[webidl(required, converter = "raw")]+ _display_name: Text,+ #[webidl(required, converter = "raw")]+ _id: Buffer,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "PublicKeyCredentialDescriptor")]+struct Descriptor {+ #[webidl(required, converter = "raw")]+ _id: Buffer,+ #[webidl(converter = "raw")]+ _transports: Option<webidl::Sequence<Text>>,+ #[webidl(required, name = "type", converter = "raw")]+ _credential_type: Text,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "AuthenticationExtensionsClientInputs")]+struct Extensions {+ #[webidl(converter = "raw")]+ _appid: Option<Text>,+ #[webidl(converter = "raw")]+ _appid_exclude: Option<Text>,+ #[webidl(converter = "raw")]+ _cred_blob: Option<Buffer>,+ _cred_props: Option<bool>,+ #[webidl(converter = "usv_string")]+ _credential_protection_policy: Option<String>,+ #[webidl(default = false)]+ _enforce_credential_protection_policy: bool,+ _get_cred_blob: Option<bool>,+ _hmac_create_secret: Option<bool>,+ #[webidl(converter = "raw")]+ _large_blob: Option<Dictionary<LargeBlob>>,+ _min_pin_length: Option<bool>,+ #[webidl(converter = "raw")]+ _prf: Option<Dictionary<Prf>>,+ #[webidl(name = "remoteClientDataJSON", converter = "raw")]+ _remote_client_data_json: Option<Text>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "AuthenticationExtensionsLargeBlobInputs")]+struct LargeBlob {+ _read: Option<bool>,+ #[webidl(converter = "raw")]+ _support: Option<Text>,+ #[webidl(converter = "raw")]+ _write: Option<Buffer>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "AuthenticationExtensionsPRFInputs")]+struct Prf {+ #[webidl(converter = "raw")]+ _eval: Option<Dictionary<PrfValues>>,+ #[webidl(converter = "raw")]+ _eval_by_credential: Option<webidl::Record<Text, Dictionary<PrfValues>>>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "AuthenticationExtensionsPRFValues")]+struct PrfValues {+ #[webidl(required, converter = "raw")]+ _first: Buffer,+ #[webidl(converter = "raw")]+ _second: Option<Buffer>,+}diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rsindex 2ea2c0b71..f3f40fe71 100644--- a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs@@ -74,6 +74,7 @@ const NAVIGATOR_RUNTIME_DATA_KEYS: &[&str] = &["storageBuckets","geolocation","mediaCapabilities",+ "credentials",];const WORKER_NAVIGATOR_INSTALLED_SLOT: &str = "__moliWorkerNavigatorInstalled";const WORKER_NAVIGATOR_MATERIALIZING_SLOT: &str = "__moliWorkerNavigatorMaterializing";@@ -197,6 +198,13 @@ struct NavigatorRuntimeDataPrototypeDeclaration {cookie_enabled: (),}+#[derive(Default, WebApiObject)]+#[webapi(fragment, prototype = "Navigator")]+struct NavigatorCredentialsPrototypeDeclaration {+ #[webapi(accessor_property, enumerable, receiver = web_api_interfaces::Navigator::is_instance, getter = navigator_runtime_data_getter_callback, data = callback_data_index_value(scope, 33))]+ credentials: (),+}+#[derive(Default, WebApiFunctionTemplate)]#[webapi(interface = web_api_interfaces::Navigator)]struct NavigatorPrototypeMethodsDeclaration {@@ -591,6 +599,8 @@ struct WindowNavigatorBackingDeclaration<'scope, 'profile> {#[webapi(data_property, enumerable)]media_capabilities: v8::Local<'scope, v8::Value>,+ #[webapi(data_property, enumerable)]+ credentials: v8::Local<'scope, v8::Value>,}#[derive(WebApiObject)]@@ -927,6 +937,19 @@ pub(in crate::context_bootstrap) fn install_navigator_template_bindings<'s>(}}+pub(in crate::context_bootstrap) fn finalize_navigator_credentials_realm_bindings<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ prototype: v8::Local<'s, v8::Object>,+) -> Result<()> {+ let global = scope.get_current_context().global(scope);+ if super::super::runtime_state::window_realm_secure_context_available(scope, global) {+ NavigatorCredentialsPrototypeDeclaration::default()+ .initialize(scope, prototype)+ .map_err(|error| anyhow!("failed to initialize Navigator credentials: {error}"))?;+ }+ Ok(())+}+fn filter_navigator_secure_context_exposure<'s>(scope: &mut v8::PinScope<'s, '_>,prototype: v8::Local<'s, v8::Object>,@@ -934,6 +957,7 @@ fn filter_navigator_secure_context_exposure<'s>() -> Result<()> {if !secure_context {delete_object_property(scope, prototype, "clipboard")?;+ delete_object_property(scope, prototype, "credentials")?;delete_object_property(scope, prototype, "mediaDevices")?;delete_object_property(scope, prototype, "storage")?;delete_object_property(scope, prototype, "storageBuckets")?;@@ -1086,6 +1110,7 @@ pub(super) fn build_lazy_navigator_subobject_in_current_realm<'s>(build_service_worker_container(scope, owner_child, owner_popup)?.into()}NavigatorSubobject::Clipboard => build_clipboard_object(scope)?.into(),+ NavigatorSubobject::Credentials => super::credentials::build_container(scope)?.into(),NavigatorSubobject::UserActivation => build_user_activation(scope)?.into(),NavigatorSubobject::StorageBuckets => {build_storage_bucket_manager(scope, owner_child, owner_popup)?.into()@@ -1275,6 +1300,7 @@ fn build_window_navigator_backing_for_owner<'s>(storage_buckets: v8::undefined(scope).into(),geolocation: v8::undefined(scope).into(),media_capabilities: v8::undefined(scope).into(),+ credentials: v8::undefined(scope).into(),}.bind(scope).map_err(|error| anyhow!("failed to bind Navigator backing object: {error}"))@@ -1685,6 +1711,7 @@ fn navigator_runtime_data_object<'s>(scope: &mut v8::PinScope<'s, '_>,navigator: v8::Local<'s, v8::Object>,) -> Option<v8::Local<'s, v8::Object>> {+ let navigator = moli_webapi_declare::web_api_object_target(scope, navigator)?;get_private_value(scope, navigator, NAVIGATOR_RUNTIME_DATA_SLOT).and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())}diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator_subobjects.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator_subobjects.rsindex 76e3def92..29af01ff7 100644--- a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator_subobjects.rs+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator_subobjects.rs@@ -22,11 +22,12 @@ pub(super) enum NavigatorSubobject {StorageBuckets,Geolocation,MediaCapabilities,+ Credentials,}impl NavigatorSubobject {#[cfg(test)]- pub(super) const ALL: [Self; 16] = [+ pub(super) const ALL: [Self; 17] = [Self::Languages,Self::MimeTypes,Self::Plugins,@@ -43,6 +44,7 @@ impl NavigatorSubobject {Self::StorageBuckets,Self::Geolocation,Self::MediaCapabilities,+ Self::Credentials,];pub(super) fn from_key(key: &str) -> Option<Self> {@@ -63,6 +65,7 @@ impl NavigatorSubobject {"storageBuckets" => Some(Self::StorageBuckets),"geolocation" => Some(Self::Geolocation),"mediaCapabilities" => Some(Self::MediaCapabilities),+ "credentials" => Some(Self::Credentials),_ => None,}}@@ -85,6 +88,7 @@ impl NavigatorSubobject {Self::StorageBuckets => "storageBuckets",Self::Geolocation => "geolocation",Self::MediaCapabilities => "mediaCapabilities",+ Self::Credentials => "credentials",}}}diff --git a/moli-renderer-v8/src/native_bridge/context_host/activity.rs b/moli-renderer-v8/src/native_bridge/context_host/activity.rsindex f17482dcc..dce14f145 100644--- a/moli-renderer-v8/src/native_bridge/context_host/activity.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/activity.rs@@ -1,5 +1,6 @@use super::workers::WorkerExecutionState;use super::*;+use crate::dom::native::Node;impl JsContextHost {pub(crate) fn document_has_browsing_context(&self, document: DomHandle) -> bool {@@ -14,6 +15,35 @@ impl JsContextHost {.is_some()}+ pub(crate) fn document_is_fully_active(&self, document: DomHandle) -> bool {+ if self.page_context_resources_closed {+ return false;+ }+ // A retained Window association is insufficient: the Document and each+ // ancestor must still be current in a live browsing context.+ let mut document = document;+ let mut visited = std::collections::HashSet::new();+ loop {+ if document == self.document_handle() {+ return true;+ }+ if let Some(popup_id) = self.lightweight_popup_id_for_document_handle(document) {+ return self.lightweight_popup_is_open(popup_id);+ }+ let Some(frame) = self.child_browsing_context_host_for_document_handle(document) else {+ return false;+ };+ if !visited.insert(frame) || !self.dom_host().is_connected(frame) {+ return false;+ }+ let Some(parent_document) = self.dom_host().node(frame).and_then(Node::owner_document)+ else {+ return false;+ };+ document = parent_document;+ }+ }+pub(crate) fn document_activity(&self) -> moli_page_types::DocumentActivity {self.document_activity}diff --git a/moli-renderer-v8/src/script_vm/tests/credential_container.js b/moli-renderer-v8/src/script_vm/tests/credential_container.jsnew file mode 100644index 000000000..422b955e6--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/credential_container.js@@ -0,0 +1,262 @@+(async () => {+ const facts = {complete: false, checks: [], traces: []};+ globalThis.__uiEventResults = facts;+ const assert = (ok, message) => { if (!ok) throw Error(message); };+ const same = (actual, expected) => assert(JSON.stringify(actual) === JSON.stringify(expected), JSON.stringify({actual, expected}));+ const foreign = document.getElementById('child').contentWindow;+ for (const [realm, w] of [['main', globalThis], ['iframe', foreign]]) {+ const run = async (name, fn) => {+ try { await fn(); facts.checks.push({realm, name, passed: true}); }+ catch (error) { facts.checks.push({realm, name, passed: false, error: error.name, message: error.message}); }+ };+ if (!w.navigator.credentials) {+ facts.checks.push({realm, name: 'navigator.credentials producer', passed: false, message: 'Missing producer'});+ continue;+ }+ const container = w.navigator.credentials;+ const prototype = w.CredentialsContainer.prototype;+ const PromiseCtor = w.Promise, TypeErrorCtor = w.TypeError, DOMExceptionCtor = w.DOMException;+ const methods = Object.fromEntries(['get', 'create', 'store', 'preventSilentAccess'].map(name => [name, prototype[name]]));+ const invoke = (name, receiver, args = []) => {+ let result;+ try { result = methods[name].apply(receiver, args); }+ catch (error) { throw Error('Synchronous exception: ' + error); }+ assert(result instanceof PromiseCtor, 'Promise must belong to function realm');+ return result;+ };+ const rejection = async (name, receiver, args, Constructor, exceptionName) => {+ let error, rejected = false;+ try { await invoke(name, receiver, args); } catch (caught) { rejected = true; error = caught; }+ assert(rejected, 'Expected a rejected Promise');+ if (Constructor) assert(error instanceof Constructor, 'Wrong exception constructor/realm: ' + String(error));+ if (exceptionName) {+ assert(error.name === exceptionName, 'Wrong exception name: ' + String(error));+ if (exceptionName === 'NotSupportedError') assert(error.code === 9, 'NotSupportedError code');+ if (exceptionName === 'InvalidStateError') assert(error.code === 11, 'InvalidStateError code');+ }+ return error;+ };+ const controller = reason => { const value = new w.AbortController(); value.abort(reason); return value; };+ const validCreation = () => ({rp: {name: 'Site'}, user: {name: 'user', displayName: 'User', id: new Uint8Array([1])}, challenge: new Uint8Array([2]), pubKeyCredParams: [{type: 'public-key', alg: -7}]});+ const validRequest = () => ({challenge: new Uint8Array([3])});+ const getters = (values, trace, prefix = '') => Object.defineProperties({}, Object.fromEntries(Object.entries(values).map(([key, value]) => [key, {enumerable: true, get() { trace.push(prefix + key); return value; }}])));+ await run('secure SameObject producer and descriptor', async () => {+ assert(w.isSecureContext, 'Fixture must run in a secure context');+ const descriptor = Object.getOwnPropertyDescriptor(w.Navigator.prototype, 'credentials');+ assert(descriptor.enumerable && descriptor.configurable && descriptor.set === undefined, 'Readonly enumerable accessor');+ assert(container === w.navigator.credentials && descriptor.get.call(w.navigator) === container, 'SameObject');+ assert(Object.getPrototypeOf(container) === prototype && container instanceof w.CredentialsContainer, 'Relevant-realm prototype');+ assert(Object.prototype.toString.call(container) === '[object CredentialsContainer]', 'Interface tag');+ let error; try { new w.CredentialsContainer(); } catch (caught) { error = caught; }+ assert(error instanceof TypeErrorCtor, 'Illegal constructor');+ const other = w === globalThis ? foreign : globalThis;+ assert(descriptor.get.call(other.navigator) === other.navigator.credentials, 'Borrowed Navigator getter uses receiver realm/cache');+ assert(Object.getPrototypeOf(descriptor.get.call(other.navigator)) === other.CredentialsContainer.prototype, 'Borrowed getter materializes in receiver realm');+ });+ await run('Navigator getter uses native brand without author traps', async () => {+ const getter = Object.getOwnPropertyDescriptor(w.Navigator.prototype, 'credentials').get;+ let reads = 0;+ const trap = () => { reads++; throw Error('Getter trap'); };+ const revoked = Proxy.revocable(w.navigator, {}); revoked.revoke();+ for (const fake of [{}, Object.create(w.navigator), Object.create(w.Navigator.prototype), new Proxy(w.navigator, {get: trap, getPrototypeOf: trap}), revoked.proxy, new EventTarget()]) {+ let error; try { getter.call(fake); } catch (caught) { error = caught; }+ assert(error instanceof TypeErrorCtor, 'Navigator getter accepted a forged receiver');+ }+ assert(reads === 0, 'Receiver check ran author traps');+ });+ const trap = () => { throw Error('Unexpected author trap'); };+ const revoked = Proxy.revocable(container, {}); revoked.revoke();+ const badReceivers = [null, undefined, {}, Object.create(container), Object.create(prototype), new Proxy(container, {get: trap, getPrototypeOf: trap}), revoked.proxy, new EventTarget()];+ for (const [name, length] of [['get', 0], ['create', 0], ['store', 1], ['preventSilentAccess', 0]]) {+ await run(name + '/native descriptor and arity', async () => {+ const descriptor = Object.getOwnPropertyDescriptor(prototype, name);+ assert(descriptor.enumerable && descriptor.configurable && descriptor.writable, 'Writable enumerable method');+ assert(methods[name].name === name && methods[name].length === length, 'Name and arity');+ assert(Function.prototype.toString.call(methods[name]).includes('[native code]'), 'Native function');+ });+ for (const [index, receiver] of badReceivers.entries()) {+ await run(name + '/brand before argument conversion/' + index, async () => {+ let reads = 0;+ const argument = new Proxy({}, {get() { reads++; throw Error('Argument conversion ran'); }});+ await rejection(name, receiver, [argument], TypeErrorCtor);+ assert(reads === 0, 'Invalid receiver must fail before any argument conversion');+ });+ }+ }+ for (const name of ['get', 'create']) {+ for (const [label, args] of [['omitted', []], ['undefined', [undefined]], ['null', [null]], ['empty', [{}]], ['unknown', [{get unknown() { throw Error('Unknown member read'); }}]]]) {+ await run(name + '/empty dictionary/' + label, () => rejection(name, container, args, DOMExceptionCtor, 'NotSupportedError'));+ }+ for (const [index, value] of [true, 1, 'string', Symbol('dictionary'), 1n].entries()) {+ await run(name + '/primitive dictionary/' + index, () => rejection(name, container, [value], TypeErrorCtor));+ }+ for (const mediation of ['silent', 'optional', 'conditional', 'required']) {+ await run(name + '/valid mediation/' + mediation, async () => {+ const marker = {}, signal = controller(marker).signal;+ assert(await rejection(name, container, [{mediation, signal}]) === marker, 'Pre-abort reason identity');+ });+ }+ for (const [index, mediation] of ['', 'OPTIONAL', null, Symbol('mediation')].entries()) {+ await run(name + '/invalid mediation/' + index, () => rejection(name, container, [{mediation, signal: controller({}).signal}], TypeErrorCtor));+ }+ for (const [index, reason] of ['reason', {}, [], new Error('reason'), null, 42, 1n, Symbol('reason')].entries()) {+ await run(name + '/pre-abort exact reason/' + index, async () => {+ const signal = controller(reason).signal;+ assert(await rejection(name, container, [{signal}]) === reason, 'Abort reason was replaced');+ });+ }+ await run(name + '/default abort reason and foreign signal', async () => {+ const other = w === globalThis ? foreign : globalThis;+ const abort = new other.AbortController(); abort.abort();+ assert(await rejection(name, container, [{signal: abort.signal}]) === abort.signal.reason, 'Cross-realm native signal/default reason');+ });+ const signal = new w.AbortController().signal;+ const revokedSignal = Proxy.revocable(signal, {}); revokedSignal.revoke();+ for (const [index, invalid] of [null, {}, Object.create(signal), Object.create(w.AbortSignal.prototype), new Proxy(signal, {get: trap, getPrototypeOf: trap}), revokedSignal.proxy, new EventTarget()].entries()) {+ await run(name + '/AbortSignal native brand/' + index, () => rejection(name, container, [{signal: invalid}], TypeErrorCtor));+ }+ await run(name + '/abort state ignores public getters', async () => {+ const marker = {}, signal = controller(marker).signal;+ Object.defineProperties(signal, {aborted: {get: trap}, reason: {get: trap}});+ assert(await rejection(name, container, [{signal}]) === marker, 'Internal abort state/reason');+ });+ await run(name + '/conversion exception before pre-abort', async () => {+ const marker = {}, signal = controller({}).signal;+ assert(await rejection(name, container, [{get mediation() { throw marker; }, signal}]) === marker, 'Conversion exception was replaced');+ });+ await run(name + '/all dictionary getters precede native algorithm', async () => {+ const trace = [], marker = {}, signal = controller(marker).signal;+ const values = name === 'get' ? {federated: undefined, mediation: 'optional', password: false, publicKey: undefined, signal, uiMode: undefined} : {federated: undefined, mediation: 'optional', password: undefined, publicKey: undefined, signal};+ const options = getters(values, trace);+ assert(await rejection(name, container, [options]) === marker, 'Abort must follow conversion');+ same(trace, Object.keys(values)); facts.traces.push({realm, name, trace});+ });+ await run(name + '/missing defaults avoid Object.prototype getters', async () => {+ let reads = 0;+ const get = () => { reads++; throw Error('Inherited default read'); };+ for (const key of ['federated', 'mediation', 'password', 'publicKey', 'signal']) Object.defineProperty(w.Object.prototype, key, {configurable: true, get});+ let error;+ try { error = await rejection(name, container, [], DOMExceptionCtor, 'NotSupportedError'); }+ finally { for (const key of ['federated', 'mediation', 'password', 'publicKey', 'signal']) delete w.Object.prototype[key]; }+ assert(reads === 0 && error.name === 'NotSupportedError', 'Empty default is not an ordinary JS object');+ });+ for (const [index, binary] of [null, [], {}, 'bytes', new Proxy(new Uint8Array([1]), {})].entries()) {+ await run(name + '/native BufferSource/' + index, async () => {+ const publicKey = name === 'create' ? validCreation() : validRequest();+ publicKey.challenge = binary;+ await rejection(name, container, [{publicKey, signal: controller({}).signal}], TypeErrorCtor);+ });+ }+ for (const [index, binary] of [new ArrayBuffer(2), new Uint8Array([1, 2]), new DataView(new ArrayBuffer(3))].entries()) {+ await run(name + '/valid BufferSource before abort/' + index, async () => {+ const marker = {}, publicKey = name === 'create' ? validCreation() : validRequest();+ publicKey.challenge = binary;+ assert(await rejection(name, container, [{publicKey, signal: controller(marker).signal}]) === marker, 'Native ArrayBuffer/view conversion');+ });+ }+ for (const [index, binary] of [new ArrayBuffer(2, {maxByteLength: 4}), new Uint8Array(new ArrayBuffer(2, {maxByteLength: 4})), new DataView(new ArrayBuffer(2, {maxByteLength: 4}))].entries()) {+ await run(name + '/reject resizable BufferSource/' + index, async () => {+ const publicKey = name === 'create' ? validCreation() : validRequest(); publicKey.challenge = binary;+ await rejection(name, container, [{publicKey, signal: controller({}).signal}], TypeErrorCtor);+ });+ }+ if (typeof w.SharedArrayBuffer === 'function') {+ for (const [index, binary] of [new w.SharedArrayBuffer(2), new Uint8Array(new w.SharedArrayBuffer(2)), new DataView(new w.SharedArrayBuffer(2))].entries()) {+ await run(name + '/reject shared BufferSource/' + index, async () => {+ const publicKey = name === 'create' ? validCreation() : validRequest(); publicKey.challenge = binary;+ await rejection(name, container, [{publicKey, signal: controller({}).signal}], TypeErrorCtor);+ });+ }+ }+ for (const extension of [{credBlob: {}}, {largeBlob: {write: {}}}, {prf: {eval: {first: {}}}}, {prf: {evalByCredential: {AA: {first: {}}}}}]) {+ await run(name + '/nested extension buffers/' + JSON.stringify(extension), async () => {+ const publicKey = name === 'create' ? validCreation() : validRequest(); publicKey.extensions = extension;+ await rejection(name, container, [{publicKey, signal: controller({}).signal}], TypeErrorCtor);+ });+ }+ await run(name + '/credential descriptor required members', async () => {+ const publicKey = name === 'create' ? validCreation() : validRequest();+ publicKey[name === 'create' ? 'excludeCredentials' : 'allowCredentials'] = [{type: 'public-key'}];+ await rejection(name, container, [{publicKey, signal: controller({}).signal}], TypeErrorCtor);+ });+ await run(name + '/PRF record key getter exception identity', async () => {+ const marker = {}, publicKey = name === 'create' ? validCreation() : validRequest();+ publicKey.extensions = {prf: {evalByCredential: {get AA() { throw marker; }}}};+ assert(await rejection(name, container, [{publicKey, signal: controller({}).signal}]) === marker, 'Record getter exception identity');+ });+ }+ await run('create/inherited dictionaries convert before derived members', async () => {+ const marker = {}, trace = [], publicKey = validCreation();+ publicKey.rp = getters({name: 'Site', id: location.hostname}, trace, 'rp.');+ publicKey.user = getters({name: 'user', displayName: 'User', id: new Uint8Array([1])}, trace, 'user.');+ assert(await rejection('create', container, [{publicKey, signal: controller(marker).signal}]) === marker, 'Valid nested conversion');+ same(trace, ['rp.name', 'rp.id', 'user.name', 'user.displayName', 'user.id']);+ });+ for (const kind of ['password', 'federated']) {+ await run('create/' + kind + '/inherited dictionary member order', async () => {+ const marker = {}, trace = [];+ const values = kind === 'password' ? {id: 'user', iconURL: '', name: 'User', origin: location.origin, password: 'secret'} : {id: 'user', iconURL: '', name: 'User', origin: location.origin, protocol: undefined, provider: 'https://idp.example'};+ const options = {[kind]: getters(values, trace), signal: controller(marker).signal};+ assert(await rejection('create', container, [options]) === marker, 'Abort after credential conversion');+ same(trace, Object.keys(values));+ });+ await run('create/' + kind + '/required origin', async () => {+ const data = kind === 'password' ? {id: 'user', password: 'secret'} : {id: 'user', provider: 'https://idp.example'};+ await rejection('create', container, [{[kind]: data, signal: controller({}).signal}], TypeErrorCtor);+ });+ }+ await run('create/native form union precedes dictionary getters', async () => {+ const marker = {}, form = document.createElement('form');+ Object.defineProperty(form, 'password', {get: trap});+ assert(await rejection('create', container, [{password: form, signal: controller(marker).signal}]) === marker, 'Native form union branch');+ });+ await run('create/multiple credential types before pre-abort', async () => {+ const password = {id: 'user', origin: location.origin, password: 'secret'}, publicKey = validCreation();+ await rejection('create', container, [{password, publicKey, signal: controller({}).signal}], DOMExceptionCtor, 'NotSupportedError');+ });+ for (const [index, args] of [[], [undefined], [null], [{}], [Object.create(w.Credential.prototype)]].entries()) {+ await run('store/required native Credential/' + index, () => rejection('store', container, args, TypeErrorCtor));+ }+ await run('preventSilentAccess/idempotent undefined without argument conversion', async () => {+ assert(await invoke('preventSilentAccess', container, [new Proxy({}, {get: trap})]) === undefined, 'No extra argument conversion');+ assert(await invoke('preventSilentAccess', container) === undefined, 'Idempotent result');+ });+ await run('native brand remains after prototype replacement', async () => {+ const saved = Object.getPrototypeOf(container);+ Object.setPrototypeOf(container, null);+ try { assert(await invoke('preventSilentAccess', container) === undefined, 'Native brand survives prototype change'); }+ finally { Object.setPrototypeOf(container, saved); }+ });+ await run('native Promise and errors ignore replaced public constructors', async () => {+ const saved = [w.Promise, w.TypeError, w.DOMException, w.CredentialsContainer];+ try {+ w.Promise = w.TypeError = w.DOMException = w.CredentialsContainer = function() { throw Error('Public constructor called'); };+ await rejection('store', container, [{}], TypeErrorCtor);+ await rejection('create', container, [], DOMExceptionCtor, 'NotSupportedError');+ assert(await invoke('preventSilentAccess', container) === undefined, 'Native Promise resolver');+ } finally { [w.Promise, w.TypeError, w.DOMException, w.CredentialsContainer] = saved; }+ });+ }+ for (const ancestor of [false, true]) {+ const name = ancestor ? 'inactive ancestor' : 'removed iframe';+ try {+ const outer = document.createElement('iframe'); document.body.appendChild(outer);+ let frame = outer;+ if (ancestor) { frame = outer.contentDocument.createElement('iframe'); outer.contentDocument.body.appendChild(frame); }+ const w = frame.contentWindow, container = w.navigator.credentials, PromiseCtor = w.Promise, DOMExceptionCtor = w.DOMException, TypeErrorCtor = w.TypeError;+ const marker = {}, abort = new w.AbortController(); abort.abort(marker);+ const get = container.get, create = container.create, prevent = container.preventSilentAccess, store = container.store;+ outer.remove();+ for (const [method, args] of [[get, [{signal: abort.signal}]], [create, [{signal: abort.signal}]], [prevent, []]]) {+ let error; const promise = method.apply(container, args); assert(promise instanceof PromiseCtor, 'Inactive function Promise realm');+ try { await promise; } catch (caught) { error = caught; }+ assert(error instanceof DOMExceptionCtor && error.name === 'InvalidStateError', 'Fully active check precedes pre-abort');+ }+ let error; try { await store.call(container, {}); } catch (caught) { error = caught; }+ assert(error instanceof TypeErrorCtor, 'WebIDL conversion precedes native activity check');+ facts.checks.push({realm: 'lifecycle', name, passed: true});+ } catch (error) { facts.checks.push({realm: 'lifecycle', name, passed: false, error: error.name, message: error.message}); }+ }+ facts.passed = facts.checks.filter(row => row.passed).length; facts.total = facts.checks.length; facts.complete = true;+ return true;+})()diff --git a/moli-renderer-v8/src/script_vm/tests/credential_container.rs b/moli-renderer-v8/src/script_vm/tests/credential_container.rsnew file mode 100644index 000000000..6cf79b1ca--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/credential_container.rs@@ -0,0 +1,123 @@+use super::*;++#[test]+fn credentials_container_preserves_native_brands_conversion_order_abort_and_inactive_realms() {+ let mut vm = new_storage_page_task_executor_test_vm("https://credentials-container.test/");+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>'")+ .unwrap();+ vm.eval(include_str!("credential_container.js")).unwrap();+ assert_eq!(vm.eval("__uiEventResults.complete").unwrap(), "true");+ assert_eq!(+ vm.eval("JSON.stringify(__uiEventResults.checks.filter(row => !row.passed))")+ .unwrap(),+ "[]"+ );+}++#[test]+fn credentials_container_exposes_navigator_property_in_secure_contexts() {+ for (url, exposed) in [+ ("https://credentials-container.test/", true),+ ("http://localhost/", true),+ ("http://credentials-container.test/", false),+ ] {+ let mut vm = new_storage_page_task_executor_test_vm(url);+ assert_eq!(vm.eval("isSecureContext").unwrap(), exposed.to_string());+ vm.eval(&format!(+ "Object.defineProperty(globalThis, 'isSecureContext', {{value: {}}})",+ !exposed+ ))+ .unwrap();+ assert_eq!(+ vm.eval("Object.hasOwn(Navigator.prototype, 'credentials')")+ .unwrap(),+ exposed.to_string(),+ "{url}"+ );+ assert_eq!(+ vm.eval("'credentials' in navigator").unwrap(),+ exposed.to_string(),+ "{url} after Navigator materialization"+ );+ }+}++#[test]+fn credentials_container_accepts_registered_native_proxies_and_native_credential_arguments() {+ let mut vm = new_storage_page_task_executor_test_vm("https://credentials-container.test/");+ vm.eval("globalThis.nativeSignal = AbortSignal.abort({})")+ .unwrap();+ let context_ptr = &vm.page_default_runtime.context as *const _;+ vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {+ let global = scope.get_current_context().global(scope);+ let fixtures = v8::Object::new(scope);+ for name in ["CredentialsContainer", "Credential", "PublicKeyCredential"] {+ let object = v8::Object::new(scope);+ // Identity-only fixtures, not produced credentials or saved secrets.+ moli_webapi_declare::initialize_web_api_object(scope, object, name).unwrap();+ let handler = crate::util::new_null_prototype_object(scope);+ let proxy = v8::Proxy::new(scope, object, handler).unwrap();+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();+ let key = crate::util::v8str(scope, name);+ assert_eq!(+ fixtures.create_data_property(scope, key.into(), proxy.into()),+ Some(true)+ );+ }+ let key = crate::util::v8str(scope, "navigator");+ let navigator = global.get(scope, key.into()).unwrap();+ let navigator = v8::Local::<v8::Object>::try_from(navigator).unwrap();+ let handler = crate::util::new_null_prototype_object(scope);+ let proxy = v8::Proxy::new(scope, navigator, handler).unwrap();+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();+ let key = crate::util::v8str(scope, "Navigator");+ assert_eq!(+ fixtures.create_data_property(scope, key.into(), proxy.into()),+ Some(true)+ );+ let key = crate::util::v8str(scope, "nativeSignal");+ let signal = global.get(scope, key.into()).unwrap();+ let signal = v8::Local::<v8::Object>::try_from(signal).unwrap();+ let handler = crate::util::new_null_prototype_object(scope);+ let proxy = v8::Proxy::new(scope, signal, handler).unwrap();+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();+ let key = crate::util::v8str(scope, "AbortSignal");+ assert_eq!(+ fixtures.create_data_property(scope, key.into(), proxy.into()),+ Some(true)+ );+ let key = crate::util::v8str(scope, "nativeFixtures");+ assert_eq!(+ global.create_data_property(scope, key.into(), fixtures.into()),+ Some(true)+ );+ Ok(())+ })+ .unwrap();+ vm.eval(r#"(async () => {+ const prototype = CredentialsContainer.prototype, container = nativeFixtures.CredentialsContainer;+ const getter = Object.getOwnPropertyDescriptor(Navigator.prototype, 'credentials').get;+ if (getter.call(nativeFixtures.Navigator) !== navigator.credentials) throw Error('Native Navigator proxy rejected');+ if (await prototype.preventSilentAccess.call(container) !== undefined) throw Error('Native proxy receiver rejected');+ for (const method of ['get', 'create']) {+ let reason; try { await prototype[method].call(container, {signal: nativeFixtures.AbortSignal}); } catch (caught) { reason = caught; }+ if (reason !== nativeSignal.reason) throw Error('Native AbortSignal proxy rejected');+ }+ for (const credential of [nativeFixtures.Credential, nativeFixtures.PublicKeyCredential]) {+ let error; try { await prototype.store.call(container, credential); } catch (caught) { error = caught; }+ if (!(error instanceof DOMException) || error.name !== 'NotSupportedError') throw Error('Native Credential brand rejected');+ let conversions = 0;+ const revoked = Proxy.revocable(credential, {}); revoked.revoke();+ for (const fake of [Object.create(credential), new Proxy(credential, {get() { conversions++; throw Error('Trap'); }}), revoked.proxy]) {+ let error; try { await prototype.store.call(container, fake); } catch (caught) { error = caught; }+ if (!(error instanceof TypeError)) throw Error('Author receiver accepted');+ }+ if (conversions) throw Error('Native interface conversion ran author trap');+ }+ globalThis.nativeCredentialTestDone = true;+ })().catch(error => globalThis.nativeCredentialTestDone = String(error))"#).unwrap();+ assert_eq!(+ vm.eval("globalThis.nativeCredentialTestDone").unwrap(),+ "true"+ );+}diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rsindex f5a98ca0c..06891f017 100644--- a/moli-renderer-v8/src/script_vm/tests/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs@@ -1,3 +1,4 @@+mod credential_container;mod credential_json_options;mod writable_stream_native_receivers;use super::post_parse::dynamic_script_execute_is_runnable_before_dom_content_loaded;