Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(sri): retain supported hashes with malformed padding

ldm0e53b60bd7ca9
diff --git a/moli-core/tests/scripts/integrity.rs b/moli-core/tests/scripts/integrity.rs
index 43fd222ba..fc9134b20 100644
--- a/moli-core/tests/scripts/integrity.rs
+++ b/moli-core/tests/scripts/integrity.rs
@@ -103,6 +103,14 @@ impl IntegrityServers {
fn network_cases(origin: &str, cross: &str) -> serde_json::Value {
serde_json::json!([
{"name": "same-origin", "src": format!("{origin}/script.js"), "integrity": INTEGRITY, "expected": "load"},
+ {"name": "excess-padding-mismatch", "src": format!("{origin}/script.js"), "integrity": "sha384-AAAA===", "expected": "error"},
+ {"name": "interior-padding-mismatch", "src": format!("{origin}/script.js"), "integrity": "sha384-A=AAA", "expected": "error"},
+ {"name": "padding-only-mismatch", "src": format!("{origin}/script.js"), "integrity": "sha384-====", "expected": "error"},
+ {"name": "malformed-stronger-hash", "src": format!("{origin}/script.js"), "integrity": format!("{INTEGRITY} sha512-AAAA==="), "expected": "error"},
+ {"name": "noncanonical-padding", "src": format!("{origin}/script.js"), "integrity": format!("{INTEGRITY}="), "expected": "load"},
+ {"name": "excess-padding-match", "src": format!("{origin}/script.js"), "integrity": format!("{INTEGRITY}===="), "expected": "load"},
+ {"name": "non-base64-ignored", "src": format!("{origin}/script.js"), "integrity": "sha384-***", "expected": "load"},
+ {"name": "malformed-and-matching", "src": format!("{origin}/script.js"), "integrity": format!("sha384-A=AAA {INTEGRITY}"), "expected": "load"},
{"name": "cross-no-cors", "src": format!("{cross}/script.js"), "integrity": INTEGRITY, "expected": "error"},
{"name": "cross-anonymous", "src": format!("{cross}/cors.js"), "integrity": INTEGRITY, "crossOrigin": "anonymous", "expected": "load"},
{"name": "cross-no-acao", "src": format!("{cross}/script.js"), "integrity": INTEGRITY, "crossOrigin": "anonymous", "expected": "error"},
diff --git a/moli-renderer-v8/src/content_security_policy.rs b/moli-renderer-v8/src/content_security_policy.rs
index d8a7da2b3..0264f4f5a 100644
--- a/moli-renderer-v8/src/content_security_policy.rs
+++ b/moli-renderer-v8/src/content_security_policy.rs
@@ -3616,7 +3616,10 @@ mod tests {
(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 sha512-***"), true),
+ (Some("sha256-testdigest sha512-*** sha512-abc==="), false),
+ (Some("sha256-testdigest sha512-A=AAA"), false),
+ (Some("sha256-testdigest sha512-===="), false),
(Some("sha256-testdigest?ignored sha-256-testdigest"), true),
(Some(" \tsha256-testdigest\r\n\x0csha256-testdigest "), true),
] {
diff --git a/moli-renderer-v8/src/subresource_integrity.rs b/moli-renderer-v8/src/subresource_integrity.rs
index cf3ea8dfb..dad471809 100644
--- a/moli-renderer-v8/src/subresource_integrity.rs
+++ b/moli-renderer-v8/src/subresource_integrity.rs
@@ -81,27 +81,13 @@ fn parse_integrity_hash(token: &str) -> Option<IntegrityMetadataHash<'_>> {
}
fn is_integrity_digest_syntax(digest: &str) -> bool {
- if digest.is_empty() {
- return false;
- }
- let mut padding = 0_u8;
- let mut data_characters = 0_usize;
- for byte in digest.bytes() {
- if byte == b'=' {
- padding = padding.saturating_add(1);
- if padding > 2 {
- return false;
- }
- continue;
- }
- if padding != 0
- || !(byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'/' | b'-' | b'_'))
- {
- return false;
- }
- data_characters += 1;
- }
- data_characters != 0
+ // Recognizing metadata and decoding its digest are separate steps. Keep
+ // hashes containing misplaced or excess padding: a decode failure must
+ // fail verification, not erase a supported (possibly stronger) algorithm.
+ !digest.is_empty()
+ && digest.bytes().all(|byte| {
+ byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'/' | b'-' | b'_' | b'=')
+ })
}
fn parse_integrity_algorithm_and_digest(token: &str) -> Option<(DigestAlgorithm, &str)> {
@@ -126,20 +112,88 @@ fn parse_integrity_algorithm_and_digest(token: &str) -> Option<(DigestAlgorithm,
}
fn decode_integrity_digest(digest: &str) -> Option<Vec<u8>> {
- [
- &base64::engine::general_purpose::STANDARD,
- &base64::engine::general_purpose::STANDARD_NO_PAD,
- &base64::engine::general_purpose::URL_SAFE,
- &base64::engine::general_purpose::URL_SAFE_NO_PAD,
- ]
- .into_iter()
- .find_map(|engine| engine.decode(digest).ok())
+ // SRI accepts unpadded and non-canonical padded representations. Normalize
+ // only for byte verification; CSP and preload metadata comparison retain
+ // the encoded value. Interior padding still causes decoding to fail.
+ const DECODER: base64::engine::GeneralPurpose = base64::engine::GeneralPurpose::new(
+ &base64::alphabet::STANDARD,
+ base64::engine::general_purpose::NO_PAD.with_decode_allow_trailing_bits(true),
+ );
+ let digest = digest.trim_end_matches('=');
+ let normalized;
+ let digest = if digest.contains(['-', '_']) {
+ normalized = digest.replace('-', "+").replace('_', "/");
+ &normalized
+ } else {
+ digest
+ };
+ DECODER.decode(digest).ok()
}
#[cfg(test)]
mod tests {
use super::*;
+ #[test]
+ fn malformed_supported_digests_do_not_disable_integrity_or_downgrade_the_algorithm() {
+ let body = b"integrity must still be checked";
+ let valid = format!(
+ "sha256-{}",
+ base64::engine::general_purpose::STANDARD
+ .encode(DigestAlgorithm::Sha256.digest_bytes(body))
+ );
+ for malformed in [
+ "sha512-AAAA===",
+ "sha512-A=AAA",
+ "sha512-====",
+ "sha-512-AAAA===",
+ ] {
+ for metadata in [malformed.to_owned(), format!("{valid} {malformed}")] {
+ for eligible in [true, false] {
+ assert!(
+ !response_matches_subresource_integrity_metadata(
+ body,
+ Some(&metadata),
+ eligible
+ ),
+ "{metadata}"
+ );
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn integrity_verification_accepts_noncanonical_base64_without_changing_metadata_identity() {
+ let body = b"noncanonical integrity";
+ let digest = base64::engine::general_purpose::STANDARD
+ .encode(DigestAlgorithm::Sha256.digest_bytes(body));
+ for padding in ["", "=", "===", "======="] {
+ let padded = format!("sha256-{}{padding}", digest.trim_end_matches('='));
+ assert!(response_matches_subresource_integrity_metadata(
+ body,
+ Some(&padded),
+ true
+ ));
+ assert!(!response_matches_subresource_integrity_metadata(
+ body,
+ Some(&padded),
+ false
+ ));
+ }
+ // Only the top four bits of the final SHA-256 base64 symbol carry data.
+ let mut noncanonical = digest.trim_end_matches('=').as_bytes().to_vec();
+ let alphabet = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ let last = noncanonical.last_mut().unwrap();
+ *last = alphabet[alphabet.iter().position(|byte| byte == last).unwrap() + 1];
+ let noncanonical = format!("sha256-{}", String::from_utf8(noncanonical).unwrap());
+ assert!(response_matches_subresource_integrity_metadata(
+ body,
+ Some(&noncanonical),
+ true
+ ));
+ }
+
fn response_body_matches_subresource_integrity_metadata(
body: &[u8],
integrity: Option<&str>,