use crate::telemetry::SecurityStore;
use axum::{extract::Request, middleware::Next, response::Response};
use std::time::{Duration, Instant};
#[derive(Clone, Debug)]
pub struct TimingGuardConfig {
pub min_duration: Duration,
pub max_jitter: Duration,
pub enable_synthetic_cpu_cycles: bool,
}
impl Default for TimingGuardConfig {
fn default() -> Self {
Self {
min_duration: Duration::from_millis(250),
max_jitter: Duration::from_millis(20),
enable_synthetic_cpu_cycles: true,
}
}
}
pub struct TimingScope {
start_time: Instant,
config: TimingGuardConfig,
}
impl TimingScope {
pub fn start(config: TimingGuardConfig) -> Self {
Self {
start_time: Instant::now(),
config,
}
}
pub async fn finish(self) {
let elapsed = self.start_time.elapsed();
let jitter_micros = if self.config.max_jitter.as_micros() > 0 {
(rand::random::<u32>() as u128) % self.config.max_jitter.as_micros()
} else {
0
};
let target_duration =
self.config.min_duration + Duration::from_micros(jitter_micros as u64);
if elapsed < target_duration {
let sleep_needed = target_duration - elapsed;
tokio::time::sleep(sleep_needed).await;
}
SecurityStore::global().inc_timing_guard_protected();
}
pub async fn finish_with_synthetic_work(self) {
if self.config.enable_synthetic_cpu_cycles {
synthetic_argon2_cpu_work();
}
self.finish().await;
}
}
pub fn synthetic_argon2_cpu_work() {
use sha2::{Digest, Sha256};
let mut state = [0x5au8; 32];
for i in 0u64..1_500u64 {
let mut hasher = Sha256::new();
hasher.update(state);
hasher.update(i.to_be_bytes());
state = hasher.finalize().into();
}
std::hint::black_box(state);
}
pub async fn equalize_response_time<F, Fut, T>(config: TimingGuardConfig, action: F) -> T
where
F: FnOnce() -> Fut,
Fut: std::future::Future<Output = T>,
{
let scope = TimingScope::start(config);
let result = action().await;
scope.finish().await;
result
}
pub async fn timing_guard_middleware(req: Request, next: Next) -> Response {
let scope = TimingScope::start(TimingGuardConfig::default());
let response = next.run(req).await;
scope.finish().await;
response
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_timing_guard_normalizes_fast_execution() {
let config = TimingGuardConfig {
min_duration: Duration::from_millis(50),
max_jitter: Duration::from_millis(5),
enable_synthetic_cpu_cycles: false,
};
let start = Instant::now();
let result = equalize_response_time(config, || async {
42
})
.await;
let elapsed = start.elapsed();
assert_eq!(result, 42);
assert!(
elapsed >= Duration::from_millis(48),
"Expected at least ~50ms duration, got {:?}",
elapsed
);
}
#[tokio::test]
async fn test_timing_guard_preserves_slow_execution() {
let config = TimingGuardConfig {
min_duration: Duration::from_millis(20),
max_jitter: Duration::from_millis(2),
enable_synthetic_cpu_cycles: false,
};
let start = Instant::now();
let result = equalize_response_time(config, || async {
tokio::time::sleep(Duration::from_millis(35)).await;
"done"
})
.await;
let elapsed = start.elapsed();
assert_eq!(result, "done");
assert!(elapsed >= Duration::from_millis(34));
}
#[test]
#[cfg_attr(miri, ignore)]
fn test_synthetic_cpu_work_runs_safely() {
synthetic_argon2_cpu_work();
}
#[test]
fn default_configuration_is_security_conservative() {
let config = TimingGuardConfig::default();
assert_eq!(config.min_duration, Duration::from_millis(250));
assert_eq!(config.max_jitter, Duration::from_millis(20));
assert!(config.enable_synthetic_cpu_cycles);
}
#[tokio::test]
async fn synthetic_finish_supports_enabled_and_disabled_modes() {
for enabled in [false, true] {
TimingScope::start(TimingGuardConfig {
min_duration: Duration::ZERO,
max_jitter: Duration::ZERO,
enable_synthetic_cpu_cycles: enabled,
})
.finish_with_synthetic_work()
.await;
}
}
#[tokio::test]
async fn middleware_returns_the_inner_response_after_padding() {
use axum::{Router, body::Body, http::Request, middleware, routing::get};
use tower::ServiceExt;
let app = Router::new()
.route("/", get(|| async { "protected" }))
.layer(middleware::from_fn(timing_guard_middleware));
let started = Instant::now();
let response = app
.oneshot(
Request::get("/")
.body(Body::empty())
.expect("request should be valid"),
)
.await
.expect("middleware request should complete");
assert!(started.elapsed() >= Duration::from_millis(245));
assert_eq!(response.status(), axum::http::StatusCode::OK);
}
}