use std::time::Duration;
use axum::http::{HeaderName, HeaderValue};
use serde::{Deserialize, Serialize};
use crate::http::{
CLIENT_ID_HEADER_NAME, IDEMPOTENCY_KEY_HEADER_NAME, IDEMPOTENCY_REPLAYED_HEADER_NAME,
LOCALE_HEADER_NAME, REQUEST_ID_HEADER_NAME, SESSION_ID_HEADER_NAME, TIME_ZONE_HEADER_NAME,
TRACEPARENT_HEADER_NAME, UTC_OFFSET_HEADER_NAME,
};
use crate::settings::{SettingsIssues, SettingsValidationError, field_path};
use super::super::{
policy::{CorsConfig, CorsPolicy},
route_settings::parse_method,
};
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default, deny_unknown_fields)]
#[non_exhaustive]
pub struct CorsSettings {
pub mode: CorsMode,
pub allowed_origins: Vec<String>,
pub allow_credentials: bool,
pub allowed_methods: Vec<String>,
pub allowed_headers: Vec<String>,
pub exposed_headers: Vec<String>,
#[serde(with = "crate::settings::human_duration::option")]
pub max_age: Option<Duration>,
}
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum CorsMode {
#[default]
Disabled,
AnyOrigin,
Restricted,
}
impl Default for CorsSettings {
fn default() -> Self {
Self {
mode: CorsMode::Disabled,
allowed_origins: Vec::new(),
allow_credentials: false,
allowed_methods: ["GET", "POST", "PUT", "PATCH", "DELETE"]
.map(str::to_owned)
.into(),
allowed_headers: [
"accept",
"accept-language",
"authorization",
"content-type",
"user-agent",
REQUEST_ID_HEADER_NAME,
TRACEPARENT_HEADER_NAME,
IDEMPOTENCY_KEY_HEADER_NAME,
LOCALE_HEADER_NAME,
TIME_ZONE_HEADER_NAME,
UTC_OFFSET_HEADER_NAME,
CLIENT_ID_HEADER_NAME,
SESSION_ID_HEADER_NAME,
]
.map(str::to_owned)
.into(),
exposed_headers: [
REQUEST_ID_HEADER_NAME,
IDEMPOTENCY_REPLAYED_HEADER_NAME,
"retry-after",
]
.map(str::to_owned)
.into(),
max_age: Some(Duration::from_secs(10 * 60)),
}
}
}
impl CorsSettings {
pub fn validate(&self) -> Result<(), SettingsValidationError> {
self.validate_at("http.cors")
}
pub fn validate_at(&self, path: &str) -> Result<(), SettingsValidationError> {
self.build_at(path).map(|_| ())
}
#[must_use]
pub fn disabled() -> Self {
Self::default()
}
#[must_use]
pub fn permissive() -> Self {
Self {
allowed_methods: vec!["*".into()],
allowed_headers: vec!["*".into()],
exposed_headers: vec!["*".into()],
max_age: None,
..Self::any_origin()
}
}
#[must_use]
pub fn any_origin() -> Self {
Self {
mode: CorsMode::AnyOrigin,
..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(in crate::http::layers) fn build_at(
&self,
path: &str,
) -> Result<CorsPolicy, SettingsValidationError> {
if self.mode == CorsMode::Disabled {
return Ok(CorsPolicy::Disabled);
}
let mut issues = SettingsIssues::new();
if self.mode == CorsMode::AnyOrigin {
issues.require(
!self.allow_credentials,
field_path(path, "allow_credentials"),
"must not be enabled with wildcard origins",
);
issues.require(
self.allowed_origins.is_empty(),
field_path(path, "allowed_origins"),
"must be empty when CORS mode is any_origin",
);
} else {
issues.require(
!self.allowed_origins.is_empty(),
field_path(path, "allowed_origins"),
"must not be empty when CORS mode is restricted",
);
}
for (field, values) in [
("allowed_methods", &self.allowed_methods),
("allowed_headers", &self.allowed_headers),
("exposed_headers", &self.exposed_headers),
] {
if values.iter().any(|value| value.trim() == "*") {
issues.require(
!self.allow_credentials,
field_path(path, field),
"must not contain '*' when credentials are enabled",
);
issues.require(
values.len() == 1,
field_path(path, field),
"'*' must be the only entry",
);
}
}
let config = CorsConfig {
allowed_origins: parse_values(
&mut issues,
&field_path(path, "allowed_origins"),
&self.allowed_origins,
parse_origin,
"must be a serialized origin (scheme://host[:port]) or 'null', without paths, credentials or wildcards",
),
allowed_methods: parse_values(
&mut issues,
&field_path(path, "allowed_methods"),
&self.allowed_methods,
parse_method,
"must be a valid HTTP method",
),
allowed_headers: parse_values(
&mut issues,
&field_path(path, "allowed_headers"),
&self.allowed_headers,
|value| HeaderName::try_from(value),
"must be a valid HTTP header name",
),
exposed_headers: parse_values(
&mut issues,
&field_path(path, "exposed_headers"),
&self.exposed_headers,
|value| HeaderName::try_from(value),
"must be a valid HTTP header name",
),
allow_credentials: self.allow_credentials,
max_age: self.max_age,
};
issues.into_result()?;
Ok(if self.mode == CorsMode::AnyOrigin {
CorsPolicy::AnyOrigin(config)
} else {
CorsPolicy::Restricted(config)
})
}
}
fn parse_origin(value: &str) -> Result<HeaderValue, ()> {
if value.contains('*')
|| (value != "null"
&& !url::Url::parse(value).is_ok_and(|url| url.origin().ascii_serialization() == value))
{
return Err(());
}
HeaderValue::from_str(value).map_err(|_| ())
}
impl TryFrom<&CorsSettings> for CorsPolicy {
type Error = SettingsValidationError;
fn try_from(value: &CorsSettings) -> Result<Self, Self::Error> {
value.build_at("http.cors")
}
}
fn parse_values<T, E>(
issues: &mut SettingsIssues,
path: &str,
values: &[String],
parse: impl Fn(&str) -> Result<T, E>,
message: &str,
) -> Vec<T> {
values
.iter()
.enumerate()
.filter_map(|(index, value)| match parse(value.trim()) {
Ok(value) => Some(value),
Err(_) => {
issues.push(field_path(path, &index.to_string()), message);
None
}
})
.collect()
}