use std::collections::HashMap;
use serde_json::Value;
const REDACTED: &str = "[REDACTED]";
const MAX_DEPTH: usize = 10;
const DEFAULT_SENSITIVE_KEYS: &[&str] = &[
"password",
"passwd",
"pwd",
"secret",
"token",
"api_key",
"apikey",
"access_token",
"auth",
"credentials",
"mysql_pwd",
"private_key",
"privatekey",
"session",
"cookie",
"csrf",
"xsrf",
"authorization",
"bearer",
"jwt",
"ssn",
"social_security",
"credit_card",
"card_number",
"cvv",
"pin",
];
pub struct Sanitizer {
patterns: Vec<String>,
}
impl Sanitizer {
pub fn new(custom_sensitive_keys: &[String]) -> Self {
let mut patterns: Vec<String> = DEFAULT_SENSITIVE_KEYS
.iter()
.map(|s| s.to_lowercase())
.collect();
patterns.extend(custom_sensitive_keys.iter().map(|s| s.to_lowercase()));
Self { patterns }
}
fn is_sensitive_key(&self, key: &str) -> bool {
let lower = key.to_lowercase();
self.patterns.iter().any(|p| lower.contains(p.as_str()))
}
pub fn sanitize_value(&self, value: &Value) -> Value {
self.sanitize_value_at_depth(value, MAX_DEPTH)
}
fn sanitize_value_at_depth(&self, value: &Value, depth: usize) -> Value {
if depth == 0 {
return Value::String("[Max Depth Reached]".to_string());
}
match value {
Value::Object(map) => {
let mut sanitized = serde_json::Map::with_capacity(map.len());
for (key, val) in map {
if self.is_sensitive_key(key) {
sanitized.insert(key.clone(), Value::String(REDACTED.to_string()));
} else {
sanitized.insert(key.clone(), self.sanitize_value_at_depth(val, depth - 1));
}
}
Value::Object(sanitized)
}
Value::Array(items) => Value::Array(
items
.iter()
.map(|item| self.sanitize_value_at_depth(item, depth - 1))
.collect(),
),
other => other.clone(),
}
}
pub fn sanitize_string_map(&self, map: &HashMap<String, String>) -> HashMap<String, String> {
map.iter()
.map(|(key, value)| {
let lower = key.to_lowercase();
let sanitized = if lower == "authorization"
|| lower == "cookie"
|| self.is_sensitive_key(key)
{
REDACTED.to_string()
} else {
value.clone()
};
(key.clone(), sanitized)
})
.collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn redacts_default_sensitive_keys() {
let sanitizer = Sanitizer::new(&[]);
let value = json!({ "username": "dave", "password": "hunter2" });
let sanitized = sanitizer.sanitize_value(&value);
assert_eq!(sanitized["username"], "dave");
assert_eq!(sanitized["password"], "[REDACTED]");
}
#[test]
fn matches_keys_containing_a_sensitive_pattern() {
let sanitizer = Sanitizer::new(&[]);
let value = json!({ "user_password_hash": "abc" });
let sanitized = sanitizer.sanitize_value(&value);
assert_eq!(sanitized["user_password_hash"], "[REDACTED]");
}
#[test]
fn redacts_custom_sensitive_keys() {
let sanitizer = Sanitizer::new(&["internal_id".to_string()]);
let value = json!({ "internal_id": "123", "public_id": "456" });
let sanitized = sanitizer.sanitize_value(&value);
assert_eq!(sanitized["internal_id"], "[REDACTED]");
assert_eq!(sanitized["public_id"], "456");
}
#[test]
fn redacts_nested_objects_and_arrays() {
let sanitizer = Sanitizer::new(&[]);
let value = json!({ "items": [{ "token": "abc" }] });
let sanitized = sanitizer.sanitize_value(&value);
assert_eq!(sanitized["items"][0]["token"], "[REDACTED]");
}
#[test]
fn always_redacts_authorization_and_cookie_headers() {
let sanitizer = Sanitizer::new(&[]);
let mut headers = HashMap::new();
headers.insert("Authorization".to_string(), "Bearer abc".to_string());
headers.insert("Cookie".to_string(), "session=abc".to_string());
headers.insert("Accept".to_string(), "application/json".to_string());
let sanitized = sanitizer.sanitize_string_map(&headers);
assert_eq!(sanitized["Authorization"], "[REDACTED]");
assert_eq!(sanitized["Cookie"], "[REDACTED]");
assert_eq!(sanitized["Accept"], "application/json");
}
}