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

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

mod common;

#[derive(LockSchema, Clone)]
#[typelock(locked(name = LockedUser), unlocked(name = UnlockedUser))]
struct User {
    #[secure(policy(encrypt))]
    user_data: UserDataEnvelope,
}

#[derive(Clone, ToBytes, FromBytes, wincode::SchemaRead, wincode::SchemaWrite)]
enum UserDataEnvelope {
    V1(UserData),
}

#[derive(Clone, wincode::SchemaRead, wincode::SchemaWrite)]
struct UserData {
    first_name: String,
    last_name: String,
}

#[test]
fn test_enum_encryption() {
    let provider = PolicyProvider;
    let user = User {
        user_data: UserDataEnvelope::V1(UserData {
            first_name: "first_name".to_string(),
            last_name: "last_name".to_string(),
        }),
    };

    let locked_user = user.clone().lock(&provider).unwrap();
    let unlocked_user = locked_user.unlock(&provider).unwrap();

    let (UserDataEnvelope::V1(original), UserDataEnvelope::V1(decrypted)) =
        (&user.user_data, &*unlocked_user.user_data);

    assert_eq!(original.first_name, decrypted.first_name);
    assert_eq!(original.last_name, decrypted.last_name);
}