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

pub mod message;
pub mod outcome;
pub mod shared_secret;

use ssb_crypto::{
    handshake::{generate_ephemeral_keypair, EphPublicKey, EphSecretKey},
    PublicKey, SecretKey, Signature,
};

/// Client long-term public key
#[derive(Clone)]
pub struct ClientPublicKey(pub PublicKey);
impl ClientPublicKey {
    pub fn from_slice(b: &[u8]) -> Option<ClientPublicKey> {
        Some(ClientPublicKey(PublicKey::from_slice(b)?))
    }
}

/// Client long-term secret key
pub struct ClientSecretKey(pub SecretKey);
impl ClientSecretKey {
    pub fn from_slice(b: &[u8]) -> Option<ClientSecretKey> {
        Some(ClientSecretKey(SecretKey::from_slice(b)?))
    }
}

/// Server long-term public key; known to client prior to the handshake
#[derive(Clone)]
pub struct ServerPublicKey(pub PublicKey);
impl ServerPublicKey {
    pub fn from_slice(b: &[u8]) -> Option<ServerPublicKey> {
        Some(ServerPublicKey(PublicKey::from_slice(b)?))
    }
    pub fn as_slice(&self) -> &[u8] {
        &self.0[..]
    }
}

/// Server long-term secret key
pub struct ServerSecretKey(pub SecretKey);
impl ServerSecretKey {
    pub fn from_slice(b: &[u8]) -> Option<ServerSecretKey> {
        Some(ServerSecretKey(SecretKey::from_slice(b)?))
    }
}

#[derive(Clone)]
pub struct ClientSignature(Signature);
struct ServerSignature(Signature);

/// Client ephemeral public key (generated anew for each connection)
#[derive(Clone)]
pub struct ClientEphPublicKey(pub EphPublicKey);
impl ClientEphPublicKey {
    pub fn from_slice(b: &[u8]) -> Option<Self> {
        Some(ClientEphPublicKey(EphPublicKey::from_slice(b)?))
    }
}

/// Client ephemeral secret key
pub struct ClientEphSecretKey(pub EphSecretKey);

/// Server ephemeral public key (generated anew for each connection)
#[derive(Clone)]
pub struct ServerEphPublicKey(pub EphPublicKey);
impl ServerEphPublicKey {
    pub fn from_slice(b: &[u8]) -> Option<Self> {
        Some(ServerEphPublicKey(EphPublicKey::from_slice(b)?))
    }
}

/// Server ephemeral secret key
pub struct ServerEphSecretKey(pub EphSecretKey);

pub fn gen_client_eph_keypair() -> (ClientEphPublicKey, ClientEphSecretKey) {
    let (pk, sk) = generate_ephemeral_keypair();
    (ClientEphPublicKey(pk), ClientEphSecretKey(sk))
}

pub fn gen_server_eph_keypair() -> (ServerEphPublicKey, ServerEphSecretKey) {
    let (pk, sk) = generate_ephemeral_keypair();
    (ServerEphPublicKey(pk), ServerEphSecretKey(sk))
}