yap2p 0.1.2

Experimental yet another peer-to-peer library
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

//! KeyChain for storing encryption keys
//! 
//! [`KeyChain`] is blockchain, used for storing keys for
//! encryption and decryption. It is our proposed way to
//! not use asymmetric cryptography, what helps to reduce
//! network load.

use sha2::{Sha256, Digest};

use std::sync::Mutex;

use super::dh::DH;
use crate::peer::Peer;

/// YAP2P keychain structure
pub struct KeyChain {
    top: Mutex<[u8; 32]>
}

impl KeyChain {
    /// Costructor for new [`KeyChain`] from `key_0` 256-bit hash
    /// 
    /// # Arguments
    /// 
    /// * `init` --- `key_0` 256-bit hash as `[u8; 32]`
    pub fn new(init: [u8; 32]) -> KeyChain {
        KeyChain { 
            top: Mutex::new(init)
        }
    }

    /// Costructor for new [`KeyChain`] from peer
    /// 
    /// # Arguments
    /// 
    /// * `peer` --- [`Peer`] you start to communicate with
    /// * `dh` --- Diffie-Hellman struct of this [`Peer`]
    pub fn new_from_peer(peer: Peer, dh: DH) -> KeyChain {
        KeyChain { 
            top: Mutex::new(dh.get_key_0_sha256(peer))
        }
    }

    /// Obtain current encryption key
    pub fn current(&self) -> [u8; 32] {
        *self.top.lock().unwrap()
    }

    /// Update encryption key
    /// 
    /// # Arguments
    /// 
    /// * `block` --- data for key updating
    pub fn update(&self, block: [u8; 32]) {
        let mut top = self.top.lock().unwrap();
        
        let mut hasher = Sha256::new();
        hasher.update(*top);
        hasher.update(block);

        *top = hasher.finalize().into();
    }
}