use std::net::SocketAddr;
use axum::{
body::Body,
extract::ConnectInfo,
http::{HeaderValue, Request},
middleware::Next,
response::Response,
};
use super::{
request_context::{REQUEST_ID_HEADER_NAME, RequestContext},
trusted_proxy::ForwardedHeadersPolicy,
};
pub async fn request_context_middleware(request: Request<Body>, next: Next) -> Response {
request_context_middleware_with_forwarded_policy(request, next, ForwardedHeadersPolicy::never())
.await
}
pub async fn request_context_middleware_with_forwarded_policy(
mut request: Request<Body>,
next: Next,
forwarded_headers: ForwardedHeadersPolicy,
) -> Response {
let peer_client_ip = request
.extensions()
.get::<ConnectInfo<SocketAddr>>()
.map(|connect_info| connect_info.0.ip());
let context = match request.extensions_mut().remove::<RequestContext>() {
Some(mut context) => {
context.refresh_client_ip(request.headers(), peer_client_ip, &forwarded_headers);
context
}
None => RequestContext::from_headers_and_peer_ip_with_forwarded_policy(
request.headers(),
peer_client_ip,
&forwarded_headers,
),
};
let request_id = HeaderValue::from(context.request_id());
request.extensions_mut().insert(context);
let mut response = next.run(request).await;
response
.headers_mut()
.insert(REQUEST_ID_HEADER_NAME, request_id);
response
}
#[cfg(test)]
mod tests {
#[cfg(feature = "http-stack")]
use axum::{Extension, http::StatusCode};
use axum::{Router, body::to_bytes, middleware::from_fn, routing::get};
use tower::ServiceExt;
use super::*;
use crate::http::ClientIpSource;
#[cfg(feature = "http-stack")]
use crate::{
auth::Principal,
http::{
AuthenticationChallenge, CurrentPrincipal, IdempotencyScope, VerifiedAuthentication,
},
};
#[cfg(feature = "http-stack")]
#[tokio::test]
async fn context_middleware_preserves_verified_authentication_from_outer_layers() {
let app =
Router::new()
.route(
"/",
get(
|principal: CurrentPrincipal,
Extension(scope): Extension<IdempotencyScope>| async move {
assert_eq!(scope, IdempotencyScope::new("user_1"));
principal.id().to_owned()
},
),
)
.layer(from_fn(request_context_middleware))
.layer(from_fn(
|mut request: Request<Body>, next: Next| async move {
VerifiedAuthentication::new(
Principal::user("user_1").unwrap(),
IdempotencyScope::new("user_1"),
)
.install(&mut request);
next.run(request).await
},
))
.with_state(AuthenticationChallenge::try_new("Bearer").unwrap());
let response = app.oneshot(Request::new(Body::empty())).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
to_bytes(response.into_body(), 1024).await.unwrap(),
"user_1"
);
}
#[tokio::test]
async fn nested_context_middleware_uses_one_request_identifier() {
let app = Router::new()
.route(
"/",
get(|context: RequestContext| async move { context.request_id().to_string() }),
)
.layer(from_fn(request_context_middleware))
.layer(from_fn(request_context_middleware));
let response = app.oneshot(Request::new(Body::empty())).await.unwrap();
let request_id = response.headers()[REQUEST_ID_HEADER_NAME].clone();
let body = to_bytes(response.into_body(), 1024).await.unwrap();
assert_eq!(body, request_id.as_bytes());
}
#[tokio::test]
async fn existing_context_keeps_explicit_ip_and_resolves_a_missing_peer() {
let app = Router::new()
.route(
"/",
get(|context: RequestContext| async move {
format!(
"{}:{}",
context.client_ip().unwrap(),
context.client_ip_source().unwrap()
)
}),
)
.layer(from_fn(request_context_middleware));
for explicit in [false, true] {
let mut request = Request::new(Body::empty());
let mut context = RequestContext::from_headers(request.headers());
if explicit {
context.set_client_ip("198.51.100.10".parse::<std::net::IpAddr>().unwrap());
}
request.extensions_mut().insert(context);
request.extensions_mut().insert(ConnectInfo(
"192.0.2.10:12345".parse::<SocketAddr>().unwrap(),
));
let response = app.clone().oneshot(request).await.unwrap();
assert_eq!(
to_bytes(response.into_body(), 1024).await.unwrap(),
if explicit {
"198.51.100.10:explicit"
} else {
"192.0.2.10:peer"
}
);
}
}
#[tokio::test]
async fn inner_context_layer_rechecks_its_forwarded_header_policy() {
let app = Router::new()
.route(
"/",
get(|context: RequestContext| async move {
assert_eq!(context.client_ip_source(), Some(ClientIpSource::Peer));
context.client_ip().unwrap().to_owned()
}),
)
.layer(from_fn(request_context_middleware))
.layer(from_fn(|request, next| {
request_context_middleware_with_forwarded_policy(
request,
next,
ForwardedHeadersPolicy::always(),
)
}));
let mut request = Request::builder()
.header("x-forwarded-for", "198.51.100.10")
.body(Body::empty())
.unwrap();
request.extensions_mut().insert(ConnectInfo(
"192.0.2.10:12345".parse::<SocketAddr>().unwrap(),
));
let response = app.oneshot(request).await.unwrap();
assert_eq!(
to_bytes(response.into_body(), 1024).await.unwrap(),
"192.0.2.10"
);
}
}