Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(webrtc): declare native receiver checks on prototypes

ldm0a7b623df6e7a
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc.rs b/moli-renderer-v8/src/context_bootstrap/webrtc.rs
index c5523d38a..6761aad90 100644
--- a/moli-renderer-v8/src/context_bootstrap/webrtc.rs
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc.rs
@@ -132,7 +132,7 @@ struct RtcSessionDescriptionInitDeclaration<'scope> {
}
#[derive(Default, WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::RTCPeerConnection, enumerable)]
+#[webapi(interface = web_api_interfaces::RTCPeerConnection, enumerable, receiver)]
struct RtcPeerConnectionPrototypeDeclaration {
#[webapi(accessor_property, getter = rtc_peer_connection_state_getter, data = callback_data_index_value(scope, 0))]
signaling_state: (),
@@ -172,7 +172,7 @@ struct RtcRtpReceiverConstructorDeclaration {
}
#[derive(Default, WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::RTCDataChannel, enumerable)]
+#[webapi(interface = web_api_interfaces::RTCDataChannel, enumerable, receiver)]
struct RtcDataChannelPrototypeDeclaration {
#[webapi(accessor_property, getter = rtc_data_channel_value_getter, data = callback_data_index_value(scope, 0))]
label: (),
@@ -270,10 +270,6 @@ fn rtc_peer_connection_state_getter<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_peer_connection_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
let Some(slot) = callback_data_item(
scope,
&args,
@@ -293,10 +289,6 @@ fn rtc_peer_connection_description_getter<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_peer_connection_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
let Some(slot) = callback_data_item(
scope,
&args,
@@ -314,10 +306,6 @@ fn rtc_peer_connection_create_data_channel_callback<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_peer_connection_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
if args.length() == 0 {
throw_type_error(
scope,
@@ -346,10 +334,6 @@ fn rtc_peer_connection_create_offer_callback<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_peer_connection_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
let options = v8::Local::<v8::Object>::try_from(args.get(0)).ok();
let audio = options
.and_then(|options| options.get(scope, v8str(scope, "offerToReceiveAudio").into()))
@@ -379,10 +363,6 @@ fn rtc_peer_connection_set_local_description_callback<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_peer_connection_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
let Ok(description) = v8::Local::<v8::Object>::try_from(args.get(0)) else {
let reason = v8::Exception::type_error(
scope,
@@ -424,10 +404,6 @@ fn rtc_peer_connection_close_callback<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_peer_connection_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
for (slot, state) in [
(RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT, "closed"),
(RTC_PEER_CONNECTION_ICE_CONNECTION_STATE_SLOT, "closed"),
@@ -465,10 +441,6 @@ fn rtc_data_channel_value_getter<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_data_channel_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
let Some(slot) = callback_data_item(
scope,
&args,
@@ -488,10 +460,6 @@ fn rtc_data_channel_close_callback<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_data_channel_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
set_string_slot(
scope,
args.this(),
@@ -502,14 +470,10 @@ fn rtc_data_channel_close_callback<'s>(
}
fn rtc_data_channel_send_callback<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- args: v8::FunctionCallbackArguments<'s>,
+ _scope: &mut v8::PinScope<'s, '_>,
+ _args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if !rtc_data_channel_receiver_branded(scope, args.this()) {
- throw_type_error(scope, "Illegal invocation");
- return;
- }
rv.set_undefined();
}
@@ -565,20 +529,6 @@ fn set_rejected_promise<'s>(
rv.set(promise.into());
}
-fn rtc_peer_connection_receiver_branded<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- receiver: v8::Local<'s, v8::Object>,
-) -> bool {
- web_api_interfaces::RTCPeerConnection::is_instance(scope, receiver)
-}
-
-fn rtc_data_channel_receiver_branded<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- receiver: v8::Local<'s, v8::Object>,
-) -> bool {
- web_api_interfaces::RTCDataChannel::is_instance(scope, receiver)
-}
-
fn build_signaling_only_offer(audio: bool, video: bool, data: bool) -> String {
let mut mids = Vec::new();
if audio {
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/events.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/events.rs
index 38c68045a..16fe5c305 100644
--- a/moli-renderer-v8/src/context_bootstrap/webrtc/events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/events.rs
@@ -1,4 +1,3 @@
-use super::{ice_candidate::ice_candidate_receiver_branded, rtc_data_channel_receiver_branded};
use crate::web_api_interfaces;
use crate::{
context_bootstrap::events::{
@@ -188,8 +187,12 @@ fn construct_event<'s>(
v8::Local::<v8::Object>::try_from(value)
.ok()
.is_some_and(|object| match kind {
- EventKind::IceCandidate => ice_candidate_receiver_branded(scope, object),
- EventKind::DataChannel => rtc_data_channel_receiver_branded(scope, object),
+ EventKind::IceCandidate => {
+ web_api_interfaces::RTCIceCandidate::is_instance(scope, object)
+ }
+ EventKind::DataChannel => {
+ web_api_interfaces::RTCDataChannel::is_instance(scope, object)
+ }
EventKind::Error => web_api_interfaces::RTCError::is_instance(scope, object),
});
if !branded {
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs
index d48729509..d1272160b 100644
--- a/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs
@@ -19,7 +19,7 @@ struct IceCandidateObjectDeclaration<'scope> {
}
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::RTCIceCandidate, enumerable)]
+#[webapi(interface = web_api_interfaces::RTCIceCandidate, enumerable, receiver)]
struct IceCandidatePrototypeDeclaration {
#[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 0))]
candidate: (),
@@ -202,13 +202,6 @@ fn parse_candidate_init<'s>(
Some(values)
}
-pub(super) fn ice_candidate_receiver_branded<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- receiver: v8::Local<'s, v8::Object>,
-) -> bool {
- web_api_interfaces::RTCIceCandidate::is_instance(scope, receiver)
-}
-
fn candidate_values<'s>(
scope: &mut v8::PinScope<'s, '_>,
receiver: v8::Local<'s, v8::Object>,
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/session_description.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/session_description.rs
index 1b1a7fed8..f3c046e0d 100644
--- a/moli-renderer-v8/src/context_bootstrap/webrtc/session_description.rs
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/session_description.rs
@@ -23,7 +23,7 @@ struct SessionDescriptionObjectDeclaration<'scope> {
}
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::RTCSessionDescription, enumerable)]
+#[webapi(interface = web_api_interfaces::RTCSessionDescription, enumerable, receiver)]
struct SessionDescriptionPrototypeDeclaration {
#[webapi(accessor_property, getter = description_attribute_getter, data = callback_data_index_value(scope, 0))]
r#type: (),
diff --git a/moli-renderer-v8/src/script_vm/tests/declarative_receivers.js b/moli-renderer-v8/src/script_vm/tests/declarative_receivers.js
new file mode 100644
index 000000000..3dbbceaf0
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/declarative_receivers.js
@@ -0,0 +1,49 @@
+(() => {
+ const child = document.querySelector('iframe').contentWindow;
+ const failures = [], promises = [];
+ const assert = (condition, message) => { if (!condition) throw Error(message); };
+ const check = (realm, target, fn, promiseResult = false) => {
+ let authorCalls = 0;
+ const poison = new Proxy({}, {get() {authorCalls++; throw Error('argument conversion');}});
+ const proxy = new Proxy(target, {
+ get() {authorCalls++; throw Error('receiver get');},
+ getPrototypeOf() {authorCalls++; throw Error('receiver prototype');},
+ });
+ const revoked = Proxy.revocable(target, {}); revoked.revoke();
+ const invalid = [{}, new child.Object(), Object.create(target),
+ Object.create(Object.getPrototypeOf(target)), proxy, revoked.proxy];
+ const checkError = error => {
+ assert(Object.getPrototypeOf(error) === realm.TypeError.prototype, fn.name + ': TypeError realm');
+ assert(error.message === 'Illegal invocation', fn.name + ': receiver precedes conversion');
+ assert(authorCalls === 0, fn.name + ': receiver check must not execute author code');
+ };
+ for (const value of invalid) {
+ if (promiseResult) {
+ const promise = Reflect.apply(fn, value, [poison, poison]);
+ assert(Object.getPrototypeOf(promise) === realm.Promise.prototype, fn.name + ': Promise realm');
+ promises.push(promise.then(() => {throw Error(fn.name + ': invalid receiver resolved');}, checkError));
+ } else {
+ let error;
+ try {Reflect.apply(fn, value, [poison, poison]);} catch (caught) {error = caught;}
+ assert(error, fn.name + ': invalid receiver accepted');
+ checkError(error);
+ }
+ }
+ };
+ globalThis.receiverChecks = {
+ child, assert, check,
+ getters(realm, interfaceName, target, names) {
+ for (const name of names) {
+ const getter = Object.getOwnPropertyDescriptor(realm[interfaceName].prototype, name).get;
+ check(realm, target, getter);
+ assert(getter.call(target) === target[name], interfaceName + '.' + name + ': foreign receiver');
+ }
+ },
+ finish() {
+ Promise.all(promises).then(() => {receiverChecks.complete = true;}, error => {
+ failures.push(String(error)); receiverChecks.complete = true;
+ });
+ },
+ failures, complete: false,
+ };
+})()
diff --git a/moli-renderer-v8/src/script_vm/tests/declarative_receivers.rs b/moli-renderer-v8/src/script_vm/tests/declarative_receivers.rs
new file mode 100644
index 000000000..f52e2cc39
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/declarative_receivers.rs
@@ -0,0 +1,53 @@
+use super::*;
+
+fn receiver_test_vm() -> crate::runtime::PageVmTaskExecutorTestHarness {
+ let mut vm = new_storage_page_task_executor_test_vm("https://declarative-receivers.test/");
+ vm.eval("document.body.innerHTML = '<iframe></iframe>'")
+ .unwrap();
+ vm.eval(include_str!("declarative_receivers.js")).unwrap();
+ vm
+}
+
+fn finish_receiver_checks(vm: &mut crate::runtime::PageVmTaskExecutorTestHarness) {
+ vm.eval("receiverChecks.finish()").unwrap();
+ vm.eval("0").unwrap();
+ assert_eq!(vm.eval("receiverChecks.complete").unwrap(), "true");
+ assert_eq!(
+ vm.eval("JSON.stringify(receiverChecks.failures)").unwrap(),
+ "[]"
+ );
+}
+
+#[test]
+fn webrtc_declarations_validate_foreign_receivers_before_converting_arguments() {
+ let mut vm = receiver_test_vm();
+ vm.eval(r#"(() => {
+ const {child, assert, check, getters} = receiverChecks;
+ for (const realm of [window, child]) {
+ const other = realm === window ? child : window;
+ const pc = new other.RTCPeerConnection();
+ const channel = pc.createDataChannel('foreign');
+ getters(realm, 'RTCPeerConnection', pc, ['signalingState', 'iceGatheringState', 'iceConnectionState',
+ 'connectionState', 'localDescription', 'currentLocalDescription', 'pendingLocalDescription']);
+ for (const name of ['getConfiguration', 'setConfiguration', 'createDataChannel', 'createOffer', 'setLocalDescription', 'close']) {
+ check(realm, pc, realm.RTCPeerConnection.prototype[name]);
+ }
+ assert(realm.RTCPeerConnection.prototype.createDataChannel.call(pc, 'borrowed').label === 'borrowed', 'foreign peer method');
+ getters(realm, 'RTCDataChannel', channel, ['label', 'ordered', 'maxPacketLifeTime', 'maxRetransmits',
+ 'protocol', 'negotiated', 'id', 'readyState', 'bufferedAmount', 'binaryType']);
+ for (const name of ['send', 'close']) check(realm, channel, realm.RTCDataChannel.prototype[name]);
+ const candidate = new other.RTCIceCandidate({candidate: 'candidate:1 1 UDP 1 127.0.0.1 9 typ host', sdpMid: '0'});
+ getters(realm, 'RTCIceCandidate', candidate, ['candidate', 'sdpMid', 'sdpMLineIndex', 'foundation',
+ 'component', 'priority', 'address', 'protocol', 'port', 'type', 'tcpType', 'relatedAddress',
+ 'relatedPort', 'usernameFragment', 'relayProtocol', 'url']);
+ check(realm, candidate, realm.RTCIceCandidate.prototype.toJSON);
+ assert(realm.RTCIceCandidate.prototype.toJSON.call(candidate).candidate === candidate.candidate, 'foreign ICE method');
+ const description = new other.RTCSessionDescription({type: 'offer', sdp: 'foreign'});
+ getters(realm, 'RTCSessionDescription', description, ['type', 'sdp']);
+ check(realm, description, realm.RTCSessionDescription.prototype.toJSON);
+ assert(realm.RTCSessionDescription.prototype.toJSON.call(description).sdp === 'foreign', 'foreign description method');
+ realm.RTCPeerConnection.prototype.close.call(pc);
+ }
+ })()"#).unwrap();
+ finish_receiver_checks(&mut vm);
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index b0df07c4c..00d6137cc 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -2180,6 +2180,7 @@ mod svg_transform_sync_consolidation;
mod audio_event_interfaces;
mod audio_value_owner_interface_exposure_interfaces;
+mod declarative_receivers;
mod hyperlink_null_url_protocol;
mod import_meta;
mod indexed_db;