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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
use crate::alert::*;
use crate::connection::*;
use crate::handshake::ServerHandshake;
use crate::key_schedule::KeySchedule;
use crate::record::{ClientRecord, ServerRecord};
use crate::{
traits::{AsyncRead, AsyncWrite},
TlsError,
};
use rand_core::{CryptoRng, RngCore};
use crate::application_data::ApplicationData;
use heapless::spsc::Queue;
pub use crate::config::*;
// Some space needed by TLS record
const TLS_RECORD_OVERHEAD: usize = 128;
/// Type representing an async TLS connection. An instance of this type can
/// be used to establish a TLS connection, write and read encrypted data over this connection,
/// and closing to free up the underlying resources.
pub struct TlsConnection<'a, Socket, CipherSuite>
where
Socket: AsyncRead + AsyncWrite + 'a,
CipherSuite: TlsCipherSuite + 'static,
{
delegate: Socket,
key_schedule: KeySchedule<CipherSuite::Hash, CipherSuite::KeyLen, CipherSuite::IvLen>,
record_buf: &'a mut [u8],
opened: bool,
}
impl<'a, Socket, CipherSuite> TlsConnection<'a, Socket, CipherSuite>
where
Socket: AsyncRead + AsyncWrite + 'a,
CipherSuite: TlsCipherSuite + 'static,
{
/// Create a new TLS connection with the provided context and a async I/O implementation
///
/// NOTE: The record buffer should be sized to fit an encrypted TLS record and the TLS handshake
/// record. The maximum value of a TLS record is 16 kB, which should be a safe value to use.
pub fn new(delegate: Socket, record_buf: &'a mut [u8]) -> Self {
Self {
delegate,
opened: false,
key_schedule: KeySchedule::new(),
record_buf,
}
}
/// Open a TLS connection, performing the handshake with the configuration provided when creating
/// the connection instance.
///
/// The handshake may support certificates up to CERT_SIZE.
///
/// Returns an error if the handshake does not proceed. If an error occurs, the connection instance
/// must be recreated.
pub async fn open<
'm,
RNG: CryptoRng + RngCore + 'static,
Clock: TlsClock + 'static,
const CERT_SIZE: usize,
>(
&mut self,
context: TlsContext<'m, CipherSuite, RNG>,
) -> Result<(), TlsError>
where
'a: 'm,
{
let mut handshake: Handshake<CipherSuite, CERT_SIZE> = Handshake::new();
let mut state = State::ClientHello;
loop {
let next_state = state
.process::<_, _, _, Clock, CERT_SIZE>(
&mut self.delegate,
&mut handshake,
&mut self.record_buf,
&mut self.key_schedule,
context.config,
context.rng,
)
.await?;
trace!("State {:?} -> {:?}", state, next_state);
state = next_state;
if let State::ApplicationData = state {
self.opened = true;
break;
}
}
Ok(())
}
/// Encrypt and send the provided slice over the connection. The connection
/// must be opened before writing.
///
/// Returns the number of bytes written.
pub async fn write(&mut self, buf: &[u8]) -> Result<usize, TlsError> {
if self.opened {
let mut wp = 0;
let mut remaining = buf.len();
let max_block_size = self.record_buf.len() - TLS_RECORD_OVERHEAD;
while remaining > 0 {
let delegate = &mut self.delegate;
let key_schedule = &mut self.key_schedule;
let to_write = core::cmp::min(remaining, max_block_size);
let record: ClientRecord<'a, '_, CipherSuite> =
ClientRecord::ApplicationData(&buf[wp..to_write]);
let (_, len) = encode_record(&mut self.record_buf, key_schedule, &record)?;
delegate.write(&self.record_buf[..len]).await?;
key_schedule.increment_write_counter();
wp += to_write;
remaining -= to_write;
}
Ok(buf.len())
} else {
Err(TlsError::MissingHandshake)
}
}
/// Read and decrypt data filling the provided slice. The slice must be able to
/// keep the expected amount of data that can be received in one record to avoid
/// loosing data.
pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, TlsError> {
if self.opened {
let mut remaining = buf.len();
// Note: Read only a single ApplicationData record for now, as we don't do any buffering.
while remaining == buf.len() {
let socket = &mut self.delegate;
let key_schedule = &mut self.key_schedule;
let record = decode_record::<Socket, CipherSuite>(
socket,
&mut self.record_buf,
key_schedule,
)
.await?;
let mut records = Queue::new();
decrypt_record::<CipherSuite>(key_schedule, &mut records, record)?;
while let Some(record) = records.dequeue() {
match record {
ServerRecord::ApplicationData(ApplicationData { header: _, data }) => {
trace!("Got application data record");
if buf.len() < data.len() {
warn!("Passed buffer is too small");
Err(TlsError::EncodeError)
} else {
let to_copy = core::cmp::min(data.len(), buf.len());
// TODO Need to buffer data not consumed
trace!("Got {} bytes to copy", to_copy);
buf[..to_copy].copy_from_slice(&data.as_slice()[..to_copy]);
remaining -= to_copy;
Ok(())
}
}
ServerRecord::Alert(alert) => {
if let AlertDescription::CloseNotify = alert.description {
Err(TlsError::ConnectionClosed)
} else {
Err(TlsError::InternalError)
}
}
ServerRecord::ChangeCipherSpec(_) => Err(TlsError::InternalError),
ServerRecord::Handshake(ServerHandshake::NewSessionTicket(_)) => {
// Ignore
Ok(())
}
_ => {
unimplemented!()
}
}?;
}
}
Ok(buf.len() - remaining)
} else {
Err(TlsError::MissingHandshake)
}
}
/// Close a connection instance, returning the ownership of the config, random generator and the async I/O provider.
pub async fn close(self) -> Result<Socket, TlsError> {
let record = ClientRecord::Alert(
Alert::new(AlertLevel::Warning, AlertDescription::CloseNotify),
self.opened,
);
let mut key_schedule = self.key_schedule;
let mut delegate = self.delegate;
let mut record_buf = self.record_buf;
let (_, len) = encode_record::<CipherSuite>(&mut record_buf, &mut key_schedule, &record)?;
delegate.write(&record_buf[..len]).await?;
key_schedule.increment_write_counter();
Ok(delegate)
}
}