jpsoron commited on
Commit
9e1a428
·
unverified ·
2 Parent(s): 3f8464629c7ae3

Merge pull request #6 from MateFerreyra/jps/integracion-M10

Browse files
.claude/.DS_Store DELETED
Binary file (6.15 kB)
 
.claude/settings.local.json DELETED
@@ -1,29 +0,0 @@
1
- {
2
- "permissions": {
3
- "allow": [
4
- "Bash(Get-ChildItem -Recurse \"C:\\\\Users\\\\mateo\\\\OneDrive\\\\Documentos\\\\modulo6\" -Name)",
5
- "Bash(Get-ChildItem -Path \"c:\\\\Users\\\\mateo\\\\OneDrive\\\\Documentos\\\\Modulo-6-backend\" -Force)",
6
- "Bash(Select-Object Name, Mode)",
7
- "Bash(python -m py_compile app/schemas/enums.py app/schemas/cama.py app/crud/solicitud.py app/services/cama_service.py app/services/solicitud_service.py app/integrations/hce.py app/routers/webhooks.py app/main.py)",
8
- "Bash(python3 -m py_compile app/schemas/enums.py app/schemas/cama.py app/crud/solicitud.py app/services/cama_service.py app/services/solicitud_service.py app/integrations/hce.py app/routers/webhooks.py app/main.py)",
9
- "Bash(git fetch *)",
10
- "Bash(git stash *)",
11
- "Bash(git pull *)",
12
- "Bash(python3 -m py_compile app/main.py app/crud/solicitud.py app/integrations/hce.py app/routers/webhooks.py app/schemas/cama.py app/schemas/enums.py app/services/cama_service.py app/services/solicitud_service.py)",
13
- "Bash(docker exec *)",
14
- "Bash(docker run *)",
15
- "Bash(xargs cat)",
16
- "Bash(python3 *)",
17
- "Bash(pip3 list *)",
18
- "Bash(/tmp/m6venv/bin/pip install *)",
19
- "Bash(pip3 install *)",
20
- "Bash(curl -s -m 20 -o /dev/null -w \"%{http_code}\\\\n\" https://modulo-6-api.hf.space/health)",
21
- "Bash(curl -s -m 20 \"https://modulo-6-api.hf.space/api/v1/auth/token?usuario=ADMINISTRATIVO&password=x\" -w \"\\\\nHTTP %{http_code}\\\\n\")",
22
- "Bash(grep -iE '\\\\.\\(sql|md\\)$|schema|migration|seed')",
23
- "Bash(python *)",
24
- "Bash(pytest /mnt/mac/Projects/Modulo-6-backend/tests/test_quirofanos.py -v)",
25
- "Read(//usr/local/bin/**)",
26
- "Bash(find / -name \"pytest\" -type f)"
27
- ]
28
- }
29
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
.env.example CHANGED
@@ -9,21 +9,18 @@ JWT_SECRET=CAMBIAR_POR_SECRET_ALEATORIO_DE_64_CARACTERES
9
  JWT_ALGORITHM=HS256
10
  JWT_EXPIRE_MINUTES=60
11
 
12
- # ─── Auth: mock local vs. Core (M10) real ──────────────────────────────────
13
- # "mock": JWT propios (comportamiento actual, requiere JWT_SECRET arriba).
14
- # "core": JWT emitidos por M10, verificados vía JWKS (requiere M10_CORE_URL
15
- # y la cuenta de servicio de abajo).
16
- AUTH_MODE=mock
17
-
18
- # Cuenta de servicio de M6 en el Core (solo si AUTH_MODE=core). Se usa para
19
- # el lookup de roles (GET /roles) y para autenticar las llamadas salientes.
 
20
  CORE_SERVICE_EMAIL=
21
  CORE_SERVICE_PASSWORD=
22
 
23
- # TTL de los caches de integración con Core (segundos)
24
- JWKS_CACHE_TTL_SECONDS=300
25
- CORE_ROLES_CACHE_TTL_SECONDS=300
26
-
27
  # ─── Entorno ───────────────────────────────────────────────────────────────
28
  # Valores válidos: development | staging | production
29
  # En 'production', el endpoint /auth/token queda deshabilitado
 
9
  JWT_ALGORITHM=HS256
10
  JWT_EXPIRE_MINUTES=60
11
 
12
+ # ─── Auth: SSO del Core (M10) ───────────────────────────────────────────────
13
+ # La sesión de M6 es siempre un JWT HS256 propio (requiere JWT_SECRET arriba).
14
+ # SSO_ENABLED habilita POST /api/v1/auth/sso-exchange, que canjea un ticket
15
+ # del Core real (requiere M10_CORE_URL) por ese JWT propio, con el rol ya
16
+ # resuelto desde user.roles[] de la respuesta del canje.
17
+ SSO_ENABLED=false
18
+
19
+ # Cuenta de servicio de M6 en el Core: autentica las llamadas salientes a
20
+ # M1/M2/M7/M10.
21
  CORE_SERVICE_EMAIL=
22
  CORE_SERVICE_PASSWORD=
23
 
 
 
 
 
24
  # ─── Entorno ───────────────────────────────────────────────────────────────
25
  # Valores válidos: development | staging | production
26
  # En 'production', el endpoint /auth/token queda deshabilitado
.gitignore CHANGED
@@ -217,6 +217,7 @@ __marimo__/
217
  # Streamlit
218
  .streamlit/secrets.toml
219
 
 
220
 
221
  .claude/
222
  .claude-flow/
 
217
  # Streamlit
218
  .streamlit/secrets.toml
219
 
220
+ .DS_Store
221
 
222
  .claude/
223
  .claude-flow/
app/.DS_Store DELETED
Binary file (6.15 kB)
 
app/config.py CHANGED
@@ -1,5 +1,3 @@
1
- from typing import Literal
2
-
3
  from pydantic_settings import BaseSettings, SettingsConfigDict
4
 
5
 
@@ -19,20 +17,22 @@ class Settings(BaseSettings):
19
  jwt_algorithm: str = "HS256"
20
  jwt_expire_minutes: int = 60
21
 
22
- # ─── Auth: mock local vs. Core (M10) real ──────────────────────────────
23
- # "mock": JWT propios firmados con jwt_secret (comportamiento actual).
24
- # "core": JWT emitidos por M10, verificados localmente vía JWKS.
25
- auth_mode: Literal["mock", "core"] = "mock"
26
-
27
- # Cuenta de servicio de M6 en el Core: usada para el lookup de roles
28
- # (GET /roles) y para autenticar las llamadas salientes a M1/M2/M7/M10.
 
 
 
 
 
 
29
  core_service_email: str = ""
30
  core_service_password: str = ""
31
 
32
- # TTL de los caches de integración con Core (segundos)
33
- jwks_cache_ttl_seconds: int = 300
34
- core_roles_cache_ttl_seconds: int = 300
35
-
36
  # Entorno — controla comportamiento de endpoints de desarrollo
37
  environment: str = "development"
38
 
 
 
 
1
  from pydantic_settings import BaseSettings, SettingsConfigDict
2
 
3
 
 
17
  jwt_algorithm: str = "HS256"
18
  jwt_expire_minutes: int = 60
19
 
20
+ # ─── Auth: SSO del Core (M10) ───────────────────────────────────────────
21
+ # La sesión de M6 es siempre un JWT HS256 propio (jwt_secret). El SSO no
22
+ # cambia esa validación por-request: solo agrega una forma de *adquirir*
23
+ # el token — `POST /auth/sso-exchange` canjea un ticket del Core contra
24
+ # `app.integrations.core_auth.exchange_sso_ticket` y M6 emite su propio
25
+ # JWT con el rol ya resuelto (`app/routers/auth.py`).
26
+ #
27
+ # `sso_enabled=False` (default) 404ea el endpoint de canje — para correr
28
+ # sin depender de que el Core real esté arriba (dev/tests).
29
+ sso_enabled: bool = False
30
+
31
+ # Cuenta de servicio de M6 en el Core: usada para autenticar las
32
+ # llamadas salientes a M1/M2/M7/M10.
33
  core_service_email: str = ""
34
  core_service_password: str = ""
35
 
 
 
 
 
36
  # Entorno — controla comportamiento de endpoints de desarrollo
37
  environment: str = "development"
38
 
app/dependencies.py CHANGED
@@ -60,12 +60,15 @@ _ERROR_403 = {"codigo": "NO_AUTORIZADO", "mensaje": "No tiene permisos para esta
60
  def get_current_user(
61
  credentials: HTTPAuthorizationCredentials | None = Depends(_security),
62
  ) -> dict:
 
 
 
 
 
 
63
  if credentials is None:
64
  raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
65
 
66
- if settings.auth_mode == "core":
67
- return _get_current_user_core(credentials.credentials)
68
-
69
  try:
70
  payload = decode_token(credentials.credentials)
71
  except ValueError:
@@ -77,33 +80,6 @@ def get_current_user(
77
  return payload
78
 
79
 
80
- def _get_current_user_core(token: str) -> dict:
81
- """
82
- Rama `auth_mode="core"`: verifica el JWT del Core vía JWKS, resuelve el
83
- rol del usuario contra el Core (el token no lo transporta — ver
84
- `app/integrations/core_auth.py`) y lo traduce al rol interno de M6.
85
- Devuelve la misma forma que el modo mock (`{"sub", "rol"}`) para que
86
- `require_roles`, la auditoría y los routers no necesiten distinguir modo.
87
- """
88
- from app.integrations import core_auth
89
-
90
- try:
91
- payload = core_auth.verify_core_token(token)
92
- except ValueError:
93
- raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
94
-
95
- user_id = payload.get("user_id")
96
- if user_id is None:
97
- raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
98
-
99
- role_names = core_auth.resolve_user_roles(user_id)
100
- rol = core_auth.map_core_roles_to_internal(role_names)
101
- if rol is None:
102
- raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=_ERROR_403)
103
-
104
- return {"sub": str(user_id), "rol": rol, "core_roles": role_names}
105
-
106
-
107
  def require_roles(*roles: str):
108
  """
109
  Uso: Depends(require_roles("ADMINISTRATIVO", "MEDICO"))
 
60
  def get_current_user(
61
  credentials: HTTPAuthorizationCredentials | None = Depends(_security),
62
  ) -> dict:
63
+ """
64
+ Valida la sesión de M6: siempre un JWT HS256 propio (`jwt_secret`),
65
+ emitido al hacer login o al canjear un ticket SSO del Core
66
+ (`app/routers/auth.py`). El rol ya viaja en el token — no hay
67
+ verificación contra el Core ni lookup de roles en cada request.
68
+ """
69
  if credentials is None:
70
  raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
71
 
 
 
 
72
  try:
73
  payload = decode_token(credentials.credentials)
74
  except ValueError:
 
80
  return payload
81
 
82
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
83
  def require_roles(*roles: str):
84
  """
85
  Uso: Depends(require_roles("ADMINISTRATIVO", "MEDICO"))
app/integrations/_base.py CHANGED
@@ -13,9 +13,9 @@ def _headers(token: str | None = None) -> dict:
13
  h = {"Content-Type": "application/json"}
14
  # Si no se pasó un token explícito (ej. propagar el del usuario), usar
15
  # la cuenta de servicio de M6 — necesaria para llamadas disparadas por
16
- # webhooks entrantes, donde no hay usuario humano autenticado. En modo
17
- # mock (`auth_mode != "core"`) devuelve None y el comportamiento no
18
- # cambia respecto de antes.
19
  effective_token = token or core_auth.get_service_token()
20
  if effective_token:
21
  h["Authorization"] = f"Bearer {effective_token}"
 
13
  h = {"Content-Type": "application/json"}
14
  # Si no se pasó un token explícito (ej. propagar el del usuario), usar
15
  # la cuenta de servicio de M6 — necesaria para llamadas disparadas por
16
+ # webhooks entrantes, donde no hay usuario humano autenticado. Sin
17
+ # CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD configurados, devuelve None y
18
+ # el request sale sin header Authorization.
19
  effective_token = token or core_auth.get_service_token()
20
  if effective_token:
21
  h["Authorization"] = f"Bearer {effective_token}"
app/integrations/core_auth.py CHANGED
@@ -1,9 +1,14 @@
1
  """
2
- M10 Core — integración de autenticación real: verificación de JWT vía JWKS,
3
- resolución de rol de usuario y cuenta de servicio de M6.
4
-
5
- Solo se usa cuando `settings.auth_mode == "core"`. En modo "mock" (default),
6
- `app/dependencies.py` sigue firmando y validando sus propios JWT (HS256).
 
 
 
 
 
7
  """
8
  import logging
9
  import time
@@ -16,72 +21,45 @@ from app.config import settings
16
  logger = logging.getLogger(__name__)
17
 
18
 
19
- # ─── Verificación de firma (JWKS) ──────────────────────────────────────────
20
-
21
- # Cache en memoria del JWKS del Core, indexado por `kid`. Un único proceso
22
- # uvicorn (igual que el resto de la app, ver M6_DISEÑO §3) — no hay estado
23
- # compartido entre workers que resolver acá.
24
- _jwks_cache: dict = {"keys_by_kid": {}, "fetched_at": 0.0}
25
-
26
 
27
- def _fetch_jwks() -> dict:
28
- url = f"{settings.m10_core_url}/.well-known/jwks.json"
29
- r = httpx.get(url, timeout=settings.http_timeout_seconds)
30
- r.raise_for_status()
31
- return r.json()
32
 
 
 
33
 
34
- def get_signing_key(kid: str) -> dict:
35
- """
36
- Devuelve la JWK (dict) del Core que matchea el `kid` del header de un
37
- token. Refresca el cache si expiró (TTL `jwks_cache_ttl_seconds`) o si el
38
- `kid` pedido no está — cubre la rotación de claves del Core sin reiniciar
39
- M6.
40
- """
41
- now = time.monotonic()
42
- stale = (now - _jwks_cache["fetched_at"]) > settings.jwks_cache_ttl_seconds
43
- if stale or kid not in _jwks_cache["keys_by_kid"]:
44
- jwks = _fetch_jwks()
45
- _jwks_cache["keys_by_kid"] = {k["kid"]: k for k in jwks.get("keys", []) if "kid" in k}
46
- _jwks_cache["fetched_at"] = now
47
 
48
- key = _jwks_cache["keys_by_kid"].get(kid)
49
- if key is None:
50
- raise ValueError(f"No se encontró una clave JWKS del Core con kid={kid!r}")
51
- return key
52
 
53
 
54
- def verify_core_token(token: str) -> dict:
55
  """
56
- Verifica la firma de un JWT emitido por M10 (Core) contra su JWKS y
57
- devuelve el payload decodificado (`{exp, iat, permissions[], user_id}`).
58
-
59
- Confirmado contra el Core real (`https://api.healthcare.cantero.ar`):
60
- el token no lleva `iss` ni `aud`, así que no se validan acá — solo firma
61
- y expiración (`jwt.decode` valida `exp` por default).
62
  """
 
63
  try:
64
- header = jwt.get_unverified_header(token)
65
- except JWTError as e:
66
- raise ValueError("Header de token inválido") from e
67
 
68
- kid = header.get("kid")
69
- if not kid:
70
- raise ValueError("Token del Core sin 'kid' en el header")
 
 
 
71
 
72
- key = get_signing_key(kid)
73
- try:
74
- return jwt.decode(token, key, algorithms=[key.get("alg", "RS256")])
75
- except JWTError as e:
76
- raise ValueError("Token del Core inválido o expirado") from e
77
 
78
 
79
  # ─── Cuenta de servicio de M6 ───────────────────────────────────────────────
80
 
81
- # Token de la cuenta de servicio de M6 en el Core. Se usa para: (1) firmar
82
- # las llamadas salientes a M1/M2/M7/M10 (adjuntado automáticamente por
83
- # `app/integrations/_base.py`), y (2) el lookup de roles de S2
84
- # (`resolve_user_roles`), incluidas las llamadas disparadas por webhooks
85
  # entrantes donde no hay un usuario humano autenticado.
86
  _service_token_cache: dict = {"token": None, "expires_at": 0.0}
87
 
@@ -92,17 +70,14 @@ _SERVICE_TOKEN_EXPIRY_MARGIN_SECONDS = 30
92
 
93
  def get_service_token() -> str | None:
94
  """
95
- Devuelve un token válido de la cuenta de servicio de M6, refrescándolo
96
- si expiró o no se pidió todavía. `None` si `auth_mode` no es "core" o si
97
- faltan las credenciales de servicio (`CORE_SERVICE_EMAIL`/`_PASSWORD`) —
98
- en ambos casos el llamador debe seguir sin el header `Authorization`,
99
- igual que el comportamiento actual en modo mock.
100
  """
101
- if settings.auth_mode != "core":
102
- return None
103
  if not settings.core_service_email or not settings.core_service_password:
104
  logger.warning(
105
- "auth_mode=core pero CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD no están configurados"
106
  )
107
  return None
108
 
@@ -139,12 +114,16 @@ def _login_service_account() -> str | None:
139
  return token
140
 
141
 
142
- # ─── Resolución de rol (S2-A: lookup de GET /roles) ────────────────────────
143
 
144
- # El JWT del Core no lleva el nombre del rol (confirmado en vivo: solo trae
145
- # `permissions[]` planas) — hay que resolverlo con una llamada aparte. Este
146
- # mapeo es la única fuente de la verdad de qué rol de Core habilita qué rol
147
- # interno de M6; ajustar acá si cambian los nombres en el Core compartido.
 
 
 
 
148
  CORE_ROLE_TO_INTERNAL: dict[str, str] = {
149
  "admin_internacion": "ADMINISTRATIVO",
150
  "admin": "ADMINISTRATIVO", # super-admin del Core — a confirmar con el equipo M10
@@ -155,52 +134,6 @@ CORE_ROLE_TO_INTERNAL: dict[str, str] = {
155
  # Si un usuario tiene varios roles mapeados, gana el de mayor alcance.
156
  _ROLE_PRECEDENCE = ("ADMINISTRATIVO", "MEDICO", "LIMPIEZA")
157
 
158
- # Índice inverso `user_id -> [nombres de rol]`, cacheado con TTL
159
- # (`core_roles_cache_ttl_seconds`). Trae el padrón completo en cada refresh
160
- # porque `GET /roles` es lo único que la cuenta de servicio puede leer hoy
161
- # (`GET /users/{id}` requiere `users:read`, no disponible — ver S2-B en el
162
- # plan). Aceptable al tamaño actual del Core compartido; un usuario recién
163
- # asignado a un rol puede tardar hasta el TTL en reflejarse.
164
- _roles_index_cache: dict = {"user_id_to_roles": {}, "fetched_at": 0.0}
165
-
166
-
167
- def _fetch_roles_index() -> dict[int, list[str]]:
168
- token = get_service_token()
169
- headers = {"Authorization": f"Bearer {token}"} if token else {}
170
- url = f"{settings.m10_core_url}/roles"
171
- r = httpx.get(
172
- url, headers=headers, params={"pageSize": 200}, timeout=settings.http_timeout_seconds
173
- )
174
- r.raise_for_status()
175
- data = r.json()
176
-
177
- index: dict[int, list[str]] = {}
178
- for role in data.get("data", []):
179
- name = role.get("name")
180
- for user in role.get("users") or []:
181
- uid = user.get("id")
182
- if uid is None or name is None:
183
- continue
184
- index.setdefault(uid, []).append(name)
185
- return index
186
-
187
-
188
- def resolve_user_roles(user_id: int) -> list[str]:
189
- """Nombres de rol de Core asignados a `user_id` (S2-A: vía GET /roles)."""
190
- now = time.monotonic()
191
- stale = (now - _roles_index_cache["fetched_at"]) > settings.core_roles_cache_ttl_seconds
192
- if stale:
193
- try:
194
- _roles_index_cache["user_id_to_roles"] = _fetch_roles_index()
195
- _roles_index_cache["fetched_at"] = now
196
- except Exception as e:
197
- logger.warning("No se pudo refrescar el índice de roles del Core: %s", e)
198
- # Sin índice previo, no hay de dónde resolver — se propaga.
199
- if not _roles_index_cache["user_id_to_roles"]:
200
- raise
201
-
202
- return _roles_index_cache["user_id_to_roles"].get(user_id, [])
203
-
204
 
205
  def map_core_roles_to_internal(role_names: list[str]) -> str | None:
206
  """
 
1
  """
2
+ M10 Core — integración de autenticación real: canje de ticket SSO y cuenta
3
+ de servicio de M6.
4
+
5
+ La sesión de M6 es siempre un JWT HS256 propio (`app/dependencies.py`,
6
+ `create_access_token`/`decode_token`). El Core se toca en dos puntos nada
7
+ más: (a) el canje del ticket SSO (`exchange_sso_ticket`, una vez por login),
8
+ y (b) la cuenta de servicio para las llamadas salientes de M6 a M1/M2/M7.
9
+ No hay verificación de JWT del Core por-request ni lookup de roles — el rol
10
+ se resuelve una sola vez, en el canje, a partir de `user.roles[]` (ver
11
+ `app/routers/auth.py`).
12
  """
13
  import logging
14
  import time
 
21
  logger = logging.getLogger(__name__)
22
 
23
 
24
+ # ─── Canje de ticket SSO ────────────────────────────────────────────────────
 
 
 
 
 
 
25
 
 
 
 
 
 
26
 
27
+ class SSOTicketInvalid(Exception):
28
+ """Ticket ausente/inválido/ya usado/expirado (el Core respondió 400/401)."""
29
 
 
 
 
 
 
 
 
 
 
 
 
 
 
30
 
31
+ class SSOExchangeError(Exception):
32
+ """Fallo al comunicarse con el Core (red, timeout, 5xx, etc.)."""
 
 
33
 
34
 
35
+ def exchange_sso_ticket(ticket: str) -> dict:
36
  """
37
+ Canjea un ticket SSO de un solo uso contra el Core por `{user, token}`
38
+ (`POST /auth/sso-exchange`, `models.AuthResponse`). `user.roles[]` trae
39
+ el/los rol(es) del usuario en el Core — de ahí sale la autorización de
40
+ M6, sin necesidad de un lookup aparte.
 
 
41
  """
42
+ url = f"{settings.m10_core_url}/auth/sso-exchange"
43
  try:
44
+ r = httpx.post(url, json={"ticket": ticket}, timeout=settings.http_timeout_seconds)
45
+ except httpx.HTTPError as e:
46
+ raise SSOExchangeError("No se pudo contactar al Core para el canje SSO") from e
47
 
48
+ if r.status_code == 401:
49
+ raise SSOTicketInvalid("Ticket inválido, ya usado o expirado")
50
+ if r.status_code == 400:
51
+ raise SSOTicketInvalid("Falta el ticket en el request")
52
+ if r.status_code >= 400:
53
+ raise SSOExchangeError(f"El Core respondió {r.status_code} al canjear el ticket SSO")
54
 
55
+ return r.json()
 
 
 
 
56
 
57
 
58
  # ─── Cuenta de servicio de M6 ───────────────────────────────────────────────
59
 
60
+ # Token de la cuenta de servicio de M6 en el Core. Se usa para firmar las
61
+ # llamadas salientes a M1/M2/M7/M10 (adjuntado automáticamente por
62
+ # `app/integrations/_base.py`), incluidas las disparadas por webhooks
 
63
  # entrantes donde no hay un usuario humano autenticado.
64
  _service_token_cache: dict = {"token": None, "expires_at": 0.0}
65
 
 
70
 
71
  def get_service_token() -> str | None:
72
  """
73
+ Devuelve un token válido de la cuenta de servicio de M6, refrescándolo si
74
+ expiró o no se pidió todavía. `None` si faltan las credenciales de
75
+ servicio (`CORE_SERVICE_EMAIL`/`_PASSWORD`) — el llamador debe seguir sin
76
+ el header `Authorization` en ese caso.
 
77
  """
 
 
78
  if not settings.core_service_email or not settings.core_service_password:
79
  logger.warning(
80
+ "CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD no están configurados"
81
  )
82
  return None
83
 
 
114
  return token
115
 
116
 
117
+ # ─── Mapeo de rol de Core → rol interno de M6 ──────────────────────────────
118
 
119
+ # El rol del usuario se obtiene una única vez, en el canje SSO
120
+ # (`user.roles[].name` de la respuesta de `/auth/sso-exchange` —
121
+ # `models.AuthResponse` → `models.User` → `models.Role`, ver
122
+ # `documentation/M10_openapi.yaml`). No hay lookup aparte (`GET /roles`) ni
123
+ # verificación de JWT del Core por-request: la sesión de M6 es siempre el
124
+ # JWT HS256 propio emitido en `app/routers/auth.py`. Este mapeo es la única
125
+ # fuente de la verdad de qué rol de Core habilita qué rol interno de M6;
126
+ # ajustar acá si cambian los nombres en el Core compartido.
127
  CORE_ROLE_TO_INTERNAL: dict[str, str] = {
128
  "admin_internacion": "ADMINISTRATIVO",
129
  "admin": "ADMINISTRATIVO", # super-admin del Core — a confirmar con el equipo M10
 
134
  # Si un usuario tiene varios roles mapeados, gana el de mayor alcance.
135
  _ROLE_PRECEDENCE = ("ADMINISTRATIVO", "MEDICO", "LIMPIEZA")
136
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
137
 
138
  def map_core_roles_to_internal(role_names: list[str]) -> str | None:
139
  """
app/main.py CHANGED
@@ -12,7 +12,7 @@ from fastapi.responses import JSONResponse
12
  from app.config import settings
13
  from app.dependencies import create_access_token
14
 
15
- from app.routers import camas, quirofanos, solicitudes, webhooks, auditoria
16
  from app.routers.webhooks import router_turnos
17
 
18
  logger = logging.getLogger(__name__)
@@ -56,6 +56,7 @@ app.add_middleware(
56
 
57
  PREFIX = "/api/v1"
58
 
 
59
  app.include_router(camas.router, prefix=PREFIX)
60
  app.include_router(quirofanos.router, prefix=PREFIX)
61
  app.include_router(solicitudes.router, prefix=PREFIX)
@@ -75,15 +76,14 @@ app.include_router(auditoria.router, prefix=PREFIX)
75
  )
76
  def get_dev_token(usuario: str, password: str):
77
  """
78
- Solo habilitado si ENVIRONMENT=development y AUTH_MODE=mock.
79
- Genera un JWT de prueba. Roles válidos: ADMINISTRATIVO | MEDICO | LIMPIEZA
 
80
 
81
- Con AUTH_MODE=core, la autenticación es responsabilidad del Core (M10):
82
- este endpoint no aplica — un token HS256 propio no pasa la verificación
83
- RS256 vía JWKS que usa `get_current_user` en ese modo. Loguearse contra
84
- el Core real: `POST /auth/login` en `settings.m10_core_url`.
85
  """
86
- if settings.environment != "development" or settings.auth_mode != "mock":
87
  return JSONResponse(
88
  status_code=404,
89
  content={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Not Found"},
 
12
  from app.config import settings
13
  from app.dependencies import create_access_token
14
 
15
+ from app.routers import auth, camas, quirofanos, solicitudes, webhooks, auditoria
16
  from app.routers.webhooks import router_turnos
17
 
18
  logger = logging.getLogger(__name__)
 
56
 
57
  PREFIX = "/api/v1"
58
 
59
+ app.include_router(auth.router, prefix=PREFIX)
60
  app.include_router(camas.router, prefix=PREFIX)
61
  app.include_router(quirofanos.router, prefix=PREFIX)
62
  app.include_router(solicitudes.router, prefix=PREFIX)
 
76
  )
77
  def get_dev_token(usuario: str, password: str):
78
  """
79
+ Solo habilitado si ENVIRONMENT=development.
80
+ Genera un JWT de prueba (el mismo formato HS256 que emite el canje SSO,
81
+ ver `app/routers/auth.py`). Roles válidos: ADMINISTRATIVO | MEDICO | LIMPIEZA
82
 
83
+ Alternativa con el Core real (M10): loguearse ahí, obtener un ticket SSO
84
+ (`POST /auth/sso-ticket`) y canjearlo en `POST /api/v1/auth/sso-exchange`.
 
 
85
  """
86
+ if settings.environment != "development":
87
  return JSONResponse(
88
  status_code=404,
89
  content={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Not Found"},
app/routers/auth.py ADDED
@@ -0,0 +1,68 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ SSO del Core (M10): canje de ticket por una sesión propia de M6.
3
+
4
+ M6 no maneja el callback del browser (`/auth/sso?ticket=…`, responsabilidad
5
+ del frontend) — este router expone solo el canje server-to-server: recibe el
6
+ ticket, lo intercambia contra el Core por `{user, token}` y emite su propio
7
+ JWT HS256 con el rol ya resuelto a partir de `user.roles[]`. Ver
8
+ `app/integrations/core_auth.py` y `documentation/M6_DISEÑO.md` §11.
9
+ """
10
+ import logging
11
+
12
+ from fastapi import APIRouter, HTTPException, status
13
+
14
+ from app.config import settings
15
+ from app.dependencies import create_access_token
16
+ from app.integrations import core_auth
17
+ from app.schemas.auth import SSOExchangeRequest, SSOExchangeResponse, SSOUser
18
+
19
+ logger = logging.getLogger(__name__)
20
+
21
+ router = APIRouter(prefix="/auth", tags=["Auth"])
22
+
23
+ _ERROR_404 = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Not Found"}
24
+ _ERROR_401_TICKET = {"codigo": "NO_AUTENTICADO", "mensaje": "Ticket inválido, ya usado o expirado"}
25
+ _ERROR_403_ROL = {"codigo": "NO_AUTORIZADO", "mensaje": "El usuario no tiene un rol habilitado en M6"}
26
+ _ERROR_502 = {"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo canjear el ticket contra el Core (M10)"}
27
+
28
+
29
+ @router.post(
30
+ "/sso-exchange",
31
+ response_model=SSOExchangeResponse,
32
+ summary="Canjear un ticket SSO del Core por una sesión de M6",
33
+ responses={
34
+ 401: {"description": "Ticket inválido, ya usado o expirado"},
35
+ 403: {"description": "El usuario no tiene un rol habilitado en M6"},
36
+ 404: {"description": "SSO no habilitado"},
37
+ 502: {"description": "El Core no respondió al canje"},
38
+ },
39
+ )
40
+ def sso_exchange(data: SSOExchangeRequest):
41
+ if not settings.sso_enabled:
42
+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=_ERROR_404)
43
+
44
+ try:
45
+ resp = core_auth.exchange_sso_ticket(data.ticket)
46
+ except core_auth.SSOTicketInvalid:
47
+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_TICKET)
48
+ except core_auth.SSOExchangeError as e:
49
+ logger.warning("Fallo al canjear ticket SSO contra el Core: %s", e)
50
+ raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502)
51
+
52
+ core_user = resp.get("user") or {}
53
+ role_names = [r["name"] for r in (core_user.get("roles") or []) if r.get("name")]
54
+ rol = core_auth.map_core_roles_to_internal(role_names)
55
+ if rol is None:
56
+ raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=_ERROR_403_ROL)
57
+
58
+ token = create_access_token(sub=str(core_user["id"]), rol=rol)
59
+ return SSOExchangeResponse(
60
+ token=token,
61
+ user=SSOUser(
62
+ id=core_user["id"],
63
+ first_name=core_user.get("first_name", ""),
64
+ last_name=core_user.get("last_name", ""),
65
+ email=core_user.get("email", ""),
66
+ ),
67
+ rol=rol,
68
+ )
app/schemas/auth.py ADDED
@@ -0,0 +1,18 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from pydantic import BaseModel, Field
2
+
3
+
4
+ class SSOExchangeRequest(BaseModel):
5
+ ticket: str = Field(..., min_length=1)
6
+
7
+
8
+ class SSOUser(BaseModel):
9
+ id: int
10
+ first_name: str
11
+ last_name: str
12
+ email: str
13
+
14
+
15
+ class SSOExchangeResponse(BaseModel):
16
+ token: str
17
+ user: SSOUser
18
+ rol: str
docs/.DS_Store DELETED
Binary file (6.15 kB)
 
docs/superpowers/.DS_Store DELETED
Binary file (6.15 kB)
 
documentation/.DS_Store DELETED
Binary file (6.15 kB)
 
documentation/M10_SSO_INTEGRATION_GUIDE.md ADDED
@@ -0,0 +1,380 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Guía de integración SSO — para módulos de Health Grid
2
+
3
+ Esta guía es para los equipos que implementan **otros módulos** de Health Grid y necesitan que un usuario que ya está logueado en otro módulo (o en el core) **llegue ya autenticado** a su aplicación, aunque estén en **dominios distintos** (no comparten cookies).
4
+
5
+ Sos el **módulo destino**: recibís al usuario por un redirect y tenés que dejarlo logueado en tu app. Esta guía cubre solo tu parte.
6
+
7
+ > **API del core:** `https://api.healthcare.cantero.ar` — emite y valida los JWT.
8
+ > **Ruta de callback del módulo:** `/auth/sso` — el usuario aterriza ahí con el ticket, p. ej.
9
+ > `https://healthgrid.cantero.ar/auth/sso?ticket=…`. Cada módulo se sirve en su propio host;
10
+ > el path `/auth/sso` es la convención común. Los ejemplos usan `healthgrid.cantero.ar`.
11
+
12
+ ---
13
+
14
+ ## Qué te da el core
15
+
16
+ - Un **JWT firmado con RS256** (válido 24 h) que identifica al usuario y trae sus permisos.
17
+ - La clave pública para validar ese JWT, publicada en
18
+ `https://api.healthcare.cantero.ar/.well-known/jwks.json` (JWKS).
19
+ **No necesitás ninguna clave secreta compartida.**
20
+
21
+ ## Qué tenés que construir
22
+
23
+ 1. Una ruta de **callback** `/auth/sso` que reciba el redirect con un `ticket`.
24
+ 2. Una llamada al core para canjear ese ticket por un JWT (servidor-a-servidor si tenés
25
+ backend; desde el navegador si sos una SPA — ver [Variante SPA](#variante-módulo-spa-sin-backend-angular--react)).
26
+ 3. Tu **propia sesión** en tu dominio (cookie / `localStorage`) con ese JWT.
27
+ 4. **Validación** del JWT en cada request siguiente, usando el JWKS.
28
+
29
+ ---
30
+
31
+ ## El flujo, de tu lado
32
+
33
+ ```mermaid
34
+ sequenceDiagram
35
+ participant U as Usuario (navegador)
36
+ participant B as Tu backend (módulo)
37
+ participant C as Core API<br/>(api.healthcare.cantero.ar)
38
+
39
+ U->>B: 1) redirect a /auth/sso?ticket=…&redirect=/x
40
+ B->>C: 2) POST /auth/sso-exchange<br/>{ "ticket": "…" }
41
+ C-->>B: { user, token } (JWT)
42
+ B-->>U: 3) set cookie de sesión + redirect
43
+ Note over U: ya logueado en tu módulo
44
+ ```
45
+
46
+ 1. El navegador llega a tu app con una URL tipo:
47
+ `https://healthgrid.cantero.ar/auth/sso?ticket=<opaco>&redirect=/dashboard`
48
+ 2. Tu backend toma el `ticket` y lo **canjea** contra el core (paso servidor-a-servidor;
49
+ el ticket no se vuelve a exponer al navegador).
50
+ 3. Recibís `{ user, token }`. Guardás el `token` en tu propia sesión y redirigís al usuario
51
+ a `redirect`.
52
+
53
+ **Importante:** el `ticket` es de **un solo uso** y **expira en ~60 segundos**. Canjealo apenas lo recibís, desde el backend. No lo guardes ni lo reenvíes al frontend.
54
+
55
+ ---
56
+
57
+ ## Paso a paso
58
+
59
+ ### 1) Endpoint de callback + canje del ticket
60
+
61
+ `POST https://api.healthcare.cantero.ar/auth/sso-exchange`
62
+
63
+ Request:
64
+
65
+ ```json
66
+ { "ticket": "9f2c1b7a…e04" }
67
+ ```
68
+
69
+ Respuesta `200`:
70
+
71
+ ```json
72
+ {
73
+ "user": {
74
+ "id": 42,
75
+ "first_name": "Ana",
76
+ "last_name": "Pérez",
77
+ "email": "ana@example.com"
78
+ },
79
+ "token": "eyJhbGciOiJSUzI1NiIsImtpZCI6Ij…"
80
+ }
81
+ ```
82
+
83
+ Errores:
84
+
85
+ | Código | Significado | Qué hacer |
86
+ | ------ | ------------------------------------ | -------------------------------------------------------- |
87
+ | `400` | Falta el `ticket` en el body | Revisar tu request |
88
+ | `401` | Ticket inválido, ya usado o expirado | Redirigir al login; el usuario reintenta desde el origen |
89
+
90
+ ### 2) Establecer tu propia sesión
91
+
92
+ El `token` es el JWT del core. Guardalo **en tu dominio** — el core no maneja tu sesión:
93
+
94
+ - **Recomendado:** cookie propia `HttpOnly` + `Secure` + `SameSite=Lax`, con el dominio de tu módulo.
95
+ - Alternativa (SPA): `localStorage` y mandarlo como `Authorization: Bearer <token>` en tus llamadas.
96
+
97
+ Ese JWT dura 24 h. Cuando vence, el usuario tiene que volver a pasar por el SSO (o, si tu módulo también habla con el core, podés usar `POST /auth/refresh` mientras siga vigente).
98
+
99
+ ### 3) Validar el JWT en cada request
100
+
101
+ En cada request protegido de tu módulo, validá el JWT **localmente** contra el JWKS del core. No hace falta llamar al core en cada request.
102
+
103
+ Endpoint del JWKS: `GET https://api.healthcare.cantero.ar/.well-known/jwks.json`
104
+
105
+ Pasos:
106
+
107
+ 1. Descargá y **cacheá** el JWKS (respetá rotación de claves vía el `kid` del header del
108
+ token).
109
+ 2. Verificá la firma con la clave pública correspondiente (**algoritmo RS256, y solo RS256**).
110
+ 3. Validá `exp` (expiración).
111
+ 4. Leé los claims de negocio (`user_id`, `permissions`).
112
+
113
+ Detalle completo y ejemplos en [`JWKS_VALIDATION.md`](JWKS_VALIDATION.md).
114
+
115
+ ---
116
+
117
+ ## Estructura del JWT que vas a recibir
118
+
119
+ Header:
120
+
121
+ ```json
122
+ { "alg": "RS256", "typ": "JWT", "kid": "a1b2c3d4e5f6a7b8" }
123
+ ```
124
+
125
+ Claims (payload):
126
+
127
+ ```json
128
+ {
129
+ "user_id": 42,
130
+ "permissions": ["users:read", "locations:read", "…"],
131
+ "iat": 1751846400,
132
+ "exp": 1751932800
133
+ }
134
+ ```
135
+
136
+ - `user_id` — id del usuario en el core.
137
+ - `permissions` — lista plana de permisos (`recurso:accion`). Usala para tu autorización.
138
+ - `exp` — expiración (24 h desde la emisión). **Validala siempre.**
139
+
140
+ > Nota: hoy el token **no** trae `iss`/`aud`. Validá firma + `exp` + los claims de negocio.
141
+
142
+ ---
143
+
144
+ ## Ejemplos de código
145
+
146
+ ### Node.js / Express (canje + validación con JWKS)
147
+
148
+ ```js
149
+ import express from "express";
150
+ import fetch from "node-fetch";
151
+ import { createRemoteJWKSet, jwtVerify } from "jose";
152
+
153
+ const CORE = "https://api.healthcare.cantero.ar";
154
+ const JWKS = createRemoteJWKSet(new URL(`${CORE}/.well-known/jwks.json`)); // cachea solo
155
+
156
+ const app = express();
157
+
158
+ // 1) Callback: recibe el ticket y lo canjea
159
+ app.get("/auth/sso", async (req, res) => {
160
+ const { ticket, redirect = "/" } = req.query;
161
+ try {
162
+ const r = await fetch(`${CORE}/auth/sso-exchange`, {
163
+ method: "POST",
164
+ headers: { "Content-Type": "application/json" },
165
+ body: JSON.stringify({ ticket }),
166
+ });
167
+ if (!r.ok) return res.redirect("/login");
168
+ const { token } = await r.json();
169
+
170
+ // 2) Sesión propia, en tu dominio
171
+ res.cookie("session", token, {
172
+ httpOnly: true,
173
+ secure: true,
174
+ sameSite: "lax",
175
+ maxAge: 24 * 3600 * 1000,
176
+ });
177
+ res.redirect(redirect);
178
+ } catch {
179
+ res.redirect("/login");
180
+ }
181
+ });
182
+
183
+ // 3) Middleware: valida el JWT del core en cada request
184
+ async function requireAuth(req, res, next) {
185
+ const token = req.cookies.session;
186
+ if (!token) return res.status(401).json({ error: "no session" });
187
+ try {
188
+ const { payload } = await jwtVerify(token, JWKS, { algorithms: ["RS256"] });
189
+ req.user = { id: payload.user_id, permissions: payload.permissions || [] };
190
+ next();
191
+ } catch {
192
+ res.status(401).json({ error: "invalid token" });
193
+ }
194
+ }
195
+ ```
196
+
197
+ ### Go / Gin (canje del ticket)
198
+
199
+ ```go
200
+ // GET /auth/sso?ticket=…&redirect=…
201
+ const coreBaseURL = "https://api.healthcare.cantero.ar"
202
+
203
+ func SSOCallbackHandler(c *gin.Context) {
204
+ ticket := c.Query("ticket")
205
+ redirect := c.DefaultQuery("redirect", "/")
206
+
207
+ body, _ := json.Marshal(map[string]string{"ticket": ticket})
208
+ client := &http.Client{Timeout: 5 * time.Second}
209
+ resp, err := client.Post(coreBaseURL+"/auth/sso-exchange",
210
+ "application/json", bytes.NewReader(body))
211
+ if err != nil || resp.StatusCode != http.StatusOK {
212
+ c.Redirect(http.StatusFound, "/login")
213
+ return
214
+ }
215
+ defer resp.Body.Close()
216
+
217
+ var out struct{ Token string `json:"token"` }
218
+ json.NewDecoder(resp.Body).Decode(&out)
219
+
220
+ // Cookie de sesión en TU dominio.
221
+ c.SetCookie("session", out.Token, 86400, "/", "healthgrid.cantero.ar", true, true)
222
+ c.Redirect(http.StatusFound, redirect)
223
+ }
224
+ ```
225
+
226
+ Para la validación del JWT en Go, ver el ejemplo con `github.com/MicahParks/keyfunc` en
227
+ [`JWKS_VALIDATION.md`](JWKS_VALIDATION.md).
228
+
229
+ ### Prueba rápida con curl
230
+
231
+ ```bash
232
+ # Canje del ticket (lo que hace tu backend)
233
+ curl -sS -X POST https://api.healthcare.cantero.ar/auth/sso-exchange \
234
+ -H 'Content-Type: application/json' \
235
+ -d '{"ticket":"PEGA_ACA_EL_TICKET"}'
236
+ # → { "user": {...}, "token": "eyJ…" }
237
+
238
+ # El JWKS que usás para validar los JWT
239
+ curl -sS https://api.healthcare.cantero.ar/.well-known/jwks.json
240
+ ```
241
+
242
+ ---
243
+
244
+ ## Variante: módulo SPA sin backend (Angular / React)
245
+
246
+ Si tu módulo es una **SPA sin backend propio** (Angular, React, etc.), no tenés un
247
+ servidor donde hacer el canje back-channel. En ese caso el canje se hace **desde el
248
+ navegador**, directo contra el endpoint público `POST /auth/sso-exchange`.
249
+
250
+ Es un patrón **aceptable** para SPAs porque:
251
+
252
+ - El `ticket` es de **un solo uso** y expira en **~60 s**: aunque quede un instante en la
253
+ URL, es de bajo valor y no se puede reusar.
254
+ - Se canjea **de inmediato** sobre HTTPS por el JWT, que se guarda en tu propio
255
+ almacenamiento (igual que harías tras un login normal).
256
+ - Después de canjear, limpiás el `ticket` de la URL (`replaceState` / `replaceUrl`) para que
257
+ no quede en el historial.
258
+
259
+ > Si tu módulo **sí** tiene backend, preferí el canje servidor-a-servidor de las secciones
260
+ > anteriores: el ticket nunca llega a exponerse al navegador.
261
+
262
+ ### El flujo, para una SPA
263
+
264
+ ```mermaid
265
+ sequenceDiagram
266
+ participant O as Otro módulo
267
+ participant S as Tu SPA (navegador)
268
+ participant C as Core API<br/>(api.healthcare.cantero.ar)
269
+
270
+ O->>S: 1) redirect a /auth/sso?ticket=…&redirect=/x
271
+ S->>C: 2) POST /auth/sso-exchange<br/>{ "ticket": "…" }
272
+ C-->>S: { user, token } (JWT)
273
+ Note over S: 3) guarda el JWT, limpia la URL<br/>y navega a /x
274
+ ```
275
+
276
+ La ruta de callback es una **ruta del router** de tu SPA (`/auth/sso`), no un endpoint de
277
+ servidor. El usuario llega ahí con `?ticket=…&redirect=/ruta-interna`.
278
+
279
+ ### Ejemplo: Angular
280
+
281
+ Ruta pública en tu `app.routes.ts`:
282
+
283
+ ```ts
284
+ {
285
+ path: 'auth/sso',
286
+ loadComponent: () =>
287
+ import('./features/auth/sso/sso.component').then((m) => m.SsoComponent),
288
+ },
289
+ ```
290
+
291
+ Servicio: canje del código por una sesión (reutiliza tu misma lógica de login):
292
+
293
+ ```ts
294
+ // AuthService
295
+ establishSessionFromTicket(ticket: string): Observable<SessionUser> {
296
+ return this.http
297
+ .post<ApiAuthResponse>(`${this.baseUrl}/sso-exchange`, { ticket })
298
+ .pipe(
299
+ map((res) => this.persistSession(res)), // guarda el JWT (localStorage/cookie)
300
+ catchError((err) => throwError(() => toError(err))),
301
+ );
302
+ }
303
+ ```
304
+
305
+ Componente de callback: lee el `ticket`, lo canjea y navega:
306
+
307
+ ```ts
308
+ ngOnInit(): void {
309
+ // Acepta el ticket en query (?ticket=) o en fragment (#ticket=), y un redirect interno.
310
+ const snap = this.route.snapshot;
311
+ const frag = snap.fragment ? new URLSearchParams(snap.fragment) : null;
312
+ const ticket = frag?.get('ticket') ?? snap.queryParamMap.get('ticket');
313
+ const redirect = frag?.get('redirect') ?? snap.queryParamMap.get('redirect');
314
+
315
+ if (!ticket) {
316
+ this.error.set('El enlace de acceso no incluye un ticket SSO.');
317
+ return;
318
+ }
319
+
320
+ this.auth.establishSessionFromTicket(ticket).subscribe({
321
+ next: () => {
322
+ const target = this.safeRedirect(redirect) ?? '/';
323
+ // replaceUrl: el código no queda en el historial de navegación.
324
+ void this.router.navigateByUrl(target, { replaceUrl: true });
325
+ },
326
+ error: (err: Error) => this.error.set(err.message),
327
+ });
328
+ }
329
+
330
+ /** Sólo rutas internas absolutas; descarta URLs externas (open redirect). */
331
+ private safeRedirect(path: string | null): string | null {
332
+ if (!path) return null;
333
+ if (!path.startsWith('/') || path.startsWith('//') || path.startsWith('/\\')) return null;
334
+ return path;
335
+ }
336
+ ```
337
+
338
+ El mismo esquema aplica a React: una ruta `/auth/sso` que, al montarse, lee el `ticket`, hace
339
+ el `POST /auth/sso-exchange`, guarda el JWT y hace `navigate(redirect, { replace: true })`.
340
+
341
+ ### Consideraciones de seguridad para SPAs
342
+
343
+ - **Canjeá apenas montás la ruta** y limpiá el `ticket` de la URL (`replaceUrl` / `replaceState`).
344
+ - **Validá el `redirect`**: sólo rutas internas absolutas (`/algo`), nunca URLs externas ni
345
+ `//host` (open redirect).
346
+ - El JWT queda en el navegador (localStorage o cookie). Es el mismo modelo de riesgo que tu
347
+ login normal; no lo empeora respecto de lo que ya hacés hoy.
348
+ - Serví tu SPA **siempre por HTTPS**.
349
+
350
+ ---
351
+
352
+ ## Checklist de implementación
353
+
354
+ - [ ] Ruta de callback (`/auth/sso?ticket=…&redirect=…`) en tu módulo.
355
+ - [ ] Canje del ticket **desde el backend** si tenés uno (server-to-server); si sos una SPA
356
+ sin backend, canjealo desde el navegador (ver [Variante SPA](#variante-módulo-spa-sin-backend-angular--react)).
357
+ - [ ] Canjear **apenas** llega (el ticket expira en ~60 s y es de un solo uso).
358
+ - [ ] Guardar el JWT en tu propia sesión (cookie `HttpOnly`+`Secure` recomendado).
359
+ - [ ] Validar el `redirect` para evitar **open redirect** (permití solo rutas internas / una
360
+ allowlist).
361
+ - [ ] Cachear el JWKS y validar firma **RS256** + `exp` en cada request.
362
+ - [ ] Manejar `401` del canje redirigiendo al login.
363
+ - [ ] Usar **HTTPS** en tu callback (el JWT viaja en la respuesta del canje).
364
+
365
+ ## Preguntas frecuentes
366
+
367
+ **¿Necesito una clave secreta del core?**
368
+ No. Validás los JWT con la clave **pública** del JWKS. Nada secreto se comparte.
369
+
370
+ **¿Qué pasa si el ticket expiró o ya se usó?**
371
+ El canje devuelve `401`. Mandá al usuario al login; reinicia el flujo desde el módulo origen y obtiene un ticket nuevo.
372
+
373
+ **¿Puedo canjear el ticket desde el frontend (SPA sin backend)?**
374
+ Sí. Si tu módulo es una SPA sin backend (Angular, React, etc.), el canje se hace desde el navegador contra el endpoint público. Es un patrón válido porque el ticket es de un solo uso y de vida corta. Seguí la sección [Variante: módulo SPA sin backend](#variante-módulo-spa-sin-backend-angular--react). Si tenés backend, preferí el canje servidor-a-servidor.
375
+
376
+ **El JWT vence a las 24 h. ¿Cómo lo renuevo?**
377
+ Si tu módulo se comunica con el core, podés usar `POST /auth/refresh` con el token todavía vigente. Si no, el usuario vuelve a pasar por el SSO.
378
+
379
+ **¿Cómo autorizo acciones?**
380
+ Con el claim `permissions` del JWT (formato `recurso:accion`, ej. `users:read`).
documentation/M6_AUTH_SSO.md ADDED
@@ -0,0 +1,227 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Autenticación de M6: SSO del Core — guía para backend y frontend
2
+
3
+ **Health Grid · Módulo 6 (Internación y Gestión de Camas)**
4
+
5
+ > Este documento explica cómo se loguea un usuario en M6 y cómo persiste su sesión, y sirve de guía de implementación para el equipo de frontend. Es específico de M6; el contrato genérico del SSO del Core está en [`M10_SSO_INTEGRATION_GUIDE.md`](M10_SSO_INTEGRATION_GUIDE.md). El detalle de la integración vive en [`M6_DISEÑO.md`](M6_DISEÑO.md) §11 y el mapeo de roles en [`roles.md`](roles.md) §6.
6
+
7
+ ---
8
+
9
+ ## 1. Resumen
10
+
11
+ **M6 no tiene login propio.** No hay pantalla de usuario/contraseña contra este backend. El usuario se loguea en el Core (M10) — ya sea directamente o porque llega logueado desde otro módulo — y M6 lo recibe **ya autenticado** vía SSO: canjea un ticket de un solo uso por los datos del usuario, y a partir de ahí **emite su propia sesión**, independiente del Core.
12
+
13
+ Dos tokens distintos entran en juego y no hay que confundirlos:
14
+
15
+ | Token | Quién lo emite | Algoritmo | Vigencia | Dónde se usa |
16
+ |---|---|---|---|---|
17
+ | Token del Core | M10 | RS256 | 24 h | Solo dentro del canje (`sso-exchange`). M6 nunca lo guarda ni lo reenvía. |
18
+ | Token de M6 | M6 (`create_access_token`) | HS256 | `JWT_EXPIRE_MINUTES` (hoy 60 min) | Es la sesión real: el frontend lo guarda y lo manda como `Authorization: Bearer` en cada request a M6. |
19
+
20
+ ---
21
+
22
+ ## 2. Flujo completo
23
+
24
+ ```mermaid
25
+ sequenceDiagram
26
+ participant U as Usuario (navegador)
27
+ participant Core as Core API (M10)
28
+ participant F as Frontend M6
29
+ participant M6 as Backend M6
30
+
31
+ U->>Core: 1) Login (u otro módulo ya logueado)
32
+ F->>Core: 2) POST /auth/sso-ticket (Bearer del Core)
33
+ Core-->>F: { ticket, expires_in }
34
+ Note over U,F: 3) Redirect a /auth/sso?ticket=…&redirect=/mapa
35
+ F->>M6: 4) POST /api/v1/auth/sso-exchange { ticket }
36
+ M6->>Core: 5) POST /auth/sso-exchange { ticket }
37
+ Core-->>M6: { user (con roles[]), token (RS256, descartado) }
38
+ M6-->>F: { token (HS256 propio), user, rol }
39
+ Note over F: 6) Guarda el token, navega a redirect
40
+ F->>M6: 7) GET /api/v1/camas (Authorization: Bearer <token M6>)
41
+ ```
42
+
43
+ 1. El usuario ya está autenticado en el Core (o en otro módulo que comparte el Core).
44
+ 2. Alguien pide un ticket de un solo uso: `POST /auth/sso-ticket` en el Core (vida ~60 s, ver `M10_SSO_INTEGRATION_GUIDE.md`).
45
+ 3. El navegador llega al frontend de M6 con `?ticket=…&redirect=…`.
46
+ 4. El **frontend de M6** canjea ese ticket contra **el backend de M6** — no contra el Core directamente. Esto es lo que distingue a M6 de la guía genérica del Core: M6 actúa de proxy del canje.
47
+ 5. El backend de M6 hace el canje real contra el Core, server-to-server.
48
+ 6. El backend de M6 resuelve el rol y emite su propio JWT.
49
+ 7. El frontend guarda ese JWT y lo usa en todas las llamadas siguientes.
50
+
51
+ ---
52
+
53
+ ## 3. Contrato: `POST /api/v1/auth/sso-exchange`
54
+
55
+ Implementado en `app/routers/auth.py`. Habilitado solo si `SSO_ENABLED=true` en el backend.
56
+
57
+ **Request**
58
+
59
+ ```json
60
+ { "ticket": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b" }
61
+ ```
62
+
63
+ `ticket`: string no vacío. Es el mismo ticket recibido en la query del callback.
64
+
65
+ **Response `200`**
66
+
67
+ ```json
68
+ {
69
+ "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
70
+ "user": {
71
+ "id": 42,
72
+ "first_name": "Ana",
73
+ "last_name": "Pérez",
74
+ "email": "ana@example.com"
75
+ },
76
+ "rol": "ADMINISTRATIVO"
77
+ }
78
+ ```
79
+
80
+ - `token`: JWT **HS256 de M6** (no el del Core). Es lo único que el frontend necesita guardar y reenviar.
81
+ - `user`: subconjunto de datos del usuario, para mostrar en la UI (no hace falta pedir nada más al Core).
82
+ - `rol`: uno de `ADMINISTRATIVO` | `MEDICO` | `LIMPIEZA` — el rol interno de M6 ya resuelto (ver §5).
83
+
84
+ **Errores**
85
+
86
+ | Código | Cuándo | Qué hacer en el frontend |
87
+ |---|---|---|
88
+ | `401` | Ticket inválido, ya usado o expirado (`NO_AUTENTICADO`) | Volver a iniciar el flujo desde el módulo de origen (pedir un ticket nuevo) |
89
+ | `403` | El usuario no tiene ningún rol de Core mapeado a M6 (`NO_AUTORIZADO`) | Mostrar "sin acceso a este módulo"; no reintentar |
90
+ | `404` | SSO deshabilitado en este backend (`SSO_ENABLED=false`) | Error de configuración/entorno, no del usuario |
91
+ | `502` | El Core no respondió al canje (`SERVICIO_EXTERNO_NO_DISPONIBLE`) | Reintentar más tarde / mostrar error de servicio |
92
+
93
+ El body de error va anidado bajo `detail` (comportamiento por defecto de FastAPI ante un `HTTPException`):
94
+
95
+ ```json
96
+ { "detail": { "codigo": "NO_AUTENTICADO", "mensaje": "Ticket inválido, ya usado o expirado" } }
97
+ ```
98
+
99
+ ---
100
+
101
+ ## 4. Cómo persiste la sesión
102
+
103
+ **M6 es completamente stateless.** No hay tabla de sesiones, no hay store en memoria ni en base de datos, no hay cookie que el backend administre. La "sesión" es, literalmente, el JWT que tiene el cliente.
104
+
105
+ - **Dónde vive:** en el cliente. El backend no lo sabe ni le importa — puede ser `localStorage` o una cookie propia del frontend, a criterio de ese equipo (igual que recomienda `M10_SSO_INTEGRATION_GUIDE.md` para SPAs).
106
+ - **Cómo se valida cada request:** `get_current_user` (`app/dependencies.py`) hace `decode_token` — verifica la firma HS256 contra `jwt_secret` y lee `sub` + `rol` directo del payload. **Cero llamadas al Core, cero lookups, cero estado compartido.** Por eso el rol tiene que viajar embebido en el token (ver §5): si hubiera que resolverlo aparte, dejaría de ser stateless.
107
+ - **Vigencia:** `JWT_EXPIRE_MINUTES` (hoy 60 min en `.env`). Ojo: el token del Core dura 24 h, pero eso es irrelevante una vez canjeado — la sesión de M6 dura lo que este valor diga.
108
+ - **Al vencer:** no hay endpoint de refresh en M6 hoy. El frontend debe manejar el `401` de un request cualquiera repitiendo el flujo SSO desde cero (nuevo ticket → nuevo canje). Si se necesita sesión más larga, es cuestión de subir `JWT_EXPIRE_MINUTES`; un refresh sin volver a pasar por SSO sería trabajo nuevo (no implementado).
109
+
110
+ ---
111
+
112
+ ## 5. De dónde sale el rol
113
+
114
+ El JWT del Core **no** trae el nombre del rol — sus claims son `{user_id, permissions[], iat, exp}`, y esos `permissions[]` son de recursos propios del Core, no de M6.
115
+
116
+ El rol se resuelve **una sola vez, en el canje**, a partir de `user.roles[]` de la respuesta de `/auth/sso-exchange` del Core (cada rol con su `name`). `app/integrations/core_auth.py::map_core_roles_to_internal` lo traduce con esta tabla:
117
+
118
+ | Rol en el Core | Rol interno de M6 |
119
+ |---|---|
120
+ | `admin_internacion` | `ADMINISTRATIVO` |
121
+ | `Medico` | `MEDICO` |
122
+ | `limpieza` | `LIMPIEZA` |
123
+ | `admin` (super-admin del Core) | `ADMINISTRATIVO` |
124
+ | cualquier otro / ninguno | sin acceso → `403` en el canje |
125
+
126
+ Una vez resuelto, el rol queda embebido en el JWT de M6 (`create_access_token(sub, rol)`) y no se vuelve a consultar. `require_roles(*roles)` (`app/dependencies.py`) es lo que cada endpoint usa para autorizar, comparando ese campo — ver matriz completa en `roles.md`.
127
+
128
+ ---
129
+
130
+ ## 6. Guía de implementación para el frontend
131
+
132
+ Lo que el equipo de frontend tiene que construir, en orden:
133
+
134
+ ### 6.1 Ruta de callback `/auth/sso`
135
+
136
+ Una ruta pública del router del SPA (no protegida) que reciba `ticket` y `redirect` por query string:
137
+
138
+ ```
139
+ https://<host-frontend-m6>/auth/sso?ticket=<opaco>&redirect=/mapa-camas
140
+ ```
141
+
142
+ ### 6.2 Validar el `redirect` (anti-open-redirect)
143
+
144
+ Antes de navegar ahí, aceptar **solo** rutas internas absolutas. Mismo criterio que `M10_SSO_INTEGRATION_GUIDE.md`:
145
+
146
+ ```ts
147
+ function safeRedirect(path: string | null): string | null {
148
+ if (!path) return null;
149
+ if (!path.startsWith('/') || path.startsWith('//') || path.startsWith('/\\')) return null;
150
+ return path;
151
+ }
152
+ ```
153
+
154
+ ### 6.3 Canjear el ticket contra **M6**, no contra el Core
155
+
156
+ Esta es la diferencia clave frente a la guía genérica: el canje va al backend de M6, que a su vez habla con el Core.
157
+
158
+ ```ts
159
+ async function exchangeSSOTicket(ticket: string) {
160
+ const res = await fetch(`${M6_API_BASE}/api/v1/auth/sso-exchange`, {
161
+ method: 'POST',
162
+ headers: { 'Content-Type': 'application/json' },
163
+ body: JSON.stringify({ ticket }),
164
+ });
165
+
166
+ if (!res.ok) {
167
+ if (res.status === 401) throw new Error('Ticket inválido o expirado — reiniciar el login');
168
+ if (res.status === 403) throw new Error('El usuario no tiene acceso a este módulo');
169
+ throw new Error('No se pudo iniciar sesión en M6');
170
+ }
171
+
172
+ return res.json(); // { token, user, rol }
173
+ }
174
+ ```
175
+
176
+ ### 6.4 Guardar la sesión y limpiar la URL
177
+
178
+ ```ts
179
+ const { token, user, rol } = await exchangeSSOTicket(ticket);
180
+ saveSession({ token, user, rol }); // localStorage o cookie propia
181
+ history.replaceState(null, '', location.pathname); // el ticket no debe quedar en el historial
182
+ navigate(safeRedirect(redirect) ?? '/');
183
+ ```
184
+
185
+ ### 6.5 Mandar el token en cada request a M6
186
+
187
+ ```ts
188
+ fetch(`${M6_API_BASE}/api/v1/camas`, {
189
+ headers: { Authorization: `Bearer ${getSessionToken()}` },
190
+ });
191
+ ```
192
+
193
+ ### 6.6 Manejar el vencimiento
194
+
195
+ Un interceptor de respuesta que, ante cualquier `401` de M6, limpie la sesión local y redirija a iniciar el flujo SSO de nuevo (no hay refresh):
196
+
197
+ ```ts
198
+ if (response.status === 401) {
199
+ clearSession();
200
+ redirectToLogin(); // vuelve a pedir ticket desde el origen
201
+ }
202
+ ```
203
+
204
+ ### 6.7 Checklist
205
+
206
+ - [ ] Ruta `/auth/sso?ticket=&redirect=` en el router del SPA.
207
+ - [ ] `redirect` validado como ruta interna antes de navegar.
208
+ - [ ] Canje contra `POST {M6_API_BASE}/api/v1/auth/sso-exchange` (no contra el Core).
209
+ - [ ] Ticket limpiado de la URL después del canje (`replaceState`/`replaceUrl`).
210
+ - [ ] Token guardado y enviado como `Authorization: Bearer` en toda llamada a M6.
211
+ - [ ] Manejo de `401`/`403`/`404`/`502` de la respuesta del canje.
212
+ - [ ] Interceptor de `401` en requests posteriores → reinicia SSO.
213
+
214
+ ---
215
+
216
+ ## 7. Desarrollo local sin el Core real
217
+
218
+ Para no depender de que el Core esté arriba, M6 expone `GET /api/v1/auth/token?usuario=&password=` (habilitado solo con `ENVIRONMENT=development`), que devuelve un JWT de M6 del mismo formato que emite el canje SSO — mismo `decode_token`, misma validación. `usuario` es en realidad el rol deseado (`ADMINISTRATIVO` | `MEDICO` | `LIMPIEZA`); `password` no se valida. Útil para levantar y probar el frontend contra M6 sin tocar el Core.
219
+
220
+ ---
221
+
222
+ ## 8. Referencias
223
+
224
+ - [`M10_SSO_INTEGRATION_GUIDE.md`](M10_SSO_INTEGRATION_GUIDE.md) — contrato genérico del SSO del Core (ticket, JWKS, ejemplos Angular/React/Go/Node).
225
+ - [`M6_DISEÑO.md`](M6_DISEÑO.md) §11 — detalle técnico de la integración de auth en M6.
226
+ - [`roles.md`](roles.md) §6 — mapeo de roles del Core a roles internos de M6 y matriz de permisos por endpoint.
227
+ - [`M6_openapi.json`](M6_openapi.json) — contrato exacto de `/auth/sso-exchange` (schemas `SSOExchangeRequest`/`SSOExchangeResponse`).
documentation/M6_DISEÑO.md CHANGED
@@ -330,12 +330,13 @@ Tablas principales en PostgreSQL (Supabase): `camas` (incluye quirófanos), `res
330
 
331
  ## 11. Seguridad
332
 
333
- Autenticación centralizada en Core (M10), integrada (no mockeada). `app/config.py::auth_mode` conmuta entre dos modos:
334
 
335
- - **`mock`** (default): M6 firma y valida sus propios JWT HS256 (`app/dependencies.py::create_access_token`/`decode_token`), con un claim `rol` directo. Es el comportamiento histórico, usado en dev/tests sin depender del Core.
336
- - **`core`**: el JWT lo emite el Core real (`https://api.healthcare.cantero.ar` en el entorno compartido). Verificado en vivo: el Core firma con **RS256** y publica sus claves en `GET /.well-known/jwks.json`; el payload del token es `{exp, iat, permissions[], user_id}` — **no lleva `iss`/`aud` ni el nombre del rol**. `app/integrations/core_auth.py::verify_core_token` valida la firma localmente contra el JWKS cacheado (`get_signing_key`, TTL `jwks_cache_ttl_seconds`), sin round-trip a `/auth/validate` por request (ese endpoint solo devuelve `{user_id, valid}`, no roles).
 
337
 
338
- **Resolución de rol (el token no lo trae):** `core_auth.resolve_user_roles(user_id)` consulta `GET /roles` con la cuenta de servicio de M6 (`core_service_email`/`core_service_password`), arma un índice `user_id → [nombres de rol de Core]` cacheado (TTL `core_roles_cache_ttl_seconds`), y `core_auth.map_core_roles_to_internal` lo traduce al rol interno de M6 vía la tabla `CORE_ROLE_TO_INTERNAL`:
339
 
340
  | Rol Core | Rol interno M6 |
341
  |---|---|
@@ -343,15 +344,16 @@ Autenticación centralizada en Core (M10), integrada (no mockeada). `app/config.
343
  | `Medico` | `MEDICO` |
344
  | `limpieza` | `LIMPIEZA` |
345
  | `admin` | `ADMINISTRATIVO` (super-admin del Core) |
346
- | cualquier otro | sin acceso a M6 → `403` |
347
 
348
- Este mecanismo (lookup de `/roles` cacheado, no `GET /users/{id}`) se eligió porque la cuenta de servicio de M6 hoy solo tiene el permiso `roles:read` en el Core compartido, no `users:read`. `get_current_user` (`app/dependencies.py`) devuelve la misma forma `{"sub", "rol"}` en ambos modos, así que `require_roles`, la auditoría y los routers no distinguen modo.
349
 
350
- **Llamadas salientes:** la misma cuenta de servicio (`core_auth.get_service_token`) autentica las llamadas de M6 a M1/M2/M7/M10 (adjuntado automático en `app/integrations/_base.py::_headers`), incluidas las disparadas por webhooks entrantes donde no hay usuario humano.
351
 
352
  **Fuera de alcance de esta integración:**
353
- - Permisos granulares (`camas:read`, etc.) — el Core no expone `permissions:manage` a la cuenta de servicio hoy; migrar `require_roles` a permisos cuando eso cambie.
354
  - Autenticación de webhooks entrantes (`/webhooks/*` sigue exigiendo JWT de usuario) — pendiente acordar secreto compartido/firma con el Bus de Eventos.
 
355
 
356
  ---
357
 
@@ -426,3 +428,9 @@ Este mecanismo (lookup de `/roles` cacheado, no `GET /users/{id}`) se eligió po
426
  23. **Filtro de quirófanos por hospital y por estado operable.** El algoritmo original no filtraba por `hospital_id` (podía asignar una urgencia a un quirófano de otra sede) ni excluía quirófanos `EN_LIMPIEZA` (además de los ya excluidos `FUERA_DE_SERVICIO`/`BAJA_PERMANENTE`). Corregido en `crear_reserva_urgente`.
427
  24. **Bug de persistencia corregido.** `reserva_crud.save` solo persistía `estado`/`observaciones`/`desplazada_por_reserva_id`; el nuevo horario de una reserva reprogramada nunca se guardaba en la tabla `reservas_quirofano` de M6 (solo se notificaba a M2). Ahora `save` también persiste `fecha_hora_inicio`/`fecha_hora_fin_estimada`.
428
  25. **Seam `reprogramar()`.** Se introdujo `cama_service.reprogramar(db, reserva, no_antes_de, motivo)` como interfaz estable que consume el algoritmo de urgencia para reubicar una reserva desplazada. La implementación actual es mínima (evita solapar horarios en el mismo quirófano) — el diseño completo (cascada, cambio de quirófano) queda pendiente como tarea siguiente.
 
 
 
 
 
 
 
330
 
331
  ## 11. Seguridad
332
 
333
+ Login centralizado en el Core (M10) vía **SSO**, integrado (no mockeado). La sesión de M6 es **siempre** un JWT HS256 propio (`app/dependencies.py::create_access_token`/`decode_token`), con un claim `rol` directo — no hay un modo de validación distinto por-request. Lo que agrega el Core es la forma de *adquirir* ese token:
334
 
335
+ - El frontend obtiene del Core un **ticket** de un solo uso (`POST /auth/sso-ticket`, requiere que el usuario ya esté logueado en el Core) y llega a M6 con ese ticket.
336
+ - M6 lo canjea server-to-server: `POST /api/v1/auth/sso-exchange` (`app/routers/auth.py`, habilitado con `settings.sso_enabled`) llama a `core_auth.exchange_sso_ticket`, que hace `POST /auth/sso-exchange` contra el Core (`https://api.healthcare.cantero.ar` en el entorno compartido) y recibe `{user, token}` (`models.AuthResponse`). El `token` del Core (RS256, `{exp, iat, permissions[], user_id}`) **no se reenvía ni se guarda** — solo se usa `user` para resolver el rol.
337
+ - El callback del browser (`/auth/sso?ticket=…&redirect=…`) y la validación anti-open-redirect del `redirect` son responsabilidad del **frontend** — fuera de este backend.
338
 
339
+ **Resolución de rol (viene en el canje, no en el JWT):** `user.roles[]` de la respuesta (`models.User.roles`, cada uno con `name`) trae el/los rol(es) del usuario en el Core. `core_auth.map_core_roles_to_internal` los traduce al rol interno de M6 vía la tabla `CORE_ROLE_TO_INTERNAL`:
340
 
341
  | Rol Core | Rol interno M6 |
342
  |---|---|
 
344
  | `Medico` | `MEDICO` |
345
  | `limpieza` | `LIMPIEZA` |
346
  | `admin` | `ADMINISTRATIVO` (super-admin del Core) |
347
+ | cualquier otro / ninguno | sin acceso a M6 → `403` en el canje |
348
 
349
+ No hay lookup aparte (`GET /roles`, `GET /users/{id}`) ni verificación de JWT del Core por-request: todo se resuelve **una sola vez**, en el canje. M6 emite entonces su propio JWT HS256 (`create_access_token(sub=str(user_id), rol=rol)`) y lo devuelve junto con el rol y los datos básicos del usuario. `get_current_user` (`app/dependencies.py`) valida ese token localmente en cada request — misma forma `{"sub", "rol"}` de siempre; `require_roles`, la auditoría y los routers no cambiaron.
350
 
351
+ **Llamadas salientes:** una cuenta de servicio propia (`core_auth.get_service_token`, login contra `POST /auth/login` del Core) autentica las llamadas de M6 a M1/M2/M7/M10 (adjuntado automático en `app/integrations/_base.py::_headers`), incluidas las disparadas por webhooks entrantes donde no hay usuario humano. Es independiente del flujo SSO — se habilita con `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD`.
352
 
353
  **Fuera de alcance de esta integración:**
354
+ - Permisos granulares (`camas:read`, etc.) — el Core no expone `permissions:manage` a la cuenta de servicio hoy, ni tiene permisos de dominio M6 en su catálogo; migrar `require_roles` a permisos cuando eso cambie.
355
  - Autenticación de webhooks entrantes (`/webhooks/*` sigue exigiendo JWT de usuario) — pendiente acordar secreto compartido/firma con el Bus de Eventos.
356
+ - Refresh de sesión: al vencer el JWT de M6, el usuario vuelve a pasar por SSO.
357
 
358
  ---
359
 
 
428
  23. **Filtro de quirófanos por hospital y por estado operable.** El algoritmo original no filtraba por `hospital_id` (podía asignar una urgencia a un quirófano de otra sede) ni excluía quirófanos `EN_LIMPIEZA` (además de los ya excluidos `FUERA_DE_SERVICIO`/`BAJA_PERMANENTE`). Corregido en `crear_reserva_urgente`.
429
  24. **Bug de persistencia corregido.** `reserva_crud.save` solo persistía `estado`/`observaciones`/`desplazada_por_reserva_id`; el nuevo horario de una reserva reprogramada nunca se guardaba en la tabla `reservas_quirofano` de M6 (solo se notificaba a M2). Ahora `save` también persiste `fecha_hora_inicio`/`fecha_hora_fin_estimada`.
430
  25. **Seam `reprogramar()`.** Se introdujo `cama_service.reprogramar(db, reserva, no_antes_de, motivo)` como interfaz estable que consume el algoritmo de urgencia para reubicar una reserva desplazada. La implementación actual es mínima (evita solapar horarios en el mismo quirófano) — el diseño completo (cascada, cambio de quirófano) queda pendiente como tarea siguiente.
431
+
432
+ ### 14.5 SSO del Core y eliminación del lookup de roles (2026-07)
433
+
434
+ 26. **Nuevo endpoint `POST /auth/sso-exchange`.** Canjea un ticket SSO de un solo uso del Core (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) por una sesión propia de M6: JWT HS256 con el rol ya resuelto. Request `{ticket}`; response `{token, user, rol}`; errores `401` (ticket inválido/usado/expirado), `403` (roles del usuario sin mapeo a M6), `404` (SSO deshabilitado), `502` (Core inalcanzable). Actualizar `M6_openapi.json` con este endpoint.
435
+ 27. **Eliminado el lookup `GET /roles` y la verificación de JWT del Core por-request.** El rol ya no se resuelve con una llamada aparte cacheada: viene directo en `user.roles[]` de la respuesta del canje SSO (`models.AuthResponse` → `models.User` → `models.Role`). Se retiraron `core_auth.resolve_user_roles`, `_fetch_roles_index`, `verify_core_token`, `get_signing_key` y sus caches (`_roles_index_cache`, `_jwks_cache`); con ellos, las settings `jwks_cache_ttl_seconds`/`core_roles_cache_ttl_seconds`. Se conserva `map_core_roles_to_internal` (§11), que ahora traduce `user.roles[].name` en vez de un índice cacheado.
436
+ 28. **`app/config.py::auth_mode` reemplazado por `sso_enabled`.** Ya no existe un modo de validación por-request alternativo — la sesión de M6 es siempre HS256 propia. `sso_enabled` (default `False`) solo habilita/deshabilita el endpoint de canje.
documentation/M6_openapi.json CHANGED
@@ -12,6 +12,9 @@
12
  }
13
  },
14
  "tags": [
 
 
 
15
  {
16
  "name": "Camas"
17
  },
@@ -4747,6 +4750,109 @@
4747
  },
4748
  "security": []
4749
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4750
  }
4751
  },
4752
  "components": {
@@ -6104,6 +6210,74 @@
6104
  }
6105
  }
6106
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6107
  }
6108
  },
6109
  "responses": {
 
12
  }
13
  },
14
  "tags": [
15
+ {
16
+ "name": "Auth"
17
+ },
18
  {
19
  "name": "Camas"
20
  },
 
4750
  },
4751
  "security": []
4752
  }
4753
+ },
4754
+ "/auth/sso-exchange": {
4755
+ "post": {
4756
+ "summary": "Canjear un ticket SSO del Core por una sesión de M6",
4757
+ "deprecated": false,
4758
+ "description": "Canjea, servidor-a-servidor, un ticket SSO de un solo uso emitido por el Core (M10) contra `POST /auth/sso-exchange` del Core, y devuelve una sesión propia de M6: un JWT HS256 con el rol ya resuelto a partir de `user.roles[]` de la respuesta del Core — no el JWT del Core.\n\nEl rol se traduce con la tabla `CORE_ROLE_TO_INTERNAL` (`admin_internacion`→`ADMINISTRATIVO`, `Medico`→`MEDICO`, `limpieza`→`LIMPIEZA`, `admin`→`ADMINISTRATIVO`). Si ninguno de los roles del usuario mapea, devuelve `403` — el canje no otorga acceso a un usuario sin rol habilitado en M6.\n\nDeshabilitado (`404`) si `SSO_ENABLED=false`.\n\n> El callback del navegador (`/auth/sso?ticket=…&redirect=…`) y la validación anti-open-redirect del `redirect` son responsabilidad del frontend, no de este endpoint.",
4759
+ "operationId": "ssoExchange",
4760
+ "tags": [
4761
+ "Auth"
4762
+ ],
4763
+ "requestBody": {
4764
+ "content": {
4765
+ "application/json": {
4766
+ "schema": {
4767
+ "$ref": "#/components/schemas/SSOExchangeRequest"
4768
+ },
4769
+ "example": {
4770
+ "ticket": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b"
4771
+ }
4772
+ }
4773
+ },
4774
+ "required": true
4775
+ },
4776
+ "responses": {
4777
+ "200": {
4778
+ "description": "Ticket canjeado; sesión de M6 emitida",
4779
+ "content": {
4780
+ "application/json": {
4781
+ "schema": {
4782
+ "$ref": "#/components/schemas/SSOExchangeResponse"
4783
+ },
4784
+ "example": {
4785
+ "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
4786
+ "user": {
4787
+ "id": 42,
4788
+ "first_name": "Ana",
4789
+ "last_name": "Pérez",
4790
+ "email": "ana@example.com"
4791
+ },
4792
+ "rol": "ADMINISTRATIVO"
4793
+ }
4794
+ }
4795
+ }
4796
+ },
4797
+ "401": {
4798
+ "description": "Ticket inválido, ya usado o expirado",
4799
+ "content": {
4800
+ "application/json": {
4801
+ "schema": {
4802
+ "$ref": "#/components/schemas/Error"
4803
+ },
4804
+ "example": {
4805
+ "codigo": "NO_AUTENTICADO",
4806
+ "mensaje": "Ticket inválido, ya usado o expirado"
4807
+ }
4808
+ }
4809
+ }
4810
+ },
4811
+ "403": {
4812
+ "description": "Los roles del usuario en el Core no mapean a ningún rol de M6",
4813
+ "content": {
4814
+ "application/json": {
4815
+ "schema": {
4816
+ "$ref": "#/components/schemas/Error"
4817
+ },
4818
+ "example": {
4819
+ "codigo": "NO_AUTORIZADO",
4820
+ "mensaje": "El usuario no tiene un rol habilitado en M6"
4821
+ }
4822
+ }
4823
+ }
4824
+ },
4825
+ "404": {
4826
+ "description": "SSO deshabilitado (SSO_ENABLED=false)",
4827
+ "content": {
4828
+ "application/json": {
4829
+ "schema": {
4830
+ "$ref": "#/components/schemas/Error"
4831
+ },
4832
+ "example": {
4833
+ "codigo": "RECURSO_NO_ENCONTRADO",
4834
+ "mensaje": "Not Found"
4835
+ }
4836
+ }
4837
+ }
4838
+ },
4839
+ "502": {
4840
+ "description": "El Core no respondió al canje",
4841
+ "content": {
4842
+ "application/json": {
4843
+ "schema": {
4844
+ "$ref": "#/components/schemas/Error"
4845
+ },
4846
+ "example": {
4847
+ "codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE",
4848
+ "mensaje": "No se pudo canjear el ticket contra el Core (M10)"
4849
+ }
4850
+ }
4851
+ }
4852
+ }
4853
+ },
4854
+ "security": []
4855
+ }
4856
  }
4857
  },
4858
  "components": {
 
6210
  }
6211
  }
6212
  }
6213
+ },
6214
+ "SSOExchangeRequest": {
6215
+ "type": "object",
6216
+ "required": [
6217
+ "ticket"
6218
+ ],
6219
+ "properties": {
6220
+ "ticket": {
6221
+ "type": "string",
6222
+ "description": "Ticket SSO de un solo uso emitido por el Core (POST /auth/sso-ticket).",
6223
+ "example": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b"
6224
+ }
6225
+ }
6226
+ },
6227
+ "SSOUser": {
6228
+ "type": "object",
6229
+ "required": [
6230
+ "id",
6231
+ "first_name",
6232
+ "last_name",
6233
+ "email"
6234
+ ],
6235
+ "properties": {
6236
+ "id": {
6237
+ "type": "integer",
6238
+ "example": 42
6239
+ },
6240
+ "first_name": {
6241
+ "type": "string",
6242
+ "example": "Ana"
6243
+ },
6244
+ "last_name": {
6245
+ "type": "string",
6246
+ "example": "Pérez"
6247
+ },
6248
+ "email": {
6249
+ "type": "string",
6250
+ "example": "ana@example.com"
6251
+ }
6252
+ }
6253
+ },
6254
+ "SSOExchangeResponse": {
6255
+ "type": "object",
6256
+ "required": [
6257
+ "token",
6258
+ "user",
6259
+ "rol"
6260
+ ],
6261
+ "properties": {
6262
+ "token": {
6263
+ "type": "string",
6264
+ "description": "JWT HS256 propio de M6 (no el JWT del Core). Usar en Authorization: Bearer.",
6265
+ "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
6266
+ },
6267
+ "user": {
6268
+ "$ref": "#/components/schemas/SSOUser"
6269
+ },
6270
+ "rol": {
6271
+ "type": "string",
6272
+ "enum": [
6273
+ "ADMINISTRATIVO",
6274
+ "MEDICO",
6275
+ "LIMPIEZA"
6276
+ ],
6277
+ "description": "Rol interno de M6, resuelto a partir de los roles del usuario en el Core.",
6278
+ "example": "ADMINISTRATIVO"
6279
+ }
6280
+ }
6281
  }
6282
  },
6283
  "responses": {
documentation/roles.md CHANGED
@@ -104,20 +104,20 @@ Los endpoints bajo `/webhooks/*` (recepción de eventos de M1 HCE, M9 Monitoreo,
104
 
105
  ## 5. Testing
106
 
107
- Los tests de autorización por rol viven junto a los tests de cada router (`tests/test_camas.py`, `tests/test_quirofanos.py`, `tests/test_solicitudes.py`, `tests/test_auditoria.py`), usando los fixtures `admin_headers`, `medico_headers`, `limpieza_headers` de `tests/conftest.py` (modo mock, HS256). El flujo de integración real con el Core (verificación JWKS, resolución y mapeo de rol) tiene su propia suite en `tests/test_core_auth.py`. Cada endpoint restringido tiene al menos un test que verifica `403` para el/los rol(es) sin permiso, y un test de happy path para el rol permitido.
108
 
109
  ---
110
 
111
- ## 6. Integración con el Core (M10)
112
 
113
- La integración con el Core real ya está implementada, detrás del flag `AUTH_MODE` (`app/config.py`) — `mock` (default) mantiene el JWT propio descripto en este documento; `core` valida contra el Core. Detalle técnico completo en `M6_DISEÑO.md §11`; resumen:
114
 
115
- - El JWT del Core (verificado en vivo contra `https://api.healthcare.cantero.ar`) **no transporta un campo `rol` ni `permissions` utilizables como rol** — el payload es `{exp, iat, permissions[], user_id}`, y `permissions[]` son strings de otro dominio (ej. `events:log:publish`), no permisos de M6. El rol se resuelve con una llamada aparte a `GET /roles` (`app/integrations/core_auth.py::resolve_user_roles`), cacheada.
116
- - Mapeo Core → M6 (`CORE_ROLE_TO_INTERNAL` en `core_auth.py`): roles de Core `admin_internacion` → `ADMINISTRATIVO`, `Medico` → `MEDICO`, `limpieza` → `LIMPIEZA`, `admin` → `ADMINISTRATIVO`. Estos tres roles de M6 (`admin_internacion`, `limpieza`, más el ya existente `Medico`) se dieron de alta en el Core compartido vía `POST /roles`.
117
- - `require_roles`, la capa de servicio y la auditoría no cambiaron — `get_current_user` devuelve la misma forma `{"sub", "rol"}` en ambos modos.
 
118
 
119
  ### Fuera de alcance / pendiente
120
 
121
- - **Permisos granulares vía Core.** El Core no expone `permissions:manage` a la cuenta de servicio de M6 hoy (`POST /permissions` → `403`), así que no se pueden dar de alta permisos propios de M6 (`camas:read`, etc.). Migrar `require_roles` a un modelo de permisos queda pendiente de esa habilitación.
122
- - **Lookup de rol más fresco (`GET /users/{id}`).** El mecanismo actual (`GET /roles` cacheado, TTL `core_roles_cache_ttl_seconds`) trae el padrón completo y un usuario recién asignado a un rol tarda hasta el TTL en verse. `GET /users/{id}` sería más directo pero requiere el permiso `users:read`, no otorgado hoy a la cuenta de servicio.
123
  - **Autenticación de webhooks entrantes.** Hoy no hay verificación de origen en `/webhooks/*` más allá de lo que ya documente cada integración puntual — siguen exigiendo un JWT de usuario, que los emisores reales (M1/M9/M2) no tienen. Pendiente acordar mecanismo (secreto compartido o firma) con el Bus de Eventos de Core.
 
104
 
105
  ## 5. Testing
106
 
107
+ Los tests de autorización por rol viven junto a los tests de cada router (`tests/test_camas.py`, `tests/test_quirofanos.py`, `tests/test_solicitudes.py`, `tests/test_auditoria.py`), usando los fixtures `admin_headers`, `medico_headers`, `limpieza_headers` de `tests/conftest.py`. El mapeo de rol de Core → M6 tiene su propia suite en `tests/test_core_auth.py`; el flujo completo de canje SSO, en `tests/test_sso.py`. Cada endpoint restringido tiene al menos un test que verifica `403` para el/los rol(es) sin permiso, y un test de happy path para el rol permitido.
108
 
109
  ---
110
 
111
+ ## 6. Integración con el Core (M10): SSO
112
 
113
+ La sesión de M6 es **siempre** un JWT HS256 propio (`app/dependencies.py::create_access_token`/`decode_token`). Lo que agrega la integración con el Core es una forma de *adquirirlo*: `POST /api/v1/auth/sso-exchange` (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) canjea un ticket de un solo uso emitido por el Core (`POST /auth/sso-ticket` en el Core) contra `POST /auth/sso-exchange` del Core, y devuelve un JWT de M6 con el rol ya resuelto. No hay verificación de JWT del Core por-request ni lookup aparte de roles — el Core se toca una sola vez, en el canje. Detalle técnico completo en `M6_DISEÑO.md §11`; resumen:
114
 
115
+ - La respuesta del canje (`models.AuthResponse` del Core) trae `user.roles[]` — cada rol con su `name`. De ahí sale el rol del usuario, **sin** `GET /roles` ni `GET /users/{id}`.
116
+ - Mapeo Core → M6 (`CORE_ROLE_TO_INTERNAL` en `core_auth.py::map_core_roles_to_internal`): roles de Core `admin_internacion` → `ADMINISTRATIVO`, `Medico` → `MEDICO`, `limpieza` → `LIMPIEZA`, `admin` → `ADMINISTRATIVO`. Si ninguno de los roles del usuario mapea, el canje devuelve `403` (no entra a M6).
117
+ - `require_roles`, la capa de servicio y la auditoría no cambiaron — siguen leyendo `payload["rol"]` del JWT de M6, sin distinguir si la sesión se originó por SSO o por el endpoint de desarrollo (`/api/v1/auth/token`).
118
+ - El callback del browser (`/auth/sso?ticket=…&redirect=…`) y la validación anti-open-redirect del `redirect` son responsabilidad del **frontend**, no de este backend.
119
 
120
  ### Fuera de alcance / pendiente
121
 
122
+ - **Permisos granulares vía Core.** El Core no expone `permissions:manage` a la cuenta de servicio de M6 hoy, y no tiene permisos de dominio M6 (`camas:read`, etc.) en su catálogo. Migrar `require_roles` a un modelo de permisos queda pendiente de esa habilitación.
 
123
  - **Autenticación de webhooks entrantes.** Hoy no hay verificación de origen en `/webhooks/*` más allá de lo que ya documente cada integración puntual — siguen exigiendo un JWT de usuario, que los emisores reales (M1/M9/M2) no tienen. Pendiente acordar mecanismo (secreto compartido o firma) con el Bus de Eventos de Core.
tests/test_core_auth.py CHANGED
@@ -1,156 +1,17 @@
1
  """
2
- Tests de la integración de autenticación con el Core (M10): verificación de
3
- JWT vía JWKS, resolución/mapeo de rol y el flujo completo de
4
- `get_current_user` bajo `auth_mode="core"`.
5
-
6
- No golpean el Core real: se stubea la fuente de datos (fetch de JWKS y de
7
- `GET /roles`), pero la verificación de firma RS256 corre de punta a punta
8
- contra un keypair de test — no se mockea `verify_core_token` en sí.
9
-
10
- Los tests de modo mock (`admin_headers`/`medico_headers`/`limpieza_headers`
11
- en `conftest.py`) siguen intactos y cubren el comportamiento HS256 actual;
12
- este módulo cubre exclusivamente el camino nuevo introducido por la
13
- integración con Core.
14
  """
15
- import time
16
-
17
  import pytest
18
- from cryptography.hazmat.primitives import serialization
19
- from cryptography.hazmat.primitives.asymmetric import rsa
20
- from fastapi import HTTPException
21
- from jose import jwk
22
- from jose import jwt as jose_jwt
23
 
24
- from app.config import settings
25
- from app.dependencies import _get_current_user_core
26
  from app.integrations import core_auth
27
 
28
- _TEST_KID = "test-kid-1"
29
-
30
-
31
- @pytest.fixture(scope="module")
32
- def rsa_keypair():
33
- private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
34
- private_pem = private_key.private_bytes(
35
- encoding=serialization.Encoding.PEM,
36
- format=serialization.PrivateFormat.PKCS8,
37
- encryption_algorithm=serialization.NoEncryption(),
38
- ).decode()
39
- public_pem = (
40
- private_key.public_key()
41
- .public_bytes(
42
- encoding=serialization.Encoding.PEM,
43
- format=serialization.PublicFormat.SubjectPublicKeyInfo,
44
- )
45
- .decode()
46
- )
47
- return private_pem, public_pem
48
-
49
-
50
- def _make_token(private_pem: str, user_id: int, permissions=None, exp_delta=3600, kid=_TEST_KID):
51
- now = int(time.time())
52
- payload = {
53
- "user_id": user_id,
54
- "iat": now,
55
- "exp": now + exp_delta,
56
- "permissions": permissions or [],
57
- }
58
- return jose_jwt.encode(payload, private_pem, algorithm="RS256", headers={"kid": kid})
59
-
60
-
61
- def _stub_jwks(monkeypatch, public_pem, kid=_TEST_KID):
62
- jwk_dict = jwk.construct(public_pem, algorithm="RS256").to_dict()
63
- jwk_dict["kid"] = kid
64
- monkeypatch.setattr(core_auth, "_fetch_jwks", lambda: {"keys": [jwk_dict]})
65
-
66
-
67
- def _stub_roles(monkeypatch, mapping: dict):
68
- monkeypatch.setattr(core_auth, "_fetch_roles_index", lambda: mapping)
69
-
70
-
71
- @pytest.fixture(autouse=True)
72
- def _reset_core_caches():
73
- """Evita que el cache de un test contamine al siguiente."""
74
- core_auth._jwks_cache["keys_by_kid"] = {}
75
- core_auth._jwks_cache["fetched_at"] = 0.0
76
- core_auth._roles_index_cache["user_id_to_roles"] = {}
77
- core_auth._roles_index_cache["fetched_at"] = 0.0
78
- yield
79
-
80
-
81
- @pytest.fixture
82
- def core_mode(monkeypatch):
83
- monkeypatch.setattr(settings, "auth_mode", "core")
84
-
85
-
86
- # ─── verify_core_token ──────────────────────────────────────────────────────
87
-
88
-
89
- def test_verify_core_token_ok(rsa_keypair, monkeypatch):
90
- private_pem, public_pem = rsa_keypair
91
- _stub_jwks(monkeypatch, public_pem)
92
- token = _make_token(private_pem, user_id=42)
93
-
94
- payload = core_auth.verify_core_token(token)
95
-
96
- assert payload["user_id"] == 42
97
-
98
-
99
- def test_verify_core_token_firma_invalida(rsa_keypair, monkeypatch):
100
- _, public_pem = rsa_keypair
101
- _stub_jwks(monkeypatch, public_pem)
102
- # Firmado con una clave distinta a la publicada en el JWKS stubeado.
103
- otra_private_pem, _ = _make_other_keypair()
104
- token = _make_token(otra_private_pem, user_id=42)
105
-
106
- with pytest.raises(ValueError):
107
- core_auth.verify_core_token(token)
108
-
109
-
110
- def _make_other_keypair():
111
- private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
112
- private_pem = private_key.private_bytes(
113
- encoding=serialization.Encoding.PEM,
114
- format=serialization.PrivateFormat.PKCS8,
115
- encryption_algorithm=serialization.NoEncryption(),
116
- ).decode()
117
- public_pem = (
118
- private_key.public_key()
119
- .public_bytes(
120
- encoding=serialization.Encoding.PEM,
121
- format=serialization.PublicFormat.SubjectPublicKeyInfo,
122
- )
123
- .decode()
124
- )
125
- return private_pem, public_pem
126
-
127
-
128
- def test_verify_core_token_expirado(rsa_keypair, monkeypatch):
129
- private_pem, public_pem = rsa_keypair
130
- _stub_jwks(monkeypatch, public_pem)
131
- token = _make_token(private_pem, user_id=42, exp_delta=-10)
132
-
133
- with pytest.raises(ValueError):
134
- core_auth.verify_core_token(token)
135
-
136
-
137
- def test_verify_core_token_kid_desconocido(rsa_keypair, monkeypatch):
138
- _, public_pem = rsa_keypair
139
- _stub_jwks(monkeypatch, public_pem, kid="otro-kid-publicado")
140
- private_pem, _ = rsa_keypair
141
- token = _make_token(private_pem, user_id=42, kid=_TEST_KID)
142
-
143
- with pytest.raises(ValueError):
144
- core_auth.verify_core_token(token)
145
-
146
-
147
- def test_verify_core_token_malformado():
148
- with pytest.raises(ValueError):
149
- core_auth.verify_core_token("esto-no-es-un-jwt")
150
-
151
-
152
- # ─── map_core_roles_to_internal ─────────────────────────────────────────────
153
-
154
 
155
  @pytest.mark.parametrize(
156
  "role_names,expected",
@@ -168,85 +29,3 @@ def test_verify_core_token_malformado():
168
  )
169
  def test_map_core_roles_to_internal(role_names, expected):
170
  assert core_auth.map_core_roles_to_internal(role_names) == expected
171
-
172
-
173
- # ─── get_current_user (flujo completo, auth_mode="core") ───────────────────
174
-
175
-
176
- def test_get_current_user_core_administrativo(rsa_keypair, monkeypatch, core_mode):
177
- private_pem, public_pem = rsa_keypair
178
- _stub_jwks(monkeypatch, public_pem)
179
- _stub_roles(monkeypatch, {7: ["admin_internacion"]})
180
- token = _make_token(private_pem, user_id=7)
181
-
182
- user = _get_current_user_core(token)
183
-
184
- assert user["sub"] == "7"
185
- assert user["rol"] == "ADMINISTRATIVO"
186
-
187
-
188
- def test_get_current_user_core_medico(rsa_keypair, monkeypatch, core_mode):
189
- private_pem, public_pem = rsa_keypair
190
- _stub_jwks(monkeypatch, public_pem)
191
- _stub_roles(monkeypatch, {9: ["Medico"]})
192
- token = _make_token(private_pem, user_id=9)
193
-
194
- user = _get_current_user_core(token)
195
-
196
- assert user["rol"] == "MEDICO"
197
-
198
-
199
- def test_get_current_user_core_limpieza(rsa_keypair, monkeypatch, core_mode):
200
- private_pem, public_pem = rsa_keypair
201
- _stub_jwks(monkeypatch, public_pem)
202
- _stub_roles(monkeypatch, {8: ["limpieza"]})
203
- token = _make_token(private_pem, user_id=8)
204
-
205
- user = _get_current_user_core(token)
206
-
207
- assert user["rol"] == "LIMPIEZA"
208
-
209
-
210
- def test_get_current_user_core_rol_no_mapeado_403(rsa_keypair, monkeypatch, core_mode):
211
- private_pem, public_pem = rsa_keypair
212
- _stub_jwks(monkeypatch, public_pem)
213
- _stub_roles(monkeypatch, {10: ["Enfermero"]})
214
- token = _make_token(private_pem, user_id=10)
215
-
216
- with pytest.raises(HTTPException) as exc_info:
217
- _get_current_user_core(token)
218
-
219
- assert exc_info.value.status_code == 403
220
-
221
-
222
- def test_get_current_user_core_sin_rol_403(rsa_keypair, monkeypatch, core_mode):
223
- private_pem, public_pem = rsa_keypair
224
- _stub_jwks(monkeypatch, public_pem)
225
- _stub_roles(monkeypatch, {}) # usuario sin roles asignados en el Core
226
- token = _make_token(private_pem, user_id=11)
227
-
228
- with pytest.raises(HTTPException) as exc_info:
229
- _get_current_user_core(token)
230
-
231
- assert exc_info.value.status_code == 403
232
-
233
-
234
- def test_get_current_user_core_token_invalido_401(rsa_keypair, monkeypatch, core_mode):
235
- _, public_pem = rsa_keypair
236
- _stub_jwks(monkeypatch, public_pem)
237
-
238
- with pytest.raises(HTTPException) as exc_info:
239
- _get_current_user_core("token-basura")
240
-
241
- assert exc_info.value.status_code == 401
242
-
243
-
244
- def test_get_current_user_core_expirado_401(rsa_keypair, monkeypatch, core_mode):
245
- private_pem, public_pem = rsa_keypair
246
- _stub_jwks(monkeypatch, public_pem)
247
- token = _make_token(private_pem, user_id=12, exp_delta=-10)
248
-
249
- with pytest.raises(HTTPException) as exc_info:
250
- _get_current_user_core(token)
251
-
252
- assert exc_info.value.status_code == 401
 
1
  """
2
+ Tests de `app/integrations/core_auth.py`: mapeo de roles del Core al rol
3
+ interno de M6.
4
+
5
+ La verificación de JWT del Core vía JWKS y el lookup de roles (`GET /roles`)
6
+ se eliminaron: la sesión de M6 es siempre un JWT HS256 propio, y el rol se
7
+ resuelve una única vez en el canje SSO (ver `tests/test_sso.py`), a partir
8
+ de `user.roles[]`. Este módulo cubre exclusivamente lo que sigue vigente:
9
+ la traducción de nombres de rol de Core a rol interno de M6.
 
 
 
 
10
  """
 
 
11
  import pytest
 
 
 
 
 
12
 
 
 
13
  from app.integrations import core_auth
14
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
15
 
16
  @pytest.mark.parametrize(
17
  "role_names,expected",
 
29
  )
30
  def test_map_core_roles_to_internal(role_names, expected):
31
  assert core_auth.map_core_roles_to_internal(role_names) == expected
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
tests/test_sso.py ADDED
@@ -0,0 +1,111 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Tests de `POST /api/v1/auth/sso-exchange`: canje de ticket SSO del Core por
3
+ una sesión propia de M6 (JWT HS256 con el rol resuelto desde `user.roles[]`
4
+ de la respuesta del canje — ver `app/routers/auth.py`).
5
+
6
+ No golpean el Core real: se stubea `core_auth.exchange_sso_ticket`.
7
+ """
8
+ import pytest
9
+
10
+ from app.config import settings
11
+ from app.dependencies import decode_token
12
+ from app.integrations import core_auth
13
+
14
+
15
+ def _core_user(roles: list[str], user_id: int = 42) -> dict:
16
+ return {
17
+ "id": user_id,
18
+ "first_name": "Ana",
19
+ "last_name": "Pérez",
20
+ "email": "ana@example.com",
21
+ "roles": [{"id": i, "name": name} for i, name in enumerate(roles)],
22
+ }
23
+
24
+
25
+ @pytest.fixture
26
+ def sso_enabled(monkeypatch):
27
+ monkeypatch.setattr(settings, "sso_enabled", True)
28
+
29
+
30
+ def test_sso_exchange_ok(client, monkeypatch, sso_enabled):
31
+ monkeypatch.setattr(
32
+ core_auth,
33
+ "exchange_sso_ticket",
34
+ lambda ticket: {"user": _core_user(["admin_internacion"]), "token": "core-jwt"},
35
+ )
36
+
37
+ resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "un-ticket-valido"})
38
+
39
+ assert resp.status_code == 200
40
+ body = resp.json()
41
+ assert body["rol"] == "ADMINISTRATIVO"
42
+ assert body["user"]["id"] == 42
43
+ assert body["user"]["email"] == "ana@example.com"
44
+
45
+ payload = decode_token(body["token"])
46
+ assert payload["sub"] == "42"
47
+ assert payload["rol"] == "ADMINISTRATIVO"
48
+
49
+
50
+ def test_sso_exchange_medico(client, monkeypatch, sso_enabled):
51
+ monkeypatch.setattr(
52
+ core_auth,
53
+ "exchange_sso_ticket",
54
+ lambda ticket: {"user": _core_user(["Medico"], user_id=9), "token": "core-jwt"},
55
+ )
56
+
57
+ resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "otro-ticket"})
58
+
59
+ assert resp.status_code == 200
60
+ assert resp.json()["rol"] == "MEDICO"
61
+
62
+
63
+ def test_sso_exchange_ticket_invalido_401(client, monkeypatch, sso_enabled):
64
+ def _raise(ticket):
65
+ raise core_auth.SSOTicketInvalid("expirado")
66
+
67
+ monkeypatch.setattr(core_auth, "exchange_sso_ticket", _raise)
68
+
69
+ resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "usado-o-expirado"})
70
+
71
+ assert resp.status_code == 401
72
+ assert resp.json()["detail"]["codigo"] == "NO_AUTENTICADO"
73
+
74
+
75
+ def test_sso_exchange_core_inalcanzable_502(client, monkeypatch, sso_enabled):
76
+ def _raise(ticket):
77
+ raise core_auth.SSOExchangeError("timeout")
78
+
79
+ monkeypatch.setattr(core_auth, "exchange_sso_ticket", _raise)
80
+
81
+ resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "cualquiera"})
82
+
83
+ assert resp.status_code == 502
84
+ assert resp.json()["detail"]["codigo"] == "SERVICIO_EXTERNO_NO_DISPONIBLE"
85
+
86
+
87
+ def test_sso_exchange_rol_no_mapeado_403(client, monkeypatch, sso_enabled):
88
+ monkeypatch.setattr(
89
+ core_auth,
90
+ "exchange_sso_ticket",
91
+ lambda ticket: {"user": _core_user(["Enfermero"], user_id=10), "token": "core-jwt"},
92
+ )
93
+
94
+ resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "un-ticket"})
95
+
96
+ assert resp.status_code == 403
97
+ assert resp.json()["detail"]["codigo"] == "NO_AUTORIZADO"
98
+
99
+
100
+ def test_sso_exchange_ticket_vacio_422(client, sso_enabled):
101
+ resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": ""})
102
+
103
+ assert resp.status_code == 422
104
+
105
+
106
+ def test_sso_exchange_deshabilitado_404(client, monkeypatch):
107
+ monkeypatch.setattr(settings, "sso_enabled", False)
108
+
109
+ resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "cualquiera"})
110
+
111
+ assert resp.status_code == 404