Something went wrong. Try again.
Mail user agent backed by notmuch.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272//! Keeping remote fetches out of CSS.//!//! A stylesheet can reach the network without a single tag doing so://! `@import`, `url(…)` in a `background`, a `src` in `@font-face`, the string//! arguments of `image-set(…)`. The `style` *attribute* is only a declaration//! list, but a `<style>` element is a whole stylesheet, and both are scrubbed//! here by tokenizing instead of pattern-matching — CSS escapes mean//! `u\72l(https://…)` and `@import` written as `@\69 mport` are the same//! thing to a browser as their plain spelling, and only a tokenizer knows//! that.
use std::ops::Range;
use cssparser::{Parser, ParserInput, Token};
/// Only `data:` URIs are local; everything else a stylesheet can name is a/// host that would learn the mail was opened.fn is_data_uri(value: &str) -> bool { value .get(..5) .is_some_and(|prefix| prefix.eq_ignore_ascii_case("data:"))}
/// Walk `parser`, collecting the byte ranges that must go: a non-`data:`/// `url(…)`, a non-`data:` string inside `image-set(…)`, the whole `@import`/// rule. Blocks are descended into (`Parser::next` skips their contents), so/// every rule in the stylesheet is visited.fn scan<'i>(parser: &mut Parser<'i, '_>, drops: &mut Vec<Range<usize>>, in_image_set: bool) { loop { let start = parser.position().byte_index(); let token = match parser.next_including_whitespace_and_comments() { Ok(token) => token.clone(), Err(_) => return, }; match token { Token::AtKeyword(name) if name.eq_ignore_ascii_case("import") => { drop_import(parser, drops, start); } Token::UnquotedUrl(url) | Token::BadUrl(url) if !is_data_uri(&url) => { drops.push(start..parser.position().byte_index()); } Token::QuotedString(value) if in_image_set && !is_data_uri(&value) => { drops.push(start..parser.position().byte_index()); } Token::Function(name) if name.eq_ignore_ascii_case("url") => { let local = parser .parse_nested_block::<_, _, ()>(|inner| Ok(argument_is_data(inner))) .unwrap_or(false); if !local { drops.push(start..parser.position().byte_index()); } } Token::Function(name) => { let picks_strings = name.eq_ignore_ascii_case("image-set") || name.eq_ignore_ascii_case("-webkit-image-set"); let _ = parser.parse_nested_block::<_, _, ()>(|inner| { scan(inner, drops, picks_strings); Ok(()) }); } Token::CurlyBracketBlock | Token::ParenthesisBlock | Token::SquareBracketBlock => { let _ = parser.parse_nested_block::<_, _, ()>(|inner| { scan(inner, drops, in_image_set); Ok(()) }); } _ => {} } }}
/// `url("…")` arrives as a function token, so its argument has to be read/// from inside the block; `url(…)` unquoted arrives as one token already.fn argument_is_data(parser: &mut Parser<'_, '_>) -> bool { match parser.next() { Ok(Token::QuotedString(value)) | Ok(Token::UnquotedUrl(value)) => is_data_uri(value), _ => false, }}
/// Consume an `@import` up to and including its `;` (or its block, which is/// not valid but is still not allowed to keep what it holds).fn drop_import<'i>(parser: &mut Parser<'i, '_>, drops: &mut Vec<Range<usize>>, start: usize) { loop { match parser.next_including_whitespace_and_comments().cloned() { Err(_) => break, Ok(Token::Semicolon) => break, Ok(Token::CurlyBracketBlock) => { let _ = parser.parse_nested_block::<_, _, ()>(|_| Ok(())); break; } Ok(_) => {} } } drops.push(start..parser.position().byte_index());}
/// Copy `css` with `drops` removed, merging overlaps so the copy cannot run/// backwards.fn apply_drops(css: &str, drops: &[Range<usize>]) -> String { let mut sorted: Vec<Range<usize>> = drops.to_vec(); sorted.sort_by_key(|range| range.start); let mut merged: Vec<Range<usize>> = Vec::with_capacity(sorted.len()); for range in sorted { let range = range.start.min(css.len())..range.end.min(css.len()); match merged.last_mut() { Some(last) if range.start <= last.end => last.end = last.end.max(range.end), _ => merged.push(range), } } let mut out = String::with_capacity(css.len()); let mut at = 0; for range in merged { if range.start < at { continue; } out.push_str(&css[at..range.start]); at = range.end; } out.push_str(&css[at..]); out}
/// `css` without any way to reach a host. Everything that is not a fetch/// survives byte for byte, so a mail's own colours and layout stay put.pub fn scrub_css(css: &str) -> String { let mut input = ParserInput::new(css); let mut parser = Parser::new(&mut input); let mut drops = Vec::new(); scan(&mut parser, &mut drops, false); apply_drops(css, &drops)}
/// The `<style>` elements of a document: their content is raw text up to the/// first `</style>`, which no element handler can see, so it is found here in/// the finished document. A `style` with no close tag is left alone rather/// than guessed at.pub fn scrub_style_elements(doc: &str) -> String { let lowered = doc.to_ascii_lowercase(); let mut out = String::with_capacity(doc.len()); let mut at = 0; while let Some(found) = lowered[at..].find("<style") { let open = at + found; let after_name = open + "<style".len(); if !matches!( lowered[after_name..].chars().next(), Some('>' | '/' | ' ' | '\t' | '\n' | '\r') ) { // `<stylesheet>` and friends: not a style element, so the text // up to here still has to be copied on. out.push_str(&doc[at..after_name]); at = after_name; continue; } let Some(tag_end) = lowered[after_name..].find('>').map(|p| after_name + p + 1) else { break; }; let Some(close) = lowered[tag_end..].find("</style").map(|p| tag_end + p) else { break; }; let Some(close_end) = lowered[close..].find('>').map(|p| close + p + 1) else { break; }; out.push_str(&doc[at..tag_end]); out.push_str(&scrub_css(&doc[tag_end..close])); out.push_str(&doc[close..close_end]); at = close_end; } out.push_str(&doc[at..]); out}
#[cfg(test)]mod tests { use super::*;
#[test] fn remote_url_in_a_rule_is_gone_but_the_rule_stays() { let css = "div { background: url(https://t/x.png) no-repeat; color: red }"; let scrubbed = scrub_css(css); assert!(!scrubbed.contains("https://t/x.png"), "{scrubbed}"); assert!(scrubbed.contains("div {"), "{scrubbed}"); assert!(scrubbed.contains("color: red"), "{scrubbed}"); }
#[test] fn data_uri_survives() { let css = "div { background: url(data:image/png;base64,UE5HREFUQQ==) }"; assert_eq!(scrub_css(css), css); }
#[test] fn quoted_url_is_read_from_inside_the_function() { let scrubbed = scrub_css("a { background: url(\"https://t/x.png\") }"); assert!(!scrubbed.contains("https://t/x.png"), "{scrubbed}"); let scrubbed = scrub_css("a { background: url(\"data:text/css,body{}\") }"); assert!(scrubbed.contains("data:text/css"), "{scrubbed}"); }
#[test] fn import_is_dropped_whole_in_any_spelling() { for css in [ "@import url(https://t/a.css); div { color: red }", "@IMPORT \"https://t/b.css\"; div { color: red }", "@import url(\"https://t/c.css\") screen; div { color: red }", ] { let scrubbed = scrub_css(css); assert!( !scrubbed.to_ascii_lowercase().contains("import"), "{scrubbed}" ); assert!(!scrubbed.contains("https://t/"), "{scrubbed}"); assert!(scrubbed.contains("color: red"), "{scrubbed}"); } }
#[test] fn escapes_are_not_a_way_around_the_scrub() { let scrubbed = scrub_css("div { background: u\\72l(https://t/x.png) }"); assert!(!scrubbed.contains("https://t/x.png"), "{scrubbed}"); let scrubbed = scrub_css("@\\69 mport \"https://t/a.css\";"); assert!(!scrubbed.contains("https://t/"), "{scrubbed}"); }
#[test] fn image_set_strings_are_urls_too() { let scrubbed = scrub_css( "div { background: image-set(\"https://t/a.png\" 1x, \"data:image/png;base64,AA==\" 2x) }", ); assert!(!scrubbed.contains("https://t/a.png"), "{scrubbed}"); assert!(scrubbed.contains("data:image/png"), "{scrubbed}"); }
#[test] fn font_face_and_keyframes_are_reached_too() { let scrubbed = scrub_css( "@font-face { font-family: x; src: url(https://t/f.woff2) } @keyframes k { from { background: url(https://t/k.png) } }", ); assert!(!scrubbed.contains("https://t/"), "{scrubbed}"); assert!(scrubbed.contains("@font-face"), "{scrubbed}"); assert!(scrubbed.contains("@keyframes"), "{scrubbed}"); }
#[test] fn comments_and_unrelated_functions_are_left_alone() { let css = "/* url(https://t/in-comment.png) */ div { transform: translateX(var(--x)) }"; assert_eq!(scrub_css(css), css); }
#[test] fn style_elements_are_scrubbed_in_place() { let doc = "<p>hi</p><STYLE>div{background:url(https://t/x.png)}</STYLE><b>x</b>"; let scrubbed = scrub_style_elements(doc); assert!(!scrubbed.contains("https://t/x.png"), "{scrubbed}"); assert!(scrubbed.contains("<p>hi</p>"), "{scrubbed}"); assert!(scrubbed.contains("</STYLE><b>x</b>"), "{scrubbed}"); assert!(scrubbed.contains("div{background:"), "{scrubbed}"); }
#[test] fn a_style_without_a_close_tag_is_not_guessed_at() { let doc = "<style>div { background: url(https://t/x.png)"; assert_eq!(scrub_style_elements(doc), doc); }
#[test] fn style_like_names_are_not_style_elements() { let doc = "<styles>div { background: url(https://t/x.png) }</styles>"; assert_eq!(scrub_style_elements(doc), doc); }}