use std::collections::HashMap;
use std::net::{IpAddr, Ipv6Addr};
use std::sync::Mutex;
use std::time::{Duration, Instant};
use hyper::StatusCode;
use crate::config::Config;
use crate::handler::{HttpResponse, rate_limited, rejection, wants_json};
use crate::request::LuaRequest;
use nitr_core::Result;
const BUCKET_PURGE_THRESHOLD: usize = 10_000;
const BUCKET_PURGE_INTERVAL: Duration = Duration::from_secs(1);
const MAX_BUCKETS: usize = 200_000;
#[derive(Debug)]
pub(crate) struct Protection {
max_body_bytes: u64,
max_uri_bytes: usize,
trust_request_id: bool,
dev_mode: bool,
body_read: Option<Duration>,
pool_wait: Duration,
rate: Option<RateLimiter>,
form: crate::request::FormLimits,
cors: Option<crate::cors::Cors>,
compression: crate::compress::Compression,
response_headers: Vec<(hyper::header::HeaderName, hyper::header::HeaderValue)>,
#[cfg(feature = "openapi")]
docs: crate::openapi::docs::DocsSlot,
}
impl Protection {
#[cfg(feature = "openapi")]
pub(crate) fn docs(&self) -> Option<std::sync::Arc<crate::openapi::docs::OpenApiDocs>> {
self.docs.read().ok().and_then(|slot| slot.clone())
}
#[cfg(feature = "openapi")]
pub(crate) fn docs_slot(&self) -> crate::openapi::docs::DocsSlot {
self.docs.clone()
}
pub(crate) fn new(cfg: &Config) -> Self {
Self {
max_body_bytes: cfg.limits.max_body_bytes,
max_uri_bytes: cfg.limits.max_uri_bytes,
trust_request_id: cfg.trust_request_id,
dev_mode: cfg.dev_mode,
body_read: match cfg.limits.body_read_ms {
0 => None,
ms => Some(Duration::from_millis(ms)),
},
pool_wait: Duration::from_millis(cfg.limits.pool_wait_ms),
rate: cfg.rate_limit.enabled.then(|| {
RateLimiter::new(
cfg.rate_limit.requests,
Duration::from_secs(cfg.rate_limit.window),
cfg.rate_limit.trust_forwarded_for,
)
}),
form: crate::request::FormLimits {
max_parts: cfg.limits.max_form_parts.max(1),
max_field_bytes: cfg.limits.max_field_bytes,
max_file_bytes: cfg.limits.max_file_bytes,
upload_root: cfg.multipart.upload_dir.clone().map(std::sync::Arc::new),
},
cors: crate::cors::Cors::new(&cfg.cors),
compression: crate::compress::Compression::new(&cfg.compression),
response_headers: cfg
.headers
.iter()
.filter_map(|(name, value)| {
Some((
hyper::header::HeaderName::from_bytes(name.as_bytes()).ok()?,
hyper::header::HeaderValue::from_str(value).ok()?,
))
})
.collect(),
#[cfg(feature = "openapi")]
docs: std::sync::Arc::new(std::sync::RwLock::new(None)),
}
}
pub(crate) fn cors(&self) -> Option<&crate::cors::Cors> {
self.cors.as_ref()
}
pub(crate) fn compression(&self) -> &crate::compress::Compression {
&self.compression
}
pub(crate) fn apply_headers(&self, headers: &mut hyper::HeaderMap) {
for (name, value) in &self.response_headers {
headers.entry(name).or_insert_with(|| value.clone());
}
}
pub(crate) fn form_limits(&self) -> crate::request::FormLimits {
self.form.clone()
}
pub(crate) fn dev_mode(&self) -> bool {
self.dev_mode
}
pub(crate) fn pool_wait(&self) -> Duration {
self.pool_wait
}
pub(crate) fn body_read_timeout(&self) -> Option<Duration> {
self.body_read
}
pub(crate) fn max_body_bytes(&self) -> u64 {
self.max_body_bytes
}
pub(crate) fn request_id(&self, req: &hyper::Request<hyper::body::Incoming>) -> String {
self.request_id_for_parts(req.headers())
}
pub(crate) fn request_id_for_parts(&self, headers: &hyper::HeaderMap) -> String {
if self.trust_request_id
&& let Some(id) = headers
.get("x-request-id")
.and_then(|v| v.to_str().ok())
.filter(|v| {
!v.is_empty() && v.len() <= 64 && v.bytes().all(|b| b.is_ascii_graphic())
})
{
return id.to_string();
}
uuid::Uuid::now_v7().to_string()
}
pub(crate) fn check(&self, req: &LuaRequest) -> Option<Result<HttpResponse>> {
let wants_json = wants_json(req.req.headers());
if let Some(rate) = &self.rate
&& let Err(retry_after) = rate.check(req)
{
tracing::debug!(peer = %req.peer_addr, "request rate limited");
return Some(rate_limited(retry_after, wants_json));
}
if uri_len(req) > self.max_uri_bytes {
return Some(rejection(
StatusCode::URI_TOO_LONG,
"URI_TOO_LONG",
None,
wants_json,
));
}
if req
.req
.headers()
.get_all(hyper::header::AUTHORIZATION)
.iter()
.nth(1)
.is_some()
{
tracing::debug!(
peer = %req.peer_addr,
"request refused: more than one Authorization header"
);
return Some(rejection(
StatusCode::BAD_REQUEST,
"BAD_REQUEST",
None,
wants_json,
));
}
let declared = req
.req
.headers()
.get(hyper::header::CONTENT_LENGTH)
.and_then(|v| v.to_str().ok())
.and_then(|v| v.parse::<u64>().ok());
if declared.is_some_and(|len| len > self.max_body_bytes) {
return Some(rejection(
StatusCode::PAYLOAD_TOO_LARGE,
"PAYLOAD_TOO_LARGE",
None,
wants_json,
));
}
None
}
}
fn uri_len(req: &LuaRequest) -> usize {
let uri = req.req.uri();
uri.path().len() + uri.query().map_or(0, |q| q.len() + 1)
}
#[derive(Debug)]
pub(crate) struct RateLimiter {
max: u32,
window: Duration,
trust_forwarded_for: bool,
buckets: Mutex<Buckets>,
}
#[derive(Debug)]
struct Buckets {
map: HashMap<IpAddr, (Instant, u32)>,
last_purge: Instant,
}
impl RateLimiter {
pub(crate) fn new(max: u32, window: Duration, trust_forwarded_for: bool) -> Self {
Self {
max,
window,
trust_forwarded_for,
buckets: Mutex::new(Buckets {
map: HashMap::new(),
last_purge: Instant::now(),
}),
}
}
pub(crate) fn check(&self, req: &LuaRequest) -> std::result::Result<(), u64> {
self.check_with(req, nitr_std::clock::now_instant)
}
#[cfg(test)]
fn check_at(&self, req: &LuaRequest, now: Instant) -> std::result::Result<(), u64> {
self.check_with(req, || now)
}
fn check_with(
&self,
req: &LuaRequest,
clock: impl FnOnce() -> Instant,
) -> std::result::Result<(), u64> {
let key = self.client_key(req);
let mut buckets = match self.buckets.lock() {
Ok(guard) => guard,
Err(_) => return Ok(()),
};
let now = clock();
if buckets.map.len() > BUCKET_PURGE_THRESHOLD
&& now.duration_since(buckets.last_purge) >= BUCKET_PURGE_INTERVAL
{
let window = self.window;
buckets
.map
.retain(|_, (start, _)| now.duration_since(*start) < window);
buckets.last_purge = now;
}
if buckets.map.len() >= MAX_BUCKETS && !buckets.map.contains_key(&key) {
tracing::debug!(
peer = %req.peer_addr,
"rate limiter at its client cap; admitting a new client untracked"
);
return Ok(());
}
let bucket = buckets.map.entry(key).or_insert((now, 0));
if now
.checked_duration_since(bucket.0)
.is_none_or(|elapsed| elapsed >= self.window)
{
*bucket = (now, 0);
}
bucket.1 += 1;
if bucket.1 > self.max {
let elapsed = now.duration_since(bucket.0);
let retry = self.window.saturating_sub(elapsed).as_secs().max(1);
return Err(retry);
}
Ok(())
}
fn client_key(&self, req: &LuaRequest) -> IpAddr {
let ip = if self.trust_forwarded_for
&& let Some(ip) = req
.req
.headers()
.get_all("x-forwarded-for")
.iter()
.next_back()
.and_then(|v| v.to_str().ok())
.and_then(|v| v.rsplit(',').next())
.and_then(|v| v.trim().parse().ok())
{
ip
} else {
req.peer_addr.ip()
};
bucket_key(ip)
}
}
fn bucket_key(ip: IpAddr) -> IpAddr {
match ip.to_canonical() {
IpAddr::V4(v4) => IpAddr::V4(v4),
IpAddr::V6(v6) => {
let s = v6.segments();
IpAddr::V6(Ipv6Addr::new(s[0], s[1], s[2], s[3], 0, 0, 0, 0))
}
}
}
#[cfg(test)]
mod tests {
use hyper::header::HeaderValue;
use super::*;
use http_body_util::BodyExt as _;
fn limiter(max: u32, window_ms: u64, trust_forwarded_for: bool) -> RateLimiter {
RateLimiter::new(max, Duration::from_millis(window_ms), trust_forwarded_for)
}
fn request(peer: &str, forwarded_for: Option<&str>) -> LuaRequest {
let mut builder = hyper::Request::builder().uri("/");
if let Some(xff) = forwarded_for {
builder = builder.header("x-forwarded-for", xff);
}
let req = builder
.body(
http_body_util::Empty::<hyper::body::Bytes>::new()
.map_err(|err| match err {})
.boxed(),
)
.expect("request");
LuaRequest {
cached_body: None,
body_consumed: false,
valid: None,
spool_dir: None,
peer_addr: format!("{peer}:1234").parse().expect("addr"),
tls: false,
req,
params: Vec::new(),
id: "test".into(),
limits: Default::default(),
cached_form: None,
body_limit: u64::MAX,
}
}
#[test]
fn the_budget_applies_per_client_ip() {
let limiter = limiter(2, 60_000, false);
let a = request("10.0.0.1", None);
let b = request("10.0.0.2", None);
assert!(limiter.check(&a).is_ok());
assert!(limiter.check(&a).is_ok());
let retry = limiter.check(&a).expect_err("third request is over");
assert!(retry >= 1, "Retry-After must be at least a second");
assert!(limiter.check(&b).is_ok());
}
#[test]
fn the_window_resets_the_budget() {
let limiter = limiter(1, 30, false);
let req = request("10.0.0.1", None);
let t0 = Instant::now();
assert!(limiter.check_at(&req, t0).is_ok());
assert!(limiter.check_at(&req, t0).is_err(), "over budget in-window");
assert!(
limiter
.check_at(&req, t0 + Duration::from_millis(29))
.is_err()
);
assert!(
limiter
.check_at(&req, t0 + Duration::from_millis(30))
.is_ok(),
"a new window starts fresh"
);
}
#[test]
fn a_window_from_the_future_starts_over() {
let limiter = limiter(1, 60_000, false);
let req = request("10.0.0.1", None);
let now = Instant::now();
let advanced = now + Duration::from_secs(86_400);
assert!(limiter.check_at(&req, advanced).is_ok());
assert!(limiter.check_at(&req, advanced).is_err());
assert!(
limiter.check_at(&req, now).is_ok(),
"back at the real clock, the future window is gone"
);
assert!(limiter.check_at(&req, now).is_err(), "and counting resumes");
}
#[test]
fn stale_buckets_are_purged_past_the_threshold() {
let limiter = limiter(100, 1_000, false);
let t0 = Instant::now();
for n in 0..=BUCKET_PURGE_THRESHOLD as u32 {
let ip = format!("10.{}.{}.{}", n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff);
assert!(limiter.check_at(&request(&ip, None), t0).is_ok());
}
assert!(
limiter.buckets.lock().expect("buckets").map.len() > BUCKET_PURGE_THRESHOLD,
"the map must actually be past the threshold for the purge to be tested"
);
let later = t0 + Duration::from_millis(1_500);
assert!(
limiter
.check_at(&request("192.168.0.1", None), later)
.is_ok()
);
assert_eq!(
limiter.buckets.lock().expect("buckets").map.len(),
1,
"stale buckets must be evicted, not accumulate forever"
);
}
#[test]
fn purges_are_spaced_out_not_paid_per_request() {
let limiter = limiter(100, 60_000, false);
let t0 = Instant::now();
for n in 0..=BUCKET_PURGE_THRESHOLD as u32 {
let ip = format!("10.{}.{}.{}", n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff);
assert!(limiter.check_at(&request(&ip, None), t0).is_ok());
}
let t1 = t0 + BUCKET_PURGE_INTERVAL + Duration::from_millis(1);
assert!(limiter.check_at(&request("192.168.0.1", None), t1).is_ok());
let stamped = limiter.buckets.lock().expect("buckets").last_purge;
assert!(
limiter
.check_at(&request("192.168.0.2", None), t1 + Duration::from_millis(1))
.is_ok()
);
assert_eq!(
limiter.buckets.lock().expect("buckets").last_purge,
stamped,
"a second purge inside the interval must not run"
);
}
#[test]
fn ipv6_clients_are_keyed_by_their_64() {
let rl = limiter(1, 60_000, false);
assert!(rl.check(&request("[2001:db8:1:2::1]", None)).is_ok());
assert!(
rl.check(&request("[2001:db8:1:2:ffff::9]", None)).is_err(),
"the same /64 is the same client"
);
assert!(
rl.check(&request("[2001:db8:1:3::1]", None)).is_ok(),
"a different /64 is a different client"
);
assert_eq!(
bucket_key("::ffff:10.0.0.1".parse().expect("ip")),
"10.0.0.1".parse::<IpAddr>().expect("ip")
);
}
#[test]
fn trusted_request_ids_validate_the_shape_edges() {
let cfg = Config {
trust_request_id: true,
..Default::default()
};
let protection = Protection::new(&cfg);
let id_for = |value: &[u8]| {
let mut headers = hyper::HeaderMap::new();
headers.insert(
"x-request-id",
HeaderValue::from_bytes(value).expect("header value"),
);
protection.request_id_for_parts(&headers)
};
assert_eq!(id_for(b"req-from-proxy-1"), "req-from-proxy-1");
let at_cap = "a".repeat(64);
assert_eq!(id_for(at_cap.as_bytes()), at_cap);
let over_cap = "a".repeat(65).into_bytes();
for bad in [&over_cap[..], b"", b"has space", "caf\u{e9}".as_bytes()] {
let id = id_for(bad);
assert_ne!(id.as_bytes(), bad, "{bad:?} must not be echoed");
assert!(
uuid::Uuid::parse_str(&id).is_ok(),
"the replacement must be a generated UUID, got `{id}`"
);
}
let untrusted = Protection::new(&Config::default());
let mut headers = hyper::HeaderMap::new();
headers.insert("x-request-id", HeaderValue::from_static("req-1"));
assert_ne!(untrusted.request_id_for_parts(&headers), "req-1");
}
#[test]
fn forwarded_for_is_honored_only_when_trusted() {
let rl = limiter(1, 60_000, false);
assert!(rl.check(&request("10.0.0.9", Some("1.1.1.1"))).is_ok());
assert!(
rl.check(&request("10.0.0.9", Some("2.2.2.2"))).is_err(),
"spoofing the header must not buy a fresh budget"
);
let rl = limiter(1, 60_000, true);
assert!(
rl.check(&request("10.0.0.9", Some("1.1.1.1, 9.9.9.9")))
.is_ok()
);
assert!(
rl.check(&request("10.0.0.9", Some("2.2.2.2, 9.9.9.9")))
.is_err(),
"a spoofed first entry must not buy a fresh budget"
);
assert!(rl.check(&request("10.0.0.9", Some("9.9.9.9"))).is_err());
assert!(
rl.check(&request("10.0.0.9", Some("2.2.2.2"))).is_ok(),
"a different client gets its own budget"
);
assert!(rl.check(&request("10.0.0.9", Some("not-an-ip"))).is_ok());
let rl = limiter(1, 60_000, true);
let two_lines = |first: &str| {
let mut req = request("10.0.0.9", Some(first));
req.req
.headers_mut()
.append("x-forwarded-for", HeaderValue::from_static("9.9.9.9"));
req
};
assert!(rl.check(&two_lines("1.1.1.1")).is_ok());
assert!(
rl.check(&two_lines("2.2.2.2")).is_err(),
"a fresh first line must not buy a fresh budget"
);
}
}