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

- **Entrante** (`POST /sso-exchange`): M6 no maneja el callback del browser
  (`/auth/sso?ticket=…`, responsabilidad del frontend) — este router expone solo el
  canje server-to-server: recibe el ticket, lo intercambia contra el Core por
  `{user, token}` y emite su propio JWT HS256 con el rol ya resuelto a partir de
  `user.roles[]` — o, si el Core no lo pobló en la respuesta del canje (pasa en la
  práctica), vía `core_auth.resolve_user_roles` (fallback, `GET /roles` con la cuenta
  de servicio). El JWT del Core (`token`) queda embebido como claim opaco
  (`core_token`) dentro del JWT de M6 — no se descarta del todo, se guarda solo para
  poder pedir tickets salientes más adelante (ver abajo). Un JWT es firmado, no
  cifrado: ese claim es legible por quien tenga el JWT de M6, incluido el frontend —
  ver `M6_AUTH_SSO.md` §1 y §9 para el detalle de este trade-off.
- **Saliente** (`POST /sso-ticket`): para que un usuario ya logueado en M6 navegue a
  otro módulo sin loguearse de nuevo. Usa el `core_token` embebido en su propia sesión
  para pedirle un ticket al Core en su nombre — sesiones que no vinieron de un SSO real
  (p.ej. el endpoint de desarrollo `GET /auth/token`) no tienen ese claim y no pueden
  usar este endpoint.

Ver `app/integrations/core_auth.py` y `documentation/M6_DISEÑO.md` §11.
"""
import logging

from fastapi import APIRouter, Depends, HTTPException, status

from app.config import settings
from app.dependencies import create_access_token, get_current_user
from app.integrations import core_auth
from app.schemas.auth import (
    SSOExchangeRequest,
    SSOExchangeResponse,
    SSOTicketResponse,
    SSOUser,
)

logger = logging.getLogger(__name__)

router = APIRouter(prefix="/auth", tags=["Auth"])

_ERROR_404 = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Not Found"}
_ERROR_401_TICKET = {"codigo": "NO_AUTENTICADO", "mensaje": "Ticket inválido, ya usado o expirado"}
_ERROR_403_ROL = {"codigo": "NO_AUTORIZADO", "mensaje": "El usuario no tiene un rol habilitado en M6"}
_ERROR_502 = {"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo canjear el ticket contra el Core (M10)"}
_ERROR_401_SIN_SESION_CORE = {
    "codigo": "SIN_SESION_CORE",
    "mensaje": "Esta sesión no se originó en un SSO real contra el Core — no se puede pedir un ticket saliente",
}
_ERROR_401_CORE_TOKEN = {
    "codigo": "NO_AUTENTICADO",
    "mensaje": "El token del Core asociado a esta sesión venció o fue rechazado — reiniciar el SSO",
}


@router.post(
    "/sso-exchange",
    response_model=SSOExchangeResponse,
    summary="Canjear un ticket SSO del Core por una sesión de M6",
    responses={
        401: {"description": "Ticket inválido, ya usado o expirado"},
        403: {"description": "El usuario no tiene un rol habilitado en M6"},
        404: {"description": "SSO no habilitado"},
        502: {"description": "El Core no respondió al canje"},
    },
)
def sso_exchange(data: SSOExchangeRequest):
    ticket_prefix = data.ticket[:8] + "…" if data.ticket else "(vacío)"
    logger.info("SSO exchange solicitado — ticket: %s", ticket_prefix)

    if not settings.sso_enabled:
        logger.warning("SSO exchange rechazado — SSO_ENABLED=false")
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=_ERROR_404)

    try:
        resp = core_auth.exchange_sso_ticket(data.ticket)
    except core_auth.SSOTicketInvalid:
        logger.warning("SSO exchange fallido — ticket inválido/expirado (ticket: %s)", ticket_prefix)
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_TICKET)
    except core_auth.SSOExchangeError as e:
        logger.warning("SSO exchange fallido — error de comunicación con Core: %s", e)
        raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502)

    core_user = resp.get("user") or {}
    user_id = core_user.get("id")
    user_email = core_user.get("email", "(sin email)")
    role_names = [r["name"] for r in (core_user.get("roles") or []) if r.get("name")]
    logger.info(
        "Core respondió OK — user_id=%s email=%s roles_core=%s",
        user_id, user_email, role_names,
    )

    if not role_names and user_id is not None:
        # El canje SSO no trajo `user.roles[]` poblado (pasa con el Core real
        # pese a que el schema lo permite) — fallback: resolverlos vía
        # `GET /roles` con la cuenta de servicio (`core_auth.resolve_user_roles`).
        try:
            role_names = core_auth.resolve_user_roles(user_id)
            logger.info(
                "roles_core vacío en el canje — resuelto vía GET /roles — user_id=%s roles=%s",
                user_id, role_names,
            )
        except Exception as e:
            logger.warning(
                "Fallback de roles (GET /roles) falló — user_id=%s error=%s", user_id, e,
            )
            raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502)

    rol = core_auth.map_core_roles_to_internal(role_names)
    if rol is None:
        logger.warning(
            "SSO exchange denegado (403) — user_id=%s email=%s roles_core=%s "
            "no mapean a ningún rol de M6. Roles conocidos: %s",
            user_id, user_email, role_names, list(core_auth.CORE_ROLE_TO_INTERNAL.keys()),
        )
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=_ERROR_403_ROL)

    core_token = resp.get("token")
    token = create_access_token(
        sub=str(core_user["id"]), rol=rol, extra={"core_token": core_token} if core_token else None,
    )
    logger.info(
        "SSO exchange exitoso — user_id=%s email=%s rol_m6=%s core_token=%s",
        user_id, user_email, rol, "presente" if core_token else "ausente",
    )
    return SSOExchangeResponse(
        token=token,
        user=SSOUser(
            id=core_user["id"],
            first_name=core_user.get("first_name", ""),
            last_name=core_user.get("last_name", ""),
            email=core_user.get("email", ""),
        ),
        rol=rol,
    )


@router.post(
    "/sso-ticket",
    response_model=SSOTicketResponse,
    summary="Pedir un ticket SSO del Core para navegar hacia otro módulo",
    responses={
        401: {"description": "Sesión sin core_token, o el Core rechazó el core_token"},
        404: {"description": "SSO no habilitado"},
        502: {"description": "El Core no respondió al pedido de ticket"},
    },
)
def sso_ticket(user: dict = Depends(get_current_user)):
    if not settings.sso_enabled:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=_ERROR_404)

    core_token = user.get("core_token")
    if not core_token:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_SIN_SESION_CORE)

    try:
        resp = core_auth.request_sso_ticket(core_token)
    except core_auth.CoreTokenInvalid:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401_CORE_TOKEN)
    except core_auth.SSOExchangeError as e:
        logger.warning("Fallo al pedir ticket SSO saliente al Core: %s", e)
        raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502)

    return SSOTicketResponse(**resp)