wordval-utils 1.0.3

Wordval utilities: string manipulation, date handling, masking, ID generation, validation, crypto, web helpers, collection tools, retry utilities
Documentation
//! 敏感信息脱敏工具

use serde_json::{Map, Value};

/// 判断是否为 18 位身份证号(17 位数字 + 数字或 X/x)
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('.')
}

/// 递归对 JSON 进行脱敏
///
/// 遍历 JSON 对象的所有字段,对匹配 `sensitive_fields` 的字段名、
/// 或字段值内容匹配手机号/身份证/邮箱格式的值进行脱敏。
///
/// # 参数
///
/// * `value` - 待脱敏的 JSON
/// * `sensitive_fields` - 敏感字段名列表
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;
            }
            // 手机号:11 位、1 开头、全数字(避免把含字母的 11 位串误判为手机号)
            if t.len() == 11 && t.starts_with('1') && t.bytes().all(|b| b.is_ascii_digit()) {
                return Value::String(mask_mobile(t));
            }
            // 身份证:18 位(is_id_card 内部已含格式校验)
            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()
    }
}

/// 敏感信息脱敏工具 —— 对手机号、邮箱、身份证、银行卡、人名等进行部分遮盖
///
/// # 示例
///
/// ```ignore
/// use wordval_utils::Mask;
/// assert_eq!(Mask::mobile("13812345678"), "138****5678");
/// assert_eq!(Mask::email("alice@mail.com"), "a***@mail.com");
/// ```
pub struct Mask;

impl Mask {
    /// 手机号脱敏:保留前3后4位
    pub fn mobile(phone: &str) -> String {
        mask_mobile(phone)
    }
    /// 邮箱脱敏:保留首字符和域名部分
    pub fn email(email: &str) -> String {
        mask_email(email)
    }
    /// 身份证脱敏:保留前4后4位
    pub fn id_card(id: &str) -> String {
        mask_id_card(id)
    }
    /// 银行卡脱敏:保留前4后4位,中间用 ` **** ` 分隔
    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");
    }
}