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(xhr): reject ineligible document responses
ldm06a498cf8c36c
diff --git a/moli-renderer-v8/src/dom_parser.rs b/moli-renderer-v8/src/dom_parser.rsindex d764b479d..00cf7c363 100644--- a/moli-renderer-v8/src/dom_parser.rs+++ b/moli-renderer-v8/src/dom_parser.rs@@ -193,12 +193,39 @@ pub(super) fn parse_detached_document_from_string<'s>();}+ parse_detached_xml_document_from_source(+ scope,+ runtime.document_url().clone(),+ source,+ mime,+ XmlParseErrorBehavior::ParserErrorDocument,+ )+}++#[derive(Clone, Copy)]+pub(super) enum XmlParseErrorBehavior {+ ParserErrorDocument,+ ReturnNone,+}++pub(super) fn parse_detached_xml_document_from_source<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ document_url: Url,+ source: &str,+ mime: &str,+ error_behavior: XmlParseErrorBehavior,+) -> Option<v8::Local<'s, v8::Object>> {let parser = XmlParser;- let parsed = parser.parse(runtime.document_url().clone(), source.to_owned());+ let parsed = parser.parse(document_url, source.to_owned());let parsed = if parsed.parse_errors().is_empty() && native_document_has_element_child(&parsed) {parsed} else {- materialize_xml_parser_error_document(parsed)+ match error_behavior {+ XmlParseErrorBehavior::ParserErrorDocument => {+ materialize_xml_parser_error_document(parsed)+ }+ XmlParseErrorBehavior::ReturnNone => return None,+ }};build_detached_document_with_content_type(scope,diff --git a/moli-renderer-v8/src/network_host/xhr/delivery/response.rs b/moli-renderer-v8/src/network_host/xhr/delivery/response.rsindex f978b0c5d..9fc9d125b 100644--- a/moli-renderer-v8/src/network_host/xhr/delivery/response.rs+++ b/moli-renderer-v8/src/network_host/xhr/delivery/response.rs@@ -3,8 +3,7 @@ use super::super::events::{};use super::super::*;use moli_web_mime::{- effective_response_mime_essence, extract_response_mime_type, is_dom_parser_xml_mime,- is_html_document_mime,+ effective_response_mime_essence, extract_response_mime_type, is_html_document_mime,};pub(crate) fn apply_xhr_response(@@ -221,13 +220,12 @@ fn apply_xhr_response_body(.unwrap_or_else(|| v8::null(scope).into())}XmlHttpRequestResponseType::Document => {- let mime = xhr_response_mime_essence(scope, xhr, &head.headers)- .unwrap_or_else(|| "text/html".to_owned());let document = parse_xhr_response_document(scope,+ xhr,body_text.as_deref().unwrap_or(""),- Some(&mime),&head.headers,+ response_type,);set_xhr_state_value(scope, xhr, XHR_RESPONSE_XML_SLOT, document);document@@ -243,11 +241,12 @@ fn apply_xhr_response_body(}XmlHttpRequestResponseType::Default | XmlHttpRequestResponseType::Text => {if response_type == XmlHttpRequestResponseType::Default {- let document = parse_default_xhr_response_xml(+ let document = parse_xhr_response_document(scope,xhr,- &head.headers,body_text.as_deref().unwrap_or(""),+ &head.headers,+ response_type,);set_xhr_state_value(scope, xhr, XHR_RESPONSE_XML_SLOT, document);}@@ -285,17 +284,20 @@ fn apply_xhr_response_text(v8_json_parse(scope, &body_text).unwrap_or_else(|| v8::null(scope).into())}XmlHttpRequestResponseType::Document => {- let mime = xhr_response_mime_essence(scope, xhr, &head.headers)- .unwrap_or_else(|| "text/html".to_owned());let document =- parse_xhr_response_document(scope, &body_text, Some(&mime), &head.headers);+ parse_xhr_response_document(scope, xhr, &body_text, &head.headers, response_type);set_xhr_state_value(scope, xhr, XHR_RESPONSE_XML_SLOT, document);document}XmlHttpRequestResponseType::Default | XmlHttpRequestResponseType::Text => {if response_type == XmlHttpRequestResponseType::Default {- let document =- parse_default_xhr_response_xml(scope, xhr, &head.headers, &body_text);+ let document = parse_xhr_response_document(+ scope,+ xhr,+ &body_text,+ &head.headers,+ response_type,+ );set_xhr_state_value(scope, xhr, XHR_RESPONSE_XML_SLOT, document);}v8_string(scope, &body_text)@@ -587,29 +589,36 @@ fn xhr_response_mime_essence(effective_response_mime_essence(headers, override_mime.as_deref())}-fn parse_default_xhr_response_xml<'s>(- scope: &mut v8::PinScope<'s, '_>,- xhr: v8::Local<'_, v8::Object>,- headers: &[(String, Vec<u8>)],- body_text: &str,-) -> v8::Local<'s, v8::Value> {- let mime = xhr_response_mime_essence(scope, xhr, headers);- parse_xhr_response_document(scope, body_text, mime.as_deref(), headers)-}-fn parse_xhr_response_document<'s>(scope: &mut v8::PinScope<'s, '_>,+ xhr: v8::Local<'_, v8::Object>,body_text: &str,- mime: Option<&str>,headers: &[(String, Vec<u8>)],+ response_type: XmlHttpRequestResponseType,) -> v8::Local<'s, v8::Value> {- let Some(mime) =- mime.filter(|mime| is_html_document_mime(mime) || is_dom_parser_xml_mime(mime))- else {+ let mime =+ xhr_response_mime_essence(scope, xhr, headers).unwrap_or_else(|| "text/xml".to_owned());+ let is_xml = matches!(mime.as_str(), "text/xml" | "application/xml") || mime.ends_with("+xml");+ let is_html = is_html_document_mime(&mime);+ if (!is_xml && !is_html) || (is_html && response_type != XmlHttpRequestResponseType::Document) {return v8::null(scope).into();+ }+ let document = if is_html {+ dom_parser::parse_detached_document_from_string(scope, body_text, &mime)+ } else {+ let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {+ return v8::null(scope).into();+ };+ let document_url = unsafe { &*host_ptr }.document_url().clone();+ dom_parser::parse_detached_xml_document_from_source(+ scope,+ document_url,+ body_text,+ &mime,+ dom_parser::XmlParseErrorBehavior::ReturnNone,+ )};- let Some(document) = dom_parser::parse_detached_document_from_string(scope, body_text, mime)- else {+ let Some(document) = document else {return v8::null(scope).into();};let Ok((runtime_ptr, document_handle)) =diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rsindex 067b78f50..1141185ab 100644--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs@@ -3891,3 +3891,183 @@ fn xml_http_request_upload_loadstart_preserves_reopened_request() {"xhr-start:1|upload-start:0:2|xhr-start:1|after-reopen:1|load:replacement|loadend:4");}++#[test]+fn xml_http_request_document_response_requires_an_eligible_mime_and_well_formed_xml() {+ for streaming in [false, true] {+ for response_type in ["", "document"] {+ for (mime, source, xml_root) in [+ (None, "<x/>", Some("x")),+ (Some("bogus"), "<x/>", Some("x")),+ (Some("video/custom+xml"), "<x/>", Some("x")),+ (Some("text/plain;+xml"), "<x/>", None),+ (Some("application/xml"), "", None),+ (Some("application/xml"), "<!--no root-->", None),+ (Some("application/xml"), "<x><y></x></y>", None),+ (Some("application/xml"), "<p:x/>", None),+ (+ Some("application/xml"),+ "<parsererror xmlns='http://www.w3.org/1999/xhtml'>author text</parsererror>",+ Some("parsererror"),+ ),+ (+ Some("text/html"),+ "<p>html",+ (response_type == "document").then_some("html"),+ ),+ ] {+ let mut vm = new_storage_test_vm("https://xhr-document-eligibility.test/");+ vm.set_fetch_subresource_interception(+ true,+ Some(crate::types::SubresourceResourceType::Xhr),+ );+ vm.eval(&format!(+ r#"globalThis.__documentXhr = new XMLHttpRequest();+ __documentXhr.open('GET', '/response');+ __documentXhr.responseType = '{response_type}';+ __documentXhr.send();"#+ ))+ .expect("intercept XHR before response delivery");+ let pending = vm.take_pending_subresource_fetch_infos();+ assert_eq!(pending.len(), 1);+ let request = &pending[0];+ let head = moli_fetch::ResponseHead {+ status_text: None,+ final_url: request.url.clone(),+ status: 200,+ headers: mime+ .map(|mime| vec![("Content-Type".to_owned(), mime.as_bytes().to_vec())])+ .unwrap_or_default(),+ request_cookie_report: None,+ cookie_set_reports: Vec::new(),+ redirected: false,+ redirect_chain: Vec::new(),+ from_cache: false,+ negotiated_http_version: None,+ };+ if streaming {+ let body_source_id = crate::network_host::new_network_body_source_id();+ vm.start_streaming_async_subresource_fetch(+ crate::types::AsyncSubresourceStreamingStarted {+ skip_fetch_security_validation: false,+ response_filter: None,+ internal_id: request.internal_id,+ request_url: request.url.clone(),+ request_method: "GET".to_owned(),+ request_headers: Default::default(),+ request_body: None,+ body_source_id,+ head,+ network_request_headers: None,+ },+ )+ .expect("deliver response headers");+ for chunk in source.as_bytes().chunks(5) {+ vm.append_streaming_async_subresource_fetch_chunk(+ body_source_id,+ chunk.to_vec(),+ );+ assert_eq!(+ vm.eval("__documentXhr.responseXML === null").unwrap(),+ "true"+ );+ }+ vm.finish_streaming_async_subresource_fetch(+ request.internal_id,+ body_source_id,+ Ok(()),+ )+ .expect("finish document response");+ } else {+ let context_ptr: *const v8::Global<v8::Context> =+ &vm.page_default_runtime.context;+ vm.renderer_document_isolate+ .with_entered_renderer_document_isolate(move |isolate| {+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));+ let scope = &mut scope.init();+ let context = unsafe { v8::Local::new(scope, &*context_ptr) };+ let scope = &mut v8::ContextScope::new(scope, context);+ let xhr = context+ .global(scope)+ .get(scope, v8str(scope, "__documentXhr").into())+ .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())+ .unwrap();+ crate::network_host::apply_xhr_response_body_source(+ scope,+ xhr,+ head,+ moli_fetch::ResponseBody::materialized_bytes(+ source.as_bytes().to_vec(),+ ),+ );+ Ok(())+ })+ .expect("deliver buffered document response");+ }+ let result = vm.eval(r#"(() => {+ const xhr = __documentXhr;+ const doc = xhr.responseXML;+ const root = doc && doc.documentElement.localName;+ const stable = doc === xhr.responseXML;+ const response = xhr.responseType === 'document'+ ? xhr.response === doc : xhr.responseText === xhr.response;+ const readyState = xhr.readyState;+ xhr.open('GET', '/next');+ return JSON.stringify([readyState, root, stable, response,+ xhr.responseXML === null, doc === null || doc.documentElement.localName === root]);+ })()"#).expect("read document response and reopen XHR");+ assert_eq!(+ result,+ serde_json::json!([4, xml_root, true, true, true, true]).to_string(),+ "streaming={streaming}, response_type={response_type}, mime={mime:?}, source={source:?}"+ );+ }+ }+ }+}++#[test]+fn xml_http_request_queued_document_response_uses_parsed_overrides_and_xml_errors() {+ let mut vm = new_storage_test_vm("https://xhr-queued-document.test/");+ vm.eval(r#"globalThis.__queuedDocumentResults = [];+ for (const responseType of ['', 'document']) {+ for (const override of [null, 'bogus', '']) {+ for (const source of ['', '<x><y></x>', '<parsererror/>']) {+ const xhr = new XMLHttpRequest();+ xhr.open('GET', 'data:application/xml,' + encodeURIComponent(source));+ xhr.responseType = responseType;+ if (override !== null) xhr.overrideMimeType(override);+ xhr.onload = () => {+ const doc = xhr.responseXML;+ __queuedDocumentResults.push([+ responseType, override, source, xhr.status,+ doc && doc.documentElement.localName,+ responseType === 'document' ? xhr.response === doc : xhr.response === source,+ ]);+ };+ xhr.send();+ }+ }+ }"#).expect("enqueue asynchronous data URL responses");+ let result = vm+ .eval("JSON.stringify(__queuedDocumentResults)")+ .expect("drain queued responses");+ let mut expected = Vec::new();+ for response_type in ["", "document"] {+ for override_mime in [None, Some("bogus"), Some("")] {+ for source in ["", "<x><y></x>", "<parsererror/>"] {+ let xml_root = (override_mime.is_none() && source == "<parsererror/>")+ .then_some("parsererror");+ expected.push(serde_json::json!([+ response_type,+ override_mime,+ source,+ 200,+ xml_root,+ true+ ]));+ }+ }+ }+ assert_eq!(result, serde_json::to_string(&expected).unwrap());+}