api / app /integrations /core_auth.py
juampisor's picture
SSO and auth fix
01e0bb5
Raw History Blame Contribute Delete
10.2 kB
"""
M10 Core — integración de autenticación real: canje de ticket SSO y cuenta
de servicio de M6.
La sesión de M6 es siempre un JWT HS256 propio (`app/dependencies.py`,
`create_access_token`/`decode_token`). El Core se toca en estos puntos:
(a) el canje del ticket SSO (`exchange_sso_ticket`, una vez por login),
(b) la cuenta de servicio para las llamadas salientes de M6 a M1/M2/M7, y
(c) el fallback de roles (`resolve_user_roles`, vía `GET /roles`) cuando el
canje no trae `user.roles[]` poblado — el Core desplegado no siempre lo
puebla, pese a que el schema lo permite. No hay verificación de JWT del Core
por-request: el rol se resuelve una sola vez, en el canje (ver
`app/routers/auth.py`).
"""
import logging
import time
import httpx
from jose import JWTError, jwt
from app.config import settings
logger = logging.getLogger(__name__)
# ─── Canje de ticket SSO ────────────────────────────────────────────────────
class SSOTicketInvalid(Exception):
"""Ticket ausente/inválido/ya usado/expirado (el Core respondió 400/401)."""
class SSOExchangeError(Exception):
"""Fallo al comunicarse con el Core (red, timeout, 5xx, etc.)."""
class CoreTokenInvalid(Exception):
"""El JWT del Core embebido en la sesión de M6 venció o el Core lo rechaza (401)."""
def exchange_sso_ticket(ticket: str) -> dict:
"""
Canjea un ticket SSO de un solo uso contra el Core por `{user, token}`
(`POST /auth/sso-exchange`, `models.AuthResponse`). `user.roles[]` trae
el/los rol(es) del usuario en el Core — de ahí sale la autorización de
M6, sin necesidad de un lookup aparte.
"""
url = f"{settings.m10_core_url}/auth/sso-exchange"
logger.info("Enviando canje SSO al Core — url=%s", url)
try:
r = httpx.post(url, json={"ticket": ticket}, timeout=settings.http_timeout_seconds)
except httpx.HTTPError as e:
logger.error("Error de red al contactar Core para canje SSO: %s", e)
raise SSOExchangeError("No se pudo contactar al Core para el canje SSO") from e
logger.info("Core respondió al canje SSO — status=%d", r.status_code)
if r.status_code == 401:
logger.warning("Core rechazó el ticket SSO (401) — body: %s", r.text[:500])
raise SSOTicketInvalid("Ticket inválido, ya usado o expirado")
if r.status_code == 400:
logger.warning("Core rechazó el request SSO (400) — body: %s", r.text[:500])
raise SSOTicketInvalid("Falta el ticket en el request")
if r.status_code >= 400:
logger.error("Core respondió error %d al canjear ticket SSO — body: %s", r.status_code, r.text[:500])
raise SSOExchangeError(f"El Core respondió {r.status_code} al canjear el ticket SSO")
data = r.json()
core_user = data.get("user") or {}
role_names = [role.get("name") for role in (core_user.get("roles") or []) if role.get("name")]
logger.debug("Respuesta Core SSO — user_id=%s roles=%s", core_user.get("id"), role_names)
return data
def request_sso_ticket(core_token: str) -> dict:
"""
Pide al Core un ticket SSO saliente en nombre del usuario (`POST /auth/sso-ticket`,
`models.SSOTicketResponse` — `{ticket, expires_in}`), usando el JWT del Core que
quedó embebido en la sesión de M6 al canjear (`app/routers/auth.py::sso_exchange`).
Es el lado inverso de `exchange_sso_ticket`: ahí M6 es el módulo destino y recibe un
ticket; acá M6 es el origen y pide uno para que el usuario navegue hacia otro módulo.
"""
url = f"{settings.m10_core_url}/auth/sso-ticket"
headers = {"Authorization": f"Bearer {core_token}"}
try:
r = httpx.post(url, headers=headers, timeout=settings.http_timeout_seconds)
except httpx.HTTPError as e:
raise SSOExchangeError("No se pudo contactar al Core para pedir el ticket SSO") from e
if r.status_code == 401:
raise CoreTokenInvalid("El Core rechazó el core_token embebido en la sesión")
if r.status_code >= 400:
raise SSOExchangeError(f"El Core respondió {r.status_code} al pedir el ticket SSO")
return r.json()
# ─── Cuenta de servicio de M6 ───────────────────────────────────────────────
# Token de la cuenta de servicio de M6 en el Core. Se usa para firmar las
# llamadas salientes a M1/M2/M7/M10 (adjuntado automáticamente por
# `app/integrations/_base.py`), incluidas las disparadas por webhooks
# entrantes donde no hay un usuario humano autenticado.
_service_token_cache: dict = {"token": None, "expires_at": 0.0}
# Margen de expiración: se renueva el token antes de que venza de verdad,
# para no arriesgar un 401 a mitad de una llamada saliente.
_SERVICE_TOKEN_EXPIRY_MARGIN_SECONDS = 30
def get_service_token() -> str | None:
"""
Devuelve un token válido de la cuenta de servicio de M6, refrescándolo si
expiró o no se pidió todavía. `None` si faltan las credenciales de
servicio (`CORE_SERVICE_EMAIL`/`_PASSWORD`) — el llamador debe seguir sin
el header `Authorization` en ese caso.
"""
if not settings.core_service_email or not settings.core_service_password:
logger.warning(
"CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD no están configurados"
)
return None
cached = _service_token_cache["token"]
if cached and time.time() < _service_token_cache["expires_at"]:
return cached
return _login_service_account()
def _login_service_account() -> str | None:
url = f"{settings.m10_core_url}/auth/login"
payload = {"email": settings.core_service_email, "password": settings.core_service_password}
try:
r = httpx.post(url, json=payload, timeout=settings.http_timeout_seconds)
r.raise_for_status()
token = r.json().get("token")
except Exception as e:
logger.warning("No se pudo autenticar la cuenta de servicio de M6 en el Core: %s", e)
return None
if not token:
return None
try:
exp = jwt.get_unverified_claims(token).get("exp")
except JWTError:
exp = None
_service_token_cache["token"] = token
_service_token_cache["expires_at"] = (
exp - _SERVICE_TOKEN_EXPIRY_MARGIN_SECONDS if exp else time.time() + 60
)
return token
# ─── Resolución de rol (fallback: lookup de GET /roles) ────────────────────
# El rol del usuario se intenta primero desde `user.roles[].name` de la
# respuesta de `/auth/sso-exchange` (`models.AuthResponse` → `models.User` →
# `models.Role`, ver `documentation/M10_openapi.yaml`). En la práctica el Core
# desplegado no puebla ese campo en el canje SSO, así que `app/routers/auth.py`
# cae a `resolve_user_roles` cuando viene vacío. Reintroducido — existió antes
# y se había retirado asumiendo (incorrectamente, contra el Core real) que
# `roles[]` siempre venía en el canje.
#
# `GET /users/{id}` sería lo obvio para resolver roles por id de usuario, pero
# exige permiso `users:read` que la cuenta de servicio de M6 no tiene. Tampoco
# hay un endpoint user-id→roles (`/roles/{id}` toma un **role** id;
# `/users/{id}/roles` sólo expone POST/DELETE). Lo único legible por la cuenta
# de servicio es `GET /roles` (permiso `roles:read`), que devuelve cada rol
# con su `users[]` embebido — de ahí se arma un índice `user_id → [roles]`.
_roles_index_cache: dict = {"user_id_to_roles": {}, "fetched_at": 0.0}
def _fetch_roles_index() -> dict[int, list[str]]:
"""Índice `user_id -> [nombres de rol]` armado desde `GET /roles` (paginado
en una sola página grande), autenticado con la cuenta de servicio de M6."""
token = get_service_token()
headers = {"Authorization": f"Bearer {token}"} if token else {}
url = f"{settings.m10_core_url}/roles"
r = httpx.get(
url, headers=headers, params={"pageSize": 200}, timeout=settings.http_timeout_seconds
)
r.raise_for_status()
data = r.json()
index: dict[int, list[str]] = {}
for role in data.get("data", []):
name = role.get("name")
for user in role.get("users") or []:
uid = user.get("id")
if uid is None or name is None:
continue
index.setdefault(uid, []).append(name)
return index
def resolve_user_roles(user_id: int) -> list[str]:
"""
Nombres de rol de Core asignados a `user_id`, vía `GET /roles` (fallback
cuando el canje SSO no trae `user.roles[]`). Sin cache: se llama sólo
cuando falta el dato en el canje, que ya de por sí ocurre una vez por
login — no vale la pena la complejidad de un TTL para esta frecuencia.
Propaga la excepción de red/HTTP al llamador (`app/routers/auth.py`),
que la traduce a `502`.
"""
return _fetch_roles_index().get(user_id, [])
# ─── Mapeo de rol de Core → rol interno de M6 ──────────────────────────────
# Este mapeo es la única fuente de la verdad de qué rol de Core habilita qué
# rol interno de M6; ajustar acá si cambian los nombres en el Core compartido.
CORE_ROLE_TO_INTERNAL: dict[str, str] = {
"admin_internacion": "ADMINISTRATIVO",
"admin": "ADMINISTRATIVO", # super-admin del Core — a confirmar con el equipo M10
"app": "ADMINISTRATIVO", # rol de la cuenta de servicio de M6 en el Core
"Medico": "MEDICO",
"limpieza": "LIMPIEZA",
}
# Si un usuario tiene varios roles mapeados, gana el de mayor alcance.
_ROLE_PRECEDENCE = ("ADMINISTRATIVO", "MEDICO", "LIMPIEZA")
def map_core_roles_to_internal(role_names: list[str]) -> str | None:
"""
Traduce roles de Core al rol interno de M6, con precedencia si el
usuario tiene más de uno mapeado. `None` si ninguno mapea (sin acceso).
"""
mapped = {CORE_ROLE_TO_INTERNAL[name] for name in role_names if name in CORE_ROLE_TO_INTERNAL}
for rol in _ROLE_PRECEDENCE:
if rol in mapped:
return rol
return None