sanitization 2.0.2

Dependency-free no_std secret memory sanitization with safe defaults and an explicit volatile wipe backend.
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

#[cfg(feature = "alloc")]
use sanitization::{BoundedSecretString, SecretString, SecretVec};

fn main() {
    #[cfg(feature = "alloc")]
    {
        let mut token = SecretString::from_string(String::from("bearer-token"));
        assert_eq!(token.try_with_secret(str::len), Ok(12));

        token = SecretString::with_capacity(32);
        token.push_str("bearer-token");
        token
            .try_with_secret_mut(|text| text.make_ascii_uppercase())
            .unwrap();
        assert_eq!(token.try_with_secret(str::len), Ok(12));

        let mut bytes = SecretVec::from_vec(vec![115, 101, 99, 114, 101, 116]);
        assert_eq!(bytes.with_secret(|value| value.len()), 6);

        bytes = SecretVec::with_capacity(16);
        bytes.extend_from_slice(b"secret");
        assert_eq!(bytes.with_secret(|value| value.len()), 6);

        let text = SecretString::from_secret_vec(bytes).unwrap();
        assert!(text.constant_time_eq("secret"));

        let mut bounded = BoundedSecretString::<16>::from_secret_string(text).unwrap();
        bounded.push_str("-token").unwrap();
        assert!(bounded.constant_time_eq("secret-token"));
    }
}