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
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

use crate::{
    types::{Decrypted, Verified},
    Error,
};

pub trait CryptoProvider {
    /// Encrypt a plaintext byte slice.
    fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, Error>;

    /// Decrypt an encrypted byte slice back into plaintext bytes.
    fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
}

pub trait SecretProvider {
    /// Produce a one-way secret hash (for example, password hashing).
    fn hash_secret(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
}

pub trait DigestProvider {
    /// Compute a digest of the input bytes.
    fn digest(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
}

pub trait SignProvider {
    /// Produce a signed payload from raw bytes.
    fn sign(&self, data: &[u8]) -> Result<Vec<u8>, Error>;

    /// Verify and recover the signed payload bytes.
    fn verify_signature(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
}

pub trait MacProvider {
    /// Attach a MAC tag to raw bytes.
    fn tag(&self, data: &[u8]) -> Result<Vec<u8>, Error>;

    /// Verify and recover MAC-tagged payload bytes.
    fn verify_mac(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
}

/// Trait for types that can be transformed into their locked representation.
///
/// Depending on field policy, locking may encrypt, hash, digest, sign, or MAC-tag data.
pub trait Lockable<P> {
    type Output;

    fn lock(self, provider: &P) -> Result<Self::Output, Error>;
}

impl<P, T> Lockable<P> for Vec<T>
where
    T: Lockable<P>,
{
    type Output = Vec<T::Output>;

    #[inline]
    fn lock(self, provider: &P) -> Result<Self::Output, Error> {
        self.into_iter().map(|m| m.lock(provider)).collect()
    }
}

/// Trait for types that can be transformed into their unlocked representation.
///
/// Depending on field policy, unlocking may decrypt or verify signed/MAC-tagged bytes,
/// while one-way policies (secret hash and digest) remain in their wrapped form.
pub trait Unlockable<P> {
    type Output;

    fn unlock(self, provider: &P) -> Result<Self::Output, Error>;
}

impl<P, T> Unlockable<P> for Vec<T>
where
    T: Unlockable<P>,
{
    type Output = Vec<T::Output>;

    #[inline]
    fn unlock(self, provider: &P) -> Result<Self::Output, Error> {
        self.into_iter().map(|m| m.unlock(provider)).collect()
    }
}

/// Trait for serializing values into bytes for provider operations.
pub trait ToBytes {
    fn to_bytes(&self) -> Result<Vec<u8>, Error>;
}

impl ToBytes for String {
    fn to_bytes(&self) -> Result<Vec<u8>, Error> {
        Ok(self.as_bytes().to_vec())
    }
}

impl ToBytes for Vec<u8> {
    fn to_bytes(&self) -> Result<Vec<u8>, Error> {
        Ok(self.to_owned())
    }
}

impl<T> ToBytes for Decrypted<T>
where
    T: ToBytes,
{
    fn to_bytes(&self) -> Result<Vec<u8>, Error> {
        (**self).to_bytes()
    }
}

impl<T> ToBytes for Verified<T>
where
    T: ToBytes,
{
    fn to_bytes(&self) -> Result<Vec<u8>, Error> {
        (**self).to_bytes()
    }
}

/// Trait for deserializing bytes back into strongly typed values.
pub trait FromBytes: Sized {
    fn from_bytes(bytes: &[u8]) -> Result<Self, Error>;
}

impl FromBytes for String {
    fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
        Ok(String::from_utf8(bytes.to_vec())?)
    }
}

impl FromBytes for Vec<u8> {
    fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
        Ok(bytes.to_owned())
    }
}