tlspuffin/tls/rustls/
ticketer.rs1use std::sync::{Arc, Mutex, MutexGuard};
2use std::{mem, time};
3
4use ring::aead;
5
6use crate::tls::rustls::error::Error;
7use crate::tls::rustls::rand;
8use crate::tls::rustls::server::server_conn::ProducesTickets;
9
10#[derive(Clone, Copy, Debug)]
15pub struct TimeBase(time::Duration);
16
17impl TimeBase {
18 #[inline]
19 pub fn now() -> Result<Self, time::SystemTimeError> {
20 Ok(Self(
21 time::SystemTime::now().duration_since(time::UNIX_EPOCH)?,
22 ))
23 }
24
25 #[inline]
26 pub fn as_secs(&self) -> u64 {
27 self.0.as_secs()
28 }
29}
30
31struct AeadTicketer {
36 alg: &'static aead::Algorithm,
37 key: aead::LessSafeKey,
38 lifetime: u32,
39}
40
41impl AeadTicketer {
42 fn new() -> Result<Self, rand::GetRandomFailed> {
44 let mut key = [0u8; 32];
45 rand::fill_random(&mut key)?;
46
47 let alg = &aead::CHACHA20_POLY1305;
48 let key = aead::UnboundKey::new(alg, &key).unwrap();
49
50 Ok(Self {
51 alg,
52 key: aead::LessSafeKey::new(key),
53 lifetime: 60 * 60 * 12,
54 })
55 }
56}
57
58impl ProducesTickets for AeadTicketer {
59 fn enabled(&self) -> bool {
60 true
61 }
62
63 fn lifetime(&self) -> u32 {
64 self.lifetime
65 }
66
67 fn encrypt(&self, message: &[u8]) -> Option<Vec<u8>> {
69 let mut nonce_buf = [0u8; 12];
71 rand::fill_random(&mut nonce_buf).ok()?;
72 let nonce = ring::aead::Nonce::assume_unique_for_key(nonce_buf);
73 let aad = ring::aead::Aad::empty();
74
75 let mut ciphertext =
76 Vec::with_capacity(nonce_buf.len() + message.len() + self.key.algorithm().tag_len());
77 ciphertext.extend(&nonce_buf);
78 ciphertext.extend(message);
79 self.key
80 .seal_in_place_separate_tag(nonce, aad, &mut ciphertext[nonce_buf.len()..])
81 .map(|tag| {
82 ciphertext.extend(tag.as_ref());
83 ciphertext
84 })
85 .ok()
86 }
87
88 fn decrypt(&self, ciphertext: &[u8]) -> Option<Vec<u8>> {
90 let nonce = ciphertext.get(..self.alg.nonce_len())?;
92 let ciphertext = ciphertext.get(nonce.len()..)?;
93
94 let nonce = ring::aead::Nonce::try_assume_unique_for_key(nonce).ok()?;
96
97 let mut out = Vec::from(ciphertext);
98
99 let plain_len = self
100 .key
101 .open_in_place(nonce, aead::Aad::empty(), &mut out)
102 .ok()?
103 .len();
104 out.truncate(plain_len);
105
106 Some(out)
107 }
108}
109
110struct TicketSwitcherState {
111 next: Option<Box<dyn ProducesTickets>>,
112 current: Box<dyn ProducesTickets>,
113 previous: Option<Box<dyn ProducesTickets>>,
114 next_switch_time: u64,
115}
116
117struct TicketSwitcher {
121 generator: fn() -> Result<Box<dyn ProducesTickets>, rand::GetRandomFailed>,
122 lifetime: u32,
123 state: Mutex<TicketSwitcherState>,
124}
125
126impl TicketSwitcher {
127 fn new(
132 lifetime: u32,
133 generator: fn() -> Result<Box<dyn ProducesTickets>, rand::GetRandomFailed>,
134 ) -> Result<Self, Error> {
135 let now = TimeBase::now()?;
136 Ok(Self {
137 generator,
138 lifetime,
139 state: Mutex::new(TicketSwitcherState {
140 next: Some(generator()?),
141 current: generator()?,
142 previous: None,
143 next_switch_time: now.as_secs() + u64::from(lifetime),
144 }),
145 })
146 }
147
148 fn maybe_roll(&self, now: TimeBase) -> Option<MutexGuard<'_, TicketSwitcherState>> {
158 let now = now.as_secs();
186 let mut are_recovering = false; {
188 let mut state = self.state.lock().ok()?;
190
191 if now <= state.next_switch_time {
193 return Some(state);
194 }
195
196 if let Some(next) = state.next.take() {
198 state.previous = Some(mem::replace(&mut state.current, next));
199 state.next_switch_time = now + u64::from(self.lifetime);
200 } else {
201 are_recovering = true;
202 }
203 }
204
205 let next = (self.generator)().ok()?;
207 if !are_recovering {
208 let mut state = self.state.lock().ok()?;
210 state.next = Some(next);
211 Some(state)
212 } else {
213 let new_current = (self.generator)().ok()?;
217 let mut state = self.state.lock().ok()?;
218 state.next = Some(next);
219 if now > state.next_switch_time {
220 state.previous = Some(mem::replace(&mut state.current, new_current));
221 state.next_switch_time = now + u64::from(self.lifetime);
222 }
223 Some(state)
224 }
225 }
226}
227
228impl ProducesTickets for TicketSwitcher {
229 fn lifetime(&self) -> u32 {
230 self.lifetime * 2
231 }
232
233 fn enabled(&self) -> bool {
234 true
235 }
236
237 fn encrypt(&self, message: &[u8]) -> Option<Vec<u8>> {
238 let state = self.maybe_roll(TimeBase::now().ok()?)?;
239
240 state.current.encrypt(message)
241 }
242
243 fn decrypt(&self, ciphertext: &[u8]) -> Option<Vec<u8>> {
244 let state = self.maybe_roll(TimeBase::now().ok()?)?;
245
246 state.current.decrypt(ciphertext).or_else(|| {
248 state
249 .previous
250 .as_ref()
251 .and_then(|previous| previous.decrypt(ciphertext))
252 })
253 }
254}
255
256pub struct Ticketer {}
258
259fn generate_inner() -> Result<Box<dyn ProducesTickets>, rand::GetRandomFailed> {
260 Ok(Box::new(AeadTicketer::new()?))
261}
262
263impl Ticketer {
264 pub fn new() -> Result<Arc<dyn ProducesTickets>, Error> {
269 Ok(Arc::new(TicketSwitcher::new(6 * 60 * 60, generate_inner)?))
270 }
271}
272
273#[cfg(test)]
274mod tests {
275 use super::*;
276
277 #[test_log::test]
278 fn basic_pairwise_test() {
279 let t = Ticketer::new().unwrap();
280 assert!(t.enabled());
281 let cipher = t.encrypt(b"hello world").unwrap();
282 let plain = t.decrypt(&cipher).unwrap();
283 assert_eq!(plain, b"hello world");
284 }
285
286 #[test_log::test]
287 fn ticketswitcher_switching_test() {
288 let t = Arc::new(TicketSwitcher::new(1, generate_inner).unwrap());
289 let now = TimeBase::now().unwrap();
290 let cipher1 = t.encrypt(b"ticket 1").unwrap();
291 assert_eq!(t.decrypt(&cipher1).unwrap(), b"ticket 1");
292 {
293 t.maybe_roll(TimeBase(now.0 + std::time::Duration::from_secs(10)));
295 }
296 let cipher2 = t.encrypt(b"ticket 2").unwrap();
297 assert_eq!(t.decrypt(&cipher1).unwrap(), b"ticket 1");
298 assert_eq!(t.decrypt(&cipher2).unwrap(), b"ticket 2");
299 {
300 t.maybe_roll(TimeBase(now.0 + std::time::Duration::from_secs(20)));
302 }
303 let cipher3 = t.encrypt(b"ticket 3").unwrap();
304 assert!(t.decrypt(&cipher1).is_none());
305 assert_eq!(t.decrypt(&cipher2).unwrap(), b"ticket 2");
306 assert_eq!(t.decrypt(&cipher3).unwrap(), b"ticket 3");
307 }
308
309 fn fail_generator() -> Result<Box<dyn ProducesTickets>, rand::GetRandomFailed> {
310 Err(rand::GetRandomFailed)
311 }
312
313 #[test_log::test]
314 fn ticketswitcher_recover_test() {
315 let mut t = TicketSwitcher::new(1, generate_inner).unwrap();
316 let now = TimeBase::now().unwrap();
317 let cipher1 = t.encrypt(b"ticket 1").unwrap();
318 assert_eq!(t.decrypt(&cipher1).unwrap(), b"ticket 1");
319 t.generator = fail_generator;
320 {
321 t.maybe_roll(TimeBase(now.0 + std::time::Duration::from_secs(10)));
323 }
324 t.generator = generate_inner;
325 let cipher2 = t.encrypt(b"ticket 2").unwrap();
326 assert_eq!(t.decrypt(&cipher1).unwrap(), b"ticket 1");
327 assert_eq!(t.decrypt(&cipher2).unwrap(), b"ticket 2");
328 {
329 t.maybe_roll(TimeBase(now.0 + std::time::Duration::from_secs(20)));
331 }
332 let cipher3 = t.encrypt(b"ticket 3").unwrap();
333 assert!(t.decrypt(&cipher1).is_none());
334 assert_eq!(t.decrypt(&cipher2).unwrap(), b"ticket 2");
335 assert_eq!(t.decrypt(&cipher3).unwrap(), b"ticket 3");
336 }
337}