use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};
use axum::extract::State;
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use axum::routing::post;
use axum::{Json, Router};
use serde::{Deserialize, Serialize};
use crate::auth::Authenticator;
use crate::error::RpError;
use crate::session::RpSession;
#[derive(Debug, Clone)]
pub struct MidRpConfig {
pub rp_origin: String,
pub max_iat_skew_secs: u64,
}
impl MidRpConfig {
pub fn new(rp_origin: impl Into<String>) -> Self {
Self {
rp_origin: rp_origin.into(),
max_iat_skew_secs: 120,
}
}
}
pub struct MidRp {
config: MidRpConfig,
auth: Authenticator,
}
impl MidRp {
pub fn new(config: MidRpConfig, auth: Authenticator) -> Self {
Self { config, auth }
}
pub fn issue_nonce(&self) -> Result<String, RpError> {
self.auth.issue_nonce(now_unix())
}
pub fn verify_jwt(&self, jwt: &str) -> Result<RpSession, RpError> {
self.auth.authenticate_with_embedded_nonce(
jwt,
&self.config.rp_origin,
now_unix(),
self.config.max_iat_skew_secs,
)
}
pub fn authenticator(&self) -> &Authenticator {
&self.auth
}
}
pub type OnVerified = Arc<dyn Fn(&RpSession) -> Option<Response> + Send + Sync>;
#[derive(Clone)]
struct RouterState {
rp: Arc<MidRp>,
on_verified: Option<OnVerified>,
}
pub fn router(rp: Arc<MidRp>) -> Router {
build_router(RouterState {
rp,
on_verified: None,
})
}
pub fn router_with(rp: Arc<MidRp>, on_verified: OnVerified) -> Router {
build_router(RouterState {
rp,
on_verified: Some(on_verified),
})
}
fn build_router(state: RouterState) -> Router {
Router::new()
.route("/auth/mid/nonce", post(issue_nonce_handler))
.route("/auth/mid/verify", post(verify_handler))
.with_state(state)
}
#[derive(Serialize)]
struct NonceResponse {
nonce: String,
}
#[derive(Deserialize)]
struct VerifyRequest {
jwt: String,
}
#[derive(Serialize)]
struct VerifiedResponse {
did: String,
roster_version: u64,
claims: std::collections::BTreeMap<String, mid_verify::ClaimValue>,
}
#[derive(Serialize)]
struct ErrorResponse {
error: &'static str,
}
async fn issue_nonce_handler(State(state): State<RouterState>) -> Response {
match state.rp.issue_nonce() {
Ok(nonce) => (StatusCode::OK, Json(NonceResponse { nonce })).into_response(),
Err(err) => error_response(&err),
}
}
async fn verify_handler(
State(state): State<RouterState>,
Json(body): Json<VerifyRequest>,
) -> Response {
match state.rp.verify_jwt(&body.jwt) {
Ok(session) => {
if let Some(hook) = &state.on_verified {
if let Some(response) = hook(&session) {
return response;
}
}
(
StatusCode::OK,
Json(VerifiedResponse {
did: session.did.clone(),
roster_version: session.current_version,
claims: session.claims,
}),
)
.into_response()
}
Err(err) => error_response(&err),
}
}
fn error_response(err: &RpError) -> Response {
let status = match err {
RpError::MalformedToken => StatusCode::BAD_REQUEST,
RpError::NonceCapacity { .. } => StatusCode::SERVICE_UNAVAILABLE,
RpError::Store(_) => StatusCode::INTERNAL_SERVER_ERROR,
_ => StatusCode::UNAUTHORIZED,
};
(status, Json(ErrorResponse { error: err.code() })).into_response()
}
fn now_unix() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("system clock before Unix epoch")
.as_secs()
}