reqtls/message/
mod.rs

1use crate::error::RlsResult;
2pub use payload::Payload;
3pub use alert::Alert;
4use certificate::{CertificateStatus, Certificates};
5use client_hello::ClientHello;
6use key_exchange::{ClientKeyExchange, ServerKeyExchange};
7use server_hello::{ServerHello, ServerHelloDone};
8use session_ticket::SessionTicket;
9use std::fmt::Debug;
10use crate::{CipherSuite, WriteExt};
11pub use certificate::{CertificateVerify, CertificateRequest};
12
13pub mod certificate;
14pub mod client_hello;
15pub mod server_hello;
16pub mod key_exchange;
17pub mod session_ticket;
18mod payload;
19mod alert;
20
21#[derive(Debug)]
22pub enum Message<'a> {
23    ClientHello(ClientHello<'a>),
24    ServerHello(ServerHello<'a>),
25    Certificate(Certificates<'a>),
26    ServerKeyExchange(ServerKeyExchange),
27    ServerHelloDone(ServerHelloDone),
28    ClientKeyExchange(ClientKeyExchange<'a>),
29    NewSessionTicket(SessionTicket<'a>),
30    Payload(Payload<'a>),
31    CertificateStatus(CertificateStatus),
32    CertificateRequest(CertificateRequest<'a>),
33    CertificateVerify(CertificateVerify<'a>),
34    Alert(Alert),
35    CipherSpec,
36}
37
38impl<'a> Message<'a> {
39    pub fn from_bytes(bytes: &'a mut [u8], payload: bool, suite: Option<&CipherSuite>) -> RlsResult<Message<'a>> {
40        if !payload {
41            let handshake_type = HandshakeType::from_byte(bytes[0]).unwrap();
42            match handshake_type {
43                HandshakeType::ClientHello => Ok(Message::ClientHello(ClientHello::from_bytes(handshake_type, bytes)?)),
44                HandshakeType::ServerHello => Ok(Message::ServerHello(ServerHello::from_bytes(handshake_type, bytes)?)),
45                HandshakeType::Certificate => Ok(Message::Certificate(Certificates::from_bytes(handshake_type, bytes)?)),
46                HandshakeType::ServerKeyExchange => Ok(Message::ServerKeyExchange(ServerKeyExchange::from_bytes(handshake_type, bytes)?)),
47                HandshakeType::ServerHelloDone => Ok(Message::ServerHelloDone(ServerHelloDone::from_bytes(handshake_type, bytes)?)),
48                HandshakeType::ClientKeyExchange => Ok(Message::ClientKeyExchange(ClientKeyExchange::from_bytes(handshake_type, bytes, suite)?)),
49                HandshakeType::NewSessionTicket => Ok(Message::NewSessionTicket(SessionTicket::from_bytes(handshake_type, bytes)?)),
50                HandshakeType::CertificateStatus => Ok(Message::CertificateStatus(CertificateStatus::from_bytes(handshake_type, bytes))),
51                HandshakeType::CertificateRequest => Ok(Message::CertificateRequest(CertificateRequest::from_bytes(handshake_type, bytes))),
52                HandshakeType::CertificateVerify => Ok(Message::CertificateVerify(CertificateVerify::from_bytes(handshake_type, bytes))),
53                HandshakeType::CipherSpec => Ok(Message::CipherSpec),
54            }
55        } else {
56            Ok(Message::Payload(Payload::from_slice(bytes)))
57        }
58    }
59
60    pub fn len(&self, key_size: u8) -> usize {
61        match self {
62            Message::ClientHello(v) => v.len(),
63            Message::ServerHello(v) => v.len(),
64            Message::Certificate(v) => v.len(),
65            Message::ServerKeyExchange(v) => v.len(),
66            Message::ServerHelloDone(v) => v.len(),
67            Message::ClientKeyExchange(v) => v.len(key_size),
68            Message::NewSessionTicket(v) => v.len(),
69            Message::Payload(v) => v.value.len(),
70            Message::CertificateStatus(v) => v.len(),
71            Message::CertificateRequest(v) => v.len(),
72            Message::CertificateVerify(v) => v.len(),
73            Message::Alert(_) => 0,
74            Message::CipherSpec => 0
75        }
76    }
77
78    pub fn write_to<W: WriteExt>(self, writer: &mut W, key_size: u8) {
79        match self {
80            Message::ClientHello(v) => v.write_to(writer),
81            Message::ServerHello(v) => v.write_to(writer),
82            Message::Certificate(v) => v.write_to(writer),
83            Message::ServerKeyExchange(v) => v.write_to(writer),
84            Message::ServerHelloDone(v) => v.write_to(writer),
85            Message::ClientKeyExchange(v) => v.write_to(writer, key_size),
86            Message::NewSessionTicket(v) => v.write_to(writer),
87            Message::Payload(v) => writer.write_slice(v.into_inner()),
88            Message::CertificateStatus(v) => v.write_to(writer),
89            Message::CertificateRequest(v) => v.write_to(writer),
90            Message::CertificateVerify(v) => v.write_to(writer),
91            Message::Alert(_) => {}
92            Message::CipherSpec => {}
93        }
94    }
95
96    pub fn client_mut(&mut self) -> Option<&mut ClientHello<'a>> {
97        match self {
98            Message::ClientHello(v) => Some(v),
99            _ => None
100        }
101    }
102    pub fn client(&self) -> Option<&ClientHello<'a>> {
103        match self {
104            Message::ClientHello(v) => Some(v),
105            _ => None
106        }
107    }
108
109    pub fn server_mut(&mut self) -> Option<&mut ServerHello<'a>> {
110        match self {
111            Message::ServerHello(v) => Some(v),
112            _ => None
113        }
114    }
115
116    pub fn server(&self) -> Option<&ServerHello<'a>> {
117        match self {
118            Message::ServerHello(v) => Some(v),
119            _ => None
120        }
121    }
122
123    // pub fn server_key_exchange(&self) -> Option<&ServerKeyExchange> {
124    //     match self {
125    //         Message::ServerKeyExchange(v) => Some(v),
126    //         _ => None
127    //     }
128    // }
129
130    pub fn client_key_exchange_mut(&mut self) -> Option<&mut ClientKeyExchange<'a>> {
131        match self {
132            Message::ClientKeyExchange(v) => Some(v),
133            _ => None
134        }
135    }
136
137    // pub fn take_payload(&mut self) -> Option<Bytes> {
138    //     match self {
139    //         Message::Payload(v) => Some(mem::take(v)),
140    //         _ => None
141    //     }
142    // }
143
144    pub fn payload(&self) -> Option<&Payload<'_>> {
145        match self {
146            Message::Payload(v) => Some(v),
147            _ => None
148        }
149    }
150
151    pub fn payload_mut(&mut self) -> Option<&'a mut Payload<'_>> {
152        match self {
153            Message::Payload(v) => Some(v),
154            _ => None
155        }
156    }
157
158    // pub fn certificate_status(&self) -> Option<&CertificateStatus> {
159    //     match self {
160    //         Message::CertificateStatus(v) => Some(v),
161    //         _ => None
162    //     }
163    // }
164}
165
166#[derive(Debug, Copy, Clone)]
167pub enum HandshakeType {
168    ClientHello = 0x1,
169    ServerHello = 0x2,
170    NewSessionTicket = 0x4,
171    Certificate = 0xb,
172    ServerKeyExchange = 0xc,
173    CertificateRequest = 0xd,
174    ServerHelloDone = 0xe,
175    CertificateVerify = 0xf,
176    ClientKeyExchange = 0x10,
177    CipherSpec = 0x14,
178    CertificateStatus = 0x16,
179
180}
181
182impl HandshakeType {
183    pub fn from_byte(byte: u8) -> Option<HandshakeType> {
184        match byte {
185            0x1 => Some(HandshakeType::ClientHello),
186            0x2 => Some(HandshakeType::ServerHello),
187            0x4 => Some(HandshakeType::NewSessionTicket),
188            0xb => Some(HandshakeType::Certificate),
189            0xc => Some(HandshakeType::ServerKeyExchange),
190            0xd => Some(HandshakeType::CertificateRequest),
191            0xe => Some(HandshakeType::ServerHelloDone),
192            0xf => Some(HandshakeType::CertificateVerify),
193            0x10 => Some(HandshakeType::ClientKeyExchange),
194            0x14 => Some(HandshakeType::CipherSpec),
195            0x16 => Some(HandshakeType::CertificateStatus),
196            _ => None
197        }
198    }
199
200    pub fn as_u8(&self) -> u8 {
201        *self as u8
202    }
203}
reqtls/message/mod.rs

reqtls/message/
mod.rs
