use std::sync::OnceLock; use regex::{Captures, Regex}; pub const REDACTED: &str = "[REDACTED]"; #[derive(Clone, Debug, Default)] pub struct Redactor { known_secrets: Vec, } impl Redactor { pub fn new(known_secrets: I) -> Self where I: IntoIterator, S: AsRef, { let mut secrets = known_secrets .into_iter() .map(|value| value.as_ref().to_owned()) .filter(|value| value.chars().count() >= 4) .collect::>(); secrets.sort_by_key(|value| std::cmp::Reverse(value.len())); secrets.dedup(); Self { known_secrets: secrets, } } pub fn redact(&self, input: &str) -> String { let mut output = input.to_owned(); for secret in &self.known_secrets { output = output.replace(secret, REDACTED); } output = pem_private_key_regex() .replace_all(&output, REDACTED) .into_owned(); output = url_credentials_regex() .replace_all(&output, "${scheme}[REDACTED]@") .into_owned(); output = bearer_regex() .replace_all(&output, "${prefix}[REDACTED]") .into_owned(); key_value_regex() .replace_all(&output, |captures: &Captures<'_>| { format!("{}{}", &captures["prefix"], REDACTED) }) .into_owned() } pub fn redact_value_for_key(&self, key: &str, value: &str) -> String { if is_sensitive_key(key) { REDACTED.to_owned() } else { self.redact(value) } } } pub fn is_sensitive_key(key: &str) -> bool { let normalized = key .chars() .filter(|character| character.is_ascii_alphanumeric()) .flat_map(char::to_lowercase) .collect::(); const SENSITIVE_SUFFIXES: &[&str] = &[ "token", "accesstoken", "refreshtoken", "apikey", "secret", "clientsecret", "password", "passwd", "privatekey", "cookie", "authorization", ]; SENSITIVE_SUFFIXES .iter() .any(|suffix| normalized == *suffix || normalized.ends_with(suffix)) } fn key_value_regex() -> &'static Regex { static INSTANCE: OnceLock = OnceLock::new(); INSTANCE.get_or_init(|| { Regex::new( r#"(?im)(?P[\"']?(?:access[_-]?token|refresh[_-]?token|api[_-]?key|client[_-]?secret|private[_-]?key|password|passwd|secret|cookie|authorization)[\"']?\s*[:=]\s*)(?:\"[^\"\r\n]*\"|'[^'\r\n]*'|[^\s,;#\r\n]+)"#, ) .expect("the sensitive key regex is valid") }) } fn bearer_regex() -> &'static Regex { static INSTANCE: OnceLock = OnceLock::new(); INSTANCE.get_or_init(|| { Regex::new(r"(?i)\b(?Pbearer\s+)[A-Za-z0-9._~+/=-]{8,}") .expect("the bearer regex is valid") }) } fn url_credentials_regex() -> &'static Regex { static INSTANCE: OnceLock = OnceLock::new(); INSTANCE.get_or_init(|| { Regex::new(r"(?i)\b(?P[a-z][a-z0-9+.-]*://)[^/@\s:]+:[^/@\s]+@") .expect("the URL credential regex is valid") }) } fn pem_private_key_regex() -> &'static Regex { static INSTANCE: OnceLock = OnceLock::new(); INSTANCE.get_or_init(|| { Regex::new( r"(?is)-----BEGIN(?: [A-Z0-9]+)* PRIVATE KEY-----.*?-----END(?: [A-Z0-9]+)* PRIVATE KEY-----", ) .expect("the PEM private key regex is valid") }) } #[cfg(test)] mod tests { use super::*; #[test] fn redacts_known_and_pattern_based_secrets() { let canary = format!("canary-{}", uuid::Uuid::new_v4()); let input = format!( "token={canary}\nAuthorization: Bearer abcdefghijklmnop\nurl=https://alice:password@example.test/path\npassword = hunter2" ); let redacted = Redactor::new([&canary]).redact(&input); assert!(!redacted.contains(&canary)); assert!(!redacted.contains("abcdefghijklmnop")); assert!(!redacted.contains("alice:password")); assert!(!redacted.contains("hunter2")); assert!(redacted.contains(REDACTED)); } #[test] fn recognizes_normalized_sensitive_keys() { assert!(is_sensitive_key("database_password")); assert!(is_sensitive_key("api-key")); assert!(is_sensitive_key("Refresh.Token")); assert!(!is_sensitive_key("token_count")); assert!(!is_sensitive_key("username")); } }