alexandria 0.2.0

An encrypted document-oriented database with tag based query support
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

use crate::{data::Encrypted, Id};
use serde::{Deserialize, Serialize};
use sodiumoxide::crypto::box_::{self, PublicKey, SecretKey};
use std::collections::BTreeMap;

/// Both public and private parts of the key tree
#[derive(Serialize, Deserialize)]
pub(crate) struct KeyTreePair {
    pub_: PubKeyTree,
    sec: SecKeyTree,
}

/// A tree of public keys
#[derive(Serialize, Deserialize)]
pub(crate) struct PubKeyTree {
    root: PublicKey,
    subs: BTreeMap<Id, PublicKey>,
}

impl PubKeyTree {
    /// Seal some data for the root key
    pub(crate) fn seal(&self, data: &[u8], sk: &SecretKey) -> Encrypted {
        let nonce = box_::gen_nonce();
        let data = box_::seal(data, &nonce, &self.root, sk);
        Encrypted { nonce, data }
    }

    /// Seal some data for a specific zone
    pub(crate) fn seal_zone(&self, zone: Id, data: &[u8], sk: &SecretKey) -> Encrypted {
        let pub_ = &self.subs.get(&zone).unwrap();
        let nonce = box_::gen_nonce();
        let data = box_::seal(data, &nonce, &pub_, sk);
        Encrypted { nonce, data }
    }
}

/// A tree of secret keys
#[derive(Serialize, Deserialize)]
pub(crate) struct SecKeyTree {
    root: SecretKey,
    subs: BTreeMap<Id, SecretKey>,
}

impl KeyTreePair {
    /// Create a new tree of keys
    pub(crate) fn new() -> Self {
        let (pub_, sec) = box_::gen_keypair();
        Self {
            pub_: PubKeyTree {
                root: pub_,
                subs: Default::default(),
            },
            sec: SecKeyTree {
                root: sec,
                subs: Default::default(),
            },
        }
    }
}

#[test]
fn encrypt() {
    use sodiumoxide::crypto::box_;

    // normally theirpk is sent by the other party
    let (theirpk, theirsk) = box_::gen_keypair();
    let nonce = box_::gen_nonce();
    let plaintext = b"some data";
    let ciphertext = box_::seal(plaintext, &nonce, &theirpk, &oursk);
    let their_plaintext = box_::open(&ciphertext, &nonce, &ourpk, &theirsk).unwrap();
    assert!(plaintext == &their_plaintext[..]);
}