typelock 0.5.1

Enforce security boundaries at the Type level
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

#![cfg(feature = "wincode-codec")]
use common::PolicyProvider;
use typelock::{FromBytes, LockSchema, ToBytes};

mod common;

#[derive(LockSchema, Clone)]
#[typelock(unlocked(name = UserUnlocked, derives(Debug)), locked(name = UserLocked))]
struct User {
    #[secure(policy(encrypt))]
    auto_codec_data: AutoCodecData,
}

#[derive(Debug, Default, Clone, ToBytes, FromBytes, wincode::SchemaRead, wincode::SchemaWrite)]
struct AutoCodecData {
    last_name: String,
    favorite_number: i64,
}

#[cfg(test)]
mod tests {
    use super::*;
    use typelock::{Lockable, Unlockable};

    #[test]
    fn test_to_and_from_bytes() {
        let provider = PolicyProvider;
        let user = User {
            auto_codec_data: AutoCodecData {
                last_name: "last_name".to_string(),
                favorite_number: 1,
            },
        };

        let locked_user = user.clone().lock(&provider).unwrap();
        assert!(locked_user.auto_codec_data.starts_with(b"encrypted:"));
        let unlocked_user = locked_user.unlock(&provider).unwrap();

        assert_eq!(
            user.auto_codec_data.last_name,
            unlocked_user.auto_codec_data.last_name
        );
        assert_eq!(
            user.auto_codec_data.favorite_number,
            unlocked_user.auto_codec_data.favorite_number
        );
    }
}