dd-sensitive-data-scanner 0.0.0

Core Sensitive Data Scanner library for detecting and redacting sensitive information.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use iso_iec_7064::{
    MOD_11_2, MOD_11_10, MOD_27_26, MOD_37_2, MOD_37_36, MOD_97_10, MOD_661_26, MOD_1271_36, System,
};

use crate::secondary_validation::Validator;

/// Filter some characters. The str input forwarded to iso_iec_7064 should only contain valid characters.
/// Filtering some characters allows to be more flexible on the regex pattern.
fn filter_chars(input: &str) -> String {
    input
        .chars()
        .filter(|c| !matches!(c, ' ' | '-' | '_' | '/'))
        .collect()
}

// Pure ISO 7064

pub struct Mod11_2checksum;
impl Validator for Mod11_2checksum {
    fn is_valid_match(&self, regex_match: &str) -> bool {
        MOD_11_2.validate_string(&filter_chars(regex_match).to_uppercase())
    }
}

pub struct Mod37_2checksum;
impl Validator for Mod37_2checksum {
    fn is_valid_match(&self, regex_match: &str) -> bool {
        MOD_37_2.validate_string(&filter_chars(regex_match).to_uppercase())
    }
}

pub struct Mod1271_36Checksum;
impl Validator for Mod1271_36Checksum {
    fn is_valid_match(&self, regex_match: &str) -> bool {
        MOD_1271_36.validate_string(&filter_chars(regex_match).to_uppercase())
    }
}

pub struct Mod661_26checksum;
impl Validator for Mod661_26checksum {
    fn is_valid_match(&self, regex_match: &str) -> bool {
        MOD_661_26.validate_string(&filter_chars(regex_match).to_uppercase())
    }
}

pub struct Mod97_10checksum;
impl Validator for Mod97_10checksum {
    fn is_valid_match(&self, regex_match: &str) -> bool {
        MOD_97_10.validate_string(&filter_chars(regex_match))
    }
}

// Hybrid ISO 7064

pub struct Mod11_10checksum;
impl Validator for Mod11_10checksum {
    fn is_valid_match(&self, regex_match: &str) -> bool {
        MOD_11_10.validate_string(&filter_chars(regex_match))
    }
}

pub struct Mod27_26checksum;
impl Validator for Mod27_26checksum {
    fn is_valid_match(&self, regex_match: &str) -> bool {
        MOD_27_26.validate_string(&filter_chars(regex_match).to_uppercase())
    }
}

pub struct Mod37_36checksum;
impl Validator for Mod37_36checksum {
    fn is_valid_match(&self, regex_match: &str) -> bool {
        MOD_37_36.validate_string(&filter_chars(regex_match).to_uppercase())
    }
}

#[cfg(test)]
mod test {
    use crate::secondary_validation::*;

    #[test]
    fn test_valid_11_10() {
        let valid_numbers = vec![
            "15203607809",
            "15 203 607 809",
            "15-203_607/809",
            "26954371827",
        ];
        for numbers in valid_numbers {
            println!("testing for input {numbers}");
            assert!(Mod11_10checksum.is_valid_match(numbers));
        }
    }

    #[test]
    fn test_invalid_11_10() {
        let valid_numbers = vec!["00 000 000 000.", "30405607809"];
        for numbers in valid_numbers {
            println!("testing for input {numbers}");
            assert!(!Mod11_10checksum.is_valid_match(numbers));
        }
    }

    #[test]
    fn test_valid_11_2() {
        let valid_ids = vec![
            "513231200012121657",
            "513231200012121673",
            "51323120001212169X",
            "513231200012121710",
            "513231200012121737",
            "513231200012121753",
            "513231200012121294",
            "51323120001212177X",
            "513231200012121796",
            "513231200012121817",
            "513231200012121833",
            "51323120001212185X",
            // Same with lowercase x should work
            "51323120001212185x",
            "513231200012121876",
            "513231200012121892",
        ];
        for id in valid_ids {
            println!("testing for input {id}");
            assert!(Mod11_2checksum.is_valid_match(id));
        }
    }

    #[test]
    fn test_invalid_11_2() {
        let invalid_ids = vec![
            // wrong checksum
            "513231200012121293",
            // non digit characters
            "a13231200012121293",
            // wrong length
            "a1323120001212129",
            // Non utf-8 characters 18 bytes
            "513231200012Àñô",
        ];
        for id in invalid_ids {
            println!("testing for input {id}");
            assert!(!Mod11_2checksum.is_valid_match(id));
        }
    }
}