footing 0.6.6

Feature-gated foundations for Rust backend services
Documentation
#![cfg(feature = "http")]

use axum::{
    Router,
    body::{Body, to_bytes},
    extract::{Request, State},
    http::{HeaderMap, HeaderValue, Method, StatusCode, header},
    middleware::{self, Next},
    response::Response,
    routing::post,
};
use footing::http::{
    ApiProblem, OriginPolicyError, OriginRejection, ProblemCode, RequestContext,
    RequestOriginPolicy,
};
use tower::ServiceExt;

fn policy() -> RequestOriginPolicy {
    RequestOriginPolicy::new(["https://app.example.com"]).unwrap()
}

fn headers(pairs: &[(&str, &str)]) -> HeaderMap {
    let mut headers = HeaderMap::new();
    for (name, value) in pairs {
        headers.append(
            axum::http::HeaderName::from_bytes(name.as_bytes()).unwrap(),
            value.parse().unwrap(),
        );
    }
    headers
}

#[test]
fn configuration_requires_explicit_web_origins() {
    assert_eq!(
        RequestOriginPolicy::new([] as [&str; 0]).unwrap_err(),
        OriginPolicyError::EmptyOrigins
    );
    for invalid in [
        "",
        "null",
        "*",
        "https://*.example.com",
        "example.com",
        "https:app.example.com",
        "https:///app.example.com",
        "//app.example.com",
        "https://app.example.com/",
        "https://app.example.com/path",
        "https://app.example.com?secret=value",
        "https://app.example.com#fragment",
        "https://user:password@app.example.com",
        "https://@app.example.com",
        "https://app.example.com:",
        "https://app.example.com:65536",
        "https://%61pp.example.com",
        "https://app.example.com\\path",
        "https://app.example.com ",
        " https://app.example.com",
        "https://app.example.com\n",
        "https://éxample.com",
        "blob:https://app.example.com/id",
        "file://app.example.com",
        "https://app.example.com https://other.example.com",
    ] {
        let error = RequestOriginPolicy::new(["https://valid.example.com", invalid]).unwrap_err();
        assert_eq!(
            error,
            OriginPolicyError::InvalidOrigin { index: 1 },
            "{invalid:?}"
        );
        assert!(!format!("{error:?} {error}").contains("secret=value"));
    }
}

#[test]
fn origins_match_normalized_scheme_host_and_effective_port() {
    let policy = RequestOriginPolicy::new([
        "https://APP.example.com:443",
        "https://app.example.com",
        "http://localhost:8080",
        "https://[2001:db8::1]:443",
        "https://xn--xample-9ua.com",
    ])
    .unwrap();
    for origin in [
        "https://app.example.com",
        "https://APP.example.com:443",
        "http://localhost:8080",
        "https://[2001:0db8:0:0:0:0:0:1]",
        "https://xn--xample-9ua.com",
    ] {
        assert_eq!(
            policy.check(&Method::POST, &headers(&[("origin", origin)])),
            Ok(()),
            "{origin}"
        );
    }
    for origin in [
        "http://app.example.com",
        "https://app.example.com:444",
        "https://sub.app.example.com",
        "https://app.example.com.evil.test",
        "https://app.example.com.",
        "http://localhost",
        "https://[2001:db8::2]",
    ] {
        assert_eq!(
            policy.check(&Method::POST, &headers(&[("origin", origin)])),
            Err(OriginRejection::NotAllowed),
            "{origin}"
        );
    }
}

#[test]
fn only_get_head_and_options_skip_origin_checks() {
    let invalid = headers(&[("origin", "null"), ("origin", "null")]);
    for method in [Method::GET, Method::HEAD, Method::OPTIONS] {
        assert_eq!(policy().check(&method, &HeaderMap::new()), Ok(()));
        assert_eq!(policy().check(&method, &invalid), Ok(()));
    }
    for method in [
        Method::POST,
        Method::PUT,
        Method::PATCH,
        Method::DELETE,
        Method::TRACE,
        Method::CONNECT,
        Method::from_bytes(b"CUSTOM").unwrap(),
    ] {
        assert_eq!(
            policy().check(&method, &HeaderMap::new()),
            Err(OriginRejection::Missing)
        );
    }
}

#[test]
fn present_origin_never_falls_back_to_referer() {
    for (origin, expected) in [
        ("null", OriginRejection::OpaqueOrigin),
        ("", OriginRejection::MalformedOrigin),
        ("https://app.example.com/", OriginRejection::MalformedOrigin),
        (
            "https://app.example.com https://evil.test",
            OriginRejection::MalformedOrigin,
        ),
        (
            "https://app.example.com,https://evil.test",
            OriginRejection::MalformedOrigin,
        ),
        ("https://@app.example.com", OriginRejection::MalformedOrigin),
        (
            "https://app.example.com\\@evil.test",
            OriginRejection::MalformedOrigin,
        ),
        (
            "blob:https://app.example.com/id",
            OriginRejection::MalformedOrigin,
        ),
        ("https://evil.test", OriginRejection::NotAllowed),
    ] {
        let headers = headers(&[
            ("origin", origin),
            ("referer", "https://app.example.com/login"),
        ]);
        assert_eq!(
            policy().check(&Method::POST, &headers),
            Err(expected),
            "{origin}"
        );
    }
    let duplicate = headers(&[
        ("origin", "https://app.example.com"),
        ("origin", "https://app.example.com"),
        ("referer", "https://app.example.com/login"),
    ]);
    assert_eq!(
        policy().check(&Method::POST, &duplicate),
        Err(OriginRejection::RepeatedOrigin)
    );
    let mut non_ascii = headers(&[("referer", "https://app.example.com/login")]);
    non_ascii.insert(
        header::ORIGIN,
        HeaderValue::from_bytes(b"https://\xff.test").unwrap(),
    );
    assert_eq!(
        policy().check(&Method::POST, &non_ascii),
        Err(OriginRejection::MalformedOrigin)
    );
}

#[test]
fn referer_is_used_only_when_origin_is_absent() {
    for referer in [
        "https://app.example.com",
        "https://app.example.com/",
        "https://app.example.com/path?next=https://evil.test/",
        "https://app.example.com/path%20with%20spaces?value=%23fragment",
    ] {
        assert_eq!(
            policy().check(&Method::POST, &headers(&[("referer", referer)])),
            Ok(())
        );
    }
    for referer in [
        "",
        "/path",
        "//app.example.com/path",
        "https:///app.example.com/path",
        "https://app.example.com/path#secret-fragment",
        "https://@app.example.com/path",
        "https://user:password@app.example.com/path",
        "https://app.example.com\\path",
        "blob:https://app.example.com/id",
        "https://app.example.com/path with spaces",
    ] {
        assert_eq!(
            policy().check(&Method::POST, &headers(&[("referer", referer)])),
            Err(OriginRejection::MalformedReferer),
            "{referer}"
        );
    }
    assert_eq!(
        policy().check(
            &Method::POST,
            &headers(&[("referer", "https://evil.test/path")])
        ),
        Err(OriginRejection::NotAllowed)
    );
    let mut duplicate = headers(&[
        ("referer", "https://app.example.com/login"),
        ("referer", "https://app.example.com/login"),
    ]);
    assert_eq!(
        policy().check(&Method::POST, &duplicate),
        Err(OriginRejection::RepeatedReferer)
    );
    duplicate.insert(
        header::ORIGIN,
        HeaderValue::from_static("https://app.example.com"),
    );
    assert_eq!(policy().check(&Method::POST, &duplicate), Ok(()));
    duplicate.insert(header::REFERER, HeaderValue::from_static("not a URL"));
    assert_eq!(policy().check(&Method::POST, &duplicate), Ok(()));
}

#[test]
fn unrelated_headers_do_not_establish_origin_trust_and_errors_retain_no_input() {
    let mut supplied = headers(&[
        ("host", "app.example.com"),
        ("forwarded", "host=app.example.com;proto=https"),
        ("x-forwarded-host", "app.example.com"),
        ("x-forwarded-proto", "https"),
        ("sec-fetch-site", "same-origin"),
    ]);
    assert_eq!(
        policy().check(&Method::POST, &supplied),
        Err(OriginRejection::Missing)
    );
    supplied.insert(
        header::REFERER,
        HeaderValue::from_static("https://evil.test/private?secret=value"),
    );
    let error = policy().check(&Method::POST, &supplied).unwrap_err();
    assert_eq!(error, OriginRejection::NotAllowed);
    let displayed = format!("{error:?} {error}");
    for value in ["evil.test", "private", "secret=value"] {
        assert!(!displayed.contains(value));
    }
}

#[tokio::test]
async fn protected_login_checks_requests_without_cookies_and_preserves_error_context() {
    async fn check_origin(
        State(policy): State<RequestOriginPolicy>,
        context: RequestContext,
        request: Request,
        next: Next,
    ) -> Result<Response, ApiProblem> {
        policy
            .check(request.method(), request.headers())
            .map_err(|_| {
                ApiProblem::forbidden(
                    ProblemCode::from_static("request_origin_rejected"),
                    "request origin is not permitted",
                )
                .with_request_context(&context)
            })?;
        Ok(next.run(request).await)
    }
    let app = Router::new()
        .route("/session", post(|| async { StatusCode::NO_CONTENT }))
        .route_layer(middleware::from_fn_with_state(policy(), check_origin));
    for origin in [
        None,
        Some("https://evil.test"),
        Some("https://app.example.com"),
    ] {
        let mut request = Request::post("/session").header("x-request-id", "origin-request");
        if let Some(origin) = origin {
            request = request.header(header::ORIGIN, origin);
        }
        let response = app
            .clone()
            .oneshot(request.body(Body::empty()).unwrap())
            .await
            .unwrap();
        if origin == Some("https://app.example.com") {
            assert_eq!(response.status(), StatusCode::NO_CONTENT);
        } else {
            assert_eq!(response.status(), StatusCode::FORBIDDEN);
            assert_eq!(
                response.headers()[header::CONTENT_TYPE],
                "application/problem+json"
            );
            let body = to_bytes(response.into_body(), 4096).await.unwrap();
            let problem: serde_json::Value = serde_json::from_slice(&body).unwrap();
            assert_eq!(problem["code"], "request_origin_rejected");
            assert_eq!(problem["request_id"], "origin-request");
            assert!(!String::from_utf8_lossy(&body).contains("evil.test"));
        }
    }
}