use super::AuthState;
use super::authorize::client_ip;
use crate::caller::{Caller, STATIC_SUBJECT, Via};
use crate::credential::{self, Credential, CredentialCheck};
use crate::credential::{CheckRunner, Lead, Ticket};
use crate::guards::{Refusal, Reservation};
use crate::jwt::TokenKind;
use crate::pkce;
use axum::extract::{ConnectInfo, Request, State};
use axum::http::{HeaderValue, StatusCode, header};
use axum::middleware::Next;
use axum::response::{IntoResponse, Response};
use secrecy::ExposeSecret;
use std::net::SocketAddr;
use std::sync::Arc;
fn unauthorized(st: &AuthState, service: &str, token_present: bool) -> Response {
let mut value = format!(
"Bearer resource_metadata=\"{}\"",
st.resource_metadata_url(service)
);
if token_present {
value.push_str(", error=\"invalid_token\"");
}
let mut res = StatusCode::UNAUTHORIZED.into_response();
if let Ok(v) = HeaderValue::from_str(&value) {
res.headers_mut().insert(header::WWW_AUTHENTICATE, v);
}
res
}
fn unavailable(st: &AuthState, why: &str) -> Response {
let body = format!(
"Your {} could not be checked right now: {why}",
st.verifier.label()
);
let mut res = (StatusCode::SERVICE_UNAVAILABLE, body).into_response();
res.headers_mut()
.insert(header::RETRY_AFTER, HeaderValue::from_static("30"));
res
}
pub(crate) const RETRY_AFTER_SECS: &str = "30";
fn too_many_attempts() -> Response {
let mut res = (
StatusCode::TOO_MANY_REQUESTS,
"Too many attempts from this address: credentials or tokens were rejected, or several \
are being checked at once. Try again shortly.",
)
.into_response();
res.headers_mut().insert(
header::RETRY_AFTER,
HeaderValue::from_static(RETRY_AFTER_SECS),
);
res
}
pub(crate) const BUSY: &str =
"the server is refusing new addresses while it is under heavy load; try again shortly";
fn refusal_response(st: &AuthState, refusal: Refusal) -> Response {
match refusal {
Refusal::Busy => unavailable(st, BUSY),
_ => too_many_attempts(),
}
}
pub(crate) fn refused() -> CredentialCheck {
CredentialCheck::Unavailable("too many attempts from this address; try again shortly".into())
}
pub(crate) async fn settled_check(
st: &Arc<AuthState>,
credential: &str,
lead: Lead,
reservation: Reservation,
cache: Option<[u8; 32]>,
) -> CredentialCheck {
let task = {
let st = st.clone();
let credential = credential.to_owned();
tokio::spawn(async move {
let verdict = st
.checks
.lead(lead, st.verifier.as_ref(), &credential)
.await;
let rejected = matches!(verdict, CredentialCheck::Invalid(_));
if rejected {
st.limiter.fail(reservation);
} else {
st.limiter.refund(reservation);
}
if let Some(fp) = cache
&& !matches!(verdict, CredentialCheck::Unavailable(_))
{
st.bearer_checks.put(fp, !rejected);
}
verdict
})
};
task.await
.unwrap_or_else(|_| CredentialCheck::Unavailable("the check stopped unexpectedly".into()))
}
fn bearer_token(value: &str) -> Option<&str> {
let (scheme, rest) = value.trim().split_once(|c: char| c.is_ascii_whitespace())?;
scheme
.eq_ignore_ascii_case("bearer")
.then(|| rest.trim())
.filter(|t| !t.is_empty())
}
fn looks_like_jwt(token: &str) -> bool {
token.split('.').count() == 3
}
pub async fn require_bearer(
State((st, service)): State<(Arc<AuthState>, String)>,
mut req: Request,
next: Next,
) -> Response {
let token = req
.headers()
.get(header::AUTHORIZATION)
.and_then(|v| v.to_str().ok())
.and_then(bearer_token)
.map(str::to_owned);
let Some(token) = token.filter(|t| !t.is_empty()) else {
return unauthorized(&st, &service, false);
};
if looks_like_jwt(&token) {
if let Ok(claims) = st
.jwt
.verify_for(&token, TokenKind::Access, &st.resource(&service))
{
if !st.grant_is_current(&claims) {
return unauthorized(&st, &service, true);
}
if st.verifier.carried() {
let Some(credential) = claims
.payload
.credential
.as_deref()
.and_then(|sealed| st.sealer.open(sealed).ok())
else {
return unauthorized(&st, &service, true);
};
req.extensions_mut().insert(credential);
}
let caller = Caller::new(
claims.sub.clone(),
Via::OAuth {
client_id: claims.payload.client_id.clone(),
},
);
req.extensions_mut().insert(caller);
req.extensions_mut().insert(claims);
return next.run(req).await;
}
if st.jwt.claims_issuer_here(&token) || !st.verifier.accepts_bearer() {
return unauthorized(&st, &service, true);
}
}
let peer = req
.extensions()
.get::<ConnectInfo<SocketAddr>>()
.map(|c| c.0.ip());
let ip = client_ip(peer, req.headers(), &st.settings.trusted_proxies);
if let Some(expected) = &st.settings.static_token {
let reservation = match st.limiter.try_reserve(ip) {
Ok(r) => r,
Err(refusal) => {
metrics::counter!("bearer_credential_checks_total", "outcome" => "rate_limited")
.increment(1);
return refusal_response(&st, refusal);
}
};
if pkce::ct_eq(&token, expected.expose_secret()) {
st.limiter.refund(reservation);
req.extensions_mut()
.insert(Caller::new(STATIC_SUBJECT, Via::StaticToken));
return next.run(req).await;
}
st.limiter.fail(reservation);
tracing::warn!(%ip, "wrong static token rejected");
return unauthorized(&st, &service, true);
}
if !st.verifier.accepts_bearer() {
return unauthorized(&st, &service, true);
}
let token = st.verifier.prepare(&token).to_owned();
if !st.verifier.plausible(&token) {
return unauthorized(&st, &service, true);
}
let fingerprint = credential::fingerprint(&token);
match st.bearer_checks.get(&fingerprint) {
Some(true) => {}
Some(false) => return unauthorized(&st, &service, true),
None => {
let verdict = match st.checks.join(fingerprint) {
Ticket::Follow(rx) => CheckRunner::follow(rx).await,
Ticket::Lead(lead) => match st.limiter.try_reserve(ip) {
Ok(reservation) => {
settled_check(&st, &token, lead, reservation, Some(fingerprint)).await
}
Err(refusal) => {
st.checks.finish(lead, refused());
metrics::counter!("bearer_credential_checks_total", "outcome" => "rate_limited")
.increment(1);
return refusal_response(&st, refusal);
}
},
};
match verdict {
CredentialCheck::Valid => {
metrics::counter!("bearer_credential_checks_total", "outcome" => "valid")
.increment(1);
}
CredentialCheck::Invalid(_) => {
metrics::counter!("bearer_credential_checks_total", "outcome" => "invalid")
.increment(1);
tracing::warn!(%ip, "bearer credential rejected");
return unauthorized(&st, &service, true);
}
CredentialCheck::Unavailable(why) => {
metrics::counter!("bearer_credential_checks_total", "outcome" => "unavailable")
.increment(1);
tracing::warn!(reason = %why, "bearer credential could not be checked");
return unavailable(&st, &why);
}
}
}
}
let subject = st.subject_of(&token);
req.extensions_mut()
.insert(Caller::new(subject, Via::Credential));
if st.verifier.carried() {
req.extensions_mut().insert(Credential::new(token));
}
next.run(req).await
}
#[cfg(test)]
mod tests {
use super::bearer_token;
#[test]
fn the_bearer_scheme_is_case_insensitive() {
for v in ["Bearer abc", "bearer abc", "BEARER abc ", "Bearer\tabc"] {
assert_eq!(bearer_token(v), Some("abc"), "{v:?}");
}
for v in ["Basic abc", "Bearer", "Bearer ", "Bearerabc", ""] {
assert_eq!(bearer_token(v), None, "{v:?}");
}
}
}