footing 0.6.4

Feature-gated foundations for Rust backend services
Documentation
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,
};

/// Populates request context using peer information and untrusted headers.
/// Existing context, including verified identity and request ID, is preserved.
/// Header-derived client IPs are reevaluated with forwarded headers disabled.
pub async fn request_context_middleware(request: Request<Body>, next: Next) -> Response {
    request_context_middleware_with_forwarded_policy(request, next, ForwardedHeadersPolicy::never())
        .await
}

/// Populates request context using an explicit forwarded-header trust policy.
/// Existing context, including verified identity and request ID, is preserved.
/// Client IPs are reevaluated using this policy unless application code installed
/// an explicit address through [`RequestContext::set_client_ip`] or
/// [`RequestContext::with_client_ip`].
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"
        );
    }
}