Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(streams): validate WritableStream receivers through native brands
ldm0bf09627a8c7a
diff --git a/moli-renderer-v8/src/context_bootstrap/streams.rs b/moli-renderer-v8/src/context_bootstrap/streams.rsindex 0797a86b8..9f4d15761 100644--- a/moli-renderer-v8/src/context_bootstrap/streams.rs+++ b/moli-renderer-v8/src/context_bootstrap/streams.rs@@ -221,13 +221,13 @@ struct ReadableStreamPrototypeDeclaration {}#[derive(WebApiFunctionTemplate)]-#[webapi(interface = web_api_interfaces::WritableStream, enumerable)]+#[webapi(interface = web_api_interfaces::WritableStream, enumerable, receiver)]struct WritableStreamPrototypeDeclaration {#[webapi(method, length = 0, callback = writable_stream_get_writer_callback)]get_writer: (),- #[webapi(method, length = 0, callback = writable_stream_abort_callback)]+ #[webapi(method, returns_promise, length = 0, callback = writable_stream_abort_callback)]abort: (),- #[webapi(method, length = 0, callback = writable_stream_close_callback)]+ #[webapi(method, returns_promise, length = 0, callback = writable_stream_close_callback)]close: (),#[webapi(accessor_property, getter = writable_stream_locked_getter)]locked: (),diff --git a/moli-renderer-v8/src/context_bootstrap/streams/writable.rs b/moli-renderer-v8/src/context_bootstrap/streams/writable.rsindex cfa4af8e7..e323321eb 100644--- a/moli-renderer-v8/src/context_bootstrap/streams/writable.rs+++ b/moli-renderer-v8/src/context_bootstrap/streams/writable.rs@@ -17,14 +17,8 @@ pub(in crate::context_bootstrap) fn writable_stream_get_writer_callback<'s>(args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {- if !is_writable_stream_object(scope, args.this()) {- throw_type_error(- scope,- "WritableStream.getWriter called on incompatible receiver",- );- return;- }- let stream = args.this();+ let stream = moli_webapi_declare::web_api_object_target(scope, args.this())+ .expect("validated WritableStream receiver");if writable_stream_snapshot(scope, stream).plan_acquire_writer()== AcquireWriterPlan::RejectLocked{@@ -43,18 +37,12 @@ pub(in crate::context_bootstrap) fn writable_stream_abort_callback<'s>(args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {- if !is_writable_stream_object(scope, args.this()) {- set_rejected_writable_stream_type_error(- scope,- &mut rv,- "WritableStream.abort called on incompatible receiver",- );- return;- }+ let stream = moli_webapi_declare::web_api_object_target(scope, args.this())+ .expect("validated WritableStream receiver");let Some(parsed) = webidl::parse_args::<WritableStreamAbortArgs<'s>>(scope, &args) else {return;};- if writable_stream_snapshot(scope, args.this()).plan_unlocked_abort_entry()+ if writable_stream_snapshot(scope, stream).plan_unlocked_abort_entry()== UnlockedEntryPlan::RejectLocked{let message = v8::String::new(scope, "WritableStream is locked").unwrap();@@ -65,7 +53,7 @@ pub(in crate::context_bootstrap) fn writable_stream_abort_callback<'s>(return;}let reason = parsed.reason.unwrap_or_else(|| v8::undefined(scope).into());- if let Some(promise) = writable_stream_abort_promise(scope, args.this(), reason) {+ if let Some(promise) = writable_stream_abort_promise(scope, stream, reason) {rv.set(promise);} else {rv.set_undefined();@@ -77,15 +65,9 @@ pub(in crate::context_bootstrap) fn writable_stream_close_callback<'s>(args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {- if !is_writable_stream_object(scope, args.this()) {- set_rejected_writable_stream_type_error(- scope,- &mut rv,- "WritableStream.close called on incompatible receiver",- );- return;- }- match writable_stream_snapshot(scope, args.this()).plan_unlocked_close_entry() {+ let stream = moli_webapi_declare::web_api_object_target(scope, args.this())+ .expect("validated WritableStream receiver");+ match writable_stream_snapshot(scope, stream).plan_unlocked_close_entry() {UnlockedCloseEntryPlan::RejectLocked => {let message = v8::String::new(scope, "WritableStream is locked").unwrap();let error = v8::Exception::type_error(scope, message);@@ -104,7 +86,7 @@ pub(in crate::context_bootstrap) fn writable_stream_close_callback<'s>(}UnlockedCloseEntryPlan::Continue => {}}- if let Some(close_result) = writable_stream_close_internal(scope, args.this()) {+ if let Some(close_result) = writable_stream_close_internal(scope, stream) {rv.set(close_result);return;}@@ -116,14 +98,9 @@ pub(in crate::context_bootstrap) fn writable_stream_locked_getter<'s>(args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {- if !is_writable_stream_object(scope, args.this()) {- throw_type_error(- scope,- "WritableStream.locked called on incompatible receiver",- );- return;- }- let locked = writable_stream_snapshot(scope, args.this()).locked();+ let stream = moli_webapi_declare::web_api_object_target(scope, args.this())+ .expect("validated WritableStream receiver");+ let locked = writable_stream_snapshot(scope, stream).locked();rv.set(v8::Boolean::new(scope, locked).into());}@@ -159,17 +136,6 @@ fn transform_stream_writable_getter_callback<'s>(rv.set(writable.into());}-fn set_rejected_writable_stream_type_error(- scope: &mut v8::PinScope<'_, '_>,- rv: &mut v8::ReturnValue<'_, v8::Value>,- message: &'static str,-) {- let error = v8::Exception::type_error(scope, v8str(scope, message));- if let Some(promise) = rejected_promise_value(scope, error) {- rv.set(promise);- }-}-#[derive(WebApiFunctionTemplate)]#[webapi(interface = web_api_interfaces::TransformStream, enumerable)]struct TransformStreamPrototypeAttributesDeclaration {diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rsindex 13dfeed3a..f5a98ca0c 100644--- a/moli-renderer-v8/src/script_vm/tests/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs@@ -1,4 +1,5 @@mod credential_json_options;+mod writable_stream_native_receivers;use super::post_parse::dynamic_script_execute_is_runnable_before_dom_content_loaded;use super::{PostParseDriverStep, PostParseLifecycleAdvance, PostParseLifecycleCompletionAction,diff --git a/moli-renderer-v8/src/script_vm/tests/writable_stream_native_receivers.rs b/moli-renderer-v8/src/script_vm/tests/writable_stream_native_receivers.rsnew file mode 100644index 000000000..54de7b02f--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/writable_stream_native_receivers.rs@@ -0,0 +1,73 @@+use super::*;++#[test]+fn writable_stream_native_proxy_state_and_error_realms_follow_generated_bindings() {+ let mut vm = new_storage_page_task_executor_test_vm("https://writable-receivers.test/");+ vm.eval(+ r#"+document.body.innerHTML = '<iframe></iframe>';+globalThis.stream = new WritableStream();+globalThis.closing = new WritableStream();+globalThis.aborting = new WritableStream();+"#,+ )+ .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);+ for (name, alias) in [+ ("stream", "streamProxy"),+ ("closing", "closingProxy"),+ ("aborting", "abortingProxy"),+ ] {+ let key = crate::util::v8str(scope, name);+ let target =+ v8::Local::<v8::Object>::try_from(global.get(scope, key.into()).unwrap()).unwrap();+ let handler = crate::util::new_null_prototype_object(scope);+ let proxy = v8::Proxy::new(scope, target, handler).unwrap();+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();+ let alias = crate::util::v8str(scope, alias);+ assert_eq!(+ global.create_data_property(scope, alias.into(), proxy.into()),+ Some(true)+ );+ }+ Ok(())+ })+ .unwrap();+ vm.eval(r#"+ globalThis.receiverResult = 'pending';+ (async () => {+ const assert = (ok, name) => {if (!ok) throw Error(name)};+ const other = document.querySelector('iframe').contentWindow;+ let traps = 0;+ const author = new Proxy(streamProxy, {get(){traps++;throw 42}, getPrototypeOf(){traps++;throw 42}});+ const revoked = Proxy.revocable(streamProxy, {}); revoked.revoke();+ for (const realm of [window, other]) {+ const p = realm.WritableStream.prototype;+ const locked = Object.getOwnPropertyDescriptor(p, 'locked').get;+ const writer = p.getWriter.call(streamProxy);+ assert(locked.call(stream) && locked.call(streamProxy), 'native Proxy shares writer lock');+ writer.releaseLock();+ assert(!locked.call(streamProxy), 'released lock reaches native target');+ for (const receiver of [{}, Object.create(stream), author, revoked.proxy]) {+ for (const fn of [p.getWriter, locked]) {+ let error;try {fn.call(receiver)} catch(caught) {error=caught}+ assert(error && Object.getPrototypeOf(error)===realm.TypeError.prototype, 'synchronous callee TypeError');+ }+ for (const fn of [p.abort, p.close]) {+ const promise=fn.call(receiver);+ assert(Object.getPrototypeOf(promise)===realm.Promise.prototype, 'callee rejection Promise');+ let error;try {await promise} catch(caught) {error=caught}+ assert(error && Object.getPrototypeOf(error)===realm.TypeError.prototype, 'asynchronous callee TypeError');+ }+ }+ }+ await other.WritableStream.prototype.close.call(closingProxy);+ await other.WritableStream.prototype.abort.call(abortingProxy, {reason:true});+ assert(!closing.locked && !aborting.locked && traps===0, 'native operations and no author traps');+ receiverResult='ok';+ })().catch(error => {receiverResult=String(error)});+ "#).unwrap();+ assert_eq!(vm.eval("receiverResult").unwrap(), "ok");+}