use std::{fmt, time::Duration};
use axum::{
Router,
body::{Body, to_bytes},
extract::MatchedPath,
http::header::{ACCEPT, AUTHORIZATION, CONTENT_TYPE},
http::{HeaderMap, HeaderName, HeaderValue, Method, Request, StatusCode},
middleware::{self, Next},
response::IntoResponse,
};
#[cfg(feature = "config")]
use serde::{Deserialize, Serialize};
use thiserror::Error;
use tower_http::{
compression::CompressionLayer,
cors::{AllowOrigin, CorsLayer},
timeout::TimeoutLayer,
trace::TraceLayer,
};
use tracing::Level;
use super::trusted_proxy::ForwardedHeadersPolicy;
#[cfg(feature = "config")]
use crate::config::{
ConfigIssueCollector, ConfigValidationError, SettingsAdapter, ValidateSettings,
};
use crate::http::{
ApiProblem, HttpMetricsLayer, IdempotencyLayer, IdempotencyRequestPolicy, IdempotencyRuntime,
ProblemCode, RateLimitError, RateLimitLayer, RateLimitRequestPolicy, RateLimitRuntime,
RequestContext, request_context_middleware_with_forwarded_policy,
};
use crate::result::{ClassifyError, ErrorKind};
#[cfg(feature = "config")]
use crate::{
http::{
DEFAULT_IDEMPOTENCY_MAX_BODY_BYTES, DEFAULT_IDEMPOTENCY_PROCESSING_TTL,
DEFAULT_IDEMPOTENCY_TTL, MemoryIdempotencyStore, RateLimitConfig, RateLimitKeySource,
TrustedProxyConfig,
},
net::IpNetworkSet,
};
pub const DEFAULT_HTTP_TIMEOUT: Duration = Duration::from_secs(30);
pub const DEFAULT_HTTP_REQUEST_BODY_LIMIT: usize = 2 * 1024 * 1024;
pub const DEFAULT_HSTS_MAX_AGE: Duration = Duration::from_secs(31_536_000);
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum CorsPolicy {
Disabled,
Permissive,
Restricted(CorsConfig),
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct CorsConfig {
allowed_origins: Vec<HeaderValue>,
allowed_methods: Vec<Method>,
allowed_headers: Vec<HeaderName>,
exposed_headers: Vec<HeaderName>,
allow_credentials: bool,
max_age: Option<Duration>,
}
impl CorsConfig {
#[must_use]
pub fn new(allowed_origins: impl IntoIterator<Item = HeaderValue>) -> Self {
Self {
allowed_origins: allowed_origins.into_iter().collect(),
allowed_methods: vec![
Method::GET,
Method::POST,
Method::PUT,
Method::PATCH,
Method::DELETE,
],
allowed_headers: default_cors_allowed_headers(),
exposed_headers: default_cors_exposed_headers(),
allow_credentials: false,
max_age: Some(Duration::from_secs(10 * 60)),
}
}
pub fn from_origin_strs(
origins: impl IntoIterator<Item = impl AsRef<str>>,
) -> Result<Self, axum::http::header::InvalidHeaderValue> {
let origins = origins
.into_iter()
.map(|origin| HeaderValue::from_str(origin.as_ref().trim()))
.collect::<Result<Vec<_>, _>>()?;
Ok(Self::new(origins))
}
#[must_use]
pub fn allow_methods(mut self, methods: impl IntoIterator<Item = Method>) -> Self {
self.allowed_methods = methods.into_iter().collect();
self
}
#[must_use]
pub fn allow_headers(mut self, headers: impl IntoIterator<Item = HeaderName>) -> Self {
self.allowed_headers = headers.into_iter().collect();
self
}
#[must_use]
pub fn expose_headers(mut self, headers: impl IntoIterator<Item = HeaderName>) -> Self {
self.exposed_headers = headers.into_iter().collect();
self
}
#[must_use]
pub const fn allow_credentials(mut self, allow_credentials: bool) -> Self {
self.allow_credentials = allow_credentials;
self
}
#[must_use]
pub const fn max_age(mut self, max_age: Option<Duration>) -> Self {
self.max_age = max_age;
self
}
#[must_use]
pub fn allowed_origins(&self) -> &[HeaderValue] {
&self.allowed_origins
}
#[must_use]
pub fn allowed_methods(&self) -> &[Method] {
&self.allowed_methods
}
#[must_use]
pub fn allowed_headers(&self) -> &[HeaderName] {
&self.allowed_headers
}
#[must_use]
pub fn exposed_headers(&self) -> &[HeaderName] {
&self.exposed_headers
}
#[must_use]
pub const fn credentials_allowed(&self) -> bool {
self.allow_credentials
}
#[must_use]
pub const fn max_age_value(&self) -> Option<Duration> {
self.max_age
}
pub fn validate(&self) -> Result<(), HttpLayerError> {
if self.allowed_origins.is_empty()
|| self
.allowed_origins
.iter()
.any(|origin| origin.as_bytes().is_empty())
{
return Err(HttpLayerError::CorsAllowedOriginsEmpty);
}
if self.allow_credentials
&& self
.allowed_origins
.iter()
.any(|origin| origin.as_bytes() == b"*")
{
return Err(HttpLayerError::CorsWildcardOriginWithCredentials);
}
Ok(())
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct HttpLayerConfig {
request_context: bool,
forwarded_headers: ForwardedHeadersPolicy,
trace: bool,
cors: CorsPolicy,
security_headers: Option<SecurityHeadersConfig>,
timeout: Option<Duration>,
request_body_limit: Option<usize>,
compression: bool,
rate_limit: Option<RateLimitRuntime>,
idempotency: Option<IdempotencyRuntime>,
metrics: Option<HttpMetricsLayer>,
request_policy: HttpRequestPolicy,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum RequestBodyLimitPolicy {
Disabled,
Bytes(usize),
}
impl RequestBodyLimitPolicy {
#[must_use]
pub const fn from_optional(value: Option<usize>) -> Self {
match value {
Some(value) => Self::Bytes(value),
None => Self::Disabled,
}
}
#[must_use]
pub const fn as_optional(self) -> Option<usize> {
match self {
Self::Disabled => None,
Self::Bytes(value) => Some(value),
}
}
pub fn validate(self) -> Result<(), HttpLayerError> {
if matches!(self, Self::Bytes(0)) {
return Err(HttpLayerError::InvalidRequestBodyLimit);
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct HttpRequestPolicy {
default_rate_limit: RateLimitRequestPolicy,
default_idempotency: IdempotencyRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
rules: Vec<HttpRouteRule>,
}
impl Default for HttpRequestPolicy {
fn default() -> Self {
Self {
default_rate_limit: RateLimitRequestPolicy::Enabled,
default_idempotency: IdempotencyRequestPolicy::HeaderOptional,
default_request_body_limit: RequestBodyLimitPolicy::Disabled,
rules: Vec::new(),
}
}
}
impl HttpRequestPolicy {
#[must_use]
pub fn disabled() -> Self {
Self {
default_rate_limit: RateLimitRequestPolicy::Disabled,
default_idempotency: IdempotencyRequestPolicy::Disabled,
default_request_body_limit: RequestBodyLimitPolicy::Disabled,
rules: Vec::new(),
}
}
#[must_use]
pub const fn with_default_rate_limit(mut self, policy: RateLimitRequestPolicy) -> Self {
self.default_rate_limit = policy;
self
}
#[must_use]
pub const fn with_default_idempotency(mut self, policy: IdempotencyRequestPolicy) -> Self {
self.default_idempotency = policy;
self
}
#[must_use]
pub const fn with_default_request_body_limit(mut self, policy: RequestBodyLimitPolicy) -> Self {
self.default_request_body_limit = policy;
self
}
#[must_use]
pub fn with_rule(mut self, rule: HttpRouteRule) -> Self {
self.rules.push(rule);
self
}
#[must_use]
pub fn with_rules(mut self, rules: impl IntoIterator<Item = HttpRouteRule>) -> Self {
self.rules.extend(rules);
self
}
#[must_use]
pub fn rules(&self) -> &[HttpRouteRule] {
&self.rules
}
#[must_use]
pub const fn default_rate_limit(&self) -> RateLimitRequestPolicy {
self.default_rate_limit
}
#[must_use]
pub const fn default_idempotency(&self) -> IdempotencyRequestPolicy {
self.default_idempotency
}
#[must_use]
pub const fn default_request_body_limit(&self) -> RequestBodyLimitPolicy {
self.default_request_body_limit
}
#[must_use]
pub fn policy_for<B>(&self, request: &Request<B>) -> EffectiveHttpRequestPolicy {
let mut policy = EffectiveHttpRequestPolicy {
rate_limit: self.default_rate_limit,
idempotency: self.default_idempotency,
request_body_limit: self.default_request_body_limit,
};
for rule in &self.rules {
if !rule.matches(request) {
continue;
}
if let Some(rate_limit) = rule.rate_limit {
policy.rate_limit = rate_limit;
}
if let Some(idempotency) = rule.idempotency {
policy.idempotency = idempotency;
}
if let Some(request_body_limit) = rule.request_body_limit {
policy.request_body_limit = request_body_limit;
}
}
policy
}
#[must_use]
pub fn has_request_body_limit_overrides(&self) -> bool {
!matches!(
self.default_request_body_limit,
RequestBodyLimitPolicy::Disabled
) || self
.rules
.iter()
.any(|rule| rule.request_body_limit.is_some())
}
fn request_body_limit_for<B>(
&self,
request: &Request<B>,
fallback: RequestBodyLimitPolicy,
) -> RequestBodyLimitPolicy {
let mut policy = match self.default_request_body_limit {
RequestBodyLimitPolicy::Disabled => fallback,
configured => configured,
};
for rule in &self.rules {
if rule.matches(request)
&& let Some(configured) = rule.request_body_limit
{
policy = configured;
}
}
policy
}
pub fn validate(&self) -> Result<(), HttpLayerError> {
self.default_request_body_limit.validate()?;
for rule in &self.rules {
rule.validate()?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct HttpRouteRule {
matcher: RouteMatcher,
methods: Vec<Method>,
rate_limit: Option<RateLimitRequestPolicy>,
idempotency: Option<IdempotencyRequestPolicy>,
request_body_limit: Option<RequestBodyLimitPolicy>,
}
impl HttpRouteRule {
#[must_use]
pub fn any() -> Self {
Self::new(RouteMatcher::Any)
}
#[must_use]
pub fn exact(path: impl Into<String>) -> Self {
Self::new(RouteMatcher::Exact(path.into()))
}
#[must_use]
pub fn prefix(prefix: impl Into<String>) -> Self {
Self::new(RouteMatcher::Prefix(prefix.into()))
}
#[must_use]
pub fn raw_prefix(prefix: impl Into<String>) -> Self {
Self::new(RouteMatcher::RawPrefix(prefix.into()))
}
#[must_use]
pub fn new(matcher: RouteMatcher) -> Self {
Self {
matcher,
methods: Vec::new(),
rate_limit: None,
idempotency: None,
request_body_limit: None,
}
}
#[must_use]
pub fn methods(mut self, methods: impl IntoIterator<Item = Method>) -> Self {
self.methods = methods.into_iter().collect();
self
}
#[must_use]
pub const fn rate_limit(mut self, policy: RateLimitRequestPolicy) -> Self {
self.rate_limit = Some(policy);
self
}
#[must_use]
pub const fn idempotency(mut self, policy: IdempotencyRequestPolicy) -> Self {
self.idempotency = Some(policy);
self
}
#[must_use]
pub const fn request_body_limit(mut self, policy: RequestBodyLimitPolicy) -> Self {
self.request_body_limit = Some(policy);
self
}
#[must_use]
pub const fn matcher(&self) -> &RouteMatcher {
&self.matcher
}
#[must_use]
pub fn methods_slice(&self) -> &[Method] {
&self.methods
}
fn matches<B>(&self, request: &Request<B>) -> bool {
(self.methods.is_empty() || self.methods.iter().any(|method| method == request.method()))
&& self.matcher.matches(request_path(request))
}
fn validate(&self) -> Result<(), HttpLayerError> {
self.matcher.validate()?;
if let Some(limit) = self.request_body_limit {
limit.validate()?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum RouteMatcher {
Any,
Exact(String),
Prefix(String),
RawPrefix(String),
}
impl RouteMatcher {
#[must_use]
pub fn matches(&self, path: &str) -> bool {
match self {
Self::Any => true,
Self::Exact(expected) => path == expected,
Self::Prefix(prefix) => path_matches_segment_prefix(path, prefix),
Self::RawPrefix(prefix) => path.starts_with(prefix),
}
}
fn validate(&self) -> Result<(), HttpLayerError> {
match self {
Self::Any => Ok(()),
Self::Exact(path) | Self::Prefix(path) | Self::RawPrefix(path) => {
if path.starts_with('/') {
Ok(())
} else {
Err(HttpLayerError::InvalidRouteMatcher)
}
}
}
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case", tag = "type", content = "value")]
#[non_exhaustive]
pub enum RouteMatcherSettings {
#[default]
Any,
Exact(String),
Prefix(String),
RawPrefix(String),
}
#[cfg(feature = "config")]
impl From<&RouteMatcherSettings> for RouteMatcher {
fn from(value: &RouteMatcherSettings) -> Self {
match value {
RouteMatcherSettings::Any => Self::Any,
RouteMatcherSettings::Exact(path) => Self::Exact(path.clone()),
RouteMatcherSettings::Prefix(path) => Self::Prefix(path.clone()),
RouteMatcherSettings::RawPrefix(path) => Self::RawPrefix(path.clone()),
}
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum RateLimitRequestPolicySettings {
Enabled,
#[default]
Disabled,
}
#[cfg(feature = "config")]
impl From<RateLimitRequestPolicySettings> for RateLimitRequestPolicy {
fn from(value: RateLimitRequestPolicySettings) -> Self {
match value {
RateLimitRequestPolicySettings::Enabled => Self::Enabled,
RateLimitRequestPolicySettings::Disabled => Self::Disabled,
}
}
}
#[cfg(feature = "config")]
impl From<RateLimitRequestPolicy> for RateLimitRequestPolicySettings {
fn from(value: RateLimitRequestPolicy) -> Self {
match value {
RateLimitRequestPolicy::Enabled => Self::Enabled,
RateLimitRequestPolicy::Disabled => Self::Disabled,
}
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum IdempotencyRequestPolicySettings {
#[default]
HeaderOptional,
Required,
Disabled,
}
#[cfg(feature = "config")]
impl From<IdempotencyRequestPolicySettings> for IdempotencyRequestPolicy {
fn from(value: IdempotencyRequestPolicySettings) -> Self {
match value {
IdempotencyRequestPolicySettings::HeaderOptional => Self::HeaderOptional,
IdempotencyRequestPolicySettings::Required => Self::Required,
IdempotencyRequestPolicySettings::Disabled => Self::Disabled,
}
}
}
#[cfg(feature = "config")]
impl From<IdempotencyRequestPolicy> for IdempotencyRequestPolicySettings {
fn from(value: IdempotencyRequestPolicy) -> Self {
match value {
IdempotencyRequestPolicy::HeaderOptional => Self::HeaderOptional,
IdempotencyRequestPolicy::Required => Self::Required,
IdempotencyRequestPolicy::Disabled => Self::Disabled,
}
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case", tag = "mode", content = "bytes")]
#[non_exhaustive]
pub enum RequestBodyLimitSettings {
#[default]
Disabled,
Bytes(usize),
}
#[cfg(feature = "config")]
impl From<RequestBodyLimitSettings> for RequestBodyLimitPolicy {
fn from(value: RequestBodyLimitSettings) -> Self {
match value {
RequestBodyLimitSettings::Disabled => Self::Disabled,
RequestBodyLimitSettings::Bytes(bytes) => Self::Bytes(bytes),
}
}
}
#[cfg(feature = "config")]
impl From<RequestBodyLimitPolicy> for RequestBodyLimitSettings {
fn from(value: RequestBodyLimitPolicy) -> Self {
match value {
RequestBodyLimitPolicy::Disabled => Self::Disabled,
RequestBodyLimitPolicy::Bytes(bytes) => Self::Bytes(bytes),
}
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct HttpRouteRuleSettings {
#[serde(default)]
pub matcher: RouteMatcherSettings,
#[serde(default)]
pub methods: Vec<String>,
#[serde(default)]
pub rate_limit: Option<RateLimitRequestPolicySettings>,
#[serde(default)]
pub idempotency: Option<IdempotencyRequestPolicySettings>,
#[serde(default)]
pub request_body_limit: Option<RequestBodyLimitSettings>,
}
#[cfg(feature = "config")]
impl Default for HttpRouteRuleSettings {
fn default() -> Self {
Self {
matcher: RouteMatcherSettings::Any,
methods: Vec::new(),
rate_limit: None,
idempotency: None,
request_body_limit: None,
}
}
}
#[cfg(feature = "config")]
impl TryFrom<&HttpRouteRuleSettings> for HttpRouteRule {
type Error = HttpLayerError;
fn try_from(value: &HttpRouteRuleSettings) -> Result<Self, Self::Error> {
let mut rule = HttpRouteRule::new(RouteMatcher::from(&value.matcher));
if !value.methods.is_empty() {
rule = rule.methods(parse_methods("methods", &value.methods)?);
}
if let Some(policy) = value.rate_limit {
rule = rule.rate_limit(policy.into());
}
if let Some(policy) = value.idempotency {
rule = rule.idempotency(policy.into());
}
if let Some(policy) = value.request_body_limit {
rule = rule.request_body_limit(policy.into());
}
rule.validate()?;
Ok(rule)
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct HttpRequestPolicySettings {
#[serde(default = "default_http_default_rate_limit_policy")]
pub default_rate_limit: RateLimitRequestPolicySettings,
#[serde(default = "default_http_default_idempotency_policy")]
pub default_idempotency: IdempotencyRequestPolicySettings,
#[serde(default)]
pub default_request_body_limit: RequestBodyLimitSettings,
#[serde(default)]
pub rules: Vec<HttpRouteRuleSettings>,
}
#[cfg(feature = "config")]
impl Default for HttpRequestPolicySettings {
fn default() -> Self {
Self::from(HttpRequestPolicy::default())
}
}
#[cfg(feature = "config")]
impl From<HttpRequestPolicy> for HttpRequestPolicySettings {
fn from(value: HttpRequestPolicy) -> Self {
Self {
default_rate_limit: value.default_rate_limit().into(),
default_idempotency: value.default_idempotency().into(),
default_request_body_limit: value.default_request_body_limit().into(),
rules: value
.rules()
.iter()
.map(|rule| HttpRouteRuleSettings {
matcher: match rule.matcher() {
RouteMatcher::Any => RouteMatcherSettings::Any,
RouteMatcher::Exact(path) => RouteMatcherSettings::Exact(path.clone()),
RouteMatcher::Prefix(path) => RouteMatcherSettings::Prefix(path.clone()),
RouteMatcher::RawPrefix(path) => {
RouteMatcherSettings::RawPrefix(path.clone())
}
},
methods: rule
.methods_slice()
.iter()
.map(ToString::to_string)
.collect(),
rate_limit: rule.rate_limit.map(Into::into),
idempotency: rule.idempotency.map(Into::into),
request_body_limit: rule.request_body_limit.map(Into::into),
})
.collect(),
}
}
}
#[cfg(feature = "config")]
impl TryFrom<&HttpRequestPolicySettings> for HttpRequestPolicy {
type Error = HttpLayerError;
fn try_from(value: &HttpRequestPolicySettings) -> Result<Self, Self::Error> {
let mut policy = HttpRequestPolicy::default()
.with_default_rate_limit(value.default_rate_limit.into())
.with_default_idempotency(value.default_idempotency.into())
.with_default_request_body_limit(value.default_request_body_limit.into());
for rule in &value.rules {
policy = policy.with_rule(HttpRouteRule::try_from(rule)?);
}
policy.validate()?;
Ok(policy)
}
}
#[cfg(feature = "config")]
impl HttpRequestPolicySettings {
#[must_use]
pub fn disabled() -> Self {
Self::from(HttpRequestPolicy::disabled())
}
#[must_use]
pub fn with_rule(mut self, rule: HttpRouteRuleSettings) -> Self {
self.rules.push(rule);
self
}
pub fn validate_at(&self, path: &str) -> Result<(), ConfigValidationError> {
let mut issues = ConfigIssueCollector::new();
validate_request_body_limit_setting(
&mut issues,
format!("{path}.default_request_body_limit"),
self.default_request_body_limit,
);
for (index, rule) in self.rules.iter().enumerate() {
rule.validate_at(&format!("{path}.rules.{index}"), &mut issues);
}
issues.into_result()
}
}
#[cfg(feature = "config")]
impl HttpRouteRuleSettings {
pub fn validate_at(&self, path: &str, issues: &mut ConfigIssueCollector) {
match &self.matcher {
RouteMatcherSettings::Any => {}
RouteMatcherSettings::Exact(path_value)
| RouteMatcherSettings::Prefix(path_value)
| RouteMatcherSettings::RawPrefix(path_value) => {
issues.require(
path_value.starts_with('/'),
format!("{path}.matcher.value"),
"must be an absolute path",
);
}
}
for (index, method) in self.methods.iter().enumerate() {
issues.require(
method.parse::<Method>().is_ok(),
format!("{path}.methods.{index}"),
"must be a valid HTTP method",
);
}
if let Some(limit) = self.request_body_limit {
validate_request_body_limit_setting(
issues,
format!("{path}.request_body_limit"),
limit,
);
}
}
}
fn path_matches_segment_prefix(path: &str, prefix: &str) -> bool {
if path == prefix {
return true;
}
let Some(rest) = path.strip_prefix(prefix) else {
return false;
};
prefix.ends_with('/') || rest.starts_with('/')
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct EffectiveHttpRequestPolicy {
rate_limit: RateLimitRequestPolicy,
idempotency: IdempotencyRequestPolicy,
request_body_limit: RequestBodyLimitPolicy,
}
impl EffectiveHttpRequestPolicy {
#[must_use]
pub const fn rate_limit(self) -> RateLimitRequestPolicy {
self.rate_limit
}
#[must_use]
pub const fn idempotency(self) -> IdempotencyRequestPolicy {
self.idempotency
}
#[must_use]
pub const fn request_body_limit(self) -> RequestBodyLimitPolicy {
self.request_body_limit
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct SecurityHeadersConfig {
content_type_options: Option<HeaderValue>,
content_security_policy: Option<HeaderValue>,
frame_options: Option<HeaderValue>,
referrer_policy: Option<HeaderValue>,
cross_origin_opener_policy: Option<HeaderValue>,
cross_origin_resource_policy: Option<HeaderValue>,
permissions_policy: Option<HeaderValue>,
strict_transport_security: Option<HeaderValue>,
}
impl SecurityHeadersConfig {
#[must_use]
pub fn api_defaults() -> Self {
Self {
content_type_options: Some(HeaderValue::from_static("nosniff")),
content_security_policy: None,
frame_options: Some(HeaderValue::from_static("DENY")),
referrer_policy: Some(HeaderValue::from_static("no-referrer")),
cross_origin_opener_policy: Some(HeaderValue::from_static("same-origin")),
cross_origin_resource_policy: Some(HeaderValue::from_static("same-origin")),
permissions_policy: None,
strict_transport_security: None,
}
}
#[must_use]
pub fn strict_api_defaults() -> Self {
Self {
strict_transport_security: Some(HeaderValue::from_static(
"max-age=31536000; includeSubDomains",
)),
..Self::api_defaults()
}
}
#[must_use]
pub fn without_strict_transport_security(mut self) -> Self {
self.strict_transport_security = None;
self
}
pub fn with_strict_transport_security(
mut self,
max_age: Duration,
include_subdomains: bool,
preload: bool,
) -> Result<Self, axum::http::header::InvalidHeaderValue> {
let mut value = format!("max-age={}", max_age.as_secs());
if include_subdomains {
value.push_str("; includeSubDomains");
}
if preload {
value.push_str("; preload");
}
self.strict_transport_security = Some(HeaderValue::from_str(&value)?);
Ok(self)
}
#[must_use]
pub fn with_content_type_options(mut self, value: Option<HeaderValue>) -> Self {
self.content_type_options = value;
self
}
#[must_use]
pub fn with_content_security_policy(mut self, value: Option<HeaderValue>) -> Self {
self.content_security_policy = value;
self
}
#[must_use]
pub fn with_frame_options(mut self, value: Option<HeaderValue>) -> Self {
self.frame_options = value;
self
}
#[must_use]
pub fn with_referrer_policy(mut self, value: Option<HeaderValue>) -> Self {
self.referrer_policy = value;
self
}
#[must_use]
pub fn with_cross_origin_opener_policy(mut self, value: Option<HeaderValue>) -> Self {
self.cross_origin_opener_policy = value;
self
}
#[must_use]
pub fn with_cross_origin_resource_policy(mut self, value: Option<HeaderValue>) -> Self {
self.cross_origin_resource_policy = value;
self
}
#[must_use]
pub fn with_permissions_policy(mut self, value: Option<HeaderValue>) -> Self {
self.permissions_policy = value;
self
}
#[must_use]
pub fn content_type_options(&self) -> Option<&HeaderValue> {
self.content_type_options.as_ref()
}
#[must_use]
pub fn content_security_policy(&self) -> Option<&HeaderValue> {
self.content_security_policy.as_ref()
}
#[must_use]
pub fn frame_options(&self) -> Option<&HeaderValue> {
self.frame_options.as_ref()
}
#[must_use]
pub fn referrer_policy(&self) -> Option<&HeaderValue> {
self.referrer_policy.as_ref()
}
#[must_use]
pub fn cross_origin_opener_policy(&self) -> Option<&HeaderValue> {
self.cross_origin_opener_policy.as_ref()
}
#[must_use]
pub fn cross_origin_resource_policy(&self) -> Option<&HeaderValue> {
self.cross_origin_resource_policy.as_ref()
}
#[must_use]
pub fn permissions_policy(&self) -> Option<&HeaderValue> {
self.permissions_policy.as_ref()
}
#[must_use]
pub fn strict_transport_security(&self) -> Option<&HeaderValue> {
self.strict_transport_security.as_ref()
}
pub fn apply(&self, headers: &mut HeaderMap) {
insert_header(
headers,
HeaderName::from_static("x-content-type-options"),
&self.content_type_options,
);
insert_header(
headers,
HeaderName::from_static("content-security-policy"),
&self.content_security_policy,
);
insert_header(
headers,
HeaderName::from_static("x-frame-options"),
&self.frame_options,
);
insert_header(
headers,
HeaderName::from_static("referrer-policy"),
&self.referrer_policy,
);
insert_header(
headers,
HeaderName::from_static("cross-origin-opener-policy"),
&self.cross_origin_opener_policy,
);
insert_header(
headers,
HeaderName::from_static("cross-origin-resource-policy"),
&self.cross_origin_resource_policy,
);
insert_header(
headers,
HeaderName::from_static("permissions-policy"),
&self.permissions_policy,
);
insert_header(
headers,
HeaderName::from_static("strict-transport-security"),
&self.strict_transport_security,
);
}
}
impl Default for SecurityHeadersConfig {
fn default() -> Self {
Self::api_defaults()
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct CorsSettings {
#[serde(default)]
pub mode: CorsMode,
#[serde(default)]
pub allowed_origins: Vec<String>,
#[serde(default)]
pub allow_credentials: bool,
#[serde(default)]
pub allowed_methods: Vec<String>,
#[serde(default)]
pub allowed_headers: Vec<String>,
#[serde(default)]
pub exposed_headers: Vec<String>,
#[serde(
default = "default_cors_max_age",
with = "crate::config::human_duration::option"
)]
pub max_age: Option<Duration>,
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum CorsMode {
#[default]
Disabled,
Permissive,
Restricted,
}
#[cfg(feature = "config")]
impl Default for CorsSettings {
fn default() -> Self {
Self {
mode: CorsMode::Disabled,
allowed_origins: Vec::new(),
allow_credentials: false,
allowed_methods: Vec::new(),
allowed_headers: Vec::new(),
exposed_headers: Vec::new(),
max_age: default_cors_max_age(),
}
}
}
#[cfg(feature = "config")]
impl CorsSettings {
#[must_use]
pub fn disabled() -> Self {
Self::default()
}
#[must_use]
pub fn permissive() -> Self {
Self {
mode: CorsMode::Permissive,
..Self::default()
}
}
#[must_use]
pub fn restricted(origins: impl IntoIterator<Item = impl Into<String>>) -> Self {
Self {
mode: CorsMode::Restricted,
allowed_origins: origins.into_iter().map(Into::into).collect(),
..Self::default()
}
}
#[must_use]
pub const fn with_credentials(mut self, allow_credentials: bool) -> Self {
self.allow_credentials = allow_credentials;
self
}
pub fn validate_at(&self, path: &str) -> Result<(), ConfigValidationError> {
let mut issues = ConfigIssueCollector::new();
if matches!(self.mode, CorsMode::Restricted) {
issues.require(
!self.allowed_origins.is_empty(),
format!("{path}.allowed_origins"),
"must not be empty when CORS mode is restricted",
);
}
for (index, origin) in self.allowed_origins.iter().enumerate() {
let origin = origin.trim();
issues.require(
!origin.is_empty(),
format!("{path}.allowed_origins.{index}"),
"must not be empty",
);
issues.require(
HeaderValue::from_str(origin).is_ok(),
format!("{path}.allowed_origins.{index}"),
"must be a valid HTTP header value",
);
}
issues.require(
!(self.allow_credentials
&& self
.allowed_origins
.iter()
.any(|origin| origin.trim() == "*")),
format!("{path}.allow_credentials"),
"must not be enabled with wildcard origins",
);
validate_method_settings(
&mut issues,
format!("{path}.allowed_methods"),
&self.allowed_methods,
);
validate_header_name_settings(
&mut issues,
format!("{path}.allowed_headers"),
&self.allowed_headers,
);
validate_header_name_settings(
&mut issues,
format!("{path}.exposed_headers"),
&self.exposed_headers,
);
issues.into_result()
}
}
#[cfg(feature = "config")]
impl TryFrom<&CorsSettings> for CorsPolicy {
type Error = HttpLayerError;
fn try_from(value: &CorsSettings) -> Result<Self, Self::Error> {
match value.mode {
CorsMode::Disabled => Ok(Self::Disabled),
CorsMode::Permissive => Ok(Self::Permissive),
CorsMode::Restricted => {
let mut config = CorsConfig::from_origin_strs(&value.allowed_origins)
.map_err(|source| HttpLayerError::InvalidHeaderValue {
field: "allowed_origins",
source,
})?
.allow_credentials(value.allow_credentials)
.max_age(value.max_age);
if !value.allowed_methods.is_empty() {
config = config
.allow_methods(parse_methods("allowed_methods", &value.allowed_methods)?);
}
if !value.allowed_headers.is_empty() {
config = config.allow_headers(parse_header_names(
"allowed_headers",
&value.allowed_headers,
)?);
}
if !value.exposed_headers.is_empty() {
config = config.expose_headers(parse_header_names(
"exposed_headers",
&value.exposed_headers,
)?);
}
config.validate()?;
Ok(Self::Restricted(config))
}
}
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct ForwardedHeadersSettings {
#[serde(default)]
pub mode: ForwardedHeadersMode,
#[serde(default)]
pub trusted_proxy_cidrs: Vec<String>,
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum ForwardedHeadersMode {
#[default]
Disabled,
TrustedProxies,
Always,
}
#[cfg(feature = "config")]
impl Default for ForwardedHeadersSettings {
fn default() -> Self {
Self {
mode: ForwardedHeadersMode::Disabled,
trusted_proxy_cidrs: Vec::new(),
}
}
}
#[cfg(feature = "config")]
impl ForwardedHeadersSettings {
#[must_use]
pub fn disabled() -> Self {
Self::default()
}
#[must_use]
pub fn trusted_proxies(cidrs: impl IntoIterator<Item = impl Into<String>>) -> Self {
Self {
mode: ForwardedHeadersMode::TrustedProxies,
trusted_proxy_cidrs: cidrs.into_iter().map(Into::into).collect(),
}
}
#[must_use]
pub fn always() -> Self {
Self {
mode: ForwardedHeadersMode::Always,
trusted_proxy_cidrs: Vec::new(),
}
}
pub fn validate_at(&self, path: &str) -> Result<(), ConfigValidationError> {
let mut issues = ConfigIssueCollector::new();
match self.mode {
ForwardedHeadersMode::TrustedProxies => {
issues.require(
!self.trusted_proxy_cidrs.is_empty(),
format!("{path}.trusted_proxy_cidrs"),
"must not be empty when mode is trusted_proxies",
);
}
ForwardedHeadersMode::Disabled | ForwardedHeadersMode::Always => {
issues.require(
self.trusted_proxy_cidrs.is_empty(),
format!("{path}.trusted_proxy_cidrs"),
"must be empty unless mode is trusted_proxies",
);
}
}
if let Err(error) = IpNetworkSet::from_cidrs(&self.trusted_proxy_cidrs) {
issues.push(
format!("{path}.trusted_proxy_cidrs"),
format!("contains invalid CIDR: {error}"),
);
}
issues.into_result()
}
}
#[cfg(feature = "config")]
impl TryFrom<&ForwardedHeadersSettings> for ForwardedHeadersPolicy {
type Error = HttpLayerError;
fn try_from(value: &ForwardedHeadersSettings) -> Result<Self, Self::Error> {
match value.mode {
ForwardedHeadersMode::Disabled => Ok(Self::Never),
ForwardedHeadersMode::Always => Ok(Self::Always),
ForwardedHeadersMode::TrustedProxies => {
let networks =
IpNetworkSet::from_cidrs(&value.trusted_proxy_cidrs).map_err(|source| {
HttpLayerError::InvalidTrustedProxyCidr {
reason: source.to_string(),
}
})?;
Ok(Self::trusted_proxies(TrustedProxyConfig::from_network_set(
networks,
)))
}
}
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct SecurityHeadersSettings {
#[serde(default = "default_true")]
pub enabled: bool,
#[serde(default)]
pub strict_transport_security: StrictTransportSecuritySettings,
#[serde(default = "default_same_origin_header")]
pub cross_origin_opener_policy: Option<String>,
#[serde(default)]
pub content_security_policy: Option<String>,
#[serde(default)]
pub permissions_policy: Option<String>,
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct StrictTransportSecuritySettings {
#[serde(default)]
pub enabled: bool,
#[serde(
default = "default_hsts_max_age_setting",
with = "crate::config::human_duration"
)]
pub max_age: Duration,
#[serde(default = "default_true")]
pub include_subdomains: bool,
#[serde(default)]
pub preload: bool,
}
#[cfg(feature = "config")]
impl Default for SecurityHeadersSettings {
fn default() -> Self {
Self {
enabled: true,
strict_transport_security: StrictTransportSecuritySettings::default(),
cross_origin_opener_policy: default_same_origin_header(),
content_security_policy: None,
permissions_policy: None,
}
}
}
#[cfg(feature = "config")]
impl Default for StrictTransportSecuritySettings {
fn default() -> Self {
Self {
enabled: false,
max_age: DEFAULT_HSTS_MAX_AGE,
include_subdomains: true,
preload: false,
}
}
}
#[cfg(feature = "config")]
impl SecurityHeadersSettings {
#[must_use]
pub const fn disabled() -> Self {
Self {
enabled: false,
strict_transport_security: StrictTransportSecuritySettings {
enabled: false,
max_age: DEFAULT_HSTS_MAX_AGE,
include_subdomains: true,
preload: false,
},
cross_origin_opener_policy: None,
content_security_policy: None,
permissions_policy: None,
}
}
#[must_use]
pub const fn with_enabled(mut self, enabled: bool) -> Self {
self.enabled = enabled;
self
}
#[must_use]
pub const fn with_strict_transport_security(
mut self,
strict_transport_security: StrictTransportSecuritySettings,
) -> Self {
self.strict_transport_security = strict_transport_security;
self
}
#[must_use]
pub fn with_cross_origin_opener_policy(mut self, value: Option<impl Into<String>>) -> Self {
self.cross_origin_opener_policy = value.map(Into::into);
self
}
#[must_use]
pub fn with_content_security_policy(mut self, value: Option<impl Into<String>>) -> Self {
self.content_security_policy = value.map(Into::into);
self
}
#[must_use]
pub fn with_permissions_policy(mut self, value: Option<impl Into<String>>) -> Self {
self.permissions_policy = value.map(Into::into);
self
}
pub fn try_config(value: &Self) -> Result<Option<SecurityHeadersConfig>, HttpLayerError> {
if !value.enabled {
return Ok(None);
}
let mut config = SecurityHeadersConfig::api_defaults();
config = config.with_cross_origin_opener_policy(optional_header_value(
"cross_origin_opener_policy",
value.cross_origin_opener_policy.as_deref(),
)?);
config = config.with_content_security_policy(optional_header_value(
"content_security_policy",
value.content_security_policy.as_deref(),
)?);
config = config.with_permissions_policy(optional_header_value(
"permissions_policy",
value.permissions_policy.as_deref(),
)?);
if value.strict_transport_security.enabled {
config = config
.with_strict_transport_security(
value.strict_transport_security.max_age,
value.strict_transport_security.include_subdomains,
value.strict_transport_security.preload,
)
.map_err(|source| HttpLayerError::InvalidHeaderValue {
field: "strict_transport_security",
source,
})?;
}
Ok(Some(config))
}
pub fn validate_at(&self, path: &str) -> Result<(), ConfigValidationError> {
let mut issues = ConfigIssueCollector::new();
if self.enabled && self.strict_transport_security.enabled {
issues.require(
!self.strict_transport_security.max_age.is_zero(),
format!("{path}.strict_transport_security.max_age"),
"must be greater than zero when strict transport security is enabled",
);
}
if let Some(value) = self.cross_origin_opener_policy.as_deref() {
issues.require(
HeaderValue::from_str(value.trim()).is_ok(),
format!("{path}.cross_origin_opener_policy"),
"must be a valid HTTP header value",
);
}
for (field, value) in [
(
"content_security_policy",
self.content_security_policy.as_deref(),
),
("permissions_policy", self.permissions_policy.as_deref()),
] {
if let Some(value) = value {
issues.require(
HeaderValue::from_str(value.trim()).is_ok(),
format!("{path}.{field}"),
"must be a valid HTTP header value",
);
}
}
issues.into_result()
}
}
#[cfg(feature = "config")]
impl StrictTransportSecuritySettings {
#[must_use]
pub const fn new(
enabled: bool,
max_age: Duration,
include_subdomains: bool,
preload: bool,
) -> Self {
Self {
enabled,
max_age,
include_subdomains,
preload,
}
}
#[must_use]
pub const fn disabled() -> Self {
Self {
enabled: false,
max_age: DEFAULT_HSTS_MAX_AGE,
include_subdomains: true,
preload: false,
}
}
#[must_use]
pub const fn enabled(max_age: Duration) -> Self {
Self {
enabled: true,
max_age,
include_subdomains: true,
preload: false,
}
}
#[must_use]
pub const fn with_include_subdomains(mut self, include_subdomains: bool) -> Self {
self.include_subdomains = include_subdomains;
self
}
#[must_use]
pub const fn with_preload(mut self, preload: bool) -> Self {
self.preload = preload;
self
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct HttpRateLimitSettings {
#[serde(default)]
pub enabled: bool,
#[serde(default = "default_rate_limit_capacity")]
pub capacity: u32,
#[serde(default = "default_rate_limit_refill_tokens")]
pub refill_tokens: u32,
#[serde(
default = "default_rate_limit_refill_interval",
with = "crate::config::human_duration"
)]
pub refill_interval: Duration,
#[serde(default)]
pub key_source: RateLimitKeySourceSettings,
}
#[cfg(feature = "config")]
#[derive(Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(tag = "type", content = "value", rename_all = "snake_case")]
#[non_exhaustive]
pub enum RateLimitKeySourceSettings {
#[default]
ClientIp,
PrincipalId,
RequestId,
Header(String),
Fixed(String),
}
#[cfg(feature = "config")]
impl fmt::Debug for RateLimitKeySourceSettings {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::ClientIp => formatter.write_str("ClientIp"),
Self::PrincipalId => formatter.write_str("PrincipalId"),
Self::RequestId => formatter.write_str("RequestId"),
Self::Header(name) => formatter.debug_tuple("Header").field(name).finish(),
Self::Fixed(_) => formatter.debug_tuple("Fixed").field(&"[REDACTED]").finish(),
}
}
}
#[cfg(feature = "config")]
impl Default for HttpRateLimitSettings {
fn default() -> Self {
Self {
enabled: false,
capacity: default_rate_limit_capacity(),
refill_tokens: default_rate_limit_refill_tokens(),
refill_interval: default_rate_limit_refill_interval(),
key_source: RateLimitKeySourceSettings::ClientIp,
}
}
}
#[cfg(feature = "config")]
impl HttpRateLimitSettings {
#[must_use]
pub const fn with_enabled(mut self, enabled: bool) -> Self {
self.enabled = enabled;
self
}
#[must_use]
pub const fn with_capacity(mut self, capacity: u32) -> Self {
self.capacity = capacity;
self
}
#[must_use]
pub const fn with_refill_tokens(mut self, refill_tokens: u32) -> Self {
self.refill_tokens = refill_tokens;
self
}
#[must_use]
pub const fn with_refill_interval(mut self, refill_interval: Duration) -> Self {
self.refill_interval = refill_interval;
self
}
#[must_use]
pub fn with_key_source(mut self, key_source: RateLimitKeySourceSettings) -> Self {
self.key_source = key_source;
self
}
pub fn runtime(&self) -> Result<Option<RateLimitRuntime>, HttpLayerError> {
if !self.enabled {
return Ok(None);
}
Ok(Some(RateLimitRuntime::new(
RateLimitConfig::new(self.capacity, self.refill_tokens, self.refill_interval),
RateLimitKeySource::try_from(&self.key_source)?,
)?))
}
pub fn validate_at(&self, path: &str) -> Result<(), ConfigValidationError> {
let mut issues = ConfigIssueCollector::new();
if self.enabled {
issues.require(
self.capacity > 0,
format!("{path}.capacity"),
"must be greater than zero when rate limit is enabled",
);
issues.require(
self.refill_tokens > 0,
format!("{path}.refill_tokens"),
"must be greater than zero when rate limit is enabled",
);
issues.require(
!self.refill_interval.is_zero(),
format!("{path}.refill_interval"),
"must be greater than zero when rate limit is enabled",
);
validate_rate_limit_key_source_setting(
&mut issues,
format!("{path}.key_source"),
&self.key_source,
);
}
issues.into_result()
}
}
#[cfg(feature = "config")]
impl TryFrom<&RateLimitKeySourceSettings> for RateLimitKeySource {
type Error = HttpLayerError;
fn try_from(value: &RateLimitKeySourceSettings) -> Result<Self, Self::Error> {
match value {
RateLimitKeySourceSettings::ClientIp => Ok(Self::ClientIp),
RateLimitKeySourceSettings::PrincipalId => Ok(Self::PrincipalId),
RateLimitKeySourceSettings::RequestId => Ok(Self::RequestId),
RateLimitKeySourceSettings::Header(value) => {
Ok(Self::Header(HeaderName::try_from(value.trim()).map_err(
|source| HttpLayerError::InvalidHeaderName {
field: "rate_limit.key_source",
source,
},
)?))
}
RateLimitKeySourceSettings::Fixed(value) => {
let value = value.trim();
if value.is_empty() {
return Err(HttpLayerError::InvalidRateLimitKeySource {
field: "rate_limit.key_source",
});
}
Ok(Self::Fixed(value.to_owned()))
}
}
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct HttpIdempotencySettings {
#[serde(default)]
pub enabled: bool,
#[serde(
default = "default_idempotency_ttl",
with = "crate::config::human_duration"
)]
pub ttl: Duration,
#[serde(
default = "default_idempotency_processing_ttl",
with = "crate::config::human_duration"
)]
pub processing_ttl: Duration,
#[serde(default = "default_idempotency_body_limit")]
pub max_request_body_bytes: usize,
#[serde(default = "default_idempotency_body_limit")]
pub max_response_body_bytes: usize,
}
#[cfg(feature = "config")]
impl Default for HttpIdempotencySettings {
fn default() -> Self {
Self {
enabled: false,
ttl: default_idempotency_ttl(),
processing_ttl: default_idempotency_processing_ttl(),
max_request_body_bytes: default_idempotency_body_limit(),
max_response_body_bytes: default_idempotency_body_limit(),
}
}
}
#[cfg(feature = "config")]
impl HttpIdempotencySettings {
#[must_use]
pub const fn with_enabled(mut self, enabled: bool) -> Self {
self.enabled = enabled;
self
}
#[must_use]
pub const fn with_ttl(mut self, ttl: Duration) -> Self {
self.ttl = ttl;
self
}
#[must_use]
pub const fn with_processing_ttl(mut self, processing_ttl: Duration) -> Self {
self.processing_ttl = processing_ttl;
self
}
#[must_use]
pub const fn with_max_request_body_bytes(mut self, max_request_body_bytes: usize) -> Self {
self.max_request_body_bytes = max_request_body_bytes;
self
}
#[must_use]
pub const fn with_max_response_body_bytes(mut self, max_response_body_bytes: usize) -> Self {
self.max_response_body_bytes = max_response_body_bytes;
self
}
pub fn runtime(&self) -> Result<Option<IdempotencyRuntime>, HttpLayerError> {
if !self.enabled {
return Ok(None);
}
if self.ttl.is_zero()
|| self.processing_ttl.is_zero()
|| self.max_request_body_bytes == 0
|| self.max_response_body_bytes == 0
{
return Err(HttpLayerError::InvalidIdempotencyConfig);
}
let store = MemoryIdempotencyStore::for_response_body_limit(self.max_response_body_bytes)
.map_err(|_| HttpLayerError::InvalidIdempotencyConfig)?;
Ok(Some(
IdempotencyRuntime::new(std::sync::Arc::new(store))
.with_ttl(self.ttl)
.with_processing_ttl(self.processing_ttl)
.with_max_request_body_bytes(self.max_request_body_bytes)
.with_max_response_body_bytes(self.max_response_body_bytes),
))
}
pub fn validate_at(&self, path: &str) -> Result<(), ConfigValidationError> {
let mut issues = ConfigIssueCollector::new();
if self.enabled {
issues.require(
!self.ttl.is_zero(),
format!("{path}.ttl"),
"must be greater than zero when idempotency is enabled",
);
issues.require(
!self.processing_ttl.is_zero(),
format!("{path}.processing_ttl"),
"must be greater than zero when idempotency is enabled",
);
issues.require(
self.max_request_body_bytes > 0,
format!("{path}.max_request_body_bytes"),
"must be greater than zero when idempotency is enabled",
);
issues.require(
self.max_response_body_bytes > 0,
format!("{path}.max_response_body_bytes"),
"must be greater than zero when idempotency is enabled",
);
}
issues.into_result()
}
}
impl HttpLayerConfig {
#[must_use]
pub fn standard() -> Self {
Self {
request_context: true,
forwarded_headers: ForwardedHeadersPolicy::never(),
trace: true,
cors: CorsPolicy::Disabled,
security_headers: Some(SecurityHeadersConfig::api_defaults()),
timeout: Some(DEFAULT_HTTP_TIMEOUT),
request_body_limit: Some(DEFAULT_HTTP_REQUEST_BODY_LIMIT),
compression: true,
rate_limit: None,
idempotency: None,
metrics: None,
request_policy: HttpRequestPolicy::default(),
}
}
#[must_use]
pub fn minimal() -> Self {
Self {
request_context: false,
forwarded_headers: ForwardedHeadersPolicy::never(),
trace: false,
cors: CorsPolicy::Disabled,
security_headers: None,
timeout: None,
request_body_limit: None,
compression: false,
rate_limit: None,
idempotency: None,
metrics: None,
request_policy: HttpRequestPolicy::disabled(),
}
}
#[must_use]
pub fn with_cors(mut self, cors: CorsPolicy) -> Self {
self.cors = cors;
self
}
#[must_use]
pub fn with_security_headers(
mut self,
security_headers: Option<SecurityHeadersConfig>,
) -> Self {
self.security_headers = security_headers;
self
}
#[must_use]
pub const fn with_trace(mut self, trace: bool) -> Self {
self.trace = trace;
self
}
#[must_use]
pub const fn with_request_context(mut self, request_context: bool) -> Self {
self.request_context = request_context;
self
}
#[must_use]
pub fn with_forwarded_headers_policy(mut self, policy: ForwardedHeadersPolicy) -> Self {
self.forwarded_headers = policy;
self
}
#[must_use]
pub const fn with_compression(mut self, compression: bool) -> Self {
self.compression = compression;
self
}
#[must_use]
pub const fn with_timeout(mut self, timeout: Option<Duration>) -> Self {
self.timeout = timeout;
self
}
#[must_use]
pub const fn with_request_body_limit(mut self, request_body_limit: Option<usize>) -> Self {
self.request_body_limit = request_body_limit;
self
}
#[must_use]
pub const fn with_request_body_limit_policy(
mut self,
request_body_limit: RequestBodyLimitPolicy,
) -> Self {
self.request_body_limit = request_body_limit.as_optional();
self
}
#[must_use]
pub fn with_rate_limit(mut self, rate_limit: Option<RateLimitRuntime>) -> Self {
self.rate_limit = rate_limit;
self
}
#[must_use]
pub fn with_idempotency(mut self, idempotency: Option<IdempotencyRuntime>) -> Self {
self.idempotency = idempotency;
self
}
#[must_use]
pub fn with_metrics(mut self, metrics: Option<HttpMetricsLayer>) -> Self {
self.metrics = metrics;
self
}
#[must_use]
pub fn with_request_policy(mut self, request_policy: HttpRequestPolicy) -> Self {
self.request_policy = request_policy;
self
}
#[must_use]
pub const fn request_context_enabled(&self) -> bool {
self.request_context
}
#[must_use]
pub fn forwarded_headers_enabled(&self) -> bool {
!self.forwarded_headers.is_disabled()
}
#[must_use]
pub const fn forwarded_headers_policy(&self) -> &ForwardedHeadersPolicy {
&self.forwarded_headers
}
#[must_use]
pub const fn trace_enabled(&self) -> bool {
self.trace
}
#[must_use]
pub const fn cors(&self) -> &CorsPolicy {
&self.cors
}
#[must_use]
pub const fn security_headers(&self) -> Option<&SecurityHeadersConfig> {
self.security_headers.as_ref()
}
#[must_use]
pub const fn timeout(&self) -> Option<Duration> {
self.timeout
}
#[must_use]
pub const fn request_body_limit(&self) -> Option<usize> {
self.request_body_limit
}
#[must_use]
pub const fn request_body_limit_policy(&self) -> RequestBodyLimitPolicy {
RequestBodyLimitPolicy::from_optional(self.request_body_limit)
}
#[must_use]
pub const fn compression_enabled(&self) -> bool {
self.compression
}
#[must_use]
pub const fn rate_limit(&self) -> Option<&RateLimitRuntime> {
self.rate_limit.as_ref()
}
#[must_use]
pub const fn idempotency(&self) -> Option<&IdempotencyRuntime> {
self.idempotency.as_ref()
}
#[must_use]
pub const fn metrics(&self) -> Option<&HttpMetricsLayer> {
self.metrics.as_ref()
}
#[must_use]
pub const fn request_policy(&self) -> &HttpRequestPolicy {
&self.request_policy
}
pub fn validate(&self) -> Result<(), HttpLayerError> {
if let Some(timeout) = self.timeout
&& timeout.is_zero()
{
return Err(HttpLayerError::InvalidTimeout);
}
if let Some(idempotency) = &self.idempotency {
if idempotency.ttl().is_zero()
|| idempotency.processing_ttl().is_zero()
|| idempotency.max_request_body_bytes() == 0
|| idempotency.max_response_body_bytes() == 0
{
return Err(HttpLayerError::InvalidIdempotencyConfig);
}
if self
.timeout
.is_some_and(|timeout| idempotency.processing_ttl() <= timeout)
{
return Err(HttpLayerError::InvalidIdempotencyConfig);
}
}
self.request_body_limit_policy().validate()?;
if let CorsPolicy::Restricted(config) = &self.cors {
config.validate()?;
}
self.request_policy.validate()?;
Ok(())
}
}
impl Default for HttpLayerConfig {
fn default() -> Self {
Self::standard()
}
}
#[cfg(feature = "config")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct HttpFoundationSettings {
#[serde(default = "default_true")]
pub request_context: bool,
#[serde(default = "default_true")]
pub trace: bool,
#[serde(default)]
pub forwarded_headers: ForwardedHeadersSettings,
#[serde(default)]
pub cors: CorsSettings,
#[serde(default)]
pub security_headers: SecurityHeadersSettings,
#[serde(
default = "default_http_timeout_setting",
with = "crate::config::human_duration::option"
)]
pub timeout: Option<Duration>,
#[serde(default = "default_http_request_body_limit_setting")]
pub request_body_limit: Option<usize>,
#[serde(default = "default_true")]
pub compression: bool,
#[serde(default)]
pub rate_limit: HttpRateLimitSettings,
#[serde(default)]
pub idempotency: HttpIdempotencySettings,
#[serde(default)]
pub request_policy: HttpRequestPolicySettings,
}
#[cfg(feature = "config")]
impl Default for HttpFoundationSettings {
fn default() -> Self {
Self {
request_context: true,
trace: true,
forwarded_headers: ForwardedHeadersSettings::default(),
cors: CorsSettings::default(),
security_headers: SecurityHeadersSettings::default(),
timeout: default_http_timeout_setting(),
request_body_limit: default_http_request_body_limit_setting(),
compression: true,
rate_limit: HttpRateLimitSettings::default(),
idempotency: HttpIdempotencySettings::default(),
request_policy: HttpRequestPolicySettings::default(),
}
}
}
#[cfg(feature = "config")]
impl HttpFoundationSettings {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub const fn with_request_context(mut self, request_context: bool) -> Self {
self.request_context = request_context;
self
}
#[must_use]
pub const fn with_trace(mut self, trace: bool) -> Self {
self.trace = trace;
self
}
#[must_use]
pub fn with_forwarded_headers(mut self, forwarded_headers: ForwardedHeadersSettings) -> Self {
self.forwarded_headers = forwarded_headers;
self
}
#[must_use]
pub fn with_cors(mut self, cors: CorsSettings) -> Self {
self.cors = cors;
self
}
#[must_use]
pub fn with_security_headers(mut self, security_headers: SecurityHeadersSettings) -> Self {
self.security_headers = security_headers;
self
}
#[must_use]
pub const fn with_timeout(mut self, timeout: Option<Duration>) -> Self {
self.timeout = timeout;
self
}
#[must_use]
pub const fn with_request_body_limit(mut self, request_body_limit: Option<usize>) -> Self {
self.request_body_limit = request_body_limit;
self
}
#[must_use]
pub const fn with_compression(mut self, compression: bool) -> Self {
self.compression = compression;
self
}
#[must_use]
pub fn with_rate_limit(mut self, rate_limit: HttpRateLimitSettings) -> Self {
self.rate_limit = rate_limit;
self
}
#[must_use]
pub fn with_idempotency(mut self, idempotency: HttpIdempotencySettings) -> Self {
self.idempotency = idempotency;
self
}
#[must_use]
pub fn with_request_policy(mut self, request_policy: HttpRequestPolicySettings) -> Self {
self.request_policy = request_policy;
self
}
pub fn into_config(self) -> Result<HttpLayerConfig, HttpLayerError> {
HttpLayerConfig::try_from(self)
}
pub fn into_config_with_metrics(
self,
metrics: Option<std::sync::Arc<dyn crate::observability::MetricRecorder>>,
) -> Result<HttpLayerConfig, HttpLayerError> {
let mut config = HttpLayerConfig::try_from(&self)?;
if let Some(metrics) = metrics {
let rate_limit = config
.rate_limit
.take()
.map(|runtime| runtime.with_metrics(Some(metrics.clone())));
let idempotency = config
.idempotency
.take()
.map(|runtime| runtime.with_metrics(Some(metrics.clone())));
config = config
.with_metrics(Some(HttpMetricsLayer::new(metrics)))
.with_rate_limit(rate_limit)
.with_idempotency(idempotency);
}
Ok(config)
}
pub fn validate_at(&self, path: &str) -> Result<(), ConfigValidationError> {
let mut issues = ConfigIssueCollector::new();
if let Some(timeout) = self.timeout {
issues.require(
!timeout.is_zero(),
format!("{path}.timeout"),
"must be greater than zero",
);
if self.idempotency.enabled {
issues.require(
self.idempotency.processing_ttl > timeout,
format!("{path}.idempotency.processing_ttl"),
"must be greater than the HTTP request timeout",
);
}
}
if let Some(limit) = self.request_body_limit {
issues.require(
limit > 0,
format!("{path}.request_body_limit"),
"must be greater than zero",
);
}
issues.extend_result(self.cors.validate_at(&format!("{path}.cors")));
issues.extend_result(
self.forwarded_headers
.validate_at(&format!("{path}.forwarded_headers")),
);
issues.extend_result(
self.security_headers
.validate_at(&format!("{path}.security_headers")),
);
issues.extend_result(self.rate_limit.validate_at(&format!("{path}.rate_limit")));
issues.extend_result(self.idempotency.validate_at(&format!("{path}.idempotency")));
issues.extend_result(
self.request_policy
.validate_at(&format!("{path}.request_policy")),
);
issues.into_result()
}
}
#[cfg(feature = "config")]
impl TryFrom<HttpFoundationSettings> for HttpLayerConfig {
type Error = HttpLayerError;
fn try_from(value: HttpFoundationSettings) -> Result<Self, Self::Error> {
Self::try_from(&value)
}
}
#[cfg(feature = "config")]
impl TryFrom<&HttpFoundationSettings> for HttpLayerConfig {
type Error = HttpLayerError;
fn try_from(value: &HttpFoundationSettings) -> Result<Self, Self::Error> {
let config = HttpFoundation::builder()
.cors(CorsPolicy::try_from(&value.cors)?)
.security_headers(SecurityHeadersSettings::try_config(
&value.security_headers,
)?)
.forwarded_headers_policy(ForwardedHeadersPolicy::try_from(&value.forwarded_headers)?)
.timeout(value.timeout)
.request_body_limit(value.request_body_limit)
.compression(value.compression)
.rate_limit(value.rate_limit.runtime()?)
.idempotency(value.idempotency.runtime()?)
.request_policy(HttpRequestPolicy::try_from(&value.request_policy)?)
.build()
.into_config()
.with_request_context(value.request_context)
.with_trace(value.trace);
config.validate()?;
Ok(config)
}
}
#[cfg(feature = "config")]
impl SettingsAdapter<HttpLayerConfig> for HttpFoundationSettings {
type Error = HttpLayerError;
fn adapt(&self) -> Result<HttpLayerConfig, Self::Error> {
HttpLayerConfig::try_from(self)
}
}
#[cfg(feature = "config")]
impl ValidateSettings for HttpFoundationSettings {
fn validate_settings(&self) -> Result<(), ConfigValidationError> {
self.validate_at("http")
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct HttpFoundation {
config: HttpLayerConfig,
}
impl HttpFoundation {
#[must_use]
pub fn builder() -> HttpFoundationBuilder {
HttpFoundationBuilder::new()
}
#[must_use]
pub fn from_config(config: HttpLayerConfig) -> Self {
Self { config }
}
#[must_use]
pub const fn config(&self) -> &HttpLayerConfig {
&self.config
}
#[must_use]
pub fn into_config(self) -> HttpLayerConfig {
self.config
}
pub fn apply<S>(self, router: Router<S>) -> Result<Router<S>, HttpLayerError>
where
S: Clone + Send + Sync + 'static,
{
apply_standard_http_layers(router, self.config)
}
}
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct HttpFoundationBuilder {
config: HttpLayerConfig,
}
impl HttpFoundationBuilder {
#[must_use]
pub fn new() -> Self {
Self {
config: HttpLayerConfig::default(),
}
}
#[must_use]
pub fn cors(mut self, cors: CorsPolicy) -> Self {
self.config = self.config.with_cors(cors);
self
}
#[must_use]
pub fn forwarded_headers_policy(mut self, policy: ForwardedHeadersPolicy) -> Self {
self.config = self.config.with_forwarded_headers_policy(policy);
self
}
pub fn strict_transport_security(
mut self,
max_age: Duration,
include_subdomains: bool,
preload: bool,
) -> Result<Self, axum::http::header::InvalidHeaderValue> {
let security = self
.config
.security_headers
.take()
.unwrap_or_default()
.with_strict_transport_security(max_age, include_subdomains, preload)?;
self.config = self.config.with_security_headers(Some(security));
Ok(self)
}
#[must_use]
pub fn no_security_headers(mut self) -> Self {
self.config = self.config.with_security_headers(None);
self
}
#[must_use]
pub fn security_headers(mut self, security_headers: Option<SecurityHeadersConfig>) -> Self {
self.config = self.config.with_security_headers(security_headers);
self
}
#[must_use]
pub fn timeout(mut self, timeout: Option<Duration>) -> Self {
self.config = self.config.with_timeout(timeout);
self
}
#[must_use]
pub fn request_body_limit(mut self, request_body_limit: Option<usize>) -> Self {
self.config = self.config.with_request_body_limit(request_body_limit);
self
}
#[must_use]
pub fn compression(mut self, enabled: bool) -> Self {
self.config = self.config.with_compression(enabled);
self
}
#[must_use]
pub fn rate_limit(mut self, rate_limit: Option<RateLimitRuntime>) -> Self {
self.config = self.config.with_rate_limit(rate_limit);
self
}
#[must_use]
pub fn idempotency(mut self, idempotency: Option<IdempotencyRuntime>) -> Self {
self.config = self.config.with_idempotency(idempotency);
self
}
#[must_use]
pub fn metrics(mut self, metrics: Option<HttpMetricsLayer>) -> Self {
self.config = self.config.with_metrics(metrics);
self
}
#[must_use]
pub fn request_policy(mut self, request_policy: HttpRequestPolicy) -> Self {
self.config = self.config.with_request_policy(request_policy);
self
}
#[must_use]
pub fn build(self) -> HttpFoundation {
HttpFoundation {
config: self.config,
}
}
}
#[derive(Error)]
#[non_exhaustive]
pub enum HttpLayerError {
#[error("restricted CORS requires at least one allowed origin")]
CorsAllowedOriginsEmpty,
#[error("CORS credentials cannot be enabled with wildcard origin")]
CorsWildcardOriginWithCredentials,
#[error("invalid HTTP header value in {field}")]
InvalidHeaderValue {
field: &'static str,
#[source]
source: axum::http::header::InvalidHeaderValue,
},
#[error("invalid HTTP header name in {field}")]
InvalidHeaderName {
field: &'static str,
#[source]
source: axum::http::header::InvalidHeaderName,
},
#[error("invalid HTTP method in {field}")]
InvalidMethod {
#[doc = "The configuration field name."]
field: &'static str,
#[doc = "The offending value."]
value: String,
},
#[error("invalid trusted proxy CIDR")]
InvalidTrustedProxyCidr {
#[doc = "The reason for this outcome."]
reason: String,
},
#[error("invalid rate limit configuration")]
InvalidRateLimitConfig(#[from] RateLimitError),
#[error("invalid rate limit key source in {field}")]
InvalidRateLimitKeySource {
#[doc = "The configuration field name."]
field: &'static str,
},
#[error("invalid idempotency configuration")]
InvalidIdempotencyConfig,
#[error("request timeout must be greater than zero")]
InvalidTimeout,
#[error("request body limit must be greater than zero")]
InvalidRequestBodyLimit,
#[error("HTTP route matcher path must be an absolute path")]
InvalidRouteMatcher,
}
impl fmt::Debug for HttpLayerError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HttpLayerError")
.field("code", &self.error_code())
.finish_non_exhaustive()
}
}
impl ClassifyError for HttpLayerError {
fn error_kind(&self) -> ErrorKind {
match self {
Self::InvalidRateLimitConfig(source) => source.error_kind(),
Self::CorsAllowedOriginsEmpty
| Self::CorsWildcardOriginWithCredentials
| Self::InvalidHeaderValue { .. }
| Self::InvalidHeaderName { .. }
| Self::InvalidMethod { .. }
| Self::InvalidTrustedProxyCidr { .. }
| Self::InvalidRateLimitKeySource { .. }
| Self::InvalidIdempotencyConfig
| Self::InvalidTimeout
| Self::InvalidRequestBodyLimit
| Self::InvalidRouteMatcher => ErrorKind::Validation,
}
}
fn error_code(&self) -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed(match self {
Self::CorsAllowedOriginsEmpty => "http_cors_origins_empty",
Self::CorsWildcardOriginWithCredentials => "http_cors_wildcard_with_credentials",
Self::InvalidHeaderValue { .. } => "http_invalid_header_value",
Self::InvalidHeaderName { .. } => "http_invalid_header_name",
Self::InvalidMethod { .. } => "http_invalid_method",
Self::InvalidTrustedProxyCidr { .. } => "http_invalid_trusted_proxy_cidr",
Self::InvalidRateLimitConfig(_) => "http_invalid_rate_limit",
Self::InvalidRateLimitKeySource { .. } => "http_invalid_rate_limit_key_source",
Self::InvalidIdempotencyConfig => "http_invalid_idempotency",
Self::InvalidTimeout => "http_invalid_timeout",
Self::InvalidRequestBodyLimit => "http_invalid_request_body_limit",
Self::InvalidRouteMatcher => "http_invalid_route_matcher",
})
}
}
pub fn apply_standard_http_layers<S>(
router: Router<S>,
config: HttpLayerConfig,
) -> Result<Router<S>, HttpLayerError>
where
S: Clone + Send + Sync + 'static,
{
config.validate()?;
let default_request_body_limit = config.request_body_limit_policy();
let mut router = router;
if let Some(metrics) = config.metrics {
router = router.layer(metrics);
}
if let Some(rate_limit) = config.rate_limit {
router = router.layer(
RateLimitLayer::new(rate_limit).with_request_policy(config.request_policy.clone()),
);
}
if let Some(idempotency) = config.idempotency {
router = router.layer(
IdempotencyLayer::new(idempotency).with_request_policy(config.request_policy.clone()),
);
}
if config.compression {
router = router.layer(CompressionLayer::new());
}
if !matches!(default_request_body_limit, RequestBodyLimitPolicy::Disabled)
|| config.request_policy.has_request_body_limit_overrides()
{
router = router.layer(RouteRequestBodyLimitLayer::new(
config.request_policy.clone(),
default_request_body_limit,
));
}
if let Some(timeout) = config.timeout {
router = router.layer(TimeoutLayer::with_status_code(
StatusCode::REQUEST_TIMEOUT,
timeout,
));
}
if config.trace {
router = router.layer(TraceLayer::new_for_http().make_span_with(
|request: &axum::http::Request<_>| {
let context = request
.extensions()
.get::<RequestContext>()
.cloned()
.unwrap_or_else(|| RequestContext::from_headers(request.headers()));
let matched_path = request
.extensions()
.get::<MatchedPath>()
.map(MatchedPath::as_str)
.unwrap_or_default();
tracing::span!(
Level::INFO,
"http_request",
method = %request.method(),
path = %request.uri().path(),
matched_path,
request_id = %context.request_id(),
trace_id = context.trace_id().unwrap_or_default()
)
},
));
}
if config.request_context {
let forwarded_headers = config.forwarded_headers;
router = router.layer(middleware::from_fn(move |request, next| {
request_context_middleware_with_forwarded_policy(
request,
next,
forwarded_headers.clone(),
)
}));
}
if let Some(cors_layer) = cors_layer(config.cors) {
router = router.layer(cors_layer);
}
if let Some(security_headers) = config.security_headers {
router = router.layer(middleware::from_fn(
move |request: Request<Body>, next: Next| {
let security_headers = security_headers.clone();
async move {
let mut response = next.run(request).await;
security_headers.apply(response.headers_mut());
response
}
},
));
}
Ok(router)
}
#[derive(Debug, Clone)]
struct RouteRequestBodyLimitLayer {
request_policy: HttpRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
}
impl RouteRequestBodyLimitLayer {
fn new(
request_policy: HttpRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
) -> Self {
Self {
request_policy,
default_request_body_limit,
}
}
}
impl<S> tower::Layer<S> for RouteRequestBodyLimitLayer {
type Service = RouteRequestBodyLimitService<S>;
fn layer(&self, inner: S) -> Self::Service {
RouteRequestBodyLimitService {
inner,
request_policy: self.request_policy.clone(),
default_request_body_limit: self.default_request_body_limit,
}
}
}
#[derive(Debug, Clone)]
struct RouteRequestBodyLimitService<S> {
inner: S,
request_policy: HttpRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
}
impl<S> tower::Service<Request<Body>> for RouteRequestBodyLimitService<S>
where
S: tower::Service<Request<Body>, Response = axum::response::Response> + Clone + Send + 'static,
S::Future: Send + 'static,
S::Error: Send + 'static,
{
type Response = axum::response::Response;
type Error = S::Error;
type Future = std::pin::Pin<
Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
>;
fn poll_ready(
&mut self,
context: &mut std::task::Context<'_>,
) -> std::task::Poll<Result<(), Self::Error>> {
self.inner.poll_ready(context)
}
fn call(&mut self, request: Request<Body>) -> Self::Future {
let request_policy = self.request_policy.clone();
let default_request_body_limit = self.default_request_body_limit;
let clone = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, clone);
Box::pin(async move {
match enforce_route_request_body_limit(
request_policy,
default_request_body_limit,
request,
)
.await
{
Ok(request) => inner.call(request).await,
Err(response) => Ok(response),
}
})
}
}
async fn enforce_route_request_body_limit(
request_policy: HttpRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
request: Request<Body>,
) -> Result<Request<Body>, axum::response::Response> {
let RequestBodyLimitPolicy::Bytes(limit) =
request_policy.request_body_limit_for(&request, default_request_body_limit)
else {
return Ok(request);
};
let (parts, body) = request.into_parts();
let body = to_bytes(body, limit).await.map_err(|_| {
ApiProblem::payload_too_large(
ProblemCode::from_static("request_body_too_large"),
"request body is too large",
)
.into_response()
})?;
Ok(Request::from_parts(parts, Body::from(body)))
}
fn request_path<B>(request: &Request<B>) -> &str {
request
.extensions()
.get::<MatchedPath>()
.map(MatchedPath::as_str)
.unwrap_or_else(|| request.uri().path())
}
fn insert_header(headers: &mut HeaderMap, name: HeaderName, value: &Option<HeaderValue>) {
if let Some(value) = value {
headers.insert(name, value.clone());
}
}
fn cors_layer(policy: CorsPolicy) -> Option<CorsLayer> {
match policy {
CorsPolicy::Disabled => None,
CorsPolicy::Permissive => Some(CorsLayer::permissive()),
CorsPolicy::Restricted(config) => {
let mut layer = CorsLayer::new()
.allow_origin(AllowOrigin::list(config.allowed_origins))
.allow_credentials(config.allow_credentials);
if !config.allowed_methods.is_empty() {
layer = layer.allow_methods(config.allowed_methods);
}
if !config.allowed_headers.is_empty() {
layer = layer.allow_headers(config.allowed_headers);
}
if !config.exposed_headers.is_empty() {
layer = layer.expose_headers(config.exposed_headers);
}
if let Some(max_age) = config.max_age {
layer = layer.max_age(max_age);
}
Some(layer)
}
}
}
fn default_cors_allowed_headers() -> Vec<HeaderName> {
vec![
ACCEPT,
AUTHORIZATION,
CONTENT_TYPE,
HeaderName::from_static("x-request-id"),
HeaderName::from_static("traceparent"),
]
}
fn default_cors_exposed_headers() -> Vec<HeaderName> {
vec![HeaderName::from_static("x-request-id")]
}
#[cfg(feature = "config")]
fn default_true() -> bool {
true
}
#[cfg(feature = "config")]
fn default_cors_max_age() -> Option<Duration> {
Some(Duration::from_secs(10 * 60))
}
#[cfg(feature = "config")]
fn default_same_origin_header() -> Option<String> {
Some("same-origin".to_owned())
}
#[cfg(feature = "config")]
fn default_hsts_max_age_setting() -> Duration {
DEFAULT_HSTS_MAX_AGE
}
#[cfg(feature = "config")]
fn default_rate_limit_capacity() -> u32 {
100
}
#[cfg(feature = "config")]
fn default_rate_limit_refill_tokens() -> u32 {
100
}
#[cfg(feature = "config")]
fn default_rate_limit_refill_interval() -> Duration {
Duration::from_secs(60)
}
#[cfg(feature = "config")]
fn default_idempotency_ttl() -> Duration {
DEFAULT_IDEMPOTENCY_TTL
}
#[cfg(feature = "config")]
fn default_idempotency_processing_ttl() -> Duration {
DEFAULT_IDEMPOTENCY_PROCESSING_TTL
}
#[cfg(feature = "config")]
fn default_idempotency_body_limit() -> usize {
DEFAULT_IDEMPOTENCY_MAX_BODY_BYTES
}
#[cfg(feature = "config")]
fn default_http_timeout_setting() -> Option<Duration> {
Some(DEFAULT_HTTP_TIMEOUT)
}
#[cfg(feature = "config")]
fn default_http_request_body_limit_setting() -> Option<usize> {
Some(DEFAULT_HTTP_REQUEST_BODY_LIMIT)
}
#[cfg(feature = "config")]
fn default_http_default_rate_limit_policy() -> RateLimitRequestPolicySettings {
HttpRequestPolicy::default().default_rate_limit().into()
}
#[cfg(feature = "config")]
fn default_http_default_idempotency_policy() -> IdempotencyRequestPolicySettings {
HttpRequestPolicy::default().default_idempotency().into()
}
#[cfg(feature = "config")]
fn validate_request_body_limit_setting(
issues: &mut ConfigIssueCollector,
path: impl Into<String>,
value: RequestBodyLimitSettings,
) {
if let RequestBodyLimitSettings::Bytes(bytes) = value {
issues.require(bytes > 0, path, "must be greater than zero when enabled");
}
}
#[cfg(feature = "config")]
fn validate_method_settings(
issues: &mut ConfigIssueCollector,
path: impl AsRef<str>,
values: &[String],
) {
let path = path.as_ref();
for (index, value) in values.iter().enumerate() {
issues.require(
value.trim().parse::<Method>().is_ok(),
format!("{path}.{index}"),
"must be a valid HTTP method",
);
}
}
#[cfg(feature = "config")]
fn validate_header_name_settings(
issues: &mut ConfigIssueCollector,
path: impl AsRef<str>,
values: &[String],
) {
let path = path.as_ref();
for (index, value) in values.iter().enumerate() {
issues.require(
HeaderName::try_from(value.trim()).is_ok(),
format!("{path}.{index}"),
"must be a valid HTTP header name",
);
}
}
#[cfg(feature = "config")]
fn validate_rate_limit_key_source_setting(
issues: &mut ConfigIssueCollector,
path: impl AsRef<str>,
value: &RateLimitKeySourceSettings,
) {
let path = path.as_ref();
match value {
RateLimitKeySourceSettings::ClientIp
| RateLimitKeySourceSettings::PrincipalId
| RateLimitKeySourceSettings::RequestId => {}
RateLimitKeySourceSettings::Header(value) => {
issues.require(
HeaderName::try_from(value.trim()).is_ok(),
format!("{path}.value"),
"must be a valid HTTP header name",
);
}
RateLimitKeySourceSettings::Fixed(value) => {
issues.require(
!value.trim().is_empty(),
format!("{path}.value"),
"must not be empty",
);
}
}
}
#[cfg(feature = "config")]
fn parse_methods(field: &'static str, values: &[String]) -> Result<Vec<Method>, HttpLayerError> {
values
.iter()
.map(|value| {
let value = value.trim();
value
.parse::<Method>()
.map_err(|_| HttpLayerError::InvalidMethod {
field,
value: value.to_owned(),
})
})
.collect()
}
#[cfg(feature = "config")]
fn parse_header_names(
field: &'static str,
values: &[String],
) -> Result<Vec<HeaderName>, HttpLayerError> {
values
.iter()
.map(|value| {
HeaderName::try_from(value.trim())
.map_err(|source| HttpLayerError::InvalidHeaderName { field, source })
})
.collect()
}
#[cfg(feature = "config")]
fn optional_header_value(
field: &'static str,
value: Option<&str>,
) -> Result<Option<HeaderValue>, HttpLayerError> {
value
.map(str::trim)
.map(HeaderValue::from_str)
.transpose()
.map_err(|source| HttpLayerError::InvalidHeaderValue { field, source })
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use axum::{
Router,
body::{Body, to_bytes},
http::{
HeaderMap, HeaderName, HeaderValue, Method, Request, StatusCode,
header::{ACCEPT_ENCODING, AUTHORIZATION, CONTENT_ENCODING, CONTENT_TYPE},
},
routing::post,
};
use tower::ServiceExt;
use super::{
CorsConfig, CorsPolicy, DEFAULT_HSTS_MAX_AGE, DEFAULT_HTTP_REQUEST_BODY_LIMIT,
DEFAULT_HTTP_TIMEOUT, ForwardedHeadersPolicy, HttpFoundation, HttpLayerConfig,
HttpLayerError, HttpRequestPolicy, HttpRouteRule, RequestBodyLimitPolicy, RouteMatcher,
SecurityHeadersConfig, apply_standard_http_layers,
};
#[cfg(feature = "config")]
use super::{
CorsMode, CorsSettings, ForwardedHeadersSettings, HttpFoundationSettings,
HttpIdempotencySettings, HttpRateLimitSettings, HttpRequestPolicySettings,
HttpRouteRuleSettings, IdempotencyRequestPolicySettings, RateLimitKeySourceSettings,
RateLimitRequestPolicySettings, RequestBodyLimitSettings, RouteMatcherSettings,
SecurityHeadersSettings, StrictTransportSecuritySettings,
};
#[cfg(feature = "config")]
use crate::config::{SettingsAdapter, ValidateSettings};
use crate::http::{
IdempotencyRequestPolicy, IdempotencyRuntime, RateLimitRequestPolicy, TrustedProxyConfig,
};
#[test]
fn builds_restricted_cors_config_from_origin_strings() {
let cors = CorsConfig::from_origin_strs(["https://console.example.com"])
.expect("origin should be a valid header value")
.allow_credentials(true);
let config = HttpLayerConfig::default().with_cors(CorsPolicy::Restricted(cors));
assert!(config.validate().is_ok());
assert!(matches!(config.cors(), CorsPolicy::Restricted(_)));
let CorsPolicy::Restricted(restricted) = config.cors() else {
panic!("restricted CORS should be configured");
};
assert!(restricted.allowed_headers().contains(&CONTENT_TYPE));
assert!(restricted.allowed_headers().contains(&AUTHORIZATION));
assert!(
restricted
.exposed_headers()
.contains(&HeaderName::from_static("x-request-id"))
);
assert!(config.request_context_enabled());
assert!(!config.forwarded_headers_enabled());
assert!(config.trace_enabled());
assert!(config.compression_enabled());
}
#[tokio::test]
async fn compression_negotiates_each_idempotent_replay_independently() {
let app = apply_standard_http_layers(
Router::new().route("/", post(|| async { "compressible response ".repeat(100) })),
HttpLayerConfig::standard().with_idempotency(Some(IdempotencyRuntime::in_memory())),
)
.expect("standard layers should build");
let first = app
.clone()
.oneshot(
Request::post("/")
.header(
crate::http::IDEMPOTENCY_KEY_HEADER_NAME,
"compression-replay",
)
.header(ACCEPT_ENCODING, "gzip")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(
first.headers().get(CONTENT_ENCODING),
Some(&HeaderValue::from_static("gzip"))
);
let _ = to_bytes(first.into_body(), usize::MAX).await.unwrap();
let replay = app
.oneshot(
Request::post("/")
.header(
crate::http::IDEMPOTENCY_KEY_HEADER_NAME,
"compression-replay",
)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert!(replay.headers().get(CONTENT_ENCODING).is_none());
assert_eq!(
replay
.headers()
.get(crate::http::IDEMPOTENCY_REPLAYED_HEADER_NAME),
Some(&HeaderValue::from_static("true"))
);
assert_eq!(
to_bytes(replay.into_body(), usize::MAX)
.await
.unwrap()
.len(),
"compressible response ".len() * 100
);
}
#[test]
fn rejects_restricted_cors_without_origins() {
let config = HttpLayerConfig::default().with_cors(CorsPolicy::Restricted(CorsConfig::new(
std::iter::empty::<HeaderValue>(),
)));
assert!(matches!(
config.validate(),
Err(HttpLayerError::CorsAllowedOriginsEmpty)
));
}
#[test]
fn rejects_cors_credentials_with_wildcard_origin() {
let config = HttpLayerConfig::default().with_cors(CorsPolicy::Restricted(
CorsConfig::new([HeaderValue::from_static("*")]).allow_credentials(true),
));
assert!(matches!(
config.validate(),
Err(HttpLayerError::CorsWildcardOriginWithCredentials)
));
}
#[test]
fn rejects_invalid_layer_limits() {
assert!(matches!(
HttpLayerConfig::default()
.with_timeout(Some(Duration::ZERO))
.validate(),
Err(HttpLayerError::InvalidTimeout)
));
assert!(matches!(
HttpLayerConfig::default()
.with_request_body_limit(Some(0))
.validate(),
Err(HttpLayerError::InvalidRequestBodyLimit)
));
}
#[test]
fn idempotency_processing_lease_must_outlive_request_timeout() {
let timeout = Duration::from_secs(30);
let invalid = HttpLayerConfig::default()
.with_timeout(Some(timeout))
.with_idempotency(Some(
IdempotencyRuntime::in_memory().with_processing_ttl(timeout),
));
assert!(matches!(
invalid.validate(),
Err(HttpLayerError::InvalidIdempotencyConfig)
));
let valid = HttpLayerConfig::default()
.with_timeout(Some(timeout))
.with_idempotency(Some(
IdempotencyRuntime::in_memory()
.with_processing_ttl(timeout + Duration::from_secs(1)),
));
valid
.validate()
.expect("processing lease longer than the request timeout should validate");
}
#[test]
fn applies_api_security_headers() {
let mut headers = HeaderMap::new();
let security_headers = SecurityHeadersConfig::api_defaults()
.with_frame_options(None)
.with_content_type_options(Some(HeaderValue::from_static("nosniff")))
.with_content_security_policy(Some(HeaderValue::from_static("default-src 'self'")))
.with_permissions_policy(Some(HeaderValue::from_static("camera=()")));
security_headers.apply(&mut headers);
assert_eq!(
headers
.get("x-content-type-options")
.and_then(|value| value.to_str().ok()),
Some("nosniff")
);
assert!(headers.get("x-frame-options").is_none());
assert_eq!(
headers
.get("content-security-policy")
.and_then(|value| value.to_str().ok()),
Some("default-src 'self'")
);
assert_eq!(
headers
.get("permissions-policy")
.and_then(|value| value.to_str().ok()),
Some("camera=()")
);
assert_eq!(
security_headers
.content_type_options()
.and_then(|value| value.to_str().ok()),
Some("nosniff")
);
}
#[test]
fn builds_strict_transport_security_header() {
let mut headers = HeaderMap::new();
let security_headers = SecurityHeadersConfig::api_defaults()
.with_strict_transport_security(DEFAULT_HSTS_MAX_AGE, true, false)
.expect("hsts header should be valid");
security_headers.apply(&mut headers);
assert_eq!(
headers
.get("strict-transport-security")
.and_then(|value| value.to_str().ok()),
Some("max-age=31536000; includeSubDomains")
);
}
#[test]
fn standard_defaults_are_explicit_and_hsts_is_opt_in() {
let standard = HttpLayerConfig::default();
assert_eq!(standard.timeout(), Some(DEFAULT_HTTP_TIMEOUT));
assert_eq!(
standard.request_body_limit(),
Some(DEFAULT_HTTP_REQUEST_BODY_LIMIT)
);
assert!(
standard
.security_headers()
.and_then(SecurityHeadersConfig::strict_transport_security)
.is_none()
);
let tls = HttpLayerConfig::default()
.with_security_headers(Some(SecurityHeadersConfig::strict_api_defaults()));
assert_eq!(
tls.security_headers()
.and_then(SecurityHeadersConfig::strict_transport_security)
.and_then(|value| value.to_str().ok()),
Some("max-age=31536000; includeSubDomains")
);
}
#[test]
fn request_policy_overrides_matching_routes_in_order() {
let policy = HttpRequestPolicy::default()
.with_rule(
HttpRouteRule::prefix("/api/admin")
.rate_limit(RateLimitRequestPolicy::Disabled)
.idempotency(IdempotencyRequestPolicy::Required),
)
.with_rule(
HttpRouteRule::exact("/api/admin/import")
.methods([Method::POST])
.request_body_limit(RequestBodyLimitPolicy::Bytes(1024)),
);
let request = Request::post("/api/admin/import")
.body(Body::empty())
.expect("request should build");
let effective = policy.policy_for(&request);
assert_eq!(effective.rate_limit(), RateLimitRequestPolicy::Disabled);
assert_eq!(effective.idempotency(), IdempotencyRequestPolicy::Required);
assert_eq!(
effective.request_body_limit(),
RequestBodyLimitPolicy::Bytes(1024)
);
let sibling = Request::post("/api/administrator")
.body(Body::empty())
.expect("request should build");
let sibling_effective = policy.policy_for(&sibling);
assert_eq!(
sibling_effective.rate_limit(),
RateLimitRequestPolicy::Enabled
);
assert_eq!(
sibling_effective.idempotency(),
IdempotencyRequestPolicy::HeaderOptional
);
}
#[cfg(feature = "config")]
#[test]
fn request_policy_settings_adapt_to_route_policy() {
let settings = HttpRequestPolicySettings::default().with_rule(HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Exact("/api/import".to_owned()),
methods: vec!["POST".to_owned()],
rate_limit: Some(RateLimitRequestPolicySettings::Disabled),
idempotency: Some(IdempotencyRequestPolicySettings::Required),
request_body_limit: Some(RequestBodyLimitSettings::Bytes(512)),
});
settings
.validate_at("server.http.request_policy")
.expect("request policy settings should validate");
let policy = HttpRequestPolicy::try_from(&settings).expect("settings should adapt");
let request = Request::post("/api/import")
.body(Body::empty())
.expect("request should build");
let effective = policy.policy_for(&request);
assert_eq!(effective.rate_limit(), RateLimitRequestPolicy::Disabled);
assert_eq!(effective.idempotency(), IdempotencyRequestPolicy::Required);
assert_eq!(
effective.request_body_limit(),
RequestBodyLimitPolicy::Bytes(512)
);
}
#[cfg(feature = "config")]
#[test]
fn request_policy_settings_report_route_paths() {
let settings = HttpRequestPolicySettings::default().with_rule(HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Prefix("api".to_owned()),
methods: vec!["not a method".to_owned()],
rate_limit: None,
idempotency: None,
request_body_limit: Some(RequestBodyLimitSettings::Bytes(0)),
});
let error = settings
.validate_at("server.http.request_policy")
.expect_err("invalid request policy settings should fail");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.http.request_policy.rules.0.matcher.value"));
assert!(paths.contains(&"server.http.request_policy.rules.0.methods.0"));
assert!(paths.contains(&"server.http.request_policy.rules.0.request_body_limit"));
}
#[test]
fn route_prefix_matches_path_segments_unless_raw_prefix_is_requested() {
assert!(RouteMatcher::Prefix("/api".to_owned()).matches("/api"));
assert!(RouteMatcher::Prefix("/api".to_owned()).matches("/api/users"));
assert!(!RouteMatcher::Prefix("/api".to_owned()).matches("/apiary"));
assert!(RouteMatcher::RawPrefix("/api".to_owned()).matches("/apiary"));
}
#[test]
fn http_foundation_builder_keeps_standard_defaults_overrideable() {
let foundation = HttpFoundation::builder()
.forwarded_headers_policy(ForwardedHeadersPolicy::always())
.request_body_limit(Some(4096))
.build();
assert!(foundation.config().forwarded_headers_enabled());
assert_eq!(foundation.config().request_body_limit(), Some(4096));
assert!(foundation.config().security_headers().is_some());
}
#[test]
fn http_foundation_builder_accepts_trusted_proxy_policy() {
let proxies = TrustedProxyConfig::from_cidrs(["10.0.0.0/8"]).expect("CIDR should parse");
let foundation = HttpFoundation::builder()
.forwarded_headers_policy(ForwardedHeadersPolicy::trusted_proxies(proxies.clone()))
.build();
assert!(foundation.config().forwarded_headers_enabled());
assert_eq!(
foundation.config().forwarded_headers_policy(),
&ForwardedHeadersPolicy::TrustedProxies(proxies)
);
}
#[cfg(feature = "config")]
#[test]
fn http_foundation_settings_adapt_to_runtime_config() {
let settings = HttpFoundationSettings::new()
.with_forwarded_headers(ForwardedHeadersSettings::trusted_proxies(["10.0.0.0/8"]))
.with_cors(CorsSettings::restricted(["https://console.example.com"]))
.with_security_headers(SecurityHeadersSettings {
strict_transport_security: StrictTransportSecuritySettings {
enabled: true,
max_age: Duration::from_secs(3600),
include_subdomains: true,
preload: false,
},
..SecurityHeadersSettings::default()
})
.with_rate_limit(HttpRateLimitSettings::default().with_enabled(true))
.with_timeout(Some(Duration::from_secs(5)));
settings
.validate_settings()
.expect("settings should validate");
let config = settings.adapt().expect("settings should adapt");
assert!(config.forwarded_headers_enabled());
assert_eq!(config.timeout(), Some(Duration::from_secs(5)));
assert!(matches!(config.cors(), CorsPolicy::Restricted(_)));
assert!(config.rate_limit().is_some());
assert_eq!(
config
.security_headers()
.and_then(SecurityHeadersConfig::strict_transport_security)
.and_then(|value| value.to_str().ok()),
Some("max-age=3600; includeSubDomains")
);
}
#[cfg(feature = "config")]
#[test]
fn http_foundation_settings_report_config_paths() {
let settings = HttpFoundationSettings::default()
.with_timeout(Some(Duration::ZERO))
.with_cors(CorsSettings {
mode: CorsMode::Restricted,
..CorsSettings::default()
});
let error = settings
.validate_at("server.http")
.expect_err("invalid HTTP settings should report paths");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.http.timeout"));
assert!(paths.contains(&"server.http.cors.allowed_origins"));
}
#[cfg(feature = "config")]
#[test]
fn http_foundation_settings_report_short_idempotency_processing_lease() {
let timeout = Duration::from_secs(30);
let settings = HttpFoundationSettings::default()
.with_timeout(Some(timeout))
.with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_processing_ttl(timeout),
);
let error = settings
.validate_at("server.http")
.expect_err("processing lease no longer than the request timeout should fail");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.http.idempotency.processing_ttl"));
}
#[cfg(feature = "config")]
#[test]
fn http_foundation_settings_report_nested_value_paths() {
let settings = HttpFoundationSettings::default()
.with_cors(CorsSettings {
mode: CorsMode::Restricted,
allowed_origins: vec![" ".to_owned()],
allowed_methods: vec!["not a method".to_owned()],
allowed_headers: vec!["bad header".to_owned()],
exposed_headers: vec!["bad header".to_owned()],
..CorsSettings::default()
})
.with_security_headers(
SecurityHeadersSettings::default()
.with_cross_origin_opener_policy(Some("bad\nheader"))
.with_content_security_policy(Some("bad\npolicy"))
.with_permissions_policy(Some("bad\npermissions")),
)
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(RateLimitKeySourceSettings::Fixed(" ".to_owned())),
);
let error = settings
.validate_at("server.http")
.expect_err("invalid nested HTTP settings should report paths");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.http.cors.allowed_origins.0"));
assert!(paths.contains(&"server.http.cors.allowed_methods.0"));
assert!(paths.contains(&"server.http.cors.allowed_headers.0"));
assert!(paths.contains(&"server.http.cors.exposed_headers.0"));
assert!(paths.contains(&"server.http.security_headers.content_security_policy"));
assert!(paths.contains(&"server.http.security_headers.permissions_policy"));
assert!(paths.contains(&"server.http.security_headers.cross_origin_opener_policy"));
assert!(paths.contains(&"server.http.rate_limit.key_source.value"));
}
#[cfg(feature = "config")]
#[test]
fn rate_limit_key_source_settings_reject_empty_fixed_key() {
let error = crate::http::RateLimitKeySource::try_from(&RateLimitKeySourceSettings::Fixed(
" ".to_owned(),
))
.expect_err("empty fixed rate limit key should fail");
assert!(matches!(
error,
HttpLayerError::InvalidRateLimitKeySource {
field: "rate_limit.key_source"
}
));
}
#[cfg(feature = "config")]
#[test]
fn http_layer_debug_redacts_invalid_values_and_fixed_keys() {
let private_value = "private-http-config-value";
let error = HttpLayerError::InvalidTrustedProxyCidr {
reason: private_value.to_owned(),
};
let settings = RateLimitKeySourceSettings::Fixed(private_value.to_owned());
let output = format!("{error:?} {error} {settings:?}");
assert!(output.contains("http_invalid_trusted_proxy_cidr"));
assert!(output.contains("[REDACTED]"));
assert!(!output.contains(private_value));
}
#[tokio::test]
async fn route_request_body_limit_rejects_oversized_matching_requests() {
let config = HttpLayerConfig::minimal().with_request_policy(
HttpRequestPolicy::disabled().with_rule(
HttpRouteRule::exact("/uploads")
.methods([Method::POST])
.request_body_limit(RequestBodyLimitPolicy::Bytes(4)),
),
);
let app = apply_standard_http_layers(
Router::new().route("/uploads", post(|| async { "ok" })),
config,
)
.expect("layers should apply");
let response = app
.oneshot(
Request::post("/uploads")
.body(Body::from("too-large"))
.expect("request should build"),
)
.await
.expect("request should complete");
assert_eq!(response.status(), StatusCode::PAYLOAD_TOO_LARGE);
}
#[tokio::test]
async fn route_request_body_limit_can_raise_or_disable_global_limit() {
let config = HttpLayerConfig::minimal()
.with_request_body_limit(Some(4))
.with_request_policy(
HttpRequestPolicy::disabled()
.with_rule(
HttpRouteRule::exact("/larger")
.methods([Method::POST])
.request_body_limit(RequestBodyLimitPolicy::Bytes(16)),
)
.with_rule(
HttpRouteRule::exact("/unlimited")
.methods([Method::POST])
.request_body_limit(RequestBodyLimitPolicy::Disabled),
),
);
let app = apply_standard_http_layers(
Router::new()
.route("/default", post(|body: String| async move { body }))
.route("/larger", post(|body: String| async move { body }))
.route("/unlimited", post(|body: String| async move { body })),
config,
)
.expect("layers should apply");
let default_response = app
.clone()
.oneshot(
Request::post("/default")
.body(Body::from("eight123"))
.expect("request should build"),
)
.await
.expect("request should complete");
assert_eq!(default_response.status(), StatusCode::PAYLOAD_TOO_LARGE);
for path in ["/larger", "/unlimited"] {
let response = app
.clone()
.oneshot(
Request::post(path)
.body(Body::from("eight123"))
.expect("request should build"),
)
.await
.expect("request should complete");
assert_eq!(response.status(), StatusCode::OK);
}
}
}