use std::collections::BTreeMap;
use serde_json::Value;
pub const REDACTED: &str = "[REDACTED]";
const SENSITIVE_HEADER_PARTS: &[&str] = &[
"token",
"secret",
"password",
"api-key",
"apikey",
"key",
"auth",
"session",
"signature",
"credential",
];
const SENSITIVE_HEADERS: &[&str] = &[
"authorization",
"proxy-authorization",
"cookie",
"set-cookie",
];
pub const SENSITIVE_FIELDS: &[&str] = &[
"password",
"passwd",
"secret",
"token",
"authorization",
"cookie",
"api_key",
"apikey",
"api-key",
"access_key",
"private_key",
"client_secret",
"credential",
"session",
"signature",
];
pub fn is_sensitive_header(name: &str) -> bool {
let lower = name.to_ascii_lowercase();
SENSITIVE_HEADERS.contains(&lower.as_str())
|| SENSITIVE_HEADER_PARTS.iter().any(|p| lower.contains(p))
}
pub fn is_sensitive_field(name: &str) -> bool {
is_sensitive_field_with(name, &[])
}
fn is_sensitive_field_with(name: &str, extra: &[&str]) -> bool {
let lower = name.to_ascii_lowercase();
SENSITIVE_FIELDS.iter().any(|p| lower.contains(p))
|| extra
.iter()
.any(|p| lower.contains(&p.to_ascii_lowercase()))
}
pub fn redact_headers<I, K, V>(headers: I) -> BTreeMap<String, String>
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: AsRef<str>,
{
headers
.into_iter()
.map(|(k, v)| {
let name = k.as_ref().to_ascii_lowercase();
let value = if is_sensitive_header(&name) {
REDACTED.to_owned()
} else {
v.as_ref().to_owned()
};
(name, value)
})
.collect()
}
pub fn redact_url(raw: &str) -> String {
let Ok(mut url) = url::Url::parse(raw) else {
return raw.split(['?', '#']).next().unwrap_or_default().to_owned();
};
if url.password().is_some() {
let _ = url.set_password(Some(REDACTED));
}
if url.query().is_some() {
let pairs: Vec<(String, String)> = url
.query_pairs()
.map(|(k, v)| {
let value = if is_sensitive_field(&k) {
REDACTED.to_owned()
} else {
v.into_owned()
};
(k.into_owned(), value)
})
.collect();
url.query_pairs_mut().clear().extend_pairs(pairs);
}
url.to_string()
}
pub fn redact_fields(value: &Value, extra_keys: &[&str]) -> Value {
match value {
Value::Object(map) => Value::Object(
map.iter()
.map(|(k, v)| {
let v = if is_sensitive_field_with(k, extra_keys) {
Value::String(REDACTED.to_owned())
} else {
redact_fields(v, extra_keys)
};
(k.clone(), v)
})
.collect(),
),
Value::Array(items) => {
Value::Array(items.iter().map(|v| redact_fields(v, extra_keys)).collect())
}
other => other.clone(),
}
}
pub fn redact_text<S: AsRef<str>>(text: &str, known_secrets: &[S]) -> String {
let mut secrets: Vec<&str> = known_secrets
.iter()
.map(AsRef::as_ref)
.filter(|s| s.chars().count() >= 4)
.collect();
secrets.sort_by_key(|s| std::cmp::Reverse(s.len()));
let mut out = text.to_owned();
for s in secrets {
if out.contains(s) {
out = out.replace(s, REDACTED);
}
}
out
}
pub fn truncate(text: &str, max: usize) -> String {
if text.chars().count() <= max {
return text.to_owned();
}
let mut out: String = text.chars().take(max).collect();
out.push('…');
out
}