use std::sync::Arc;
use poem::{IntoResponse, Request, RequestBody, http::StatusCode};
use poem_openapi::{
ApiExtractor, ApiExtractorType, ExtractParamOptions, SecurityScheme, auth::Bearer,
payload::Json, registry::Registry,
};
use puerto_nucleo::{Autenticador, ErrorAuth, Principal};
use crate::RespuestaError;
pub const NO_AUTENTICADO: &str = "auth.no_autenticado";
pub const PROHIBIDO: &str = "auth.prohibido";
pub const NO_DISPONIBLE: &str = "auth.no_disponible";
pub const NO_CONFIGURADO: &str = "auth.no_configurado";
pub struct BearerAuth(pub Principal);
#[derive(SecurityScheme)]
#[oai(rename = "BearerAuth", ty = "bearer", bearer_format = "opaque or JWT")]
struct BearerScheme(Bearer);
impl<'a> ApiExtractor<'a> for BearerAuth {
const TYPES: &'static [ApiExtractorType] = &[ApiExtractorType::SecurityScheme];
type ParamType = ();
type ParamRawType = ();
fn register(registry: &mut Registry) {
BearerScheme::register(registry);
}
fn security_schemes() -> Vec<&'static str> {
BearerScheme::security_schemes()
}
async fn from_request(
req: &'a Request,
body: &mut RequestBody,
param_opts: ExtractParamOptions<Self::ParamType>,
) -> poem::Result<Self> {
let token = BearerScheme::from_request(req, body, param_opts)
.await
.map_err(|_| {
error(
StatusCode::UNAUTHORIZED,
RespuestaError::from_codigo(NO_AUTENTICADO),
)
})?
.0
.token;
let Some(authenticator) = req.data::<Arc<dyn Autenticador>>() else {
tracing::error!("BearerAuth: no hay ningún Autenticador registrado en las rutas");
return Err(error(
StatusCode::INTERNAL_SERVER_ERROR,
RespuestaError {
codigo: NO_CONFIGURADO.into(),
mensaje:
"no hay ningún Autenticador registrado en las rutas: bootstrap.rs tiene \
que añadir `.data(autenticador)` con un `Arc<dyn Autenticador>`"
.into(),
},
));
};
authenticator
.autenticar(&token)
.await
.map(Self)
.map_err(|err| {
let (status, body) = rechazo(err);
error(status, body.0)
})
}
}
pub fn rechazo(err: ErrorAuth) -> (StatusCode, Json<RespuestaError>) {
match err {
ErrorAuth::NoDisponible => {
tracing::warn!(error = %err, "BearerAuth: no se pudo comprobar el token");
(
StatusCode::SERVICE_UNAVAILABLE,
Json(RespuestaError::from_codigo(NO_DISPONIBLE)),
)
}
_ => (
StatusCode::UNAUTHORIZED,
Json(RespuestaError::from_codigo(NO_AUTENTICADO)),
),
}
}
pub fn prohibido() -> (StatusCode, Json<RespuestaError>) {
(
StatusCode::FORBIDDEN,
Json(RespuestaError::from_codigo(PROHIBIDO)),
)
}
pub fn bearer_token(req: &poem::Request) -> Option<&str> {
let (scheme, token) = req.header("Authorization")?.split_once(' ')?;
let token = token.trim();
(scheme.eq_ignore_ascii_case("bearer") && !token.is_empty()).then_some(token)
}
fn error(status: StatusCode, body: RespuestaError) -> poem::Error {
let mut response = Json(body).into_response();
response.set_status(status);
poem::Error::from_response(response)
}
#[cfg(test)]
mod tests {
use super::*;
fn request(authorization: Option<&str>) -> poem::Request {
let builder = poem::Request::builder();
match authorization {
Some(valor) => builder.header("Authorization", valor).finish(),
None => builder.finish(),
}
}
#[test]
fn should_read_the_bearer_token_whatever_the_scheme_case() {
assert_eq!(bearer_token(&request(Some("Bearer abc"))), Some("abc"));
assert_eq!(bearer_token(&request(Some("bearer abc "))), Some("abc"));
}
#[test]
fn should_read_no_token_when_there_is_no_bearer_one() {
assert_eq!(bearer_token(&request(None)), None);
assert_eq!(bearer_token(&request(Some("Basic abc"))), None);
assert_eq!(bearer_token(&request(Some("Bearer "))), None);
assert_eq!(bearer_token(&request(Some("Bearer"))), None);
}
#[test]
fn should_answer_401_unauthenticated_when_the_token_is_invalid() {
let (status, body) = rechazo(ErrorAuth::Invalido);
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body.0.codigo, "auth.no_autenticado");
}
#[test]
fn should_answer_401_unauthenticated_when_the_token_expired() {
let (status, body) = rechazo(ErrorAuth::Expirado);
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body.0.codigo, "auth.no_autenticado");
}
#[test]
fn should_answer_503_unavailable_when_the_token_cannot_be_checked() {
let (status, body) = rechazo(ErrorAuth::NoDisponible);
assert_eq!(status, StatusCode::SERVICE_UNAVAILABLE);
assert_eq!(body.0.codigo, "auth.no_disponible");
}
#[test]
fn should_answer_403_forbidden_when_a_role_is_missing() {
let (status, body) = prohibido();
assert_eq!(status, StatusCode::FORBIDDEN);
assert_eq!(body.0.codigo, "auth.prohibido");
assert_eq!(body.0.mensaje, "auth.prohibido");
}
}