use axum::http::{HeaderMap, HeaderName, Method, header};
use thiserror::Error;
use url::{Origin, Url};
use crate::result::{ClassifyError, ErrorCode, ErrorKind};
#[derive(Clone, Debug)]
pub struct RequestOriginPolicy {
allowed: Vec<Origin>,
}
impl RequestOriginPolicy {
pub fn new(
origins: impl IntoIterator<Item = impl AsRef<str>>,
) -> Result<Self, OriginPolicyError> {
let mut allowed = Vec::new();
for (index, value) in origins.into_iter().enumerate() {
let origin = parse_web_origin(value.as_ref(), false)
.ok_or(OriginPolicyError::InvalidOrigin { index })?;
if !allowed.contains(&origin) {
allowed.push(origin);
}
}
if allowed.is_empty() {
return Err(OriginPolicyError::EmptyOrigins);
}
Ok(Self { allowed })
}
pub fn check(&self, method: &Method, headers: &HeaderMap) -> Result<(), OriginRejection> {
if matches!(*method, Method::GET | Method::HEAD | Method::OPTIONS) {
return Ok(());
}
let origin = if let Some(value) =
single_header(headers, header::ORIGIN).map_err(|()| OriginRejection::RepeatedOrigin)?
{
let value = value
.to_str()
.map_err(|_| OriginRejection::MalformedOrigin)?;
if value == "null" {
return Err(OriginRejection::OpaqueOrigin);
}
parse_web_origin(value, false).ok_or(OriginRejection::MalformedOrigin)?
} else {
let value = single_header(headers, header::REFERER)
.map_err(|()| OriginRejection::RepeatedReferer)?
.ok_or(OriginRejection::Missing)?
.to_str()
.map_err(|_| OriginRejection::MalformedReferer)?;
parse_web_origin(value, true).ok_or(OriginRejection::MalformedReferer)?
};
if self.allowed.contains(&origin) {
Ok(())
} else {
Err(OriginRejection::NotAllowed)
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum OriginPolicyError {
#[error("at least one allowed origin is required")]
EmptyOrigins,
#[error(
"allowed origin at index {index} must be an HTTP(S) origin without credentials, path, query, or fragment"
)]
InvalidOrigin {
index: usize,
},
}
impl ClassifyError for OriginPolicyError {
fn error_kind(&self) -> ErrorKind {
ErrorKind::Validation
}
fn error_code(&self) -> ErrorCode {
ErrorCode::internal(match self {
Self::EmptyOrigins => "origin_policy_empty_origins",
Self::InvalidOrigin { .. } => "origin_policy_invalid_origin",
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum OriginRejection {
#[error("request origin is missing")]
Missing,
#[error("request contains repeated Origin fields")]
RepeatedOrigin,
#[error("request Origin is malformed")]
MalformedOrigin,
#[error("opaque request origins are not permitted")]
OpaqueOrigin,
#[error("request contains repeated Referer fields")]
RepeatedReferer,
#[error("request Referer is malformed")]
MalformedReferer,
#[error("request origin is not permitted")]
NotAllowed,
}
impl ClassifyError for OriginRejection {
fn error_kind(&self) -> ErrorKind {
ErrorKind::Authorization
}
fn error_code(&self) -> ErrorCode {
ErrorCode::internal(match self {
Self::Missing => "request_origin_missing",
Self::RepeatedOrigin => "request_origin_repeated",
Self::MalformedOrigin => "request_origin_malformed",
Self::OpaqueOrigin => "request_origin_opaque",
Self::RepeatedReferer => "request_referer_repeated",
Self::MalformedReferer => "request_referer_malformed",
Self::NotAllowed => "request_origin_not_allowed",
})
}
}
fn single_header(
headers: &HeaderMap,
name: HeaderName,
) -> Result<Option<&axum::http::HeaderValue>, ()> {
let mut values = headers.get_all(name).iter();
let first = values.next();
if values.next().is_some() {
Err(())
} else {
Ok(first)
}
}
fn parse_web_origin(value: &str, allow_path: bool) -> Option<Origin> {
if !value.is_ascii()
|| value
.bytes()
.any(|byte| byte.is_ascii_control() || byte.is_ascii_whitespace() || byte == b'\\')
{
return None;
}
let (scheme, rest) = value.split_once("://")?;
if !scheme.eq_ignore_ascii_case("http") && !scheme.eq_ignore_ascii_case("https") {
return None;
}
let authority_end = rest.find(['/', '?', '#']).unwrap_or(rest.len());
let authority = &rest[..authority_end];
if authority.is_empty()
|| authority.contains(['@', '%', '*'])
|| authority.ends_with(':')
|| (!allow_path && authority_end != rest.len())
{
return None;
}
let url = Url::parse(value).ok()?;
if url.host().is_none() || url.fragment().is_some() {
return None;
}
Some(url.origin())
}