use serde_json::Value;
use std::collections::HashMap;
use std::sync::{Mutex, OnceLock};
const REGEX_CACHE_CAP: usize = 256;
fn regex_cache() -> &'static Mutex<HashMap<String, regex::Regex>> {
static CACHE: OnceLock<Mutex<HashMap<String, regex::Regex>>> = OnceLock::new();
CACHE.get_or_init(|| Mutex::new(HashMap::new()))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MaskType {
Phone,
IdCard,
Email,
BankCard,
Custom(String),
}
#[derive(Debug, Clone, Default)]
pub struct SensitiveDataMasker {
index: HashMap<&'static str, MaskType>,
}
impl SensitiveDataMasker {
pub fn new() -> Self {
Self::default()
}
pub fn with_rule(mut self, mask_type: MaskType, field_name: &'static str) -> Self {
self.index.entry(field_name).or_insert(mask_type);
self
}
pub fn mask_value(&self, value: &str, mask_type: &MaskType) -> String {
match mask_type {
MaskType::Phone => mask_phone(value),
MaskType::IdCard => mask_id_card(value),
MaskType::Email => mask_email(value),
MaskType::BankCard => mask_bank_card(value),
MaskType::Custom(regex_str) => mask_custom(value, regex_str),
}
}
pub fn mask_field(&self, field: &str, value: &str) -> String {
match self.index.get(field) {
Some(mask_type) => self.mask_value(value, mask_type),
None => value.to_string(),
}
}
pub fn mask_json(&self, value: &Value) -> Value {
match value {
Value::Object(map) => {
let mut new_map = serde_json::Map::new();
for (key, val) in map {
let recursed = self.mask_json(val);
let final_val = if let Some(mask_type) = self.index.get(key.as_str()) {
match &recursed {
Value::String(s) => Value::String(self.mask_value(s, mask_type)),
_ => recursed,
}
} else {
recursed
};
new_map.insert(key.clone(), final_val);
}
Value::Object(new_map)
},
Value::Array(arr) => Value::Array(arr.iter().map(|v| self.mask_json(v)).collect()),
_ => value.clone(),
}
}
}
fn mask_phone(value: &str) -> String {
let chars: Vec<char> = value.chars().collect();
if chars.len() < 7 {
return value.to_string();
}
let prefix: String = chars[..3].iter().collect();
let suffix: String = chars[chars.len() - 4..].iter().collect();
let stars = "*".repeat(chars.len() - 7);
format!("{prefix}{stars}{suffix}")
}
fn mask_id_card(value: &str) -> String {
let chars: Vec<char> = value.chars().collect();
if chars.len() < 7 {
return value.to_string();
}
let prefix: String = chars[..3].iter().collect();
let suffix: String = chars[chars.len() - 4..].iter().collect();
let stars = "*".repeat(chars.len() - 7);
format!("{prefix}{stars}{suffix}")
}
fn mask_email(value: &str) -> String {
match value.find('@') {
Some(at_pos) if at_pos > 0 => {
let first = value
.chars()
.next()
.expect("at_pos > 0 guarantees non-empty local part");
let domain = &value[at_pos..];
format!("{first}***{domain}")
},
_ => value.to_string(),
}
}
fn mask_bank_card(value: &str) -> String {
const BANK_CARD_PREFIX_LEN: usize = 6;
const BANK_CARD_SUFFIX_LEN: usize = 4;
const BANK_CARD_MIN_LEN: usize = BANK_CARD_PREFIX_LEN + BANK_CARD_SUFFIX_LEN;
let chars: Vec<char> = value.chars().collect();
if chars.len() < BANK_CARD_MIN_LEN {
return "*".repeat(chars.len());
}
let prefix: String = chars[..BANK_CARD_PREFIX_LEN].iter().collect();
let suffix: String = chars[chars.len() - BANK_CARD_SUFFIX_LEN..].iter().collect();
let stars = "*".repeat(chars.len() - BANK_CARD_MIN_LEN);
format!("{prefix}{stars}{suffix}")
}
fn mask_custom(value: &str, regex_str: &str) -> String {
let compiled: Option<regex::Regex> = {
let mut cache = match regex_cache().lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
if let Some(re) = cache.get(regex_str) {
Some(re.clone())
} else {
match regex::Regex::new(regex_str) {
Ok(re) => {
if cache.len() < REGEX_CACHE_CAP {
cache.insert(regex_str.to_string(), re.clone());
}
Some(re)
},
Err(e) => {
tracing::error!(
error = %e,
pattern = regex_str,
"Custom mask regex compilation failed; returning '***' as safe fallback"
);
None
},
}
}
};
match compiled {
Some(re) => re.replace_all(value, "***").to_string(),
None => "***".to_string(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn mask_phone_returns_138_1234() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("13812341234", &MaskType::Phone);
assert_eq!(result, "138****1234");
}
#[test]
fn mask_id_card_returns_masked() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("110101199001011234", &MaskType::IdCard);
assert_eq!(result, "110***********1234");
}
#[test]
fn mask_email_returns_masked() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("alice@example.com", &MaskType::Email);
assert_eq!(result, "a***@example.com");
}
#[test]
fn mask_bank_card_returns_masked() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("6222021234567890", &MaskType::BankCard);
assert_eq!(result, "622202******7890");
}
#[test]
fn mask_custom_redacts_matching_digits() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("123-45-6789", &MaskType::Custom(r"\d+".to_string()));
assert_eq!(result, "***-***-***");
}
#[test]
fn mask_custom_no_match_returns_original() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("no-digits-here", &MaskType::Custom(r"\d+".to_string()));
assert_eq!(result, "no-digits-here");
}
#[test]
fn mask_custom_invalid_regex_returns_safe_fallback() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("sensitive-secret", &MaskType::Custom(r"[".to_string()));
assert_eq!(result, "***");
}
#[test]
fn mask_custom_redacts_ip_pattern() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value(
"client_ip=192.168.1.1;",
&MaskType::Custom(r"\d+\.\d+\.\d+\.\d+".to_string()),
);
assert_eq!(result, "client_ip=***;");
}
#[test]
fn mask_phone_short_returns_original() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("123456", &MaskType::Phone);
assert_eq!(result, "123456");
}
#[test]
fn mask_id_card_short_returns_original() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("123456", &MaskType::IdCard);
assert_eq!(result, "123456");
}
#[test]
fn mask_email_no_at_returns_original() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("noemail", &MaskType::Email);
assert_eq!(result, "noemail");
}
#[test]
fn mask_email_at_start_returns_original() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("@example.com", &MaskType::Email);
assert_eq!(result, "@example.com");
}
#[test]
fn mask_bank_card_short_returns_all_stars() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("1234567", &MaskType::BankCard);
assert_eq!(result, "*******");
}
#[test]
fn mask_bank_card_pci_dss_first6_last4() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("6225881234567890", &MaskType::BankCard);
assert_eq!(result, "622588******7890");
}
#[test]
fn mask_bank_card_pci_dss_boundary_10_chars() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("6225887890", &MaskType::BankCard);
assert_eq!(result, "6225887890");
}
#[test]
fn mask_bank_card_pci_dss_short_9_chars_all_stars() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("622588789", &MaskType::BankCard);
assert_eq!(result, "*********");
}
#[test]
fn mask_bank_card_pci_dss_empty_string() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("", &MaskType::BankCard);
assert_eq!(result, "");
}
#[test]
fn mask_phone_handles_multibyte_input() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("ab中cdefg", &MaskType::Phone);
assert!(!result.is_empty(), "多字节输入不应 panic 且应返回非空结果");
}
#[test]
fn mask_id_card_handles_multibyte_input() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("ab中cdefg", &MaskType::IdCard);
assert!(!result.is_empty(), "多字节输入不应 panic 且应返回非空结果");
}
#[test]
fn mask_bank_card_handles_multibyte_input() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("ab中cdefg", &MaskType::BankCard);
assert!(!result.is_empty(), "多字节输入不应 panic 且应返回非空结果");
}
#[test]
fn mask_field_matches_phone_rule() {
let masker = SensitiveDataMasker::new().with_rule(MaskType::Phone, "phone");
let result = masker.mask_field("phone", "13812341234");
assert_eq!(result, "138****1234");
}
#[test]
fn mask_field_no_match_returns_original() {
let masker = SensitiveDataMasker::new().with_rule(MaskType::Phone, "phone");
let result = masker.mask_field("email", "alice@example.com");
assert_eq!(result, "alice@example.com");
}
#[test]
fn mask_field_matches_first_rule() {
let masker = SensitiveDataMasker::new()
.with_rule(MaskType::Phone, "contact")
.with_rule(MaskType::Email, "contact");
let result = masker.mask_field("contact", "13812341234");
assert_eq!(result, "138****1234");
}
#[test]
fn mask_field_empty_rules_returns_original() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_field("phone", "13812341234");
assert_eq!(result, "13812341234");
}
#[test]
fn mask_json_masks_phone_field() {
let masker = SensitiveDataMasker::new().with_rule(MaskType::Phone, "phone");
let input = json!({"phone": "13812341234"});
let masked = masker.mask_json(&input);
assert_eq!(masked, json!({"phone": "138****1234"}));
}
#[test]
fn mask_json_masks_nested_object() {
let masker = SensitiveDataMasker::new().with_rule(MaskType::Phone, "phone");
let input = json!({"user": {"phone": "13812341234"}});
let masked = masker.mask_json(&input);
assert_eq!(masked, json!({"user": {"phone": "138****1234"}}));
}
#[test]
fn mask_json_masks_array_of_objects() {
let masker = SensitiveDataMasker::new().with_rule(MaskType::Phone, "phone");
let input = json!([{"phone": "13812341234"}, {"phone": "13912341234"}]);
let masked = masker.mask_json(&input);
assert_eq!(
masked,
json!([{"phone": "138****1234"}, {"phone": "139****1234"}])
);
}
#[test]
fn mask_json_non_object_returns_original() {
let masker = SensitiveDataMasker::new();
let input = json!("just a string");
let masked = masker.mask_json(&input);
assert_eq!(masked, input);
}
#[test]
fn mask_json_no_matching_field_returns_original() {
let masker = SensitiveDataMasker::new().with_rule(MaskType::Phone, "phone");
let input = json!({"name": "Alice"});
let masked = masker.mask_json(&input);
assert_eq!(masked, json!({"name": "Alice"}));
}
#[test]
fn mask_json_masks_multiple_fields() {
let masker = SensitiveDataMasker::new()
.with_rule(MaskType::Phone, "phone")
.with_rule(MaskType::Email, "email");
let input = json!({
"name": "Alice",
"phone": "13812341234",
"email": "alice@example.com"
});
let masked = masker.mask_json(&input);
assert_eq!(
masked,
json!({
"name": "Alice",
"phone": "138****1234",
"email": "a***@example.com"
})
);
}
#[test]
fn mask_custom_regex_replaces_digits_with_star() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("123-45-6789", &MaskType::Custom(r"\d".to_string()));
assert_eq!(result, "*********-******-************");
}
#[test]
fn mask_custom_regex_replaces_email_local_part() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value(
"alice@example.com",
&MaskType::Custom(r"^[^@]+".to_string()),
);
assert_eq!(result, "***@example.com");
}
#[test]
fn mask_custom_regex_no_match_returns_original() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("no-digits-here", &MaskType::Custom(r"\d".to_string()));
assert_eq!(result, "no-digits-here");
}
#[test]
fn mask_custom_regex_empty_input_returns_empty() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("", &MaskType::Custom(r"\d".to_string()));
assert_eq!(result, "");
}
#[test]
fn mask_custom_regex_empty_pattern_returns_original() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("anything", &MaskType::Custom("".to_string()));
assert_eq!(result, "***a***n***y***t***h***i***n***g***");
}
#[test]
fn mask_custom_regex_invalid_pattern_returns_safe_fallback() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("test", &MaskType::Custom(r"[".to_string()));
assert_eq!(result, "***");
}
#[test]
fn mask_custom_regex_replaces_all_matches() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("a1b2c3d4", &MaskType::Custom(r"\d".to_string()));
assert_eq!(result, "a***b***c***d***");
}
#[test]
fn mask_custom_regex_bank_card_partial_mask() {
let masker = SensitiveDataMasker::new();
let result = masker.mask_value("6222021234567890", &MaskType::Custom(r"\d".to_string()));
assert_eq!(result, "*".repeat(48));
}
#[test]
fn mask_field_custom_regex_error_returns_safe_fallback() {
let masker = SensitiveDataMasker::new().with_rule(MaskType::Custom("[".to_string()), "ssn");
let result = masker.mask_field("ssn", "123-45-6789");
assert_eq!(result, "***");
}
#[test]
fn mask_field_custom_regex_valid_masks_correctly() {
let masker =
SensitiveDataMasker::new().with_rule(MaskType::Custom(r"\d".to_string()), "ssn");
let result = masker.mask_field("ssn", "123-45-6789");
assert_eq!(result, "*********-******-************");
}
}