File size: 7,373 Bytes
624c7c9 15c2525 624c7c9 15c2525 01e0bb5 15c2525 624c7c9 15c2525 624c7c9 15c2525 624c7c9 15c2525 624c7c9 15c2525 624c7c9 58e4c2a 624c7c9 58e4c2a 624c7c9 58e4c2a 624c7c9 58e4c2a 624c7c9 58e4c2a 624c7c9 58e4c2a 01e0bb5 624c7c9 58e4c2a 624c7c9 15c2525 58e4c2a 624c7c9 15c2525 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | """
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)
|