""" 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", } @router.post( "/sso-exchange", response_model=SSOExchangeResponse, summary="Canjear un ticket SSO del Core por una sesión de M6", responses={ 401: {"description": "Ticket inválido, ya usado o expirado"}, 403: {"description": "El usuario no tiene un rol habilitado en M6"}, 404: {"description": "SSO no habilitado"}, 502: {"description": "El Core no respondió al canje"}, }, ) 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, ) @router.post( "/sso-ticket", response_model=SSOTicketResponse, summary="Pedir un ticket SSO del Core para navegar hacia otro módulo", responses={ 401: {"description": "Sesión sin core_token, o el Core rechazó el core_token"}, 404: {"description": "SSO no habilitado"}, 502: {"description": "El Core no respondió al pedido de ticket"}, }, ) 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)