devolutions-crypto 0.3.0

An abstraction layer for the cryptography used by Devolutions
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

mod dc_key_v1;

use super::DcHeader;
use super::DevoCryptoError;
use super::Result;

use self::dc_key_v1::DcKeyV1;

pub const KEY: u16 = 1;

const V1: u16 = 1;

pub enum DcKey {
    V1(DcKeyV1),
}

impl DcKey {
    pub fn try_from_header(data: &[u8], header: &DcHeader) -> Result<DcKey> {
        match header.version {
            V1 => Ok(DcKey::V1(DcKeyV1::try_from_header(data, header)?)),
            _ => Err(DevoCryptoError::UnknownVersion),
        }
    }

    pub fn generate_key_exchange(
        private_header: &mut DcHeader,
        public_header: &mut DcHeader,
    ) -> Result<(DcKey, DcKey)> {
        private_header.data_type = KEY;
        public_header.data_type = KEY;
        private_header.version = V1;
        public_header.version = V1;

        let (private_key, public_key) =
            DcKeyV1::generate_key_exchange(private_header, public_header)?;

        Ok((DcKey::V1(private_key), DcKey::V1(public_key)))
    }

    pub fn mix_key_exchange(self, public: DcKey) -> Result<Vec<u8>> {
        match (self, public) {
            (DcKey::V1(private), DcKey::V1(public)) => private.mix_key_exchange(public),
        }
    }
}

impl From<DcKey> for Vec<u8> {
    fn from(key: DcKey) -> Vec<u8> {
        match key {
            DcKey::V1(x) => x.into(),
        }
    }
}