webrtc_dtls/handshake/
mod.rs

1pub mod handshake_cache;
2pub mod handshake_header;
3pub mod handshake_message_certificate;
4pub mod handshake_message_certificate_request;
5pub mod handshake_message_certificate_verify;
6pub mod handshake_message_client_hello;
7pub mod handshake_message_client_key_exchange;
8pub mod handshake_message_finished;
9pub mod handshake_message_hello_verify_request;
10pub mod handshake_message_server_hello;
11pub mod handshake_message_server_hello_done;
12pub mod handshake_message_server_key_exchange;
13pub mod handshake_random;
14
15#[cfg(test)]
16mod handshake_test;
17
18use std::fmt;
19use std::io::{Read, Write};
20
21use handshake_header::*;
22use handshake_message_certificate::*;
23use handshake_message_certificate_request::*;
24use handshake_message_certificate_verify::*;
25use handshake_message_client_hello::*;
26use handshake_message_client_key_exchange::*;
27use handshake_message_finished::*;
28use handshake_message_hello_verify_request::*;
29use handshake_message_server_hello::*;
30use handshake_message_server_hello_done::*;
31use handshake_message_server_key_exchange::*;
32
33use super::content::*;
34use super::error::*;
35
36/// ## Specifications
37///
38/// * [RFC 5246 §7.4]
39///
40/// [RFC 5246 §7.4]: https://tools.ietf.org/html/rfc5246#section-7.4
41#[derive(Default, Copy, Clone, Debug, PartialEq, Eq, Hash)]
42pub enum HandshakeType {
43    HelloRequest = 0,
44    ClientHello = 1,
45    ServerHello = 2,
46    HelloVerifyRequest = 3,
47    Certificate = 11,
48    ServerKeyExchange = 12,
49    CertificateRequest = 13,
50    ServerHelloDone = 14,
51    CertificateVerify = 15,
52    ClientKeyExchange = 16,
53    Finished = 20,
54    #[default]
55    Invalid,
56}
57
58impl fmt::Display for HandshakeType {
59    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
60        match *self {
61            HandshakeType::HelloRequest => write!(f, "HelloRequest"),
62            HandshakeType::ClientHello => write!(f, "ClientHello"),
63            HandshakeType::ServerHello => write!(f, "ServerHello"),
64            HandshakeType::HelloVerifyRequest => write!(f, "HelloVerifyRequest"),
65            HandshakeType::Certificate => write!(f, "Certificate"),
66            HandshakeType::ServerKeyExchange => write!(f, "ServerKeyExchange"),
67            HandshakeType::CertificateRequest => write!(f, "CertificateRequest"),
68            HandshakeType::ServerHelloDone => write!(f, "ServerHelloDone"),
69            HandshakeType::CertificateVerify => write!(f, "CertificateVerify"),
70            HandshakeType::ClientKeyExchange => write!(f, "ClientKeyExchange"),
71            HandshakeType::Finished => write!(f, "Finished"),
72            HandshakeType::Invalid => write!(f, "Invalid"),
73        }
74    }
75}
76
77impl From<u8> for HandshakeType {
78    fn from(val: u8) -> Self {
79        match val {
80            0 => HandshakeType::HelloRequest,
81            1 => HandshakeType::ClientHello,
82            2 => HandshakeType::ServerHello,
83            3 => HandshakeType::HelloVerifyRequest,
84            11 => HandshakeType::Certificate,
85            12 => HandshakeType::ServerKeyExchange,
86            13 => HandshakeType::CertificateRequest,
87            14 => HandshakeType::ServerHelloDone,
88            15 => HandshakeType::CertificateVerify,
89            16 => HandshakeType::ClientKeyExchange,
90            20 => HandshakeType::Finished,
91            _ => HandshakeType::Invalid,
92        }
93    }
94}
95
96#[derive(PartialEq, Debug, Clone)]
97pub enum HandshakeMessage {
98    //HelloRequest(errNotImplemented),
99    ClientHello(HandshakeMessageClientHello),
100    ServerHello(HandshakeMessageServerHello),
101    HelloVerifyRequest(HandshakeMessageHelloVerifyRequest),
102    Certificate(HandshakeMessageCertificate),
103    ServerKeyExchange(HandshakeMessageServerKeyExchange),
104    CertificateRequest(HandshakeMessageCertificateRequest),
105    ServerHelloDone(HandshakeMessageServerHelloDone),
106    CertificateVerify(HandshakeMessageCertificateVerify),
107    ClientKeyExchange(HandshakeMessageClientKeyExchange),
108    Finished(HandshakeMessageFinished),
109}
110
111impl HandshakeMessage {
112    pub fn handshake_type(&self) -> HandshakeType {
113        match self {
114            HandshakeMessage::ClientHello(msg) => msg.handshake_type(),
115            HandshakeMessage::ServerHello(msg) => msg.handshake_type(),
116            HandshakeMessage::HelloVerifyRequest(msg) => msg.handshake_type(),
117            HandshakeMessage::Certificate(msg) => msg.handshake_type(),
118            HandshakeMessage::ServerKeyExchange(msg) => msg.handshake_type(),
119            HandshakeMessage::CertificateRequest(msg) => msg.handshake_type(),
120            HandshakeMessage::ServerHelloDone(msg) => msg.handshake_type(),
121            HandshakeMessage::CertificateVerify(msg) => msg.handshake_type(),
122            HandshakeMessage::ClientKeyExchange(msg) => msg.handshake_type(),
123            HandshakeMessage::Finished(msg) => msg.handshake_type(),
124        }
125    }
126
127    pub fn size(&self) -> usize {
128        match self {
129            HandshakeMessage::ClientHello(msg) => msg.size(),
130            HandshakeMessage::ServerHello(msg) => msg.size(),
131            HandshakeMessage::HelloVerifyRequest(msg) => msg.size(),
132            HandshakeMessage::Certificate(msg) => msg.size(),
133            HandshakeMessage::ServerKeyExchange(msg) => msg.size(),
134            HandshakeMessage::CertificateRequest(msg) => msg.size(),
135            HandshakeMessage::ServerHelloDone(msg) => msg.size(),
136            HandshakeMessage::CertificateVerify(msg) => msg.size(),
137            HandshakeMessage::ClientKeyExchange(msg) => msg.size(),
138            HandshakeMessage::Finished(msg) => msg.size(),
139        }
140    }
141
142    pub fn marshal<W: Write>(&self, writer: &mut W) -> Result<()> {
143        match self {
144            HandshakeMessage::ClientHello(msg) => msg.marshal(writer)?,
145            HandshakeMessage::ServerHello(msg) => msg.marshal(writer)?,
146            HandshakeMessage::HelloVerifyRequest(msg) => msg.marshal(writer)?,
147            HandshakeMessage::Certificate(msg) => msg.marshal(writer)?,
148            HandshakeMessage::ServerKeyExchange(msg) => msg.marshal(writer)?,
149            HandshakeMessage::CertificateRequest(msg) => msg.marshal(writer)?,
150            HandshakeMessage::ServerHelloDone(msg) => msg.marshal(writer)?,
151            HandshakeMessage::CertificateVerify(msg) => msg.marshal(writer)?,
152            HandshakeMessage::ClientKeyExchange(msg) => msg.marshal(writer)?,
153            HandshakeMessage::Finished(msg) => msg.marshal(writer)?,
154        }
155
156        Ok(())
157    }
158}
159
160// The handshake protocol is responsible for selecting a cipher spec and
161// generating a master secret, which together comprise the primary
162// cryptographic parameters associated with a secure session.  The
163// handshake protocol can also optionally authenticate parties who have
164// certificates signed by a trusted certificate authority.
165// https://tools.ietf.org/html/rfc5246#section-7.3
166#[derive(PartialEq, Debug, Clone)]
167pub struct Handshake {
168    pub(crate) handshake_header: HandshakeHeader,
169    pub(crate) handshake_message: HandshakeMessage,
170}
171
172impl Handshake {
173    pub fn new(handshake_message: HandshakeMessage) -> Self {
174        Handshake {
175            handshake_header: HandshakeHeader {
176                handshake_type: handshake_message.handshake_type(),
177                length: handshake_message.size() as u32,
178                message_sequence: 0,
179                fragment_offset: 0,
180                fragment_length: handshake_message.size() as u32,
181            },
182            handshake_message,
183        }
184    }
185
186    pub fn content_type(&self) -> ContentType {
187        ContentType::Handshake
188    }
189
190    pub fn size(&self) -> usize {
191        self.handshake_header.size() + self.handshake_message.size()
192    }
193
194    pub fn marshal<W: Write>(&self, writer: &mut W) -> Result<()> {
195        self.handshake_header.marshal(writer)?;
196        self.handshake_message.marshal(writer)?;
197        Ok(())
198    }
199
200    pub fn unmarshal<R: Read>(reader: &mut R) -> Result<Self> {
201        let handshake_header = HandshakeHeader::unmarshal(reader)?;
202
203        let handshake_message = match handshake_header.handshake_type {
204            HandshakeType::ClientHello => {
205                HandshakeMessage::ClientHello(HandshakeMessageClientHello::unmarshal(reader)?)
206            }
207            HandshakeType::ServerHello => {
208                HandshakeMessage::ServerHello(HandshakeMessageServerHello::unmarshal(reader)?)
209            }
210            HandshakeType::HelloVerifyRequest => HandshakeMessage::HelloVerifyRequest(
211                HandshakeMessageHelloVerifyRequest::unmarshal(reader)?,
212            ),
213            HandshakeType::Certificate => {
214                HandshakeMessage::Certificate(HandshakeMessageCertificate::unmarshal(reader)?)
215            }
216            HandshakeType::ServerKeyExchange => HandshakeMessage::ServerKeyExchange(
217                HandshakeMessageServerKeyExchange::unmarshal(reader)?,
218            ),
219            HandshakeType::CertificateRequest => HandshakeMessage::CertificateRequest(
220                HandshakeMessageCertificateRequest::unmarshal(reader)?,
221            ),
222            HandshakeType::ServerHelloDone => HandshakeMessage::ServerHelloDone(
223                HandshakeMessageServerHelloDone::unmarshal(reader)?,
224            ),
225            HandshakeType::CertificateVerify => HandshakeMessage::CertificateVerify(
226                HandshakeMessageCertificateVerify::unmarshal(reader)?,
227            ),
228            HandshakeType::ClientKeyExchange => HandshakeMessage::ClientKeyExchange(
229                HandshakeMessageClientKeyExchange::unmarshal(reader)?,
230            ),
231            HandshakeType::Finished => {
232                HandshakeMessage::Finished(HandshakeMessageFinished::unmarshal(reader)?)
233            }
234            _ => return Err(Error::ErrNotImplemented),
235        };
236
237        Ok(Handshake {
238            handshake_header,
239            handshake_message,
240        })
241    }
242}
webrtc_dtls/handshake/mod.rs

webrtc_dtls/handshake/
mod.rs
