Skip to content

armgit / moli

Public Imported from GitHub
0

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

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.rs
index 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: &[&str
let 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.rs
index 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)