infinitree 0.11.0

Embedded, encrypted database with tiered cache
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

use crate::{ChunkPointer, Digest, ObjectId};
use blake3::Hasher;
use std::sync::Arc;

/// A derived key that's directly usable to execute encypt/decrypt operations.
pub(crate) type CryptoOps = Arc<dyn ICryptoOps>;

/// Low level encrypt/decrypt operations using a derivative key.
pub(crate) trait ICryptoOps: Send + Sync {
    fn encrypt_chunk(
        &self,
        object_id: ObjectId,
        offs: u32,
        hash: &Digest,
        data: &mut [u8],
    ) -> ChunkPointer;

    fn decrypt_chunk<'buf>(
        &self,
        target: &'buf mut [u8],
        source: &[u8],
        chunk: &ChunkPointer,
    ) -> &'buf mut [u8];

    /// Provide a hash (or HMAC) of `data`
    fn hash(&self, data: &[u8]) -> Digest;

    /// Return a freely usable and cloneable Hasher. May be keyed.
    fn hasher(&self) -> Hasher;
}

macro_rules! key_type {
    ($name:ident) => {
        #[derive(Clone)]
        pub struct $name(pub(crate) CryptoOps);

        impl $name {
            #[allow(unused)]
            pub(crate) fn new(ops: impl ICryptoOps + 'static) -> Self {
                Self(Arc::new(ops))
            }

            #[allow(unused)]
            pub(crate) fn into_inner(self) -> CryptoOps {
                self.0
            }
        }

        impl ICryptoOps for $name {
            fn encrypt_chunk(
                &self,
                object_id: ObjectId,
                offs: u32,
                hash: &Digest,
                data: &mut [u8],
            ) -> ChunkPointer {
                self.0.encrypt_chunk(object_id, offs, hash, data)
            }

            fn decrypt_chunk<'buf>(
                &self,
                target: &'buf mut [u8],
                source: &[u8],
                chunk: &ChunkPointer,
            ) -> &'buf mut [u8] {
                self.0.decrypt_chunk(target, source, chunk)
            }

            fn hash(&self, data: &[u8]) -> Digest {
                self.0.hash(data)
            }

            fn hasher(&self) -> Hasher {
                self.0.hasher()
            }
        }
    };
}

pub(crate) use private::*;
mod private {
    use super::*;

    key_type!(IndexKey);
    key_type!(ChunkKey);
    key_type!(StorageKey);
}