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
}
pub fn api_key(key: &str) -> String {
let chars: Vec<char> = key.chars().collect();
let len = chars.len();
if len <= 8 {
return "*".repeat(len);
}
let first: String = chars[..4].iter().collect();
let last: String = chars[len - 4..].iter().collect();
format!("{first}...{last}")
}
}
#[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");
}
#[test]
fn short_inputs_passthrough() {
assert_eq!(Mask::mobile("123456"), "123456"); assert_eq!(Mask::id_card("1234567"), "1234567"); assert_eq!(Mask::bank_card("6228481234567890"), "6228 **** 7890");
assert_eq!(Mask::bank_card("1234567"), "1234567");
assert_eq!(Mask::name("李"), "李");
assert_eq!(Mask::name("李小明"), "李**");
assert_eq!(Mask::email("a@mail.com"), "*@mail.com"); assert_eq!(Mask::email("no-at-sign"), "no-at-sign");
}
#[test]
fn api_key_masking() {
assert_eq!(Mask::api_key("abcdefghijklmnop"), "abcd...mnop");
assert_eq!(Mask::api_key("VeryLongAPIKey123456789"), "Very...6789");
assert_eq!(Mask::api_key("short"), "*****");
assert_eq!(Mask::api_key("abcdefgh"), "********");
assert_eq!(Mask::api_key(""), "");
assert_eq!(Mask::api_key("密钥abc"), "*****");
}
#[test]
fn mask_json_value_recursive_detection() {
let input: serde_json::Value = serde_json::from_str(
r#"{
"phone": "13812345678",
"idCard": "11010119900307123X",
"email": "bob@example.com",
"password": "secret",
"nested": {"mobile": "15000000000", "note": "正常文本"},
"list": [{"tel": "13911112222"}, "abc", 42, null],
"blank": " "
}"#,
)
.unwrap();
let out = mask_json_value(input, &["password"]);
assert_eq!(out["phone"], "138****5678");
assert_eq!(out["idCard"], "1101****123X");
assert_eq!(out["email"], "b***@example.com");
assert_eq!(out["password"], "****"); assert_eq!(out["nested"]["mobile"], "150****0000");
assert_eq!(out["nested"]["note"], "正常文本");
assert_eq!(out["list"][0]["tel"], "139****2222");
assert_eq!(out["list"][1], "abc"); assert_eq!(out["list"][2], 42); assert_eq!(out["blank"], " "); }
#[test]
fn anti_false_positive() {
let v: serde_json::Value = serde_json::from_str(r#"{"a":"1a234567890","b":"12345678901234567890"}"#).unwrap();
let out = mask_json_value(v, &[]);
assert_eq!(out["a"], "1a234567890");
assert_eq!(out["b"], "12345678901234567890");
}
}