Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(xhr): reject ineligible document responses

ldm06a498cf8c36c
diff --git a/moli-renderer-v8/src/dom_parser.rs b/moli-renderer-v8/src/dom_parser.rs
index 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.rs
index 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.rs
index 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());
+}