pub fn sanitize_ip(text: &str) -> String {
let mut result = String::with_capacity(text.len());
let mut chars = text.char_indices().peekable();
let mut last_end = 0;
while let Some(&(i, c)) = chars.peek() {
if c.is_ascii_digit() {
let start = i;
let mut octet_count = 0;
let mut curr_end = start;
while let Some(&(idx, ch)) = chars.peek() {
if ch.is_ascii_digit() {
curr_end = idx + 1;
chars.next();
} else if ch == '.' {
octet_count += 1;
curr_end = idx + 1;
chars.next();
} else if ch == ':' && octet_count == 3 {
chars.next();
while let Some(&(p_idx, p_ch)) = chars.peek() {
if p_ch.is_ascii_digit() {
curr_end = p_idx + 1;
chars.next();
} else {
break;
}
}
break;
} else {
break;
}
}
let candidate = &text[start..curr_end];
let host_part = candidate.split(':').next().unwrap_or("");
let octets: Vec<&str> = host_part.split('.').collect();
if octets.len() == 4
&& octets
.iter()
.all(|o| !o.is_empty() && o.len() <= 3 && o.parse::<u8>().is_ok())
{
result.push_str(&text[last_end..start]);
result.push_str("[REDACTED_IP]");
last_end = curr_end;
}
} else {
chars.next();
}
}
result.push_str(&text[last_end..]);
result
}
fn sanitize_connection_strings(text: &str) -> String {
let prefixes = [
"postgres://",
"postgresql://",
"mysql://",
"redis://",
"nats://",
"mongodb://",
];
let mut result = text.to_string();
for prefix in prefixes {
while let Some(start) = result.find(prefix) {
let rest = &result[start..];
let end = rest
.find(|c: char| c.is_whitespace() || c == '"' || c == '\'' || c == ')' || c == ']')
.map(|idx| start + idx)
.unwrap_or(result.len());
result.replace_range(start..end, "[REDACTED_CONNECTION_STRING]");
}
}
result
}
pub fn sanitize_url(raw: &str) -> String {
let raw_clean = sanitize_ip(raw);
match url::Url::parse(&raw_clean) {
Ok(mut parsed) => {
let has_password = parsed.password().is_some();
let has_username = !parsed.username().is_empty();
if has_password || has_username {
let _ = parsed.set_username("[REDACTED]");
let _ = parsed.set_password(Some("[REDACTED]"));
}
let sensitive_keys: &[&str] = &[
"api-key", "api_key", "apikey", "key", "token", "secret",
"password", "pass", "auth", "authorization",
];
let original_pairs: Vec<(String, String)> = parsed
.query_pairs()
.map(|(k, v)| (k.into_owned(), v.into_owned()))
.collect();
let needs_redaction = original_pairs
.iter()
.any(|(k, _)| sensitive_keys.contains(&k.to_lowercase().as_str()));
if needs_redaction {
let redacted: Vec<(String, String)> = original_pairs
.into_iter()
.map(|(k, v)| {
if sensitive_keys.contains(&k.to_lowercase().as_str()) {
(k, "[REDACTED]".to_string())
} else {
(k, v)
}
})
.collect();
parsed.set_query(None);
{
let mut pairs = parsed.query_pairs_mut();
for (k, v) in &redacted {
pairs.append_pair(k, v);
}
}
}
parsed.to_string()
}
Err(_) => raw_clean,
}
}
pub fn sanitize_text(text: &str) -> String {
let clean_conn = sanitize_connection_strings(text);
let clean_ip = sanitize_ip(&clean_conn);
sanitize_url(&clean_ip)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_no_sensitive_params_unchanged() {
let url = "https://api.example.com/v1/health";
assert_eq!(sanitize_url(url), url);
}
#[test]
fn test_api_key_param_redacted() {
let url = "https://devnet.helius-rpc.com/?api-key=super_secret_key";
let sanitized = sanitize_url(url);
let redacted = sanitized.contains("[REDACTED]")
|| sanitized.contains("%5BREDACTED%5D")
|| sanitized.contains("REDACTED");
assert!(redacted, "sanitized URL must contain REDACTED: {}", sanitized);
assert!(!sanitized.contains("super_secret_key"));
}
#[test]
fn test_multiple_params_only_sensitive_redacted() {
let url = "https://api.example.com/v1/strategy?objective=fastest&token=abc123&other=visible";
let sanitized = sanitize_url(url);
assert!(sanitized.contains("objective=fastest"));
assert!(sanitized.contains("other=visible"));
assert!(sanitized.contains("token=%5BREDACTED%5D") || sanitized.contains("token=[REDACTED]"));
assert!(!sanitized.contains("abc123"));
}
#[test]
fn test_userinfo_redacted() {
let url = "https://user:password@api.example.com/v1/health";
let sanitized = sanitize_url(url);
assert!(!sanitized.contains("password"));
}
#[test]
fn test_ip_address_redacted() {
let text = "failed to connect to http://132.226.188.165:3000/v1/health on 10.0.0.161";
let sanitized = sanitize_text(text);
assert!(!sanitized.contains("132.226.188.165"));
assert!(!sanitized.contains("10.0.0.161"));
assert!(sanitized.contains("[REDACTED_IP]"));
}
#[test]
fn test_db_connection_string_redacted() {
let text = "error: failed to connect to postgresql://user:secret123@ep-cool-db.neon.tech/neondb?sslmode=require";
let sanitized = sanitize_text(text);
assert!(!sanitized.contains("secret123"));
assert!(!sanitized.contains("neon.tech"));
assert!(sanitized.contains("[REDACTED_CONNECTION_STRING]"));
}
#[test]
fn test_ip_address_edge_cases() {
let text_invalid = "value is 999.999.999.999 in logs";
assert_eq!(sanitize_ip(text_invalid), text_invalid);
let version_str = "running solana-validator v2.1.0-beta.1 on cluster";
assert_eq!(sanitize_ip(version_str), version_str);
let ip_port = "validator at 198.13.130.39:8003 active";
assert_eq!(sanitize_ip(ip_port), "validator at [REDACTED_IP] active");
}
}