use serde_json::{Map, Value};
fn is_id_card(s: &str) -> bool {
if s.len() != 18 {
return false;
}
let bytes = s.as_bytes();
bytes[..17].iter().all(|b| b.is_ascii_digit())
&& (bytes[17].is_ascii_digit() || matches!(bytes[17], b'X' | b'x'))
}
fn is_email_like(s: &str) -> bool {
let Some(at) = s.rfind('@') else {
return false;
};
if at == 0 {
return false;
}
let part_ok = |p: &str| {
!p.is_empty()
&& p.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | '-'))
};
part_ok(&s[..at]) && part_ok(&s[at + 1..]) && s[at + 1..].contains('.')
}
pub fn mask_json_value(value: Value, sensitive_fields: &[&str]) -> Value {
match value {
Value::Object(map) => mask_object(map, sensitive_fields),
Value::Array(arr) => Value::Array(
arr.into_iter()
.map(|v| mask_json_value(v, sensitive_fields))
.collect(),
),
other => mask_scalar_if_needed(other),
}
}
fn mask_object(map: Map<String, Value>, sensitive_fields: &[&str]) -> Value {
let mut masked = Map::new();
for (key, val) in map {
let is_sensitive = sensitive_fields
.iter()
.any(|f| f.eq_ignore_ascii_case(&key));
if is_sensitive {
masked.insert(key, Value::String("****".into()));
} else {
masked.insert(key, mask_json_value(val, sensitive_fields));
}
}
Value::Object(masked)
}
fn mask_scalar_if_needed(val: Value) -> Value {
match &val {
Value::String(s) => {
let t = s.trim();
if t.is_empty() {
return val;
}
if t.len() == 11 && t.starts_with('1') && t.bytes().all(|b| b.is_ascii_digit()) {
return Value::String(mask_mobile(t));
}
if t.len() == 18 && is_id_card(t) {
return Value::String(mask_id_card(t));
}
if is_email_like(t) {
return Value::String(mask_email(t));
}
val
}
_ => val,
}
}
fn mask_mobile(s: &str) -> String {
let chars: Vec<char> = s.chars().collect();
if chars.len() < 7 {
return s.to_string();
}
let head: String = chars[..3].iter().collect();
let tail: String = chars[chars.len() - 4..].iter().collect();
format!("{}****{}", head, tail)
}
fn mask_id_card(s: &str) -> String {
let chars: Vec<char> = s.chars().collect();
if chars.len() < 8 {
return s.to_string();
}
let head: String = chars[..4].iter().collect();
let tail: String = chars[chars.len() - 4..].iter().collect();
format!("{}****{}", head, tail)
}
fn mask_email(s: &str) -> String {
if let Some(at) = s.find('@') {
let prefix_chars: Vec<char> = s[..at].chars().collect();
let suffix = &s[at..];
if prefix_chars.len() <= 2 {
format!("*{}", suffix)
} else {
let head: String = prefix_chars[..1].iter().collect();
format!("{}***{}", head, suffix)
}
} else {
s.to_string()
}
}
pub struct Mask;
impl Mask {
pub fn mobile(phone: &str) -> String {
mask_mobile(phone)
}
pub fn email(email: &str) -> String {
mask_email(email)
}
pub fn id_card(id: &str) -> String {
mask_id_card(id)
}
pub fn bank_card(card: &str) -> String {
let chars: Vec<char> = card.chars().collect();
if chars.len() < 8 {
return card.to_string();
}
let head: String = chars[..4].iter().collect();
let tail: String = chars[chars.len() - 4..].iter().collect();
format!("{} **** {}", head, tail)
}
pub fn name(name: &str) -> String {
let chars: Vec<char> = name.chars().collect();
if chars.len() <= 1 {
return name.to_string();
}
let mut result = String::new();
result.push(chars[0]);
for _ in 1..chars.len() {
result.push('*');
}
result
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_mobile() {
assert_eq!(Mask::mobile("13812345678"), "138****5678");
}
#[test]
fn test_email() {
assert_eq!(Mask::email("alice@mail.com"), "a***@mail.com");
}
}