Download app/routers/auth.py from Modulo-6/api: direct link, hf CLI and curl.
- Browser
- Download file 7.37 kB
-
https://huggingface.co/spaces/Modulo-6/api/resolve/main/app/routers/auth.py
- Command line
-
hf download hf://spaces/Modulo-6/api/app/routers/auth.py
-
curl -L -o auth.py https://huggingface.co/spaces/Modulo-6/api/resolve/main/app/routers/auth.py
7.37 kB
| """ | |
| SSO del Core (M10): canje de ticket por una sesión propia de M6, en ambos sentidos. | |
| - **Entrante** (`POST /sso-exchange`): M6 no maneja el callback del browser | |
| (`/auth/sso?ticket=…`, responsabilidad del frontend) — este router expone solo el | |
| canje server-to-server: recibe el ticket, lo intercambia contra el Core por | |
| `{user, token}` y emite su propio JWT HS256 con el rol ya resuelto a partir de | |
| `user.roles[]` — o, si el Core no lo pobló en la respuesta del canje (pasa en la | |
| práctica), vía `core_auth.resolve_user_roles` (fallback, `GET /roles` con la cuenta | |
| de servicio). El JWT del Core (`token`) queda embebido como claim opaco | |
| (`core_token`) dentro del JWT de M6 — no se descarta del todo, se guarda solo para | |
| poder pedir tickets salientes más adelante (ver abajo). Un JWT es firmado, no | |
| cifrado: ese claim es legible por quien tenga el JWT de M6, incluido el frontend — | |
| ver `M6_AUTH_SSO.md` §1 y §9 para el detalle de este trade-off. | |
| - **Saliente** (`POST /sso-ticket`): para que un usuario ya logueado en M6 navegue a | |
| otro módulo sin loguearse de nuevo. Usa el `core_token` embebido en su propia sesión | |
| para pedirle un ticket al Core en su nombre — sesiones que no vinieron de un SSO real | |
| (p.ej. el endpoint de desarrollo `GET /auth/token`) no tienen ese claim y no pueden | |
| usar este endpoint. | |
| Ver `app/integrations/core_auth.py` y `documentation/M6_DISEÑO.md` §11. | |
| """ | |
| import logging | |
| from fastapi import APIRouter, Depends, HTTPException, status | |
| from app.config import settings | |
| from app.dependencies import create_access_token, get_current_user | |
| from app.integrations import core_auth | |
| from app.schemas.auth import ( | |
| SSOExchangeRequest, | |
| SSOExchangeResponse, | |
| SSOTicketResponse, | |
| SSOUser, | |
| ) | |
| logger = logging.getLogger(__name__) | |
| router = APIRouter(prefix="/auth", tags=["Auth"]) | |
| _ERROR_404 = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Not Found"} | |
| _ERROR_401_TICKET = {"codigo": "NO_AUTENTICADO", "mensaje": "Ticket inválido, ya usado o expirado"} | |
| _ERROR_403_ROL = {"codigo": "NO_AUTORIZADO", "mensaje": "El usuario no tiene un rol habilitado en M6"} | |
| _ERROR_502 = {"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo canjear el ticket contra el Core (M10)"} | |
| _ERROR_401_SIN_SESION_CORE = { | |
| "codigo": "SIN_SESION_CORE", | |
| "mensaje": "Esta sesión no se originó en un SSO real contra el Core — no se puede pedir un ticket saliente", | |
| } | |
| _ERROR_401_CORE_TOKEN = { | |
| "codigo": "NO_AUTENTICADO", | |
| "mensaje": "El token del Core asociado a esta sesión venció o fue rechazado — reiniciar el SSO", | |
| } | |
| def sso_exchange(data: SSOExchangeRequest): | |
| ticket_prefix = data.ticket[:8] + "…" if data.ticket else "(vacío)" | |
| logger.info("SSO exchange solicitado — ticket: %s", ticket_prefix) | |
| if not settings.sso_enabled: | |
| logger.warning("SSO exchange rechazado — SSO_ENABLED=false") | |
| raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=_ERROR_404) | |
| try: | |
| resp = core_auth.exchange_sso_ticket(data.ticket) | |
| except core_auth.SSOTicketInvalid: | |
| logger.warning("SSO exchange fallido — ticket inválido/expirado (ticket: %s)", ticket_prefix) | |
| raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_TICKET) | |
| except core_auth.SSOExchangeError as e: | |
| logger.warning("SSO exchange fallido — error de comunicación con Core: %s", e) | |
| raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502) | |
| core_user = resp.get("user") or {} | |
| user_id = core_user.get("id") | |
| user_email = core_user.get("email", "(sin email)") | |
| role_names = [r["name"] for r in (core_user.get("roles") or []) if r.get("name")] | |
| logger.info( | |
| "Core respondió OK — user_id=%s email=%s roles_core=%s", | |
| user_id, user_email, role_names, | |
| ) | |
| if not role_names and user_id is not None: | |
| # El canje SSO no trajo `user.roles[]` poblado (pasa con el Core real | |
| # pese a que el schema lo permite) — fallback: resolverlos vía | |
| # `GET /roles` con la cuenta de servicio (`core_auth.resolve_user_roles`). | |
| try: | |
| role_names = core_auth.resolve_user_roles(user_id) | |
| logger.info( | |
| "roles_core vacío en el canje — resuelto vía GET /roles — user_id=%s roles=%s", | |
| user_id, role_names, | |
| ) | |
| except Exception as e: | |
| logger.warning( | |
| "Fallback de roles (GET /roles) falló — user_id=%s error=%s", user_id, e, | |
| ) | |
| raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502) | |
| rol = core_auth.map_core_roles_to_internal(role_names) | |
| if rol is None: | |
| logger.warning( | |
| "SSO exchange denegado (403) — user_id=%s email=%s roles_core=%s " | |
| "no mapean a ningún rol de M6. Roles conocidos: %s", | |
| user_id, user_email, role_names, list(core_auth.CORE_ROLE_TO_INTERNAL.keys()), | |
| ) | |
| raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=_ERROR_403_ROL) | |
| core_token = resp.get("token") | |
| token = create_access_token( | |
| sub=str(core_user["id"]), rol=rol, extra={"core_token": core_token} if core_token else None, | |
| ) | |
| logger.info( | |
| "SSO exchange exitoso — user_id=%s email=%s rol_m6=%s core_token=%s", | |
| user_id, user_email, rol, "presente" if core_token else "ausente", | |
| ) | |
| return SSOExchangeResponse( | |
| token=token, | |
| user=SSOUser( | |
| id=core_user["id"], | |
| first_name=core_user.get("first_name", ""), | |
| last_name=core_user.get("last_name", ""), | |
| email=core_user.get("email", ""), | |
| ), | |
| rol=rol, | |
| ) | |
| def sso_ticket(user: dict = Depends(get_current_user)): | |
| if not settings.sso_enabled: | |
| raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=_ERROR_404) | |
| core_token = user.get("core_token") | |
| if not core_token: | |
| raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_SIN_SESION_CORE) | |
| try: | |
| resp = core_auth.request_sso_ticket(core_token) | |
| except core_auth.CoreTokenInvalid: | |
| raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_CORE_TOKEN) | |
| except core_auth.SSOExchangeError as e: | |
| logger.warning("Fallo al pedir ticket SSO saliente al Core: %s", e) | |
| raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502) | |
| return SSOTicketResponse(**resp) | |