use std::time::Duration;
use axum::body::Body;
use axum::error_handling::HandleErrorLayer;
use axum::extract::State;
use axum::http::{header, Request, StatusCode};
use axum::middleware::Next;
use axum::response::{IntoResponse, Response};
use axum::{BoxError, Json, Router};
use tower::ServiceBuilder;
#[derive(Debug, Clone)]
pub struct BearerAuthState {
pub token: String,
}
pub async fn bearer_auth(
State(state): State<BearerAuthState>,
req: Request<Body>,
next: Next,
) -> Response {
let path = req.uri().path();
if path == "/health" || path == "/metrics" {
return next.run(req).await;
}
let header_value = req
.headers()
.get(header::AUTHORIZATION)
.and_then(|v| v.to_str().ok());
let presented = match header_value.and_then(|h| h.strip_prefix("Bearer ")) {
Some(tok) => tok.trim(),
None => {
return unauthorized("missing or malformed Authorization header").into_response();
}
};
if !constant_time_eq(presented.as_bytes(), state.token.as_bytes()) {
return unauthorized("invalid bearer token").into_response();
}
next.run(req).await
}
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
let mut diff: u8 = 0;
for (x, y) in a.iter().zip(b.iter()) {
diff |= x ^ y;
}
diff == 0
}
fn unauthorized(msg: &str) -> (StatusCode, Json<serde_json::Value>) {
(
StatusCode::UNAUTHORIZED,
Json(serde_json::json!({
"error": {
"message": msg,
"type": "auth_error",
"param": null,
"code": null,
}
})),
)
}
pub fn apply_admission(router: Router, max_concurrent_requests: usize, timeout_ms: u64) -> Router {
let concurrency_semaphore =
tower::limit::GlobalConcurrencyLimitLayer::new(max_concurrent_requests);
let admission = ServiceBuilder::new()
.layer(HandleErrorLayer::new(handle_admission_error))
.load_shed()
.layer(concurrency_semaphore)
.timeout(Duration::from_millis(timeout_ms));
router.layer(admission)
}
async fn handle_admission_error(err: BoxError) -> (StatusCode, Json<serde_json::Value>) {
let (status, kind, message) = if err.is::<tower::load_shed::error::Overloaded>() {
(
StatusCode::SERVICE_UNAVAILABLE,
"overloaded_error",
"server is at its configured --max-concurrent-requests capacity; retry after a \
short backoff"
.to_string(),
)
} else if err.is::<tower::timeout::error::Elapsed>() {
(
StatusCode::REQUEST_TIMEOUT,
"timeout_error",
"request exceeded the configured --request-timeout-ms budget".to_string(),
)
} else {
(
StatusCode::INTERNAL_SERVER_ERROR,
"internal_error",
format!("unhandled admission-layer error: {err}"),
)
};
(
status,
Json(serde_json::json!({
"error": {
"message": message,
"type": kind,
"param": null,
"code": null,
}
})),
)
}
#[cfg(test)]
mod tests {
use super::*;
use axum::http::Method;
use axum::routing::get;
use tower::ServiceExt;
fn protected_router() -> Router {
Router::new().route("/protected", get(|| async { "ok" }))
}
fn auth_router(token: &str) -> Router {
let state = BearerAuthState {
token: token.to_string(),
};
protected_router().layer(axum::middleware::from_fn_with_state(state, bearer_auth))
}
#[test]
fn equal_bytes_are_equal() {
assert!(constant_time_eq(b"my-secret-token", b"my-secret-token"));
}
#[test]
fn different_bytes_are_unequal() {
assert!(!constant_time_eq(b"my-secret-token", b"not-the-token!!"));
}
#[test]
fn different_lengths_are_unequal() {
assert!(!constant_time_eq(b"short", b"a-much-longer-token"));
}
#[tokio::test]
async fn bearer_auth_rejects_missing_header() {
let app = auth_router("secret-abc");
let req = Request::builder()
.method(Method::GET)
.uri("/protected")
.body(Body::empty())
.expect("request builds");
let resp = app.oneshot(req).await.expect("oneshot succeeds");
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
}
#[tokio::test]
async fn bearer_auth_rejects_wrong_token() {
let app = auth_router("secret-abc");
let req = Request::builder()
.method(Method::GET)
.uri("/protected")
.header(header::AUTHORIZATION, "Bearer wrong-token")
.body(Body::empty())
.expect("request builds");
let resp = app.oneshot(req).await.expect("oneshot succeeds");
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
}
#[tokio::test]
async fn bearer_auth_accepts_correct_token() {
let app = auth_router("secret-abc");
let req = Request::builder()
.method(Method::GET)
.uri("/protected")
.header(header::AUTHORIZATION, "Bearer secret-abc")
.body(Body::empty())
.expect("request builds");
let resp = app.oneshot(req).await.expect("oneshot succeeds");
assert_eq!(resp.status(), StatusCode::OK);
}
#[tokio::test]
async fn bearer_auth_exempts_health_and_metrics() {
for path in ["/health", "/metrics"] {
let app = Router::new().route(path, get(|| async { "ok" })).layer(
axum::middleware::from_fn_with_state(
BearerAuthState {
token: "secret-abc".to_string(),
},
bearer_auth,
),
);
let req = Request::builder()
.method(Method::GET)
.uri(path)
.body(Body::empty())
.expect("request builds");
let resp = app.oneshot(req).await.expect("oneshot succeeds");
assert_eq!(resp.status(), StatusCode::OK, "{path} must bypass auth");
}
}
#[tokio::test]
async fn apply_admission_lets_ordinary_requests_through() {
let app = apply_admission(protected_router(), 8, 60_000);
let req = Request::builder()
.method(Method::GET)
.uri("/protected")
.body(Body::empty())
.expect("request builds");
let resp = app.oneshot(req).await.expect("oneshot succeeds");
assert_eq!(resp.status(), StatusCode::OK);
}
#[tokio::test]
async fn apply_admission_times_out_slow_handlers() {
let slow = Router::new().route(
"/slow",
get(|| async {
tokio::time::sleep(Duration::from_millis(50)).await;
"too slow"
}),
);
let app = apply_admission(slow, 8, 5);
let req = Request::builder()
.method(Method::GET)
.uri("/slow")
.body(Body::empty())
.expect("request builds");
let resp = app.oneshot(req).await.expect("oneshot succeeds");
assert_eq!(resp.status(), StatusCode::REQUEST_TIMEOUT);
}
}