Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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");
+}