//! Secret handling and redaction. //! //! `SecretString` never reveals its contents through `Debug`/`Display` and //! zeroizes on drop. The `Redactor` is a process-wide (per-context) registry of //! secret values that must not appear in logs. The command runner and logger //! route every message through it, so callers cannot forget to redact. use std::fmt; use std::sync::{Arc, Mutex}; use zeroize::{Zeroize, ZeroizeOnDrop}; /// A string that is redacted in formatting and zeroized on drop. #[derive(Clone, Zeroize, ZeroizeOnDrop)] pub struct SecretString(String); impl SecretString { pub fn new(value: impl Into) -> Self { Self(value.into()) } /// Read the secret. Use only where the plaintext is genuinely required /// (feeding a passphrase to cryptsetup over stdin, hashing a password). pub fn expose(&self) -> &str { &self.0 } pub fn is_empty(&self) -> bool { self.0.is_empty() } pub fn into_inner(mut self) -> String { let out = self.0.clone(); self.0.zeroize(); out } } impl fmt::Debug for SecretString { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("") } } impl fmt::Display for SecretString { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("") } } /// Registry of secret plaintexts that must be scrubbed from logs. #[derive(Clone, Default)] pub struct Redactor { inner: Arc>>, } impl Redactor { pub fn new() -> Self { Self::default() } /// Remember a secret so it is scrubbed from every future log line. pub fn register(&self, secret: &SecretString) { if secret.is_empty() { return; } if let Ok(mut values) = self.inner.lock() { // Avoid storing duplicates. if !values.iter().any(|v| v.expose() == secret.expose()) { values.push(secret.clone()); } } } pub fn register_plain(&self, secret: &str) { self.register(&SecretString::new(secret)); } /// Replace every registered secret in `text` with ``. pub fn redact(&self, text: &str) -> String { let Ok(values) = self.inner.lock() else { return text.to_string(); }; let mut out = text.to_string(); for secret in values.iter() { let plain = secret.expose(); if !plain.is_empty() { out = out.replace(plain, ""); } } out } } #[cfg(test)] mod tests { use super::*; #[test] fn debug_and_display_are_redacted() { let s = SecretString::new("hunter2"); assert_eq!(format!("{s:?}"), ""); assert_eq!(format!("{s}"), ""); assert_eq!(s.expose(), "hunter2"); } #[test] fn redactor_scrubs_registered_values() { let r = Redactor::new(); r.register_plain("hunter2"); assert_eq!(r.redact("pw=hunter2 end"), "pw= end"); assert_eq!(r.redact("nothing"), "nothing"); } #[test] fn redactor_handles_multiple_and_dedup() { let r = Redactor::new(); r.register_plain("a1"); r.register_plain("a1"); r.register_plain("bb"); assert_eq!(r.redact("a1 and bb"), " and "); } }