+151

crates/tranquil-comms/src/email/message.rs

reviewed

··· 1 1 + use lettre::Message; 2 2 + use lettre::message::Mailbox; 3 3 + use lettre::message::header::ContentType; 4 4 + use uuid::Uuid; 5 5 + 6 6 + use super::types::EmailDomain; 7 7 + use crate::sender::SendError; 8 8 + use crate::types::QueuedComms; 9 9 + 10 10 + pub(super) fn build(from: &Mailbox, qc: &QueuedComms) -> Result<Message, SendError> { 11 11 + let to: Mailbox = qc 12 12 + .recipient 13 13 + .parse() 14 14 + .map_err(|e: lettre::address::AddressError| SendError::InvalidRecipient(e.to_string()))?; 15 15 + let subject = qc.subject.as_deref().unwrap_or("Notification"); 16 16 + let message_id = format!("<{}@{}>", Uuid::new_v4(), from.email.domain()); 17 17 + Message::builder() 18 18 + .from(from.clone()) 19 19 + .to(to) 20 20 + .subject(subject) 21 21 + .message_id(Some(message_id)) 22 22 + .header(ContentType::TEXT_PLAIN) 23 23 + .body(qc.body.clone()) 24 24 + .map_err(|e| SendError::MessageBuild(e.to_string())) 25 25 + } 26 26 + 27 27 + pub(super) fn recipient_domain(message: &Message) -> Result<EmailDomain, SendError> { 28 28 + let envelope = message.envelope(); 29 29 + let first = envelope 30 30 + .to() 31 31 + .first() 32 32 + .ok_or_else(|| SendError::MessageBuild("envelope has no recipients".to_string()))?; 33 33 + EmailDomain::parse(first.domain()) 34 34 + .map_err(|e| SendError::InvalidRecipient(format!("invalid recipient domain: {e}"))) 35 35 + } 36 36 + 37 37 + #[cfg(test)] 38 38 + mod tests { 39 39 + use super::*; 40 40 + use crate::types::{CommsChannel, CommsStatus, CommsType}; 41 41 + use chrono::Utc; 42 42 + use uuid::Uuid; 43 43 + 44 44 + fn from_mailbox() -> Mailbox { 45 45 + "Test Sender <noreply@nel.pet>".parse().unwrap() 46 46 + } 47 47 + 48 48 + fn fixture(recipient: &str, subject: Option<&str>, body: &str) -> QueuedComms { 49 49 + QueuedComms { 50 50 + id: Uuid::new_v4(), 51 51 + user_id: None, 52 52 + channel: CommsChannel::Email, 53 53 + comms_type: CommsType::Welcome, 54 54 + status: CommsStatus::Pending, 55 55 + recipient: recipient.to_string(), 56 56 + subject: subject.map(String::from), 57 57 + body: body.to_string(), 58 58 + metadata: None, 59 59 + attempts: 0, 60 60 + max_attempts: 3, 61 61 + last_error: None, 62 62 + created_at: Utc::now(), 63 63 + updated_at: Utc::now(), 64 64 + scheduled_for: Utc::now(), 65 65 + processed_at: None, 66 66 + } 67 67 + } 68 68 + 69 69 + #[test] 70 70 + fn build_basic_message() { 71 71 + let msg = build( 72 72 + &from_mailbox(), 73 73 + &fixture("user@nel.pet", Some("Welcome"), "Hello world."), 74 74 + ) 75 75 + .unwrap(); 76 76 + let raw = String::from_utf8(msg.formatted()).unwrap(); 77 77 + let lower = raw.to_lowercase(); 78 78 + assert!(raw.contains("From: \"Test Sender\" <noreply@nel.pet>")); 79 79 + assert!(raw.contains("To: user@nel.pet")); 80 80 + assert!(raw.contains("Subject: Welcome")); 81 81 + assert!(lower.contains("content-type: text/plain")); 82 82 + assert!(raw.contains("Hello world.")); 83 83 + } 84 84 + 85 85 + #[test] 86 86 + fn utf8_subject_is_encoded() { 87 87 + let msg = build( 88 88 + &from_mailbox(), 89 89 + &fixture("user@nel.pet", Some("héllo wörld"), "Body"), 90 90 + ) 91 91 + .unwrap(); 92 92 + let raw = String::from_utf8(msg.formatted()).unwrap(); 93 93 + assert!(raw.contains("=?utf-8?")); 94 94 + assert!(!raw.contains("héllo")); 95 95 + } 96 96 + 97 97 + #[test] 98 98 + fn header_injection_rejected() { 99 99 + let result = build( 100 100 + &from_mailbox(), 101 101 + &fixture("x@nel.pet\r\nBcc: evil@x", Some("s"), "b"), 102 102 + ); 103 103 + assert!(matches!(result, Err(SendError::InvalidRecipient(_)))); 104 104 + } 105 105 + 106 106 + #[test] 107 107 + fn subject_crlf_does_not_inject_headers() { 108 108 + let msg = build( 109 109 + &from_mailbox(), 110 110 + &fixture("user@nel.pet", Some("hi\r\nBcc: evil@nel.pet"), "body"), 111 111 + ) 112 112 + .expect("subject CRLF should be encoded, not rejected"); 113 113 + let raw = String::from_utf8(msg.formatted()).unwrap(); 114 114 + assert!( 115 115 + !raw.contains("Bcc:"), 116 116 + "CRLF in subject must not produce a Bcc header: {raw}" 117 117 + ); 118 118 + assert!( 119 119 + raw.contains("Subject: ="), 120 120 + "subject with non-printable chars should be RFC 2047 encoded: {raw}" 121 121 + ); 122 122 + } 123 123 + 124 124 + #[test] 125 125 + fn message_id_uses_from_domain() { 126 126 + let msg = build(&from_mailbox(), &fixture("user@nel.pet", Some("s"), "b")).unwrap(); 127 127 + let raw = String::from_utf8(msg.formatted()).unwrap(); 128 128 + let line = raw 129 129 + .lines() 130 130 + .find(|l| l.starts_with("Message-ID:") || l.starts_with("Message-Id:")) 131 131 + .expect("message-id header present"); 132 132 + assert!( 133 133 + line.contains("@nel.pet>"), 134 134 + "message-id should use From domain: {line}" 135 135 + ); 136 136 + } 137 137 + 138 138 + #[test] 139 139 + fn missing_subject_uses_default() { 140 140 + let msg = build(&from_mailbox(), &fixture("user@nel.pet", None, "Body")).unwrap(); 141 141 + let raw = String::from_utf8(msg.formatted()).unwrap(); 142 142 + assert!(raw.contains("Subject: Notification")); 143 143 + } 144 144 + 145 145 + #[test] 146 146 + fn recipient_domain_extracted() { 147 147 + let msg = build(&from_mailbox(), &fixture("user@Nel.PET", Some("s"), "b")).unwrap(); 148 148 + let d = recipient_domain(&msg).unwrap(); 149 149 + assert_eq!(d.as_str(), "nel.pet"); 150 150 + } 151 151 + }

+250

crates/tranquil-comms/src/email/mx.rs

reviewed

··· 1 1 + use hickory_resolver::TokioAsyncResolver; 2 2 + use hickory_resolver::error::{ResolveError, ResolveErrorKind}; 3 3 + use hickory_resolver::proto::op::ResponseCode; 4 4 + use rand::seq::SliceRandom; 5 5 + 6 6 + use super::types::{EmailDomain, MxHost, MxPriority, MxRecord}; 7 7 + use crate::sender::SendError; 8 8 + 9 9 + pub async fn resolve( 10 10 + resolver: &TokioAsyncResolver, 11 11 + domain: &EmailDomain, 12 12 + ) -> Result<Vec<MxRecord>, SendError> { 13 13 + match resolver.mx_lookup(domain.as_str()).await { 14 14 + Ok(lookup) => interpret_lookup( 15 15 + lookup 16 16 + .iter() 17 17 + .map(|mx| (mx.preference(), mx.exchange().clone())), 18 18 + domain, 19 19 + ), 20 20 + Err(e) => classify_lookup_error(e, domain), 21 21 + } 22 22 + } 23 23 + 24 24 + fn interpret_lookup( 25 25 + items: impl IntoIterator<Item = (u16, hickory_resolver::Name)>, 26 26 + domain: &EmailDomain, 27 27 + ) -> Result<Vec<MxRecord>, SendError> { 28 28 + let entries: Vec<_> = items.into_iter().collect(); 29 29 + match entries.iter().any(|(_, name)| name.is_root()) { 30 30 + true => Err(SendError::DnsPermanent(format!( 31 31 + "null MX record at {}: domain refuses mail", 32 32 + domain.as_str() 33 33 + ))), 34 34 + false => { 35 35 + let records: Vec<MxRecord> = entries 36 36 + .into_iter() 37 37 + .filter_map(|(prio, name)| { 38 38 + MxHost::parse(&name.to_utf8()).ok().map(|host| MxRecord { 39 39 + priority: MxPriority::new(prio), 40 40 + host, 41 41 + }) 42 42 + }) 43 43 + .collect(); 44 44 + match records.is_empty() { 45 45 + true => implicit_mx(domain), 46 46 + false => Ok(prioritize(records)), 47 47 + } 48 48 + } 49 49 + } 50 50 + } 51 51 + 52 52 + fn prioritize(mut records: Vec<MxRecord>) -> Vec<MxRecord> { 53 53 + records.shuffle(&mut rand::thread_rng()); 54 54 + records.sort_by_key(|r| r.priority); 55 55 + records 56 56 + } 57 57 + 58 58 + fn classify_lookup_error( 59 59 + e: ResolveError, 60 60 + domain: &EmailDomain, 61 61 + ) -> Result<Vec<MxRecord>, SendError> { 62 62 + match e.kind() { 63 63 + ResolveErrorKind::NoRecordsFound { response_code, .. } => match *response_code { 64 64 + ResponseCode::NoError => implicit_mx(domain), 65 65 + ResponseCode::NXDomain => Err(SendError::DnsPermanent(format!( 66 66 + "domain {} does not exist", 67 67 + domain.as_str() 68 68 + ))), 69 69 + other => Err(SendError::DnsTransient(format!( 70 70 + "MX lookup for {} failed with {other}", 71 71 + domain.as_str() 72 72 + ))), 73 73 + }, 74 74 + _ => Err(SendError::DnsTransient(e.to_string())), 75 75 + } 76 76 + } 77 77 + 78 78 + fn implicit_mx(domain: &EmailDomain) -> Result<Vec<MxRecord>, SendError> { 79 79 + MxHost::parse(domain.as_str()) 80 80 + .map(|host| { 81 81 + vec![MxRecord { 82 82 + priority: MxPriority::new(0), 83 83 + host, 84 84 + }] 85 85 + }) 86 86 + .map_err(|e| SendError::DnsPermanent(format!("invalid recipient domain: {e}"))) 87 87 + } 88 88 + 89 89 + #[cfg(test)] 90 90 + mod tests { 91 91 + use super::*; 92 92 + 93 93 + fn record(prio: u16, host: &str) -> MxRecord { 94 94 + MxRecord { 95 95 + priority: MxPriority::new(prio), 96 96 + host: MxHost::parse(host).unwrap(), 97 97 + } 98 98 + } 99 99 + 100 100 + #[test] 101 101 + fn prioritize_sorts_by_priority_ascending() { 102 102 + let result = prioritize(vec![ 103 103 + record(20, "mx2.nel.pet"), 104 104 + record(10, "mx1.nel.pet"), 105 105 + record(10, "mx1b.nel.pet"), 106 106 + ]); 107 107 + assert_eq!(result[0].priority.as_u16(), 10); 108 108 + assert_eq!(result[1].priority.as_u16(), 10); 109 109 + assert_eq!(result[2].priority.as_u16(), 20); 110 110 + } 111 111 + 112 112 + #[test] 113 113 + fn prioritize_randomizes_equal_priority_order() { 114 114 + let attempts: Vec<Vec<String>> = (0..200) 115 115 + .map(|_| { 116 116 + prioritize(vec![ 117 117 + record(10, "a.nel.pet"), 118 118 + record(10, "b.nel.pet"), 119 119 + record(10, "c.nel.pet"), 120 120 + record(10, "d.nel.pet"), 121 121 + ]) 122 122 + .into_iter() 123 123 + .map(|r| r.host.as_str().to_string()) 124 124 + .collect() 125 125 + }) 126 126 + .collect(); 127 127 + let distinct: std::collections::HashSet<_> = attempts.iter().cloned().collect(); 128 128 + assert!( 129 129 + distinct.len() > 1, 130 130 + "equal-priority MX order should vary across calls; got only {}", 131 131 + distinct.len() 132 132 + ); 133 133 + } 134 134 + 135 135 + #[test] 136 136 + fn implicit_mx_uses_domain_as_host() { 137 137 + let d = EmailDomain::parse("nel.pet").unwrap(); 138 138 + let result = implicit_mx(&d).unwrap(); 139 139 + assert_eq!(result.len(), 1); 140 140 + assert_eq!(result[0].priority.as_u16(), 0); 141 141 + assert_eq!(result[0].host.as_str(), "nel.pet"); 142 142 + } 143 143 + 144 144 + #[test] 145 145 + fn no_error_response_yields_implicit_mx() { 146 146 + let d = EmailDomain::parse("nel.pet").unwrap(); 147 147 + let err = ResolveError::from(ResolveErrorKind::NoRecordsFound { 148 148 + query: Box::new(hickory_resolver::proto::op::Query::default()), 149 149 + soa: None, 150 150 + negative_ttl: None, 151 151 + response_code: ResponseCode::NoError, 152 152 + trusted: false, 153 153 + }); 154 154 + let result = classify_lookup_error(err, &d).unwrap(); 155 155 + assert_eq!(result.len(), 1); 156 156 + assert_eq!(result[0].host.as_str(), "nel.pet"); 157 157 + } 158 158 + 159 159 + #[test] 160 160 + fn nxdomain_response_is_permanent() { 161 161 + let d = EmailDomain::parse("does-not-exist.invalid").unwrap(); 162 162 + let err = ResolveError::from(ResolveErrorKind::NoRecordsFound { 163 163 + query: Box::new(hickory_resolver::proto::op::Query::default()), 164 164 + soa: None, 165 165 + negative_ttl: None, 166 166 + response_code: ResponseCode::NXDomain, 167 167 + trusted: true, 168 168 + }); 169 169 + match classify_lookup_error(err, &d) { 170 170 + Err(SendError::DnsPermanent(_)) => {} 171 171 + other => panic!("expected DnsPermanent, got {other:?}"), 172 172 + } 173 173 + } 174 174 + 175 175 + #[test] 176 176 + fn servfail_response_is_transient() { 177 177 + let d = EmailDomain::parse("nel.pet").unwrap(); 178 178 + let err = ResolveError::from(ResolveErrorKind::NoRecordsFound { 179 179 + query: Box::new(hickory_resolver::proto::op::Query::default()), 180 180 + soa: None, 181 181 + negative_ttl: None, 182 182 + response_code: ResponseCode::ServFail, 183 183 + trusted: false, 184 184 + }); 185 185 + match classify_lookup_error(err, &d) { 186 186 + Err(SendError::DnsTransient(_)) => {} 187 187 + other => panic!("expected DnsTransient, got {other:?}"), 188 188 + } 189 189 + } 190 190 + 191 191 + #[test] 192 192 + fn timeout_is_transient() { 193 193 + let d = EmailDomain::parse("nel.pet").unwrap(); 194 194 + let err = ResolveError::from(ResolveErrorKind::Timeout); 195 195 + match classify_lookup_error(err, &d) { 196 196 + Err(SendError::DnsTransient(_)) => {} 197 197 + other => panic!("expected DnsTransient, got {other:?}"), 198 198 + } 199 199 + } 200 200 + 201 201 + #[test] 202 202 + fn message_variant_is_transient() { 203 203 + let d = EmailDomain::parse("nel.pet").unwrap(); 204 204 + let err = ResolveError::from(ResolveErrorKind::Message("transient resolver glitch")); 205 205 + match classify_lookup_error(err, &d) { 206 206 + Err(SendError::DnsTransient(_)) => {} 207 207 + other => panic!("expected DnsTransient default, got {other:?}"), 208 208 + } 209 209 + } 210 210 + 211 211 + #[test] 212 212 + fn null_mx_is_permanent() { 213 213 + let d = EmailDomain::parse("nomail.nel.pet").unwrap(); 214 214 + let result = interpret_lookup(vec![(0, hickory_resolver::Name::root())], &d); 215 215 + match result { 216 216 + Err(SendError::DnsPermanent(msg)) => { 217 217 + assert!(msg.contains("null MX"), "msg: {msg}") 218 218 + } 219 219 + other => panic!("expected DnsPermanent, got {other:?}"), 220 220 + } 221 221 + } 222 222 + 223 223 + #[test] 224 224 + fn null_mx_alongside_real_records_still_permanent() { 225 225 + let d = EmailDomain::parse("mixed.nel.pet").unwrap(); 226 226 + let real = hickory_resolver::Name::from_ascii("mx1.nel.pet.").unwrap(); 227 227 + let result = interpret_lookup(vec![(10, real), (0, hickory_resolver::Name::root())], &d); 228 228 + assert!(matches!(result, Err(SendError::DnsPermanent(_)))); 229 229 + } 230 230 + 231 231 + #[test] 232 232 + fn empty_lookup_uses_implicit_mx() { 233 233 + let d = EmailDomain::parse("nel.pet").unwrap(); 234 234 + let result = interpret_lookup(Vec::<(u16, hickory_resolver::Name)>::new(), &d).unwrap(); 235 235 + assert_eq!(result.len(), 1); 236 236 + assert_eq!(result[0].host.as_str(), "nel.pet"); 237 237 + } 238 238 + 239 239 + #[test] 240 240 + fn valid_records_pass_through_with_priority_sort() { 241 241 + let d = EmailDomain::parse("nel.pet").unwrap(); 242 242 + let mx1 = hickory_resolver::Name::from_ascii("mx1.nel.pet.").unwrap(); 243 243 + let mx2 = hickory_resolver::Name::from_ascii("mx2.nel.pet.").unwrap(); 244 244 + let result = interpret_lookup(vec![(20, mx2), (10, mx1)], &d).unwrap(); 245 245 + assert_eq!(result.len(), 2); 246 246 + assert_eq!(result[0].priority.as_u16(), 10); 247 247 + assert_eq!(result[0].host.as_str(), "mx1.nel.pet"); 248 248 + assert_eq!(result[1].priority.as_u16(), 20); 249 249 + } 250 250 + }