#![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"));
}
}
}