rustls/ticketer.rs
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 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
use alloc::boxed::Box;
use alloc::vec::Vec;
use core::mem;
use pki_types::UnixTime;
use crate::lock::{Mutex, MutexGuard};
use crate::server::ProducesTickets;
#[cfg(not(feature = "std"))]
use crate::time_provider::TimeProvider;
use crate::{rand, Error};
#[derive(Debug)]
pub(crate) struct TicketSwitcherState {
next: Option<Box<dyn ProducesTickets>>,
current: Box<dyn ProducesTickets>,
previous: Option<Box<dyn ProducesTickets>>,
next_switch_time: u64,
}
/// A ticketer that has a 'current' sub-ticketer and a single
/// 'previous' ticketer. It creates a new ticketer every so
/// often, demoting the current ticketer.
#[cfg_attr(feature = "std", derive(Debug))]
pub struct TicketSwitcher {
pub(crate) generator: fn() -> Result<Box<dyn ProducesTickets>, rand::GetRandomFailed>,
lifetime: u32,
state: Mutex<TicketSwitcherState>,
#[cfg(not(feature = "std"))]
time_provider: &'static dyn TimeProvider,
}
impl TicketSwitcher {
/// Creates a new `TicketSwitcher`, which rotates through sub-ticketers
/// based on the passage of time.
///
/// `lifetime` is in seconds, and is how long the current ticketer
/// is used to generate new tickets. Tickets are accepted for no
/// longer than twice this duration. `generator` produces a new
/// `ProducesTickets` implementation.
#[cfg(feature = "std")]
pub fn new(
lifetime: u32,
generator: fn() -> Result<Box<dyn ProducesTickets>, rand::GetRandomFailed>,
) -> Result<Self, Error> {
Ok(Self {
generator,
lifetime,
state: Mutex::new(TicketSwitcherState {
next: Some(generator()?),
current: generator()?,
previous: None,
next_switch_time: UnixTime::now()
.as_secs()
.saturating_add(u64::from(lifetime)),
}),
})
}
/// Creates a new `TicketSwitcher`, which rotates through sub-ticketers
/// based on the passage of time.
///
/// `lifetime` is in seconds, and is how long the current ticketer
/// is used to generate new tickets. Tickets are accepted for no
/// longer than twice this duration. `generator` produces a new
/// `ProducesTickets` implementation.
#[cfg(not(feature = "std"))]
pub fn new<M: crate::lock::MakeMutex>(
lifetime: u32,
generator: fn() -> Result<Box<dyn ProducesTickets>, rand::GetRandomFailed>,
time_provider: &'static dyn TimeProvider,
) -> Result<Self, Error> {
Ok(Self {
generator,
lifetime,
state: Mutex::new::<M>(TicketSwitcherState {
next: Some(generator()?),
current: generator()?,
previous: None,
next_switch_time: time_provider
.current_time()
.unwrap()
.as_secs()
.saturating_add(u64::from(lifetime)),
}),
time_provider,
})
}
/// If it's time, demote the `current` ticketer to `previous` (so it
/// does no new encryptions but can do decryption) and use next for a
/// new `current` ticketer.
///
/// Calling this regularly will ensure timely key erasure. Otherwise,
/// key erasure will be delayed until the next encrypt/decrypt call.
///
/// For efficiency, this is also responsible for locking the state mutex
/// and returning the mutexguard.
pub(crate) fn maybe_roll(&self, now: UnixTime) -> Option<MutexGuard<'_, TicketSwitcherState>> {
// The code below aims to make switching as efficient as possible
// in the common case that the generator never fails. To achieve this
// we run the following steps:
// 1. If no switch is necessary, just return the mutexguard
// 2. Shift over all of the ticketers (so current becomes previous,
// and next becomes current). After this, other threads can
// start using the new current ticketer.
// 3. unlock mutex and generate new ticketer.
// 4. Place new ticketer in next and return current
//
// There are a few things to note here. First, we don't check whether
// a new switch might be needed in step 4, even though, due to locking
// and entropy collection, significant amounts of time may have passed.
// This is to guarantee that the thread doing the switch will eventually
// make progress.
//
// Second, because next may be None, step 2 can fail. In that case
// we enter a recovery mode where we generate 2 new ticketers, one for
// next and one for the current ticketer. We then take the mutex a
// second time and redo the time check to see if a switch is still
// necessary.
//
// This somewhat convoluted approach ensures good availability of the
// mutex, by ensuring that the state is usable and the mutex not held
// during generation. It also ensures that, so long as the inner
// ticketer never generates panics during encryption/decryption,
// we are guaranteed to never panic when holding the mutex.
let now = now.as_secs();
let mut are_recovering = false; // Are we recovering from previous failure?
{
// Scope the mutex so we only take it for as long as needed
let mut state = self.state.lock()?;
// Fast path in case we do not need to switch to the next ticketer yet
if now <= state.next_switch_time {
return Some(state);
}
// Make the switch, or mark for recovery if not possible
if let Some(next) = state.next.take() {
state.previous = Some(mem::replace(&mut state.current, next));
state.next_switch_time = now.saturating_add(u64::from(self.lifetime));
} else {
are_recovering = true;
}
}
// We always need a next, so generate it now
let next = (self.generator)().ok()?;
if !are_recovering {
// Normal path, generate new next and place it in the state
let mut state = self.state.lock()?;
state.next = Some(next);
Some(state)
} else {
// Recovering, generate also a new current ticketer, and modify state
// as needed. (we need to redo the time check, otherwise this might
// result in very rapid switching of ticketers)
let new_current = (self.generator)().ok()?;
let mut state = self.state.lock()?;
state.next = Some(next);
if now > state.next_switch_time {
state.previous = Some(mem::replace(&mut state.current, new_current));
state.next_switch_time = now.saturating_add(u64::from(self.lifetime));
}
Some(state)
}
}
}
impl ProducesTickets for TicketSwitcher {
fn lifetime(&self) -> u32 {
self.lifetime * 2
}
fn enabled(&self) -> bool {
true
}
fn encrypt(&self, message: &[u8]) -> Option<Vec<u8>> {
#[cfg(feature = "std")]
let now = UnixTime::now();
#[cfg(not(feature = "std"))]
let now = self
.time_provider
.current_time()
.unwrap();
self.maybe_roll(now)?
.current
.encrypt(message)
}
fn decrypt(&self, ciphertext: &[u8]) -> Option<Vec<u8>> {
#[cfg(feature = "std")]
let now = UnixTime::now();
#[cfg(not(feature = "std"))]
let now = self
.time_provider
.current_time()
.unwrap();
let state = self.maybe_roll(now)?;
// Decrypt with the current key; if that fails, try with the previous.
state
.current
.decrypt(ciphertext)
.or_else(|| {
state
.previous
.as_ref()
.and_then(|previous| previous.decrypt(ciphertext))
})
}
}
#[cfg(not(feature = "std"))]
impl core::fmt::Debug for TicketSwitcher {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("TicketSwitcher")
.field("generator", &self.generator)
.field("lifetime", &self.lifetime)
.field("state", &**self.state.lock().unwrap())
.finish()
}
}