Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(fetch): bypass interception for local blob and data URLs

ldm0f3c87f394d54
diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch.rs
index d2627f579..1d0bceb7f 100644
--- a/moli-protocol/src/domains/fetch/tests/runtime_fetch.rs
+++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch.rs
@@ -13,6 +13,124 @@ use crate::testing::{
protocol_events_into_internal_messages, wait_until_scheduler_message,
};
+#[tokio::test(flavor = "multi_thread")]
+async fn runtime_local_fetch_and_xhr_bypass_request_and_response_interception() {
+ for request_stage in ["Request", "Response"] {
+ let mut ctx = TestContext::new();
+ with_loaded_http_document(
+ &mut ctx,
+ "data:text/html,<html><body>ready</body></html>",
+ "SID-1",
+ "TID-1",
+ )
+ .await;
+ enable_runtime_async(&mut ctx, "SID-1", 1).await;
+ ctx.process_async(json!({
+ "id": 2,
+ "method": "Fetch.enable",
+ "sessionId": "SID-1",
+ "params": { "patterns": [{ "urlPattern": "*", "requestStage": request_stage }] }
+ }))
+ .await;
+ ctx.expect_result(2, json!({}), Some("SID-1"));
+
+ ctx.process_async(json!({
+ "id": 3,
+ "method": "Runtime.evaluate",
+ "sessionId": "SID-1",
+ "params": {
+ "expression": r#"
+globalThis.__localInterceptionResult = 'pending';
+(async () => {
+ const check = (value, message) => { if (!value) throw new Error(message); };
+ const blob = URL.createObjectURL(new Blob(['payload'], {type: 'text/plain'}));
+ const revoked = URL.createObjectURL(new Blob(['revoked']));
+ URL.revokeObjectURL(revoked);
+ try {
+ for (const [url, method, success] of [
+ [blob + '#fragment', 'GET', true],
+ [blob, 'POST', false],
+ ['data:text/plain,payload', 'POST', true],
+ [revoked, 'GET', false],
+ ['data:invalid', 'GET', false],
+ ]) {
+ let response;
+ try { response = await fetch(url, {method}); }
+ catch (error) {
+ check(!success && error instanceof TypeError, 'fetch rejection: ' + error);
+ }
+ check(Boolean(response) === success, 'fetch outcome: ' + url);
+ if (response) {
+ check(response.status === 200 && await response.text() === 'payload', 'fetch response');
+ }
+ for (const async of [true, false]) {
+ const xhr = new XMLHttpRequest();
+ xhr.open(method, url, async);
+ const label = [url, method, async].join(':');
+ if (async) {
+ await new Promise((resolve, reject) => {
+ let returned = false;
+ const events = [];
+ xhr.onload = () => events.push('load');
+ xhr.onerror = () => events.push('error');
+ xhr.onloadend = () => {
+ try {
+ check(returned, label + ': completion during send');
+ check(events.join(',') === (success ? 'load' : 'error'), label + ': events');
+ resolve();
+ } catch (error) { reject(error); }
+ };
+ xhr.send();
+ returned = true;
+ });
+ } else {
+ let failure;
+ try { xhr.send(); } catch (error) { failure = error; }
+ check(success ? failure === undefined : failure instanceof DOMException && failure.name === 'NetworkError', label + ': exception');
+ }
+ check(xhr.readyState === 4 && xhr.status === (success ? 200 : 0), label + ': state/status');
+ check(xhr.responseText === (success ? 'payload' : ''), label + ': body');
+ }
+ }
+ } finally { URL.revokeObjectURL(blob); }
+})().then(
+ () => { globalThis.__localInterceptionResult = 'ok'; },
+ error => { globalThis.__localInterceptionResult = String(error); },
+);
+'scheduled'
+"#
+ }
+ }))
+ .await;
+ let scheduled = take_response_by_id(&mut ctx, 3);
+ assert_eq!(scheduled["result"]["result"]["value"], "scheduled");
+ assert!(
+ ctx.sent
+ .iter()
+ .all(|message| message["method"] != "Fetch.requestPaused"),
+ "local requests must bypass {request_stage} interception: {:?}",
+ ctx.sent
+ );
+
+ evaluate_until_value_async(
+ &mut ctx,
+ "SID-1",
+ 4,
+ "globalThis.__localInterceptionResult",
+ &json!("ok"),
+ "local fetch and XHR completion with Fetch enabled",
+ )
+ .await;
+ assert!(
+ ctx.sent
+ .iter()
+ .all(|message| message["method"] != "Fetch.requestPaused"),
+ "local responses and errors must bypass {request_stage} interception: {:?}",
+ ctx.sent
+ );
+ }
+}
+
async fn wait_for_request_paused(ctx: &mut TestContext, url: &str, description: &str) -> Value {
wait_for_request_paused_on_session(ctx, "SID-1", url, None, description).await
}
diff --git a/moli-renderer-v8/src/network_host/fetch/bindings.rs b/moli-renderer-v8/src/network_host/fetch/bindings.rs
index c46e9ae9f..b3511bb2e 100644
--- a/moli-renderer-v8/src/network_host/fetch/bindings.rs
+++ b/moli-renderer-v8/src/network_host/fetch/bindings.rs
@@ -281,6 +281,30 @@ fn window_fetch_callback_in_relevant_realm<'s>(
return;
}
+ // Renderer-owned URLs, including local errors, bypass network interception.
+ match resolve_local_fetch(host, &prepared) {
+ Ok(Some(response)) => {
+ let response_obj = build_fetch_response_object_for_request_mode(
+ scope,
+ &prepared.request_origin,
+ prepared.request_mode,
+ response,
+ );
+ resolver.resolve(scope, response_obj.into());
+ rv.set(promise.into());
+ return;
+ }
+ Ok(None) => {}
+ Err(message) => {
+ let exception = v8_string(scope, &message)
+ .map(|message| v8::Exception::type_error(scope, message))
+ .unwrap_or_else(|| v8::undefined(scope).into());
+ resolver.reject(scope, exception);
+ rv.set(promise.into());
+ return;
+ }
+ }
+
if host.should_intercept_subresource(SubresourceResourceType::Fetch) {
record_intercepted_fetch(scope, host, resolver, prepared);
rv.set(promise.into());
@@ -308,29 +332,6 @@ fn window_fetch_callback_in_relevant_realm<'s>(
}
}
- match resolve_local_fetch(host, &prepared) {
- Ok(Some(response)) => {
- let response_obj = build_fetch_response_object_for_request_mode(
- scope,
- &prepared.request_origin,
- prepared.request_mode,
- response,
- );
- resolver.resolve(scope, response_obj.into());
- rv.set(promise.into());
- return;
- }
- Ok(None) => {}
- Err(message) => {
- let exception = v8_string(scope, &message)
- .map(|message| v8::Exception::type_error(scope, message))
- .unwrap_or_else(|| v8::undefined(scope).into());
- resolver.reject(scope, exception);
- rv.set(promise.into());
- return;
- }
- }
-
let internal_id = match spawn_network_fetch(scope, host, resolver, prepared) {
Ok(internal_id) => internal_id,
Err(message) => {
diff --git a/moli-renderer-v8/src/network_host/xhr/send.rs b/moli-renderer-v8/src/network_host/xhr/send.rs
index 02e0dfb46..1166fd6bc 100644
--- a/moli-renderer-v8/src/network_host/xhr/send.rs
+++ b/moli-renderer-v8/src/network_host/xhr/send.rs
@@ -164,23 +164,7 @@ pub(super) fn xhr_send_callback<'s>(
return;
}
- if host.should_intercept_subresource(SubresourceResourceType::Xhr) {
- if !async_request {
- record_synchronous_xhr_failure(
- scope,
- host,
- xhr,
- prepared,
- "Synchronous XMLHttpRequest interception is not supported".to_owned(),
- );
- return;
- }
- let internal_id = record_intercepted_xhr(scope, host, xhr, prepared);
- set_xhr_state_number(scope, xhr, XHR_ACTIVE_INTERNAL_ID_SLOT, internal_id as f64);
- schedule_xhr_timeout(scope, host, xhr, internal_id);
- return;
- }
-
+ // Renderer-owned URLs, including local errors, bypass network interception.
if let Some(result) = local_url_response_result(&prepared.resolved_url, &prepared.method) {
match result {
Ok(response) if async_request => {
@@ -200,6 +184,23 @@ pub(super) fn xhr_send_callback<'s>(
return;
}
+ if host.should_intercept_subresource(SubresourceResourceType::Xhr) {
+ if !async_request {
+ record_synchronous_xhr_failure(
+ scope,
+ host,
+ xhr,
+ prepared,
+ "Synchronous XMLHttpRequest interception is not supported".to_owned(),
+ );
+ return;
+ }
+ let internal_id = record_intercepted_xhr(scope, host, xhr, prepared);
+ set_xhr_state_number(scope, xhr, XHR_ACTIVE_INTERNAL_ID_SLOT, internal_id as f64);
+ schedule_xhr_timeout(scope, host, xhr, internal_id);
+ return;
+ }
+
if host.network_offline() {
if async_request {
record_offline_xhr_failure(scope, host, xhr, prepared);
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs
index 26be41f01..f1a57bc0c 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs
@@ -4002,7 +4002,18 @@ async fn window_fetch_file_url_rejects_before_interception_or_transport() {
#[tokio::test]
async fn blob_fetch_and_xhr_reject_non_get_methods_in_window_and_worker() {
- run_page_vm_async_test(async move {
+ check_blob_fetch_and_xhr_methods_in_window_and_worker(false).await;
+}
+
+#[tokio::test]
+async fn blob_fetch_and_xhr_bypass_interception_in_window_and_worker() {
+ check_blob_fetch_and_xhr_methods_in_window_and_worker(true).await;
+}
+
+fn check_blob_fetch_and_xhr_methods_in_window_and_worker(
+ interception: bool,
+) -> impl std::future::Future<Output = ()> {
+ Box::pin(run_page_vm_async_test(async move {
for worker in [false, true] {
let mut page_vm = test_page_vm();
let local_executor = page_vm.local_executor.clone();
@@ -4096,8 +4107,11 @@ async fn blob_fetch_and_xhr_reject_non_get_methods_in_window_and_worker() {
"globalThis.__blobMethodResult = 'pending'; {probe}.then(() => {{ globalThis.__blobMethodResult = 'ok'; }}, error => {{ globalThis.__blobMethodResult = String(error); }})"
)
};
- let (result, network_output) = local_executor
+ let (result, pending_count, network_output) = local_executor
.run(async move {
+ page_vm
+ .vm_mut()
+ .set_fetch_subresource_interception(interception, None);
page_vm.vm_mut().eval(&script)?;
drive_websocket_until_done(
&mut page_vm,
@@ -4106,21 +4120,37 @@ async fn blob_fetch_and_xhr_reject_non_get_methods_in_window_and_worker() {
)
.await?;
let result = page_vm.vm_mut().eval("globalThis.__blobMethodResult")?;
- Ok::<_, anyhow::Error>((result, page_vm.vm_mut().take_network_output()))
+ let pending_count = page_vm
+ .vm_mut()
+ .take_pending_subresource_fetch_infos()
+ .len();
+ Ok::<_, anyhow::Error>((
+ result,
+ pending_count,
+ page_vm.vm_mut().take_network_output(),
+ ))
})
.await
.expect("blob method probe should run on owner lane");
assert_eq!(result, "ok", "worker={worker}");
+ assert_eq!(
+ pending_count, 0,
+ "local fetch and XHR must bypass interception; worker={worker}"
+ );
let (records, _, _) = split_network_output_items(network_output);
let failures = records
.iter()
- .filter(|record| matches!(record.outcome(), SubresourceNetworkOutcome::Failure { error_text }
- if error_text.contains("blob URL fetch requires GET")))
+ .filter(|record| {
+ matches!(record.outcome(), SubresourceNetworkOutcome::Failure { error_text }
+ if error_text.contains("blob URL fetch requires GET"))
+ })
.count();
- assert_eq!(failures, 56, "each rejected request must record a local network error; worker={worker}");
+ assert_eq!(
+ failures, 56,
+ "each rejected request must record a local network error; worker={worker}"
+ );
}
- })
- .await;
+ }))
}
#[tokio::test]
diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs
index 38d06b2d1..5fa97fa24 100644
--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs
+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs
@@ -2083,7 +2083,9 @@ pub(in crate::worker) fn worker_fetch_callback<'s>(
return;
}
- if fetch_subresource_interception_enabled
+ // Local URLs are resolved by the worker fetch task without interception.
+ if !matches!(resolved_url.scheme(), "blob" | "data")
+ && fetch_subresource_interception_enabled
&& fetch_subresource_interception_resource_type.is_none_or(|expected| {
expected.has_same_cdp_fetch_interception_type(SubresourceResourceType::Fetch)
})