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): validate Trusted Types directive name tokens

ldm0ffe2805e0831
diff --git a/moli-renderer-v8/src/content_security_policy.rs b/moli-renderer-v8/src/content_security_policy.rs
index 865c437ea..93b7df1dc 100644
--- a/moli-renderer-v8/src/content_security_policy.rs
+++ b/moli-renderer-v8/src/content_security_policy.rs
@@ -1152,12 +1152,14 @@ fn policy_allows_trusted_type_policy_name(policy: &str, policy_name: &str) -> bo
return true;
};
sources.iter().any(|source| {
- let source = source.trim();
+ let source = *source;
source == "*"
|| (!source.is_empty()
- && !csp_keyword_eq(source, "none")
- && !csp_keyword_eq(source, "allow-duplicates")
- && source == policy_name)
+ && source == policy_name
+ && source.bytes().all(|byte| {
+ byte.is_ascii_alphanumeric()
+ || matches!(byte, b'-' | b'#' | b'=' | b'_' | b'/' | b'@' | b'.' | b'%')
+ }))
})
}
@@ -1231,12 +1233,15 @@ fn parsed_directives(policy: &str) -> Vec<(&str, Vec<&str>)> {
policy
.split(';')
.filter_map(|directive| {
- let mut parts = directive.split_ascii_whitespace();
- let name = parts.next()?.trim();
- if name.is_empty() {
+ // CSP discards the entire non-ASCII directive, independently of
+ // other directives in the same policy and before duplicate lookup.
+ if !directive.is_ascii() {
return None;
}
- Some((name, parts.collect()))
+ let mut parts = directive.split_ascii_whitespace();
+ // split_ascii_whitespace already trims exactly the CSP whitespace
+ // set. A subsequent str::trim would incorrectly erase vertical tabs.
+ Some((parts.next()?, parts.collect()))
})
.collect()
}
@@ -3323,6 +3328,110 @@ mod tests {
));
}
+ #[test]
+ fn trusted_types_csp_name_grammar_matches_only_valid_tokens() {
+ for byte in 0..=127u8 {
+ let name = format!("policy{}name", char::from(byte));
+ let policy = format!("trusted-types {name}");
+ let expected = byte.is_ascii_alphanumeric() || b"-#=_/@.%".contains(&byte);
+ assert_eq!(
+ policy_allows_trusted_type_policy_name(&policy, &name),
+ expected,
+ "invalid tt-policy-name byte {byte:#04x} must not match literally",
+ );
+ }
+ for name in ["none", "allow-duplicates", "A-z_09#=/@.%"] {
+ assert!(policy_allows_trusted_type_policy_name(
+ &format!("trusted-types {name}"),
+ name
+ ));
+ }
+ assert!(policy_allows_trusted_type_policy_name(
+ "trusted-types valid policy*name",
+ "valid"
+ ));
+ assert!(!policy_allows_trusted_type_policy_name(
+ "trusted-types valid policy*name",
+ "policy*name"
+ ));
+ for wildcard in ["\u{000b}*", "*\u{000b}", "policy*"] {
+ assert!(!policy_allows_trusted_type_policy_name(
+ &format!("trusted-types {wildcard}"),
+ "valid"
+ ));
+ }
+ }
+
+ #[test]
+ fn trusted_types_csp_name_grammar_does_not_restrict_unlisted_or_wildcard_names() {
+ for name in [
+ "",
+ "policy*name",
+ "policy$name",
+ "política",
+ "ポリシー",
+ "\0",
+ ] {
+ for policy in ["", "trusted-types *"] {
+ assert!(policy_allows_trusted_type_policy_name(policy, name));
+ }
+ }
+ }
+
+ #[test]
+ fn csp_directive_parser_discards_each_non_ascii_directive_before_duplicate_matching() {
+ for directive in [
+ "trusted-types allowed política",
+ "trusted-types\u{a0}allowed",
+ "\u{a0}trusted-types allowed",
+ "trusted-types allowed\u{a0}",
+ "require-trusted-types-for 'script' ポリシー",
+ "script-src 'none' https://例子.test",
+ ] {
+ assert!(parsed_directives(directive).is_empty(), "{directive}");
+ }
+
+ let directives = parsed_directives(
+ "trusted-types invalid política; TRUSTED-TYPES allowed; trusted-types *; \
+ script-src 'none'; img-src https://例子.test; img-src 'self'",
+ );
+ assert_eq!(
+ directive_source_list(&directives, TRUSTED_TYPES),
+ Some(["allowed"].as_slice()),
+ );
+ assert_eq!(
+ directive_source_list(&directives, SCRIPT_SRC),
+ Some(["'none'"].as_slice()),
+ );
+ assert_eq!(
+ directive_source_list(&directives, IMG_SRC),
+ Some(["'self'"].as_slice()),
+ );
+ }
+
+ #[test]
+ fn csp_directive_parser_uses_only_ascii_whitespace_around_names() {
+ for space in ['\t', '\n', '\u{000c}', '\r', ' '] {
+ let policy = format!("{space}TrUsTeD-TyPeS{space}allowed{space}");
+ let directives = parsed_directives(&policy);
+ assert_eq!(
+ directive_source_list(&directives, TRUSTED_TYPES),
+ Some(["allowed"].as_slice()),
+ );
+ }
+ for invalid in ['\0', '\u{000b}', '\u{001f}', '\u{007f}'] {
+ for policy in [
+ format!("{invalid}trusted-types allowed"),
+ format!("trusted-types{invalid} allowed"),
+ ] {
+ assert!(
+ directive_source_list(&parsed_directives(&policy), TRUSTED_TYPES).is_none(),
+ "{policy:?}",
+ );
+ }
+ }
+ }
+
#[test]
fn trusted_types_eval_requires_enforcement_and_an_operative_keyword() {
let allowed = |policies: &[&str]| {
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/trusted_types.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/trusted_types.rs
index ba10f1e38..6863ce3d0 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/trusted_types.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/trusted_types.rs
@@ -1,5 +1,45 @@
use super::*;
+#[test]
+fn trusted_types_csp_policy_creation_matches_only_valid_name_tokens() {
+ for (policy, name, expected) in [
+ ("trusted-types valid policy*name", "valid", "allowed"),
+ (
+ "trusted-types valid policy*name",
+ "policy*name",
+ "TypeError",
+ ),
+ ("trusted-types none allow-duplicates", "none", "allowed"),
+ (
+ "trusted-types none allow-duplicates",
+ "allow-duplicates",
+ "allowed",
+ ),
+ (
+ "trusted-types ignored política; trusted-types valid",
+ "valid",
+ "allowed",
+ ),
+ (
+ "trusted-types ignored política; trusted-types valid",
+ "ignored",
+ "TypeError",
+ ),
+ ("trusted-types \u{000b}*", "arbitrary", "TypeError"),
+ ("trusted-types *", "name with spaces", "allowed"),
+ ("", "name with spaces", "allowed"),
+ ("trusted-types valid", "policy$name", "TypeError"),
+ ] {
+ let mut vm = new_storage_test_vm("https://trusted-types-name-grammar.test/");
+ vm.set_response_content_security_policies(&[policy.to_owned()]);
+ let script = format!(
+ "(() => {{ try {{ trustedTypes.createPolicy({}, {{createHTML: value => value}}); return 'allowed'; }} catch (error) {{ return error.name; }} }})()",
+ serde_json::to_string(name).unwrap(),
+ );
+ assert_eq!(vm.eval(&script).unwrap(), expected, "{policy:?}, {name:?}");
+ }
+}
+
#[test]
fn element_markup_sinks_enforce_trusted_html_and_standard_sink_names() {
let mut vm = new_storage_test_vm("https://element-markup-trusted-types.test/");