Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(modules): share JSON and CSS response MIME validation

ldm010ccdc2064e5
diff --git a/moli-renderer-v8/src/module_runtime.rs b/moli-renderer-v8/src/module_runtime.rs
index 9b1278a45..2ac34262f 100644
--- a/moli-renderer-v8/src/module_runtime.rs
+++ b/moli-renderer-v8/src/module_runtime.rs
@@ -11,6 +11,7 @@ mod parser_tree_registry;
mod record;
mod record_resolver;
mod resolver;
+mod response_mime;
mod single_module_fetch;
#[cfg(test)]
mod tests;
@@ -50,6 +51,9 @@ pub(crate) use self::record::{ModuleRecordEntry, WasmImportRecord, WasmModuleRec
pub(crate) use self::resolver::{
ResolverScopeGuard, resolve_static_module_callback, resolve_static_source_callback,
};
+pub(crate) use self::response_mime::{
+ validate_css_module_response_mime, validate_json_module_response_mime,
+};
pub(crate) use self::single_module_fetch::NativeModuleSingleFetchRequest;
pub(crate) use self::tree_owner::{
NativeModuleTreeDocumentOwnerAdapter, NativeModuleTreeFrameDocumentOwner,
diff --git a/moli-renderer-v8/src/module_runtime/graph.rs b/moli-renderer-v8/src/module_runtime/graph.rs
index 94ca19de8..0e57c1fab 100644
--- a/moli-renderer-v8/src/module_runtime/graph.rs
+++ b/moli-renderer-v8/src/module_runtime/graph.rs
@@ -459,13 +459,23 @@ impl NativeModuleGraphFetchRequest {
.message()
.to_owned());
}
- if matches!(kind, ModuleKind::JavaScript | ModuleKind::WebAssembly)
- && let Err(error) = crate::planning::validate_external_script_response_mime(
- &source_url,
- ScriptKind::Module,
- &response,
- )
- {
+ let mime_result = match kind {
+ ModuleKind::JavaScript | ModuleKind::WebAssembly => {
+ crate::planning::validate_external_script_response_mime(
+ &source_url,
+ ScriptKind::Module,
+ &response,
+ )
+ }
+ ModuleKind::Json => {
+ super::validate_json_module_response_mime(&response.headers)
+ }
+ ModuleKind::Css => {
+ super::validate_css_module_response_mime(&response.headers)
+ }
+ ModuleKind::ModulePreloadText => Ok(()),
+ };
+ if let Err(error) = mime_result {
return Err(ModuleLoadError::new(ModuleLoadStage::Fetch, error)
.message()
.to_owned());
@@ -3871,6 +3881,7 @@ import "./c.mjs";
let first_response = fetch_module_for_test(
&loader,
module_url.clone(),
+ ModuleKind::JavaScript,
Url::parse(&format!("http://{addr}/first-page.html"))?,
ModuleFetchMetadata::default(),
)
@@ -3878,6 +3889,7 @@ import "./c.mjs";
let second_response = fetch_module_for_test(
&loader,
module_url,
+ ModuleKind::JavaScript,
Url::parse(&format!("http://{addr}/second-page.html"))?,
ModuleFetchMetadata::default(),
)
@@ -3929,6 +3941,7 @@ import "./c.mjs";
let error = fetch_module_for_test(
&loader,
module_url,
+ ModuleKind::JavaScript,
Url::parse(&format!("http://{addr}/page.html"))?,
metadata,
)
@@ -3943,9 +3956,84 @@ import "./c.mjs";
Ok(())
}
+ #[tokio::test(flavor = "multi_thread")]
+ async fn module_graph_fetch_enforces_json_and_css_response_mime() -> anyhow::Result<()> {
+ for (kind, mime, body) in [
+ (ModuleKind::Json, "application/json", r#"{"answer":42}"#),
+ (ModuleKind::Css, "text/css", "#test { color: red; }"),
+ ] {
+ let cases = [
+ (vec![mime.to_owned()], true),
+ (
+ vec![format!("{}; charset=utf-16", mime.to_ascii_uppercase())],
+ true,
+ ),
+ (vec!["text/plain".to_owned(), mime.to_owned()], true),
+ (vec![format!("text/plain, {mime}")], true),
+ (
+ vec![mime.to_owned(), "invalid".to_owned(), "*/*".to_owned()],
+ true,
+ ),
+ (vec![mime.to_owned(), "text/plain".to_owned()], false),
+ (vec![format!("{mime}, text/plain")], false),
+ (vec![format!(r#"text/plain; a=",{mime}""#)], false),
+ (
+ vec![r#"text/plain; a=""#.to_owned(), mime.to_owned()],
+ false,
+ ),
+ (vec!["text/plain".to_owned()], false),
+ (vec!["applic(ation/vnd.api+json".to_owned()], false),
+ (vec!["application/vnd)api+json".to_owned()], false),
+ (vec!["*/*".to_owned()], false),
+ (vec![String::new()], false),
+ (vec![], false),
+ ];
+ for (values, accepts) in cases {
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
+ let addr = listener.local_addr()?;
+ let fields: String = values
+ .iter()
+ .map(|value| format!("Content-Type: {value}\r\n"))
+ .collect();
+ let server = tokio::spawn(async move {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ read_http_request_head(&mut stream).await.unwrap();
+ let response = format!(
+ "HTTP/1.1 200 OK\r\n{fields}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",
+ body.len()
+ );
+ tokio::io::AsyncWriteExt::write_all(&mut stream, response.as_bytes())
+ .await
+ .unwrap();
+ });
+ let loader = ResourceRequestClient::new(&FetchConfig::default())?;
+ let result = fetch_module_for_test(
+ &loader,
+ Url::parse(&format!("http://{addr}/module"))?,
+ kind,
+ Url::parse(&format!("http://{addr}/page"))?,
+ ModuleFetchMetadata::default(),
+ )
+ .await;
+ server.await?;
+ assert_eq!(result.is_ok(), accepts, "{kind:?}: {values:?}: {result:?}");
+ if let Err(error) = result {
+ let expected = if kind == ModuleKind::Json {
+ "non-JSON module response"
+ } else {
+ "non-CSS module response"
+ };
+ assert!(error.to_string().contains(expected), "{error:#}");
+ }
+ }
+ }
+ Ok(())
+ }
+
async fn fetch_module_for_test(
loader: &ResourceRequestClient,
source_url: Url,
+ kind: ModuleKind,
initiator_url: Url,
fetch_metadata: ModuleFetchMetadata,
) -> anyhow::Result<crate::protocol_types::NavigationResponse> {
@@ -3953,7 +4041,7 @@ import "./c.mjs";
source_url,
initiator_url,
fetch_metadata,
- kind: ModuleKind::JavaScript,
+ kind,
tree_client: None,
tree_graph_level: None,
module_key: None,
diff --git a/moli-renderer-v8/src/module_runtime/response_mime.rs b/moli-renderer-v8/src/module_runtime/response_mime.rs
new file mode 100644
index 000000000..ab3422e4d
--- /dev/null
+++ b/moli-renderer-v8/src/module_runtime/response_mime.rs
@@ -0,0 +1,30 @@
+use moli_web_mime::{extract_response_mime_essence, is_css_mime, is_json_module_mime};
+
+pub(crate) fn validate_json_module_response_mime(
+ headers: &[(String, Vec<u8>)],
+) -> Result<(), String> {
+ validate_module_response_mime(headers, "JSON", is_json_module_mime)
+}
+
+pub(crate) fn validate_css_module_response_mime(
+ headers: &[(String, Vec<u8>)],
+) -> Result<(), String> {
+ validate_module_response_mime(headers, "CSS", is_css_mime)
+}
+
+fn validate_module_response_mime(
+ headers: &[(String, Vec<u8>)],
+ expected: &str,
+ accepts: fn(&str) -> bool,
+) -> Result<(), String> {
+ let essence = extract_response_mime_essence(headers);
+ if essence.as_deref().is_some_and(accepts) {
+ return Ok(());
+ }
+ let actual = essence
+ .as_deref()
+ .unwrap_or("missing or invalid Content-Type");
+ Err(format!(
+ "non-{expected} module response for {expected} import attribute: `{actual}`"
+ ))
+}
diff --git a/moli-renderer-v8/src/worker/module_mime.rs b/moli-renderer-v8/src/worker/module_mime.rs
index b8b34b8e5..210e72d1f 100644
--- a/moli-renderer-v8/src/worker/module_mime.rs
+++ b/moli-renderer-v8/src/worker/module_mime.rs
@@ -1,4 +1,4 @@
-use moli_web_mime::{is_css_mime, is_json_module_mime, is_text_mime, response_header_values};
+use moli_web_mime::{is_text_mime, response_header_values};
pub(crate) fn ensure_worker_wasm_module_mime(
response: &moli_fetch::Response,
@@ -18,33 +18,11 @@ pub(crate) fn ensure_worker_wasm_module_mime(
pub(crate) fn ensure_worker_json_module_mime(
response: &moli_fetch::Response,
) -> Result<(), String> {
- let content_type = worker_module_response_content_type(&response.headers);
- let Some(content_type) = content_type else {
- return Err(
- "non-JSON module response for JSON import attribute: missing Content-Type".to_owned(),
- );
- };
- if is_json_module_mime(&content_type) {
- return Ok(());
- }
- Err(format!(
- "non-JSON module response for JSON import attribute: `{content_type}`"
- ))
+ crate::module_runtime::validate_json_module_response_mime(&response.headers)
}
pub(crate) fn ensure_worker_css_module_mime(response: &moli_fetch::Response) -> Result<(), String> {
- let content_type = worker_module_response_content_type(&response.headers);
- let Some(content_type) = content_type else {
- return Err(
- "non-CSS module response for CSS import attribute: missing Content-Type".to_owned(),
- );
- };
- if is_css_mime(&content_type) {
- return Ok(());
- }
- Err(format!(
- "non-CSS module response for CSS import attribute: `{content_type}`"
- ))
+ crate::module_runtime::validate_css_module_response_mime(&response.headers)
}
pub(crate) fn ensure_worker_text_module_mime(
diff --git a/moli-renderer-v8/src/worker/thread/tests/modules.rs b/moli-renderer-v8/src/worker/thread/tests/modules.rs
index 8376899dc..13ef8b160 100644
--- a/moli-renderer-v8/src/worker/thread/tests/modules.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/modules.rs
@@ -5662,3 +5662,38 @@ async fn worker_importscripts_cross_origin_failure_reports_helper_callsite_from_
.await
.expect("cross-origin importScripts server should finish");
}
+
+#[tokio::test]
+async fn worker_json_imports_use_shared_response_mime_extraction() {
+ ensure_v8();
+ for (mime, accepts) in [
+ ("text/plain, application/json", true),
+ ("application/json, invalid, */*", true),
+ ("application/json, text/plain", false),
+ (r#"text/plain; a=",application/json""#, false),
+ ("applic(ation/vnd.api+json", false),
+ ("*/*", false),
+ ] {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/worker/module.json",
+ "HTTP/1.1 200 OK",
+ mime,
+ r#"{"answer":42}"#.to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
+ let mut handle = spawn_worker_with_request_client_and_kind(
+ "import('./module.json', {with:{type:'json'}}).then(m => postMessage(m.default.answer), e => postMessage(e.name));".into(),
+ format!("{base_url}/worker/main.js"), loader, WorkerScriptKind::Module,
+ );
+ let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
+ assert_eq!(
+ expect_post_json(message),
+ if accepts { "42" } else { r#""TypeError""# },
+ "{mime}"
+ );
+ handle.terminate_and_join();
+ server.await.unwrap();
+ }
+}