pipenet 0.1.4

Non blocking tcp stream wrapper using channels
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

use std::error::Error;

use chacha20poly1305::{
    AeadCore, ChaCha20Poly1305, Nonce,
    aead::{Aead, OsRng},
};

pub(crate) enum Encryption {
    #[allow(unused)]
    Ccp(ChaCha20Poly1305),
}

impl super::PackUnpack for Encryption {
    fn pack(&self, data: &[u8]) -> Result<Vec<u8>, Box<dyn Error>> {
        match self {
            Encryption::Ccp(c) => {
                let nonce = ChaCha20Poly1305::generate_nonce(&mut OsRng);
                let mut result = nonce.to_vec();
                result.extend_from_slice(&c.encrypt(&nonce, data).map_err(|_| "Error encrypting")?);
                Ok(result)
            }
        }
    }

    fn unpack(&self, data: &[u8]) -> Result<Vec<u8>, Box<dyn Error>> {
        match self {
            Encryption::Ccp(c) => {
                if data.len() < 12 {
                    return Err("not enough data for the nonce".into());
                }
                let nonce_block: [u8; 12] = data[..12].try_into()?;
                let nonce: Nonce = nonce_block.into();
                Ok(c.decrypt(&nonce, &data[12..])
                    .map_err(|_| "Error decrypting")?)
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::super::PackUnpack;
    use super::*;
    use chacha20poly1305::KeyInit;
    use quickcheck::quickcheck;

    #[test]
    fn check_encryption_cc20p1305() {
        fn check_array(data: Vec<u8>) -> bool {
            let k = ChaCha20Poly1305::generate_key(&mut OsRng);
            let c = Encryption::Ccp(ChaCha20Poly1305::new(&k));
            let packed = c.pack(&data).unwrap();
            let unpacked = c.unpack(&packed).unwrap();
            data == unpacked
        }

        quickcheck(check_array as fn(Vec<u8>) -> bool);
    }
}