emerald-vault 0.36.0

Emerald Vault - Key Storage for Emerald Wallet
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
134
135

use uuid::Uuid;
use crate::storage::archive::{Archive, ArchiveType};
use crate::storage::vault::VaultStorage;
use crate::structs::seed::Seed;
use crate::structs::types::UsesOddKey;

///
/// Utility operations to administrate the Vault Storage
pub struct VaultAdmin {
    vault: VaultStorage,
}

impl VaultAdmin {
    pub fn create(vault: VaultStorage) -> VaultAdmin {
        VaultAdmin {
            vault
        }
    }

    ///
    /// _Tries_ to re-encrypt Secrets encrypted with an individual password, i.e., which are not using the Global Key.
    /// It checks provided `legacy_password` against each of them, and where it decrypt the Secret it re-encrypts with using Global Key. I.e.,
    /// this function may upgrade multiple vault items, or none at all if the provided legacy password is incorrect. It doesn't produce any error,
    /// only returns a list of items successfully upgraded.
    ///
    /// Params:
    /// - `legacy_password` a password that some of legacy encrypted elements _may_ have
    /// - `global_password` password for the Global Key
    ///
    /// Returns list or successfully re-encrypted object. Can be id of a Seed or a Private Key.
    pub fn upgrade_all_legacy(&self, legacy_password: &str, global_password: &str) -> Vec<Uuid> {
        if !self.vault.global_key().is_set() {
            return vec![]
        }

        let mut result: Vec<Uuid> = Vec::new();
        let archive = Archive::create(&self.vault.dir, ArchiveType::Update);
        let global = self.vault.global_key().get().expect("GlobalKey is not available");

        self.vault.seeds()
            .list_entries().unwrap_or(vec![])
            .iter()
            .filter(|seed| seed.is_odd_key())
            .for_each(|seed| {
                let id = seed.id;
                let updated = seed.clone().source.reencrypt(legacy_password.as_bytes(), global_password.as_bytes(), global.clone());
                if updated.is_ok() {
                    let seed = Seed {
                        source: updated.unwrap(),
                        ..seed.clone()
                    };
                    if self.vault.seeds().update_multiple(seed, &archive).is_ok() {
                        result.push(id)
                    }
                }
            });

        self.vault.keys()
            .list_entries().unwrap_or(vec![])
            .iter()
            .filter(|key| key.is_odd_key())
            .for_each(|key| {
                let id = key.id;
                let updated = key.clone().reencrypt(legacy_password.as_bytes(), global_password.as_bytes(), global.clone());
                if updated.is_ok() && self.vault.keys().update_multiple(updated.unwrap(), &archive).is_ok() {
                    result.push(id)
                }
            });

        archive.finalize();

        result
    }
}

#[cfg(test)]
mod tests {
    use tempdir::TempDir;
    use crate::storage::admin::VaultAdmin;
    use crate::storage::vault::VaultStorage;
    use crate::structs::pk::PrivateKeyHolder;
    use crate::structs::seed::Seed;
    use crate::structs::types::UsesOddKey;

    #[test]
    fn try_all_upgrades() {
        let tmp_dir = TempDir::new("emerald-global-key-test").unwrap();
        let vault = VaultStorage::create(tmp_dir.path()).unwrap();

        let seed_id_1 = vault.seeds().add(
            Seed::test_generate(None, "test-1".as_bytes(), None).unwrap()
        ).unwrap();

        let key_id_1 = vault.keys().add(
            PrivateKeyHolder::generate_ethereum_raw("test-2").unwrap()
        ).unwrap();

        let key_id_2 = vault.keys().add(
            PrivateKeyHolder::generate_ethereum_raw("test-3").unwrap()
        ).unwrap();

        let key_id_3 = vault.keys().add(
            PrivateKeyHolder::generate_ethereum_raw("test-2").unwrap()
        ).unwrap();

        println!("init: {:?}, {:?}, {:?}, {:?}", seed_id_1, key_id_1, key_id_2, key_id_3);

        let admin = VaultAdmin::create(vault.clone());
        let global_store = vault.global_key();
        global_store.create("test-g").unwrap();

        let upgraded = admin.upgrade_all_legacy("test-wrong", "test-g");
        println!("Upgraded: {:?}", upgraded);
        assert!(upgraded.is_empty());

        let upgraded = admin.upgrade_all_legacy("test-1", "test-g");
        println!("Upgraded: {:?}", upgraded);
        assert_eq!(upgraded.len(), 1);
        assert!(!vault.seeds().get(seed_id_1).unwrap().is_odd_key());

        let upgraded = admin.upgrade_all_legacy("test-2", "test-g");
        println!("Upgraded: {:?}", upgraded);
        assert_eq!(upgraded.len(), 2);
        assert!(!vault.keys().get(key_id_1).unwrap().is_odd_key());
        assert!(vault.keys().get(key_id_2).unwrap().is_odd_key());
        assert!(!vault.keys().get(key_id_3).unwrap().is_odd_key());

        let upgraded = admin.upgrade_all_legacy("test-3", "test-g");
        println!("Upgraded: {:?}", upgraded);
        assert_eq!(upgraded.len(), 1);
        assert!(!vault.keys().get(key_id_1).unwrap().is_odd_key());
        assert!(!vault.keys().get(key_id_2).unwrap().is_odd_key());
        assert!(!vault.keys().get(key_id_3).unwrap().is_odd_key());
    }
}