use std::fmt;
pub(crate) enum Redacted {
Absent,
Present,
}
impl fmt::Debug for Redacted {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Redacted::Absent => f.write_str("None"),
Redacted::Present => f.write_str("<redacted>"),
}
}
}
pub(crate) trait Secret {
fn redacted(&self) -> Redacted;
}
impl Secret for String {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl Secret for Vec<String> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl Secret for Vec<u8> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<T> Secret for Option<T> {
fn redacted(&self) -> Redacted {
if self.is_some() {
Redacted::Present
} else {
Redacted::Absent
}
}
}
impl Secret for serde_json::Value {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<K, V, S> Secret for std::collections::HashMap<K, V, S> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<K, V> Secret for std::collections::BTreeMap<K, V> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<T, S> Secret for std::collections::HashSet<T, S> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<K: Eq + std::hash::Hash, V> Secret for dashmap::DashMap<K, V> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<T: ?Sized> Secret for std::sync::Arc<T> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<T: ?Sized> Secret for tokio::sync::RwLock<T> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<T: ?Sized> Secret for tokio::sync::Mutex<T> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<T: ?Sized> Secret for std::sync::Mutex<T> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
impl<T: ?Sized> Secret for std::sync::RwLock<T> {
fn redacted(&self) -> Redacted {
Redacted::Present
}
}
pub(crate) fn redacted<T: Secret>(value: &T) -> Redacted {
value.redacted()
}
pub(crate) struct Fingerprint(String);
impl fmt::Display for Fingerprint {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.0)
}
}
impl fmt::Debug for Fingerprint {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.0)
}
}
pub(crate) fn fingerprint(value: &str) -> Fingerprint {
use sha2::{Digest, Sha256};
let digest = Sha256::digest(value.as_bytes());
let mut out = String::from("sha256:");
for byte in &digest[..4] {
out.push_str(&format!("{byte:02x}"));
}
Fingerprint(out)
}
pub(crate) fn url_origin(url: &str) -> String {
let Some((scheme, rest)) = url.split_once("://") else {
return "<invalid url>".to_string();
};
let authority = rest.split(['/', '?', '#']).next().unwrap_or("");
let host = authority.rsplit('@').next().unwrap_or("");
let scheme_ok = !scheme.is_empty()
&& scheme
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'));
if !scheme_ok || host.is_empty() {
return "<invalid url>".to_string();
}
format!("{scheme}://{host}")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn url_origin_keeps_only_scheme_and_host() {
assert_eq!(
url_origin("https://hooks.slack.com/services/T000/B000/SECRET-MARKER"),
"https://hooks.slack.com"
);
assert_eq!(
url_origin("https://user:SECRET-MARKER@example.com:8443/p?license_key=SECRET-MARKER#f"),
"https://example.com:8443"
);
assert_eq!(
url_origin("https://example.com?key=SECRET-MARKER"),
"https://example.com"
);
}
#[test]
fn url_origin_does_not_echo_text_that_is_not_a_url() {
assert_eq!(url_origin("SECRET-MARKER"), "<invalid url>");
assert_eq!(url_origin("https:///SECRET-MARKER"), "<invalid url>");
assert_eq!(url_origin("://example.com"), "<invalid url>");
}
#[test]
fn fingerprint_is_a_prefix_of_the_sha256_digest() {
assert_eq!(fingerprint("abc").to_string(), "sha256:ba7816bf");
assert_eq!(format!("{:?}", fingerprint("abc")), "sha256:ba7816bf");
}
#[test]
fn fingerprint_does_not_contain_the_value() {
let secret = "SECRET-MARKER-7f3a9c";
assert!(!fingerprint(secret).to_string().contains(secret));
assert_ne!(
fingerprint(secret).to_string(),
fingerprint("other").to_string()
);
}
}