use axum::extract::{Extension, Form, Request, State};
use axum::http::{HeaderValue, StatusCode, header};
use axum::middleware::Next;
use axum::response::{IntoResponse, Response};
use axum::routing::post;
use axum::{Json, Router};
use crate::error::Error;
use crate::jwt::AccessTokenClaims;
use crate::server::{AuthorizeRequest, DeviceAuthorizationRequest, PassportServer, TokenRequest};
use crate::store::Stores;
#[derive(Debug, Clone)]
pub struct AuthContext {
pub claims: AccessTokenClaims,
pub user_id: Option<String>,
pub client_id: String,
pub scopes: Vec<String>,
}
impl AuthContext {
pub fn has_scope(&self, scope: &str) -> bool {
self.scopes.iter().any(|s| s == scope)
}
pub fn has_all_scopes(&self, scopes: &[&str]) -> bool {
scopes.iter().all(|s| self.has_scope(s))
}
pub fn has_any_scope(&self, scopes: &[&str]) -> bool {
scopes.iter().any(|s| self.has_scope(s))
}
}
#[derive(Debug, Clone, Default)]
pub struct ScopePolicy {
pub any_of: Option<Vec<String>>,
pub all_of: Option<Vec<String>>,
}
impl ScopePolicy {
pub fn any(scopes: impl IntoIterator<Item = impl Into<String>>) -> Self {
Self {
any_of: Some(scopes.into_iter().map(Into::into).collect()),
all_of: None,
}
}
pub fn all(scopes: impl IntoIterator<Item = impl Into<String>>) -> Self {
Self {
any_of: None,
all_of: Some(scopes.into_iter().map(Into::into).collect()),
}
}
}
pub fn router<S: Stores>() -> Router<()> {
Router::new()
.route("/oauth/token", post(token_handler::<S>))
.route("/oauth/authorize", post(authorize_handler::<S>))
.route("/oauth/revoke", post(revoke_handler::<S>))
.route("/oauth/device", post(device_authorization_handler::<S>))
.route("/oauth/device/verify", post(device_approve_handler::<S>))
}
pub async fn token_handler<S: Stores>(
Extension(server): Extension<PassportServer<S>>,
Form(form): Form<TokenRequest>,
) -> Response {
match server.issue_token(&form).await {
Ok(response) => (StatusCode::OK, Json(response)).into_response(),
Err(err) => oauth_error_response(&err),
}
}
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct RevokeRequest {
pub token: String,
}
pub async fn revoke_handler<S: Stores>(
Extension(server): Extension<PassportServer<S>>,
Form(form): Form<RevokeRequest>,
) -> Response {
match server.revoke_token(&form.token).await {
Ok(()) => StatusCode::NO_CONTENT.into_response(),
Err(err) => oauth_error_response(&err),
}
}
pub async fn authorize_handler<S: Stores>(
Extension(server): Extension<PassportServer<S>>,
Form(form): Form<AuthorizeRequest>,
) -> Response {
let Some(user_id) = form.user_id.clone() else {
return oauth_error_response(&Error::InvalidRequest("user_id is required".into()));
};
match server.authorize(user_id, &form).await {
Ok(decision) => {
let mut uri = format!("{}?code={}", decision.redirect_uri, decision.code);
if let Some(state) = decision.state {
uri.push_str(&format!("&state={}", state));
}
(StatusCode::FOUND, [(header::LOCATION, uri)]).into_response()
}
Err(err) => oauth_error_response(&err),
}
}
pub async fn device_authorization_handler<S: Stores>(
Extension(server): Extension<PassportServer<S>>,
Form(form): Form<DeviceAuthorizationRequest>,
) -> Response {
match server.issue_device_code(&form).await {
Ok(response) => (StatusCode::OK, Json(response)).into_response(),
Err(err) => oauth_error_response(&err),
}
}
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct DeviceApproveRequest {
pub user_code: String,
pub user_id: String,
pub approve: Option<bool>,
pub deny: Option<bool>,
}
pub async fn device_approve_handler<S: Stores>(
Extension(server): Extension<PassportServer<S>>,
Form(form): Form<DeviceApproveRequest>,
) -> Response {
if form.deny.unwrap_or(false) {
return (
StatusCode::BAD_REQUEST,
Json(serde_json::json!({
"error": "access_denied",
"error_description": "The user denied the authorization request",
})),
)
.into_response();
}
if form.user_code.is_empty() || form.user_id.is_empty() {
return oauth_error_response(&Error::InvalidRequest(
"user_code and user_id are required".into(),
));
}
match server
.approve_device_code(&form.user_id, &form.user_code)
.await
{
Ok(_) => StatusCode::OK.into_response(),
Err(err) => oauth_error_response(&err),
}
}
pub async fn require_auth<S: Stores>(
State(server): State<PassportServer<S>>,
mut req: Request,
next: Next,
) -> Response {
let token = req
.headers()
.get(header::AUTHORIZATION)
.and_then(|value| value.to_str().ok())
.and_then(|value| {
value
.strip_prefix("Bearer ")
.or_else(|| value.strip_prefix("bearer "))
});
let Some(token) = token else {
return unauthorized_response();
};
match server.validate_access_token(token).await {
Ok(validated) => {
let claims = validated.claims;
let user_id = (claims.sub != claims.client_id).then(|| claims.sub.clone());
req.extensions_mut().insert(AuthContext {
user_id,
client_id: claims.client_id.clone(),
scopes: claims.scopes.clone(),
claims,
});
next.run(req).await
}
Err(_) => unauthorized_response(),
}
}
pub async fn check_scopes(State(policy): State<ScopePolicy>, req: Request, next: Next) -> Response {
let Some(ctx) = req.extensions().get::<AuthContext>() else {
return unauthorized_response();
};
let allowed = match (&policy.all_of, &policy.any_of) {
(Some(all), _) => all.iter().all(|scope| ctx.has_scope(scope)),
(None, Some(any)) => any.iter().any(|scope| ctx.has_scope(scope)),
(None, None) => true,
};
if allowed {
next.run(req).await
} else {
(
StatusCode::FORBIDDEN,
Json(serde_json::json!({
"error": "insufficient_scope",
"error_description": "The request requires higher privileges than provided by the access token",
})),
)
.into_response()
}
}
fn unauthorized_response() -> Response {
let mut response = (
StatusCode::UNAUTHORIZED,
Json(serde_json::json!({
"error": "invalid_token",
"error_description": "The access token is invalid or has expired",
})),
)
.into_response();
response
.headers_mut()
.insert(header::WWW_AUTHENTICATE, HeaderValue::from_static("Bearer"));
response
}
fn oauth_error_response(err: &Error) -> Response {
let oauth_error = err.to_oauth_error();
let status = StatusCode::from_u16(oauth_error.status()).unwrap_or(StatusCode::BAD_REQUEST);
(status, Json(oauth_error)).into_response()
}