juampisor commited on
Commit
15c2525
Β·
1 Parent(s): 29c7ae3

SSO ticket saliente

Browse files
app/integrations/core_auth.py CHANGED
@@ -32,6 +32,10 @@ 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}`
@@ -55,6 +59,30 @@ def exchange_sso_ticket(ticket: str) -> dict:
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
 
32
  """Fallo al comunicarse con el Core (red, timeout, 5xx, etc.)."""
33
 
34
 
35
+ class CoreTokenInvalid(Exception):
36
+ """El JWT del Core embebido en la sesiΓ³n de M6 venciΓ³ o el Core lo rechaza (401)."""
37
+
38
+
39
  def exchange_sso_ticket(ticket: str) -> dict:
40
  """
41
  Canjea un ticket SSO de un solo uso contra el Core por `{user, token}`
 
59
  return r.json()
60
 
61
 
62
+ def request_sso_ticket(core_token: str) -> dict:
63
+ """
64
+ Pide al Core un ticket SSO saliente en nombre del usuario (`POST /auth/sso-ticket`,
65
+ `models.SSOTicketResponse` β€” `{ticket, expires_in}`), usando el JWT del Core que
66
+ quedΓ³ embebido en la sesiΓ³n de M6 al canjear (`app/routers/auth.py::sso_exchange`).
67
+
68
+ Es el lado inverso de `exchange_sso_ticket`: ahΓ­ M6 es el mΓ³dulo destino y recibe un
69
+ ticket; acΓ‘ M6 es el origen y pide uno para que el usuario navegue hacia otro mΓ³dulo.
70
+ """
71
+ url = f"{settings.m10_core_url}/auth/sso-ticket"
72
+ headers = {"Authorization": f"Bearer {core_token}"}
73
+ try:
74
+ r = httpx.post(url, headers=headers, timeout=settings.http_timeout_seconds)
75
+ except httpx.HTTPError as e:
76
+ raise SSOExchangeError("No se pudo contactar al Core para pedir el ticket SSO") from e
77
+
78
+ if r.status_code == 401:
79
+ raise CoreTokenInvalid("El Core rechazΓ³ el core_token embebido en la sesiΓ³n")
80
+ if r.status_code >= 400:
81
+ raise SSOExchangeError(f"El Core respondiΓ³ {r.status_code} al pedir el ticket SSO")
82
+
83
+ return r.json()
84
+
85
+
86
  # ─── Cuenta de servicio de M6 ───────────────────────────────────────────────
87
 
88
  # Token de la cuenta de servicio de M6 en el Core. Se usa para firmar las
app/routers/auth.py CHANGED
@@ -1,20 +1,36 @@
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
 
@@ -24,6 +40,14 @@ _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(
@@ -55,7 +79,10 @@ def sso_exchange(data: SSOExchangeRequest):
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(
@@ -66,3 +93,32 @@ def sso_exchange(data: SSOExchangeRequest):
66
  ),
67
  rol=rol,
68
  )
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
  """
2
+ SSO del Core (M10): canje de ticket por una sesiΓ³n propia de M6, en ambos sentidos.
3
 
4
+ - **Entrante** (`POST /sso-exchange`): M6 no maneja el callback del browser
5
+ (`/auth/sso?ticket=…`, responsabilidad del frontend) β€” este router expone solo el
6
+ canje server-to-server: recibe el ticket, lo intercambia contra el Core por
7
+ `{user, token}` y emite su propio JWT HS256 con el rol ya resuelto a partir de
8
+ `user.roles[]`. El JWT del Core (`token`) queda embebido como claim opaco
9
+ (`core_token`) dentro del JWT de M6 β€” no se descarta del todo, se guarda solo para
10
+ poder pedir tickets salientes mΓ‘s adelante (ver abajo). Un JWT es firmado, no
11
+ cifrado: ese claim es legible por quien tenga el JWT de M6, incluido el frontend β€”
12
+ ver `M6_AUTH_SSO.md` Β§1 y Β§9 para el detalle de este trade-off.
13
+ - **Saliente** (`POST /sso-ticket`): para que un usuario ya logueado en M6 navegue a
14
+ otro mΓ³dulo sin loguearse de nuevo. Usa el `core_token` embebido en su propia sesiΓ³n
15
+ para pedirle un ticket al Core en su nombre β€” sesiones que no vinieron de un SSO real
16
+ (p.ej. el endpoint de desarrollo `GET /auth/token`) no tienen ese claim y no pueden
17
+ usar este endpoint.
18
+
19
+ Ver `app/integrations/core_auth.py` y `documentation/M6_DISEΓ‘O.md` Β§11.
20
  """
21
  import logging
22
 
23
+ from fastapi import APIRouter, Depends, HTTPException, status
24
 
25
  from app.config import settings
26
+ from app.dependencies import create_access_token, get_current_user
27
  from app.integrations import core_auth
28
+ from app.schemas.auth import (
29
+ SSOExchangeRequest,
30
+ SSOExchangeResponse,
31
+ SSOTicketResponse,
32
+ SSOUser,
33
+ )
34
 
35
  logger = logging.getLogger(__name__)
36
 
 
40
  _ERROR_401_TICKET = {"codigo": "NO_AUTENTICADO", "mensaje": "Ticket invΓ‘lido, ya usado o expirado"}
41
  _ERROR_403_ROL = {"codigo": "NO_AUTORIZADO", "mensaje": "El usuario no tiene un rol habilitado en M6"}
42
  _ERROR_502 = {"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo canjear el ticket contra el Core (M10)"}
43
+ _ERROR_401_SIN_SESION_CORE = {
44
+ "codigo": "SIN_SESION_CORE",
45
+ "mensaje": "Esta sesiΓ³n no se originΓ³ en un SSO real contra el Core β€” no se puede pedir un ticket saliente",
46
+ }
47
+ _ERROR_401_CORE_TOKEN = {
48
+ "codigo": "NO_AUTENTICADO",
49
+ "mensaje": "El token del Core asociado a esta sesiΓ³n venciΓ³ o fue rechazado β€” reiniciar el SSO",
50
+ }
51
 
52
 
53
  @router.post(
 
79
  if rol is None:
80
  raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=_ERROR_403_ROL)
81
 
82
+ core_token = resp.get("token")
83
+ token = create_access_token(
84
+ sub=str(core_user["id"]), rol=rol, extra={"core_token": core_token} if core_token else None,
85
+ )
86
  return SSOExchangeResponse(
87
  token=token,
88
  user=SSOUser(
 
93
  ),
94
  rol=rol,
95
  )
96
+
97
+
98
+ @router.post(
99
+ "/sso-ticket",
100
+ response_model=SSOTicketResponse,
101
+ summary="Pedir un ticket SSO del Core para navegar hacia otro mΓ³dulo",
102
+ responses={
103
+ 401: {"description": "SesiΓ³n sin core_token, o el Core rechazΓ³ el core_token"},
104
+ 404: {"description": "SSO no habilitado"},
105
+ 502: {"description": "El Core no respondiΓ³ al pedido de ticket"},
106
+ },
107
+ )
108
+ def sso_ticket(user: dict = Depends(get_current_user)):
109
+ if not settings.sso_enabled:
110
+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=_ERROR_404)
111
+
112
+ core_token = user.get("core_token")
113
+ if not core_token:
114
+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_SIN_SESION_CORE)
115
+
116
+ try:
117
+ resp = core_auth.request_sso_ticket(core_token)
118
+ except core_auth.CoreTokenInvalid:
119
+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_CORE_TOKEN)
120
+ except core_auth.SSOExchangeError as e:
121
+ logger.warning("Fallo al pedir ticket SSO saliente al Core: %s", e)
122
+ raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502)
123
+
124
+ return SSOTicketResponse(**resp)
app/schemas/auth.py CHANGED
@@ -16,3 +16,8 @@ class SSOExchangeResponse(BaseModel):
16
  token: str
17
  user: SSOUser
18
  rol: str
 
 
 
 
 
 
16
  token: str
17
  user: SSOUser
18
  rol: str
19
+
20
+
21
+ class SSOTicketResponse(BaseModel):
22
+ ticket: str
23
+ expires_in: int
documentation/M6_AUTH_SSO.md CHANGED
@@ -10,13 +10,20 @@
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
@@ -217,11 +224,81 @@ if (response.status === 401) {
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`).
 
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
+ M6 implementa el SSO en **ambos sentidos**:
14
+
15
+ - **Entrante** (Β§2 a Β§6): un usuario llega a M6 desde otro mΓ³dulo o desde el Core, con un ticket. M6 lo canjea y emite su propia sesiΓ³n.
16
+ - **Saliente** (Β§9): un usuario ya logueado en M6 navega *hacia* otro mΓ³dulo sin loguearse de nuevo. M6 le pide un ticket al Core en su nombre.
17
+
18
  Dos tokens distintos entran en juego y no hay que confundirlos:
19
 
20
  | Token | QuiΓ©n lo emite | Algoritmo | Vigencia | DΓ³nde se usa |
21
  |---|---|---|---|---|
22
+ | Token del Core | M10 | RS256 | 24 h | Se usa dentro del canje entrante (`sso-exchange`) para resolver el rol, y ademΓ‘s queda **embebido como claim** (`core_token`) dentro del JWT de M6, para poder pedir tickets salientes despuΓ©s (Β§9) β€” no se descarta del todo. |
23
  | 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. |
24
 
25
+ **Nota de seguridad sobre el `core_token` embebido:** un JWT estΓ‘ firmado, no cifrado β€” su payload es base64, legible por cualquiera que tenga el token, incluido el propio frontend/browser (decodificarlo no requiere romper la firma). Esto significa que el JWT del Core embebido es tΓ©cnicamente visible para quien tenga el JWT de M6. Es un trade-off consciente: la alternativa (guardar el token del Core en un store server-side en vez de en el JWT) reintroduce estado en un backend que es deliberadamente stateless (Β§4), y no se tomΓ³ acΓ‘. En la prΓ‘ctica, si se filtra un JWT de M6 ya es grave por sΓ­ solo (acceso a datos mΓ©dicos vΓ­a la API); esto extiende el radio de impacto tambiΓ©n al Core por hasta 24 h, sin que M6 pueda revocarlo.
26
+
27
  ---
28
 
29
  ## 2. Flujo completo
 
224
 
225
  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.
226
 
227
+ **Ojo:** las sesiones creadas por este endpoint **no tienen `core_token` embebido** (no pasaron por un SSO real) β€” no pueden usar el SSO saliente de Β§9. Para probar ese flujo localmente hace falta un token real del Core (login real + `sso-exchange` real).
228
+
229
+ ---
230
+
231
+ ## 9. Navegar hacia otro mΓ³dulo desde M6 (SSO saliente)
232
+
233
+ El camino inverso de Β§2: un usuario ya logueado en M6 quiere ir a otro mΓ³dulo (por ejemplo, un link en el menΓΊ) y llegar ahΓ­ ya autenticado, sin loguearse de nuevo.
234
+
235
+ ```mermaid
236
+ sequenceDiagram
237
+ participant F as Frontend M6
238
+ participant M6 as Backend M6
239
+ participant Core as Core API (M10)
240
+ participant O as Otro mΓ³dulo
241
+
242
+ F->>M6: 1) POST /api/v1/auth/sso-ticket (Bearer: JWT de M6)
243
+ M6->>Core: 2) POST /auth/sso-ticket (Bearer: core_token embebido)
244
+ Core-->>M6: { ticket, expires_in }
245
+ M6-->>F: { ticket, expires_in }
246
+ Note over F: 3) window.location.href a /auth/sso?ticket=…&redirect=… del otro mΓ³dulo
247
+ ```
248
+
249
+ 1. El frontend pide un ticket saliente a **su propio backend** (M6) β€” no al Core directamente, porque el frontend nunca tuvo el JWT del Core (solo el de M6).
250
+ 2. M6 saca el `core_token` embebido en la sesiΓ³n del usuario (ver Β§1) y hace `POST /auth/sso-ticket` al Core en su nombre.
251
+ 3. El frontend recibe el ticket y redirige el browser al callback del otro mΓ³dulo, igual que documenta `M10_SSO_INTEGRATION_GUIDE.md` para el mΓ³dulo de origen.
252
+
253
+ ### 9.1 Contrato: `POST /api/v1/auth/sso-ticket`
254
+
255
+ Implementado en `app/routers/auth.py`. Requiere sesiΓ³n de M6 vigente (`Authorization: Bearer <JWT de M6>`) β€” es la propia sesiΓ³n del usuario la que autoriza el pedido, no un secreto aparte.
256
+
257
+ **Request:** sin body.
258
+
259
+ **Response `200`**
260
+
261
+ ```json
262
+ { "ticket": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b", "expires_in": 60 }
263
+ ```
264
+
265
+ Mismo shape que devuelve el Core (`models.SSOTicketResponse`) β€” sin envoltorio adicional.
266
+
267
+ **Errores**
268
+
269
+ | CΓ³digo | `codigo` | CuΓ‘ndo | QuΓ© hacer en el frontend |
270
+ |---|---|---|---|
271
+ | `401` | `SIN_SESION_CORE` | La sesiΓ³n no tiene `core_token` embebido β€” no vino de un SSO real (p.ej. sesiΓ³n de desarrollo, Β§7) | No se puede navegar a otro mΓ³dulo desde esta sesiΓ³n; no reintentar |
272
+ | `401` | `NO_AUTENTICADO` | El Core rechazΓ³ el `core_token` (venciΓ³ o es invΓ‘lido) | Reiniciar el flujo de login/SSO desde cero |
273
+ | `404` | β€” | SSO deshabilitado (`SSO_ENABLED=false`) | Error de configuraciΓ³n/entorno |
274
+ | `502` | `SERVICIO_EXTERNO_NO_DISPONIBLE` | El Core no respondiΓ³ al pedido de ticket | Reintentar mΓ‘s tarde |
275
+
276
+ ### 9.2 Frontend: usar el ticket
277
+
278
+ ```ts
279
+ async function requestOutboundTicket(): Promise<{ ticket: string; expires_in: number }> {
280
+ const res = await fetch(`${M6_API_BASE}/api/v1/auth/sso-ticket`, {
281
+ method: 'POST',
282
+ headers: { Authorization: `Bearer ${getSessionToken()}` },
283
+ });
284
+ if (!res.ok) throw new Error('No se pudo obtener el ticket SSO saliente');
285
+ return res.json();
286
+ }
287
+
288
+ async function navigateToModule(otherModuleHost: string, internalPath: string) {
289
+ const { ticket } = await requestOutboundTicket();
290
+ const redirect = encodeURIComponent(internalPath);
291
+ window.location.href = `https://${otherModuleHost}/auth/sso?ticket=${ticket}&redirect=${redirect}`;
292
+ }
293
+ ```
294
+
295
+ El ticket es de un solo uso y expira en `expires_in` segundos (~60 s, como documenta `M10_SSO_INTEGRATION_GUIDE.md`) β€” pedirlo justo antes de navegar, no guardarlo.
296
+
297
  ---
298
 
299
+ ## 10. Referencias
300
 
301
  - [`M10_SSO_INTEGRATION_GUIDE.md`](M10_SSO_INTEGRATION_GUIDE.md) β€” contrato genΓ©rico del SSO del Core (ticket, JWKS, ejemplos Angular/React/Go/Node).
302
  - [`M6_DISEΓ‘O.md`](M6_DISEΓ‘O.md) Β§11 β€” detalle tΓ©cnico de la integraciΓ³n de auth en M6.
303
  - [`roles.md`](roles.md) Β§6 β€” mapeo de roles del Core a roles internos de M6 y matriz de permisos por endpoint.
304
+ - [`M6_openapi.json`](M6_openapi.json) β€” contrato exacto de `/auth/sso-exchange`/`/auth/sso-ticket` (schemas `SSOExchangeRequest`/`SSOExchangeResponse`/`SSOTicketResponse`).
documentation/M6_openapi.json CHANGED
@@ -4853,6 +4853,92 @@
4853
  },
4854
  "security": []
4855
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4856
  }
4857
  },
4858
  "components": {
@@ -6278,6 +6364,25 @@
6278
  "example": "ADMINISTRATIVO"
6279
  }
6280
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6281
  }
6282
  },
6283
  "responses": {
 
4853
  },
4854
  "security": []
4855
  }
4856
+ },
4857
+ "/auth/sso-ticket": {
4858
+ "post": {
4859
+ "summary": "Pedir un ticket SSO del Core para navegar hacia otro mΓ³dulo",
4860
+ "deprecated": false,
4861
+ "description": "Lado saliente del SSO (inverso de `/auth/sso-exchange`): usa el `core_token` embebido en la sesiΓ³n de M6 (guardado al canjear, ver `SSOExchangeResponse`) para pedirle al Core un ticket SSO en nombre del usuario logueado, y asΓ­ poder navegar hacia otro mΓ³dulo sin loguearse de nuevo.\n\nRequiere sesiΓ³n de M6 vigente (`Authorization: Bearer <JWT de M6>`). Sesiones sin `core_token` embebido (p.ej. las del endpoint de desarrollo `GET /auth/token`, que no pasaron por un SSO real) no pueden usar este endpoint.\n\nDeshabilitado (`404`) si `SSO_ENABLED=false`.",
4862
+ "operationId": "ssoTicket",
4863
+ "tags": [
4864
+ "Auth"
4865
+ ],
4866
+ "responses": {
4867
+ "200": {
4868
+ "description": "Ticket saliente emitido por el Core",
4869
+ "content": {
4870
+ "application/json": {
4871
+ "schema": {
4872
+ "$ref": "#/components/schemas/SSOTicketResponse"
4873
+ },
4874
+ "example": {
4875
+ "ticket": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b",
4876
+ "expires_in": 60
4877
+ }
4878
+ }
4879
+ }
4880
+ },
4881
+ "401": {
4882
+ "description": "SesiΓ³n sin core_token embebido, o el Core rechazΓ³ el core_token",
4883
+ "content": {
4884
+ "application/json": {
4885
+ "schema": {
4886
+ "$ref": "#/components/schemas/Error"
4887
+ },
4888
+ "examples": {
4889
+ "sin_sesion_core": {
4890
+ "summary": "SesiΓ³n sin core_token",
4891
+ "value": {
4892
+ "codigo": "SIN_SESION_CORE",
4893
+ "mensaje": "Esta sesiΓ³n no se originΓ³ en un SSO real contra el Core β€” no se puede pedir un ticket saliente"
4894
+ }
4895
+ },
4896
+ "core_token_invalido": {
4897
+ "summary": "core_token vencido o rechazado",
4898
+ "value": {
4899
+ "codigo": "NO_AUTENTICADO",
4900
+ "mensaje": "El token del Core asociado a esta sesiΓ³n venciΓ³ o fue rechazado β€” reiniciar el SSO"
4901
+ }
4902
+ }
4903
+ }
4904
+ }
4905
+ }
4906
+ },
4907
+ "404": {
4908
+ "description": "SSO deshabilitado (SSO_ENABLED=false)",
4909
+ "content": {
4910
+ "application/json": {
4911
+ "schema": {
4912
+ "$ref": "#/components/schemas/Error"
4913
+ },
4914
+ "example": {
4915
+ "codigo": "RECURSO_NO_ENCONTRADO",
4916
+ "mensaje": "Not Found"
4917
+ }
4918
+ }
4919
+ }
4920
+ },
4921
+ "502": {
4922
+ "description": "El Core no respondiΓ³ al pedido de ticket",
4923
+ "content": {
4924
+ "application/json": {
4925
+ "schema": {
4926
+ "$ref": "#/components/schemas/Error"
4927
+ },
4928
+ "example": {
4929
+ "codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE",
4930
+ "mensaje": "No se pudo canjear el ticket contra el Core (M10)"
4931
+ }
4932
+ }
4933
+ }
4934
+ }
4935
+ },
4936
+ "security": [
4937
+ {
4938
+ "BearerAuth": []
4939
+ }
4940
+ ]
4941
+ }
4942
  }
4943
  },
4944
  "components": {
 
6364
  "example": "ADMINISTRATIVO"
6365
  }
6366
  }
6367
+ },
6368
+ "SSOTicketResponse": {
6369
+ "type": "object",
6370
+ "required": [
6371
+ "ticket",
6372
+ "expires_in"
6373
+ ],
6374
+ "properties": {
6375
+ "ticket": {
6376
+ "type": "string",
6377
+ "description": "Ticket SSO de un solo uso emitido por el Core, para navegar hacia otro mΓ³dulo.",
6378
+ "example": "9f2c1b7a3e045e6f7a8b9c0d1e2f3a4b"
6379
+ },
6380
+ "expires_in": {
6381
+ "type": "integer",
6382
+ "description": "Segundos de validez del ticket (~60s).",
6383
+ "example": 60
6384
+ }
6385
+ }
6386
  }
6387
  },
6388
  "responses": {
tests/test_sso.py CHANGED
@@ -1,14 +1,15 @@
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
 
@@ -45,6 +46,9 @@ def test_sso_exchange_ok(client, monkeypatch, sso_enabled):
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):
@@ -109,3 +113,82 @@ def test_sso_exchange_deshabilitado_404(client, monkeypatch):
109
  resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "cualquiera"})
110
 
111
  assert resp.status_code == 404
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
  """
2
+ Tests de `POST /api/v1/auth/sso-exchange` (SSO entrante) y `POST /api/v1/auth/sso-ticket`
3
+ (SSO saliente): canje de ticket del Core por una sesiΓ³n propia de M6, y el camino
4
+ inverso β€” pedirle al Core un ticket para navegar hacia otro mΓ³dulo, usando el
5
+ `core_token` embebido en la sesiΓ³n (ver `app/routers/auth.py`).
6
 
7
+ No golpean el Core real: se stubean `core_auth.exchange_sso_ticket`/`request_sso_ticket`.
8
  """
9
  import pytest
10
 
11
  from app.config import settings
12
+ from app.dependencies import create_access_token, decode_token
13
  from app.integrations import core_auth
14
 
15
 
 
46
  payload = decode_token(body["token"])
47
  assert payload["sub"] == "42"
48
  assert payload["rol"] == "ADMINISTRATIVO"
49
+ # El JWT del Core queda embebido β€” necesario para pedir tickets SSO salientes
50
+ # mΓ‘s adelante (POST /auth/sso-ticket), sin volver a tocar el Core en cada request.
51
+ assert payload["core_token"] == "core-jwt"
52
 
53
 
54
  def test_sso_exchange_medico(client, monkeypatch, sso_enabled):
 
113
  resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "cualquiera"})
114
 
115
  assert resp.status_code == 404
116
+
117
+
118
+ # ─── POST /auth/sso-ticket (SSO saliente) ──────────────────────────────────
119
+
120
+
121
+ def _headers_con_core_token(core_token: str = "core-jwt-vigente") -> dict:
122
+ token = create_access_token(sub="1", rol="ADMINISTRATIVO", extra={"core_token": core_token})
123
+ return {"Authorization": f"Bearer {token}"}
124
+
125
+
126
+ def test_sso_ticket_ok(client, monkeypatch, sso_enabled):
127
+ monkeypatch.setattr(
128
+ core_auth, "request_sso_ticket", lambda core_token: {"ticket": "un-ticket-nuevo", "expires_in": 60}
129
+ )
130
+
131
+ resp = client.post("/api/v1/auth/sso-ticket", headers=_headers_con_core_token())
132
+
133
+ assert resp.status_code == 200
134
+ assert resp.json() == {"ticket": "un-ticket-nuevo", "expires_in": 60}
135
+
136
+
137
+ def test_sso_ticket_pasa_el_core_token_correcto(client, monkeypatch, sso_enabled):
138
+ received = []
139
+ monkeypatch.setattr(
140
+ core_auth,
141
+ "request_sso_ticket",
142
+ lambda core_token: received.append(core_token) or {"ticket": "t", "expires_in": 60},
143
+ )
144
+
145
+ client.post("/api/v1/auth/sso-ticket", headers=_headers_con_core_token("mi-core-token"))
146
+
147
+ assert received == ["mi-core-token"]
148
+
149
+
150
+ def test_sso_ticket_sin_core_token_401(client, admin_headers, sso_enabled):
151
+ """Sesiones que no vinieron de un SSO real (p.ej. el endpoint de dev, admin_headers
152
+ de conftest.py) no tienen core_token embebido β€” no pueden pedir un ticket saliente."""
153
+ resp = client.post("/api/v1/auth/sso-ticket", headers=admin_headers)
154
+
155
+ assert resp.status_code == 401
156
+ assert resp.json()["detail"]["codigo"] == "SIN_SESION_CORE"
157
+
158
+
159
+ def test_sso_ticket_core_token_vencido_401(client, monkeypatch, sso_enabled):
160
+ def _raise(core_token):
161
+ raise core_auth.CoreTokenInvalid("vencido")
162
+
163
+ monkeypatch.setattr(core_auth, "request_sso_ticket", _raise)
164
+
165
+ resp = client.post("/api/v1/auth/sso-ticket", headers=_headers_con_core_token())
166
+
167
+ assert resp.status_code == 401
168
+ assert resp.json()["detail"]["codigo"] == "NO_AUTENTICADO"
169
+
170
+
171
+ def test_sso_ticket_core_inalcanzable_502(client, monkeypatch, sso_enabled):
172
+ def _raise(core_token):
173
+ raise core_auth.SSOExchangeError("timeout")
174
+
175
+ monkeypatch.setattr(core_auth, "request_sso_ticket", _raise)
176
+
177
+ resp = client.post("/api/v1/auth/sso-ticket", headers=_headers_con_core_token())
178
+
179
+ assert resp.status_code == 502
180
+ assert resp.json()["detail"]["codigo"] == "SERVICIO_EXTERNO_NO_DISPONIBLE"
181
+
182
+
183
+ def test_sso_ticket_sin_sesion_401(client, sso_enabled):
184
+ resp = client.post("/api/v1/auth/sso-ticket")
185
+
186
+ assert resp.status_code == 401
187
+
188
+
189
+ def test_sso_ticket_deshabilitado_404(client, monkeypatch):
190
+ monkeypatch.setattr(settings, "sso_enabled", False)
191
+
192
+ resp = client.post("/api/v1/auth/sso-ticket", headers=_headers_con_core_token())
193
+
194
+ assert resp.status_code == 404