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(csp): require every integrity hash to match policy
ldm0320d82d19196
diff --git a/moli-renderer-v8/src/content_security_policy.rs b/moli-renderer-v8/src/content_security_policy.rsindex 94e855392..52e0d5ac3 100644--- a/moli-renderer-v8/src/content_security_policy.rs+++ b/moli-renderer-v8/src/content_security_policy.rs@@ -3,6 +3,7 @@ use std::collections::BTreeMap;use crate::context_bootstrap::{initialize_event_object, mark_event_trusted};use crate::network::ResourceRequestClient;+use crate::subresource_integrity::integrity_metadata_hashes;use crate::util::v8_string;use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};use moli_crypto::DigestAlgorithm;@@ -1553,16 +1554,19 @@ fn script_integrity_matches_hash_source(integrity: Option<&str>, sources: &[&strlet Some(integrity) = integrity else {return false;};- integrity.split_whitespace().any(|metadata| {- let metadata = metadata.split_once('?').map_or(metadata, |(hash, _)| hash);- let Some(metadata) = hash_source_value(metadata) else {- return false;- };- sources- .iter()- .filter_map(|source| csp_hash_source_value(source))- .any(|source| source == metadata)- })+ // CSP requires a nonempty subset of its hash sources, including weaker+ // algorithms. SRI checks the strongest hashes against the response later.+ let mut hashes = integrity_metadata_hashes(integrity).peekable();+ hashes.peek().is_some()+ && hashes.all(|hash| {+ sources+ .iter()+ .filter_map(|source| csp_hash_source_value(source))+ .any(|source| {+ source.algorithm.digest_algorithm() == hash.algorithm+ && source.digest == hash.digest+ })+ })}fn source_expression_matches(@@ -2032,6 +2036,22 @@ mod tests {)}+ fn script_element_request_allowed(+ policy: &str,+ request: ContentSecurityPolicyScriptElementRequest<'_>,+ ) -> bool {+ content_security_policy_script_element_url_violation_with_redirect_status_disposition_reporting_endpoints_and_request(+ &[policy.to_owned()],+ &protected_url(),+ &request_url("https://cdn.test/script.js"),+ ContentSecurityPolicyRedirectStatus::NoRedirect,+ ContentSecurityPolicyDisposition::Enforce,+ &ContentSecurityPolicyReportingEndpoints::default(),+ request,+ )+ .is_none()+ }+fn frame_ancestors_violation(policies: &[&str],protected_url: &str,@@ -2734,6 +2754,110 @@ mod tests {);}+ #[test]+ fn script_element_integrity_requires_every_supported_hash_in_the_source_list() {+ for directive in ["script-src-elem", "script-src", "default-src"] {+ let policy = format!("{directive} 'ShA256-testdigest' 'sha384-strong' 'sha512-other'");+ for (integrity, expected) in [+ ("sha256-testdigest sha384-strong", true),+ ("sha256-testdigest sha256-testdigest", true),+ ("sha512-other sha384-strong sha256-testdigest", true),+ ("sha256-testdigest sha256-unknown", false),+ ("sha256-unknown sha256-testdigest", false),+ ("sha256-testdigest sha512-unknown", false),+ ("sha256-unknown sha384-strong", false),+ ] {+ assert_eq!(+ script_element_request_allowed(+ &policy,+ ContentSecurityPolicyScriptElementRequest {+ nonce: None,+ integrity: Some(integrity),+ parser_inserted: true,+ },+ ),+ expected,+ "{policy}: {integrity}"+ );+ }+ }+ }++ #[test]+ fn script_element_integrity_uses_nonempty_parsed_sri_metadata() {+ for (integrity, expected) in [+ (None, false),+ (Some(" \t\r\n\x0c"), false),+ (Some("sha1-ignored sha512-***"), false),+ (Some("sha256-***"), false),+ (Some("SHA256-testdigest"), false),+ (Some("sha256-testdigest\u{a0}"), false),+ (Some("sha256-testdigest sha1-ignored"), true),+ (Some("sha256-testdigest sha512-*** sha512-abc==="), true),+ (Some("sha256-testdigest?ignored sha-256-testdigest"), true),+ (Some(" \tsha256-testdigest\r\n\x0csha256-testdigest "), true),+ ] {+ assert_eq!(+ script_element_request_allowed(+ "script-src 'sha256-testdigest' 'sha256-***'",+ ContentSecurityPolicyScriptElementRequest {+ nonce: None,+ integrity,+ parser_inserted: true,+ },+ ),+ expected,+ "{integrity:?}"+ );+ }+ }++ #[test]+ fn script_element_integrity_compares_encoded_digests_literally() {+ for (source, integrity, expected) in [+ ("'sha256-YQ=='", "sha256-YQ==", true),+ ("'sha256-YQ=='", "sha256-YQ", false),+ ("'sha256-+w=='", "sha256--w==", false),+ ("'sha256-YR=='", "sha256-YR==", true),+ ] {+ assert_eq!(+ script_element_request_allowed(+ &format!("script-src {source}"),+ ContentSecurityPolicyScriptElementRequest {+ nonce: None,+ integrity: Some(integrity),+ parser_inserted: true,+ },+ ),+ expected,+ "{source}: {integrity}"+ );+ }+ }++ #[test]+ fn partial_integrity_match_preserves_other_script_authorizations() {+ for (other_sources, nonce, parser_inserted, expected) in [+ ("'nonce-allowed'", Some("allowed"), true, true),+ ("https://cdn.test", None, true, true),+ ("'strict-dynamic'", None, false, true),+ ("'strict-dynamic' https://cdn.test", None, true, false),+ ] {+ assert_eq!(+ script_element_request_allowed(+ &format!("script-src 'sha256-testdigest' {other_sources}"),+ ContentSecurityPolicyScriptElementRequest {+ nonce,+ integrity: Some("sha256-testdigest sha256-unknown"),+ parser_inserted,+ },+ ),+ expected,+ "{other_sources}: nonce={nonce:?}, parser_inserted={parser_inserted}"+ );+ }+ }+#[test]fn script_src_elem_directive_controls_strict_dynamic_script_element_requests() {let allowed =diff --git a/moli-renderer-v8/src/subresource_integrity.rs b/moli-renderer-v8/src/subresource_integrity.rsindex 8da12287d..cf3ea8dfb 100644--- a/moli-renderer-v8/src/subresource_integrity.rs+++ b/moli-renderer-v8/src/subresource_integrity.rs@@ -1,25 +1,9 @@use base64::Engine;use moli_crypto::DigestAlgorithm;-#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]-enum SubresourceIntegrityAlgorithm {- Sha256,- Sha384,- Sha512,-}--impl SubresourceIntegrityAlgorithm {- fn output_len_bytes(self) -> usize {- self.digest_algorithm().output_len_bytes()- }-- fn digest_algorithm(self) -> DigestAlgorithm {- match self {- Self::Sha256 => DigestAlgorithm::Sha256,- Self::Sha384 => DigestAlgorithm::Sha384,- Self::Sha512 => DigestAlgorithm::Sha512,- }- }+pub(crate) struct IntegrityMetadataHash<'a> {+ pub(crate) algorithm: DigestAlgorithm,+ pub(crate) digest: &'a str,}struct ParsedIntegrityMetadata {@@ -27,7 +11,7 @@ struct ParsedIntegrityMetadata {}struct ParsedIntegrityToken {- algorithm: SubresourceIntegrityAlgorithm,+ algorithm: DigestAlgorithm,expected_digest: Option<Vec<u8>>,}@@ -57,7 +41,7 @@ pub(crate) fn response_matches_subresource_integrity_metadata(if !response_is_eligible {return false;}- let actual_digest = strongest_algorithm.digest_algorithm().digest_bytes(body);+ let actual_digest = strongest_algorithm.digest_bytes(body);metadata.tokens.iter().any(|token| {token.algorithm == strongest_algorithm&& token@@ -68,24 +52,32 @@ pub(crate) fn response_matches_subresource_integrity_metadata(}fn parse_integrity_metadata(integrity: &str) -> ParsedIntegrityMetadata {- let tokens = integrity- .split_ascii_whitespace()- .filter_map(parse_integrity_token)+ let tokens = integrity_metadata_hashes(integrity)+ .map(|hash| ParsedIntegrityToken {+ algorithm: hash.algorithm,+ expected_digest: decode_integrity_digest(hash.digest),+ }).collect();ParsedIntegrityMetadata { tokens }}-fn parse_integrity_token(token: &str) -> Option<ParsedIntegrityToken> {+/// Keep the encoded digest for CSP's literal hash-source comparison. Response+/// integrity verification separately decodes it and selects the strongest hash.+pub(crate) fn integrity_metadata_hashes(+ integrity: &str,+) -> impl Iterator<Item = IntegrityMetadataHash<'_>> {+ integrity+ .split_ascii_whitespace()+ .filter_map(parse_integrity_hash)+}++fn parse_integrity_hash(token: &str) -> Option<IntegrityMetadataHash<'_>> {let (algorithm, digest) = parse_integrity_algorithm_and_digest(token)?;let digest = digest.split_once('?').map_or(digest, |(digest, _)| digest);if !is_integrity_digest_syntax(digest) {return None;}- let expected_digest = decode_integrity_digest(digest);- Some(ParsedIntegrityToken {- algorithm,- expected_digest,- })+ Some(IntegrityMetadataHash { algorithm, digest })}fn is_integrity_digest_syntax(digest: &str) -> bool {@@ -112,16 +104,14 @@ fn is_integrity_digest_syntax(digest: &str) -> bool {data_characters != 0}-fn parse_integrity_algorithm_and_digest(- token: &str,-) -> Option<(SubresourceIntegrityAlgorithm, &str)> {- const PREFIXES: &[(&str, SubresourceIntegrityAlgorithm)] = &[- ("sha256", SubresourceIntegrityAlgorithm::Sha256),- ("sha-256", SubresourceIntegrityAlgorithm::Sha256),- ("sha384", SubresourceIntegrityAlgorithm::Sha384),- ("sha-384", SubresourceIntegrityAlgorithm::Sha384),- ("sha512", SubresourceIntegrityAlgorithm::Sha512),- ("sha-512", SubresourceIntegrityAlgorithm::Sha512),+fn parse_integrity_algorithm_and_digest(token: &str) -> Option<(DigestAlgorithm, &str)> {+ const PREFIXES: &[(&str, DigestAlgorithm)] = &[+ ("sha256", DigestAlgorithm::Sha256),+ ("sha-256", DigestAlgorithm::Sha256),+ ("sha384", DigestAlgorithm::Sha384),+ ("sha-384", DigestAlgorithm::Sha384),+ ("sha512", DigestAlgorithm::Sha512),+ ("sha-512", DigestAlgorithm::Sha512),];for (prefix, algorithm) in PREFIXES {let Some(rest) = token.strip_prefix(prefix) else {@@ -203,10 +193,7 @@ mod tests {let metadata = parse_integrity_metadata(&integrity);assert_eq!(metadata.tokens.len(), 1);- assert_eq!(- metadata.tokens[0].algorithm,- SubresourceIntegrityAlgorithm::Sha384- );+ assert_eq!(metadata.tokens[0].algorithm, DigestAlgorithm::Sha384);assert_eq!(metadata.tokens[0].expected_digest.as_ref().map(Vec::len),Some(48)@@ -293,7 +280,7 @@ mod tests {.iter().map(|token| token.algorithm).max_by_key(|algorithm| algorithm.output_len_bytes());- assert_eq!(strongest, Some(SubresourceIntegrityAlgorithm::Sha384));+ assert_eq!(strongest, Some(DigestAlgorithm::Sha384));assert!(response_body_matches_subresource_integrity_metadata(body,Some(&integrity)