Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(script): require supplied JavaScript MIME for strict loads

ldm08cd6fa48076c
diff --git a/moli-renderer-v8/src/worker/script_mime.rs b/moli-renderer-v8/src/worker/script_mime.rs
index 58209656e..40080d0c6 100644
--- a/moli-renderer-v8/src/worker/script_mime.rs
+++ b/moli-renderer-v8/src/worker/script_mime.rs
@@ -60,21 +60,23 @@ mod tests {
}
#[test]
- fn worker_script_mime_does_not_reject_blob_or_missing_content_type() {
+ fn worker_script_mime_rejects_missing_content_type() {
let blob_url = Url::parse("blob:https://example.test/id").expect("valid url");
let http_url = Url::parse("https://example.test/worker").expect("valid url");
- assert!(ensure_worker_script_mime_acceptable(&blob_url, &[], b"").is_ok());
- assert!(ensure_worker_script_mime_acceptable(&http_url, &[], b"").is_ok());
+ // Classic blob/data main scripts are materialized without this check;
+ // imported scripts and modules still require a JavaScript MIME type.
+ assert!(ensure_worker_script_mime_acceptable(&blob_url, &[], b"").is_err());
+ assert!(ensure_worker_script_mime_acceptable(&http_url, &[], b"").is_err());
}
#[test]
- fn worker_script_mime_allows_invalid_content_type_through_script_context_default() {
+ fn worker_script_mime_rejects_invalid_content_type() {
let url = Url::parse("https://example.test/worker").expect("valid url");
let headers: Vec<(String, Vec<u8>)> =
vec![("content-type".to_owned(), b"not a mime type".to_vec())];
- assert!(ensure_worker_script_mime_acceptable(&url, &headers, b"").is_ok());
+ assert!(ensure_worker_script_mime_acceptable(&url, &headers, b"").is_err());
}
#[test]
diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs
index b8f5593db..3584222ee 100644
--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs
@@ -1529,6 +1529,8 @@ mod abort_signal_statics;
mod lazy_storage;
mod lifecycle;
mod modules;
+mod strict_script_mime;
+
mod network;
mod postmessage;
mod tls;
diff --git a/moli-renderer-v8/src/worker/thread/tests/strict_script_mime.rs b/moli-renderer-v8/src/worker/thread/tests/strict_script_mime.rs
new file mode 100644
index 000000000..f1f78c966
--- /dev/null
+++ b/moli-renderer-v8/src/worker/thread/tests/strict_script_mime.rs
@@ -0,0 +1,73 @@
+use super::*;
+
+#[tokio::test]
+async fn worker_importscripts_rejects_missing_or_invalid_http_mime_before_execution() {
+ ensure_v8();
+ for content_type in [
+ None,
+ Some(""),
+ Some("not a mime type"),
+ Some("text/javascript"),
+ ] {
+ let headers = content_type
+ .map(|mime| format!("Content-Type: {mime}\r\n"))
+ .unwrap_or_default();
+ let body = "self.executed = true;";
+ let (base_url, server) = spawn_raw_path_response_http_server(vec![(
+ "/dep.js",
+ format!(
+ "HTTP/1.1 200 OK\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",
+ body.len()
+ ),
+ Duration::ZERO,
+ )])
+ .await;
+ let mut handle = spawn_test_worker_with_options(WorkerSpawnOptions::new(
+ r#"
+ let result = 'ok';
+ try { importScripts('./dep.js'); }
+ catch (error) { result = error.name; }
+ postMessage([result, self.executed === true]); close();
+ "#
+ .into(),
+ format!("{base_url}/worker.js"),
+ ));
+ assert_eq!(
+ recv_post_json(&mut handle).await,
+ if content_type == Some("text/javascript") {
+ "[\"ok\",true]"
+ } else {
+ "[\"NetworkError\",false]"
+ },
+ "{content_type:?}"
+ );
+ handle.terminate_and_join();
+ server.await.unwrap();
+ }
+}
+
+#[tokio::test]
+async fn worker_importscripts_rejects_missing_or_invalid_blob_mime() {
+ ensure_v8();
+ let mut handle = spawn_test_worker_with_options(WorkerSpawnOptions::new(
+ r#"
+ const results = [];
+ for (const type of ['text/plain', '', 'not a mime type']) {
+ self.second = false;
+ const badMime = URL.createObjectURL(new Blob(['self.second = true'], {type}));
+ let result = 'ok';
+ try { importScripts(badMime); }
+ catch (error) { result = error.name; }
+ URL.revokeObjectURL(badMime);
+ results.push([self.second === true, result]);
+ }
+ postMessage(results); close();
+ "#
+ .into(),
+ "https://example.test/worker.js".into(),
+ ));
+ assert_eq!(
+ recv_post_json(&mut handle).await,
+ "[[false,\"NetworkError\"],[false,\"NetworkError\"],[false,\"NetworkError\"]]"
+ );
+}
diff --git a/moli-web-mime/src/response_policy.rs b/moli-web-mime/src/response_policy.rs
index 1f13bdb07..6c560dd7b 100644
--- a/moli-web-mime/src/response_policy.rs
+++ b/moli-web-mime/src/response_policy.rs
@@ -172,15 +172,22 @@ pub fn check_script_response_mime(
return Err(ScriptResponseMimeError::Nosniff);
}
- let computed_mime_type =
- computed_response_mime_type(headers, MimeSniffingContext::Script, body);
if require_javascript_mime {
- return is_javascript_mime(&computed_mime_type)
+ // A script-context sniffing default cannot satisfy an explicit
+ // JavaScript MIME requirement, including when Content-Type is absent
+ // or cannot be parsed.
+ let supplied_mime_type = response_header_value(headers, "content-type")
+ .as_deref()
+ .and_then(mime_essence)
+ .unwrap_or_default();
+ return is_javascript_mime(&supplied_mime_type)
.then_some(())
- .ok_or(ScriptResponseMimeError::Unsupported(computed_mime_type));
+ .ok_or(ScriptResponseMimeError::Unsupported(supplied_mime_type));
}
if should_script_like_response_be_blocked_due_to_mime_type(headers) {
+ let computed_mime_type =
+ computed_response_mime_type(headers, MimeSniffingContext::Script, body);
return Err(ScriptResponseMimeError::Unsupported(computed_mime_type));
}
Ok(())
diff --git a/moli-web-mime/src/tests.rs b/moli-web-mime/src/tests.rs
index 560449b5d..b2c49be9d 100644
--- a/moli-web-mime/src/tests.rs
+++ b/moli-web-mime/src/tests.rs
@@ -769,6 +769,45 @@ fn checks_script_response_mime_for_nosniff_strict_and_classic_rules() {
);
}
+#[test]
+fn strict_script_response_mime_never_uses_a_sniffing_default() {
+ for content_type in [None, Some(""), Some("not a mime type"), Some("text/")] {
+ let headers: Vec<_> = content_type
+ .map(|value| ("Content-Type".to_owned(), value.as_bytes().to_vec()))
+ .into_iter()
+ .collect();
+ for body in [b"".as_slice(), b"self.executed = true;"] {
+ for destination in [FetchDestination::Script, FetchDestination::Worker] {
+ assert_eq!(
+ check_script_response_mime(&headers, body, destination, true),
+ Err(ScriptResponseMimeError::Unsupported(String::new())),
+ "{content_type:?}, {destination:?}"
+ );
+ }
+ // Classic document scripts retain their permissive MIME rules.
+ assert!(
+ check_script_response_mime(&headers, body, FetchDestination::Script, false).is_ok()
+ );
+ }
+ }
+}
+
+#[test]
+fn strict_script_response_mime_accepts_supplied_javascript_essences() {
+ for content_type in [
+ "Text/JavaScript; charset=utf-8",
+ "text/javascript; broken parameter",
+ "application/x-javascript",
+ "text/javascript1.5",
+ ] {
+ let headers = [("Content-Type".to_owned(), content_type.as_bytes().to_vec())];
+ assert!(
+ check_script_response_mime(&headers, b"", FetchDestination::Worker, true).is_ok(),
+ "{content_type}"
+ );
+ }
+}
+
#[test]
fn script_like_mime_type_block_matches_fetch_response_rule() {
let image: Vec<(String, Vec<u8>)> = vec![("content-type".to_owned(), b"image/png".to_vec())];