use std::{borrow::Cow, fmt, net::IpAddr};
use axum::http::HeaderMap;
use serde::{Deserialize, Serialize};
use crate::{http::trusted_proxy::ForwardedHeadersPolicy, net::ClientIp};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum ClientIpSource {
Peer,
XForwardedFor,
XRealIp,
Forwarded,
Explicit,
}
impl ClientIpSource {
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Peer => "peer",
Self::XForwardedFor => "x_forwarded_for",
Self::XRealIp => "x_real_ip",
Self::Forwarded => "forwarded",
Self::Explicit => "explicit",
}
}
}
impl fmt::Display for ClientIpSource {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum ForwardedHeadersStatus {
Resolved,
Absent,
Disabled,
MissingPeer,
UntrustedPeer,
Malformed,
Conflicting,
NoUntrustedHop,
}
pub(super) fn client_ip_from_forwarded_headers(
headers: &HeaderMap,
peer_client_ip: Option<IpAddr>,
policy: &ForwardedHeadersPolicy,
) -> Result<(ClientIp, ClientIpSource), ForwardedHeadersStatus> {
if !["forwarded", "x-forwarded-for", "x-real-ip"]
.iter()
.any(|name| headers.contains_key(*name))
{
return Err(ForwardedHeadersStatus::Absent);
}
match policy {
ForwardedHeadersPolicy::Never => return Err(ForwardedHeadersStatus::Disabled),
ForwardedHeadersPolicy::TrustedProxies(_) if peer_client_ip.is_none() => {
return Err(ForwardedHeadersStatus::MissingPeer);
}
ForwardedHeadersPolicy::TrustedProxies(_) if !policy.should_trust(peer_client_ip) => {
return Err(ForwardedHeadersStatus::UntrustedPeer);
}
_ => {}
}
match forwarding_chain(headers)? {
Some((chain, source)) => forwarded_chain_client_ip(&chain, policy)
.map(|client_ip| (client_ip, source))
.ok_or(ForwardedHeadersStatus::NoUntrustedHop),
None => single_proxy_real_ip(headers)
.map_err(|()| ForwardedHeadersStatus::Malformed)?
.map(|client_ip| (client_ip, ClientIpSource::XRealIp))
.ok_or(ForwardedHeadersStatus::Absent),
}
}
fn forwarding_chain(
headers: &HeaderMap,
) -> Result<Option<(Vec<ClientIp>, ClientIpSource)>, ForwardedHeadersStatus> {
let forwarded_for =
parse_x_forwarded_for(headers).map_err(|()| ForwardedHeadersStatus::Malformed)?;
let forwarded = parse_forwarded(headers).map_err(|()| ForwardedHeadersStatus::Malformed)?;
match (forwarded_for, forwarded) {
(None, None) => Ok(None),
(Some(chain), None) => Ok(Some((chain, ClientIpSource::XForwardedFor))),
(None, Some(chain)) => Ok(Some((chain, ClientIpSource::Forwarded))),
(Some(forwarded_for), Some(forwarded)) if forwarded_for == forwarded => {
Ok(Some((forwarded, ClientIpSource::Forwarded)))
}
(Some(_), Some(_)) => Err(ForwardedHeadersStatus::Conflicting),
}
}
fn parse_x_forwarded_for(headers: &HeaderMap) -> Result<Option<Vec<ClientIp>>, ()> {
let values = headers.get_all("x-forwarded-for");
let mut chain = Vec::new();
for value in &values {
let value = value.to_str().map_err(|_| ())?;
for hop in value.split(',') {
chain.push(ClientIp::parse(hop.trim()).ok_or(())?);
}
}
Ok((!chain.is_empty()).then_some(chain))
}
fn parse_forwarded(headers: &HeaderMap) -> Result<Option<Vec<ClientIp>>, ()> {
let values = headers.get_all("forwarded");
let mut chain = Vec::new();
for value in &values {
let value = value.to_str().map_err(|_| ())?;
for element in split_forwarded_quoted(value, b',')? {
let mut forwarded_for = None;
let mut names: Vec<&str> = Vec::new();
for parameter in split_forwarded_quoted(element, b';')? {
let parameter = parameter.trim_matches([' ', '\t']);
if parameter.is_empty() {
continue;
}
let (name, value) = parameter.split_once('=').ok_or(())?;
if !is_token(name) || names.iter().any(|seen| seen.eq_ignore_ascii_case(name)) {
return Err(());
}
names.push(name);
let value = parse_forwarded_value(value)?;
if name.eq_ignore_ascii_case("for") {
forwarded_for = Some(parse_forwarded_for(&value)?);
}
}
chain.push(forwarded_for.ok_or(())?);
}
}
Ok((!chain.is_empty()).then_some(chain))
}
fn split_forwarded_quoted(value: &str, separator: u8) -> Result<Vec<&str>, ()> {
let mut parts = Vec::new();
let mut start = 0;
let mut quoted = false;
let mut escaped = false;
for (index, byte) in value.bytes().enumerate() {
if escaped {
escaped = false;
} else if quoted && byte == b'\\' {
escaped = true;
} else if byte == b'"' {
quoted = !quoted;
} else if !quoted && byte == separator {
parts.push(&value[start..index]);
start = index + 1;
}
}
if quoted || escaped {
return Err(());
}
parts.push(&value[start..]);
Ok(parts)
}
fn parse_forwarded_value(value: &str) -> Result<Cow<'_, str>, ()> {
let Some(quoted) = value.strip_circumfix('"', '"') else {
return is_token(value).then_some(Cow::Borrowed(value)).ok_or(());
};
if !quoted.contains(['"', '\\']) {
return Ok(Cow::Borrowed(quoted));
}
let mut decoded = String::with_capacity(quoted.len());
let mut chars = quoted.chars();
while let Some(ch) = chars.next() {
decoded.push(match ch {
'"' => return Err(()),
'\\' => chars.next().ok_or(())?,
_ => ch,
});
}
Ok(Cow::Owned(decoded))
}
fn is_token(value: &str) -> bool {
!value.is_empty()
&& value
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || b"!#$%&'*+-.^_`|~".contains(&byte))
}
fn parse_forwarded_for(value: &str) -> Result<ClientIp, ()> {
let (address, port) = if let Some(rest) = value.strip_prefix('[') {
let (host, suffix) = rest.split_once(']').ok_or(())?;
let address = IpAddr::V6(host.parse().map_err(|_| ())?);
let port = if suffix.is_empty() {
None
} else {
Some(suffix.strip_prefix(':').ok_or(())?)
};
(address, port)
} else {
let (host, port) = value
.split_once(':')
.map_or((value, None), |(host, port)| (host, Some(port)));
(IpAddr::V4(host.parse().map_err(|_| ())?), port)
};
if let Some(port) = port {
let valid = if let Some(obfuscated) = port.strip_prefix('_') {
!obfuscated.is_empty()
&& obfuscated
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
} else {
(1..=5).contains(&port.len())
&& port.bytes().all(|byte| byte.is_ascii_digit())
&& port.parse::<u16>().is_ok()
};
if !valid {
return Err(());
}
}
Ok(ClientIp::from_ip_addr(address))
}
fn forwarded_chain_client_ip(
chain: &[ClientIp],
policy: &ForwardedHeadersPolicy,
) -> Option<ClientIp> {
match policy {
ForwardedHeadersPolicy::Never => None,
ForwardedHeadersPolicy::Always => chain.last().cloned(),
ForwardedHeadersPolicy::TrustedProxies(networks) => chain
.iter()
.rev()
.find(|hop| !networks.contains(hop.as_ip_addr()))
.cloned(),
}
}
fn single_proxy_real_ip(headers: &HeaderMap) -> Result<Option<ClientIp>, ()> {
let mut values = headers.get_all("x-real-ip").iter();
let Some(value) = values.next() else {
return Ok(None);
};
if values.next().is_some() {
return Err(());
}
let value = value.to_str().map_err(|_| ())?;
if value.contains(',') {
return Err(());
}
ClientIp::parse(value.trim()).ok_or(()).map(Some)
}