skymd 0.1.10

Rust bindings for hacl*
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

use rand_core::{OsRng, RngCore};
use zeroize::Zeroize;

use crate::ffi::{EverCrypt_Curve25519_ecdh, EverCrypt_Curve25519_secret_to_public};

pub const KEY_LEN: usize = 32;

#[derive(Debug, Default)]
pub struct PublicKey {
    key: [u8; KEY_LEN],
}

#[derive(Debug, Default)]
pub struct PrivateKey {
    key: [u8; KEY_LEN],
}

#[derive(Debug)]
pub struct SharedSecret {
    key: [u8; KEY_LEN],
}

impl Drop for PrivateKey {
    fn drop(&mut self) {
        self.key.zeroize();
    }
}

impl Drop for SharedSecret {
    fn drop(&mut self) {
        self.key.zeroize();
    }
}

pub fn keypair() -> (PublicKey, PrivateKey) {
    let priv_key = PrivateKey::new();
    let mut pub_key = [0u8; KEY_LEN];

    unsafe {
        EverCrypt_Curve25519_secret_to_public(pub_key.as_mut_ptr(), priv_key.key.as_ptr());
    }

    let pub_key = PublicKey { key: pub_key };

    (pub_key, priv_key)
}

impl SharedSecret {
    pub fn as_bytes(&self) -> &[u8] {
        &self.key
    }
}

impl PublicKey {
    pub fn as_bytes(&self) -> &[u8] {
        &self.key
    }
}

impl PrivateKey {
    pub fn new() -> Self {
        let mut buf = [0u8; KEY_LEN];

        OsRng.fill_bytes(&mut buf);
        PrivateKey::scalar(&mut buf);

        Self { key: buf }
    }

    fn scalar(buf: &mut [u8; KEY_LEN]) {
        buf[0] &= 248;
        buf[31] &= 127;
        buf[31] |= 64;
    }

    pub fn as_bytes(&self) -> &[u8] {
        &self.key
    }

    pub fn from_slice(mut slice: [u8; KEY_LEN]) -> Self {
        PrivateKey::scalar(&mut slice);
        Self { key: slice }
    }

    pub fn ecdh(&self, public_key: &PublicKey) -> SharedSecret {
        let mut ss = [0u8; KEY_LEN];
        unsafe {
            EverCrypt_Curve25519_ecdh(ss.as_mut_ptr(), self.key.as_ptr(), public_key.key.as_ptr());
        }
        SharedSecret { key: ss }
    }
}

impl From<[u8; KEY_LEN]> for PrivateKey {
    fn from(pk: [u8; KEY_LEN]) -> PrivateKey {
        let mut pk = PrivateKey { key: pk };
        PrivateKey::scalar(&mut pk.key);
        pk
    }
}

impl From<[u8; KEY_LEN]> for PublicKey {
    fn from(pk: [u8; KEY_LEN]) -> PublicKey {
        PublicKey { key: pk }
    }
}

impl From<&PrivateKey> for PublicKey {
    fn from(privkey: &PrivateKey) -> PublicKey {
        let mut pubkey = PublicKey { key: [0; KEY_LEN] };
        unsafe {
            EverCrypt_Curve25519_secret_to_public(pubkey.key.as_mut_ptr(), privkey.key.as_ptr());
        }
        pubkey
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn ecdh_test() {
        crate::skymd_init();
        let (pub_key1, priv_key1) = keypair();
        let (pub_key2, priv_key2) = keypair();
        assert_eq!(priv_key1.ecdh(&pub_key2).key, priv_key2.ecdh(&pub_key1).key);
    }
}