Skip to main content

vcl_protocol/
handshake.rs

1use x25519_dalek::{EphemeralSecret, PublicKey, SharedSecret};
2use rand::rngs::OsRng;
3use serde::{Serialize, Deserialize};
4
5#[derive(Serialize, Deserialize, Clone, Debug)]
6pub enum HandshakeMessage {
7    ClientHello { public_key: [u8; 32] },
8    ServerHello { public_key: [u8; 32] },
9    Ack,
10}
11
12pub struct HandshakeState {
13    shared_secret: Option<[u8; 32]>,
14}
15
16impl HandshakeState {
17    pub fn new() -> Self {
18        HandshakeState {
19            shared_secret: None,
20        }
21    }
22
23    pub fn get_shared_secret(&self) -> Option<[u8; 32]> {
24        self.shared_secret
25    }
26
27    pub fn set_shared_secret(&mut self, secret: [u8; 32]) {
28        self.shared_secret = Some(secret);
29    }
30
31    pub fn is_complete(&self) -> bool {
32        self.shared_secret.is_some()
33    }
34}
35
36// Вынесено наружу — теперь можно импортировать как crate::handshake::create_client_hello
37pub fn create_client_hello() -> (HandshakeMessage, EphemeralSecret) {
38    let ephemeral = EphemeralSecret::random_from_rng(OsRng);
39    let public = PublicKey::from(&ephemeral);
40    let msg = HandshakeMessage::ClientHello {
41        public_key: public.to_bytes(),
42    };
43    (msg, ephemeral)
44}
45
46pub fn process_client_hello(ephemeral: EphemeralSecret, client_public: [u8; 32]) -> (HandshakeMessage, Option<[u8; 32]>) {
47    let server_public = PublicKey::from(&ephemeral);
48    let client_pk = PublicKey::from(client_public);
49    let shared: SharedSecret = ephemeral.diffie_hellman(&client_pk);
50    let shared_bytes = shared.to_bytes();
51    let msg = HandshakeMessage::ServerHello {
52        public_key: server_public.to_bytes(),
53    };
54    (msg, Some(shared_bytes))
55}
56
57pub fn process_server_hello(ephemeral: EphemeralSecret, server_public: [u8; 32]) -> Option<[u8; 32]> {
58    let server_pk = PublicKey::from(server_public);
59    let shared: SharedSecret = ephemeral.diffie_hellman(&server_pk);
60    Some(shared.to_bytes())
61}