Sesiones revocables: logout real y cierre en todos los dispositivos

ARCHITECTURE_REVIEW §2.3. Las sesiones son cookies firmadas sin estado y el
logout se limitaba a borrar la cookie del navegador: el token seguía siendo
VÁLIDO allá donde se hubiera copiado, hasta `session_max_age_s` (8h). No había
forma de invalidar una sesión filtrada ni de echar a nadie tras un incidente,
salvo rotar MORPHOS_SESSION_SECRET, que tira a todos los usuarios a la vez.

Dos mecanismos, porque resuelven cosas distintas (migración 4):
- `sesiones_revocadas`: una sesión concreta, por `jti`. Se recuerda sólo hasta que
su firma caduca por sí sola; a partir de ahí la fila sobra y se poda.
- `usuarios.sesiones_validas_desde`: TODAS las de una cuenta a la vez, con el
nuevo POST /api/auth/logout-todas. Un sello temporal en vez de un contador de
versión porque la pregunta es «¿se emitió antes del corte?».

`jti` y `emitida_en` los añade `firmar_sesion`, no quien llama: si se generaran
fuera, una ruta podría emitir por descuido una sesión irrevocable.

TIMESTAMPS EN PYTHON, NO EN SQLITE. `datetime('now')` tiene resolución de SEGUNDO,
y con ella una sesión emitida en el mismo segundo que el corte SOBREVIVÍA a la
revocación —lo detectó la prueba de logout-todas—. Además SQLite separa fecha y
hora con un espacio y las sesiones usan 'T', así que comparar sus cadenas ordenaba
mal. Ahora ambos lados son ISO-8601 UTC con microsegundos.

Se arregla también la segunda mitad de §2.3: `delete_cookie()` a secas emite un
Set-Cookie sin samesite/secure/path y varios navegadores lo tratan como una cookie
DISTINTA de la original, así que la sesión se quedaba en el navegador.

Las cookies sin `jti` (emitidas antes de esto) se aceptan hasta caducar:
invalidarlas de golpe echaría a todo el mundo en el despliegue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/app/db.py

@@ -15,6 +15,7 @@ import secrets
 import sqlite3
 from collections.abc import Iterator
 from contextlib import contextmanager
+from datetime import UTC, datetime
 
 from .config import TENANT_POR_DEFECTO, VOLUMEN_PERSISTENTE, obtener_config
 
@@ -67,6 +68,22 @@ CREATE INDEX IF NOT EXISTS idx_intentos_email_ip_momento
     # de una sola clínica no nota el cambio.
     f"""
 ALTER TABLE usuarios ADD COLUMN tenant TEXT NOT NULL DEFAULT '{TENANT_POR_DEFECTO}';
+""",
+    # 4 — revocación de sesiones. Las cookies firmadas son válidas hasta que caducan mirándolas
+    # sólo a ellas, así que no había forma de invalidar una copiada ni de echar a nadie tras un
+    # incidente. Dos mecanismos, porque resuelven cosas distintas:
+    #   - `sesiones_revocadas`: una sesión concreta (logout). Se guarda hasta su caducidad; a
+    #     partir de ahí la firma ya no vale por sí sola y la fila sobra.
+    #   - `usuarios.sesiones_validas_desde`: TODAS las de una cuenta a la vez (cambio de
+    #     contraseña, robo). Un sello temporal en vez de un contador de versión porque la
+    #     pregunta que hay que responder es «¿se emitió antes del corte?».
+    """
+CREATE TABLE IF NOT EXISTS sesiones_revocadas (
+    jti TEXT PRIMARY KEY,
+    expira_en DATETIME NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_sesiones_revocadas_expira ON sesiones_revocadas (expira_en);
+ALTER TABLE usuarios ADD COLUMN sesiones_validas_desde DATETIME;
 """,
 ]
 
@@ -150,6 +167,55 @@ def crear_usuario(nombre: str, apellido: str, email: str, password: str, tenant:
         )
 
 
+# --- Revocación de sesiones ---
+
+def _ahora_iso() -> str:
+    """Instante actual en ISO-8601 UTC con microsegundos.
+
+    Se genera en Python y NO con `datetime('now')` de SQLite por dos motivos: SQLite tiene
+    resolución de SEGUNDO —una sesión emitida en el mismo segundo que un corte de revocación
+    sobrevivía— y usa un espacio en vez de 'T', así que comparar sus cadenas con las ISO de las
+    sesiones daba órdenes incorrectos.
+    """
+    return datetime.now(UTC).isoformat()
+
+
+def revocar_sesion(jti: str, expira_en: str) -> None:
+    """Invalida UNA sesión (logout) hasta que su firma caduque por sí sola."""
+    with _conexion() as con:
+        con.execute(
+            "INSERT OR REPLACE INTO sesiones_revocadas (jti, expira_en) VALUES (?, ?)",
+            (jti, expira_en),
+        )
+        # Poda oportunista: pasada su caducidad la firma ya no vale, así que la fila no aporta.
+        # El corte va como parámetro, en el MISMO formato que lo guardado.
+        con.execute("DELETE FROM sesiones_revocadas WHERE expira_en < ?", (_ahora_iso(),))
+
+
+def sesion_revocada(jti: str) -> bool:
+    with _conexion() as con:
+        cur = con.execute("SELECT 1 FROM sesiones_revocadas WHERE jti = ? LIMIT 1", (jti,))
+        return cur.fetchone() is not None
+
+
+def revocar_todas_las_sesiones(email: str) -> None:
+    """Corta TODAS las sesiones de una cuenta: las emitidas antes de ahora dejan de valer."""
+    with _conexion() as con:
+        con.execute(
+            "UPDATE usuarios SET sesiones_validas_desde = ? WHERE email = ?",
+            (_ahora_iso(), email),
+        )
+
+
+def sesiones_validas_desde(email: str) -> str | None:
+    with _conexion() as con:
+        cur = con.execute(
+            "SELECT sesiones_validas_desde FROM usuarios WHERE email = ? LIMIT 1", (email,)
+        )
+        fila = cur.fetchone()
+        return fila["sesiones_validas_desde"] if fila else None
+
+
 # --- Registro de intentos de login (para throttling) ---
 
 def registrar_intento(email: str, ip: str) -> None:

backend/app/routers/auth.py

@@ -21,6 +21,8 @@ from ..db import (
     intentos_recientes,
     limpiar_intentos,
     registrar_intento,
+    revocar_sesion,
+    revocar_todas_las_sesiones,
     verificar_password,
 )
 from ..security.authz import usuario_actual
@@ -28,6 +30,7 @@ from ..security.rate_limit import ip_cliente, limiter
 from ..security.session import (
     COOKIE_CSRF,
     COOKIE_SESION,
+    caducidad_de,
     firmar_sesion,
     nuevo_token_csrf,
 )
@@ -126,8 +129,36 @@ async def registro(request: Request, body: RegistroBody, response: Response) ->
     return {"ok": True, "nombre": body.nombre, "csrf": csrf}
 
 
+def _borrar_cookies(resp: Response) -> None:
+    """Borra las cookies con los MISMOS atributos con que se pusieron.
+
+    `delete_cookie()` a secas emite un Set-Cookie sin `samesite`/`secure`/`path`, y varios
+    navegadores lo tratan como una cookie DISTINTA de la original: la sesión seguía en el
+    navegador después de «cerrar sesión».
+    """
+    cfg = obtener_config()
+    for nombre in (COOKIE_SESION, COOKIE_CSRF):
+        resp.delete_cookie(nombre, path="/", samesite="strict", secure=cfg.cookie_secure)
+
+
 @router.post("/auth/logout")
-async def logout(response: Response, _sesion: dict = Depends(usuario_actual)) -> dict:
-    response.delete_cookie(COOKIE_SESION)
-    response.delete_cookie(COOKIE_CSRF)
+async def logout(response: Response, sesion: dict = Depends(usuario_actual)) -> dict:
+    """Cierra ESTA sesión. Borrar la cookie no bastaba: el token seguía siendo válido allá
+    donde se hubiera copiado, hasta `session_max_age_s` (8h por defecto)."""
+    if jti := sesion.get("jti"):
+        await asyncio.to_thread(revocar_sesion, jti, caducidad_de(sesion))
+    _borrar_cookies(response)
+    return {"ok": True}
+
+
+@router.post("/auth/logout-todas")
+async def logout_todas(response: Response, sesion: dict = Depends(usuario_actual)) -> dict:
+    """Cierra la sesión en TODOS los dispositivos.
+
+    Es la respuesta a «me han robado el portátil» o a un cambio de contraseña: sin esto, la
+    única forma de invalidar una sesión filtrada era rotar `MORPHOS_SESSION_SECRET`, que echa a
+    todos los usuarios de la instancia.
+    """
+    await asyncio.to_thread(revocar_todas_las_sesiones, sesion["email"])
+    _borrar_cookies(response)
     return {"ok": True}

backend/app/security/authz.py

@@ -7,6 +7,7 @@ abiertos. Aquí requieren sesión válida. Las peticiones mutantes exigen doble-
 from __future__ import annotations
 
 import hmac
+from datetime import datetime
 
 from fastapi import Cookie, Header, HTTPException, Request, status
 
@@ -15,14 +16,46 @@ from .session import CABECERA_CSRF, COOKIE_CSRF, COOKIE_SESION, leer_sesion
 
 
 def usuario_actual(request: Request) -> dict:
-    """Devuelve la sesión o 401. Usar como dependencia en rutas protegidas."""
+    """Devuelve la sesión o 401. Usar como dependencia en rutas protegidas.
+
+    La firma válida ya no basta: una cookie firmada valía hasta caducar mirándola sólo a ella,
+    así que una copiada no se podía invalidar. Se comprueban además las dos revocaciones
+    (`db.revocar_sesion` para una, `db.revocar_todas_las_sesiones` para las de una cuenta).
+
+    Es `def` y no `async def` a propósito: FastAPI ejecuta las dependencias síncronas en un hilo,
+    así que estas dos consultas no bloquean el bucle de eventos (ver §3.1).
+    """
     token = request.cookies.get(COOKIE_SESION)
     sesion = leer_sesion(token)
     if not sesion or not sesion.get("email"):
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="No autenticado.")
+    if _revocada(sesion):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Sesión revocada.")
     return sesion
 
 
+def _revocada(sesion: dict) -> bool:
+    from .. import db
+
+    jti = sesion.get("jti")
+    # Sin `jti` es una cookie anterior a la revocación. Se acepta hasta que caduque: invalidarlas
+    # de golpe echaría a todo el mundo en el despliegue, y su vida máxima ya es acotada.
+    if jti and db.sesion_revocada(jti):
+        return True
+    corte = db.sesiones_validas_desde(sesion["email"])
+    if not corte:
+        return False
+    emitida = sesion.get("emitida_en")
+    if not emitida:
+        return True  # hay corte y la sesión no dice cuándo nació: se descarta
+    # Ambas ISO-8601 UTC con microsegundos: a resolución de segundo, una sesión emitida en el
+    # mismo segundo que el corte sobrevivía.
+    try:
+        return datetime.fromisoformat(emitida) < datetime.fromisoformat(corte)
+    except ValueError:
+        return True
+
+
 def tenant_de_sesion(sesion: dict) -> str:
     """Clínica del usuario de la sesión.
 

backend/app/security/session.py

@@ -8,6 +8,7 @@ cabecera X-CSRF-Token en peticiones mutantes.
 from __future__ import annotations
 
 import secrets
+from datetime import UTC, datetime, timedelta
 
 from itsdangerous import BadData, URLSafeTimedSerializer
 
@@ -25,7 +26,29 @@ def _serializer() -> URLSafeTimedSerializer:
 
 
 def firmar_sesion(datos: dict) -> str:
-    return _serializer().dumps(datos)
+    """Firma la sesión añadiéndole identidad (`jti`) e instante de emisión (`emitida_en`).
+
+    Sin `jti` no se puede revocar UNA sesión —no hay nada que nombrar—, y sin `emitida_en` no se
+    puede cortar un conjunto de ellas por fecha. Se generan aquí, y no en quien llama, para que
+    ninguna ruta pueda emitir por descuido una sesión irrevocable.
+    """
+    completos = {
+        "jti": secrets.token_urlsafe(16),
+        "emitida_en": datetime.now(UTC).isoformat(),
+        **datos,
+    }
+    return _serializer().dumps(completos)
+
+
+def caducidad_de(sesion: dict) -> str:
+    """Cuándo deja de valer la firma por sí sola: hasta ahí hay que recordar una revocación."""
+    cfg = obtener_config()
+    emitida = sesion.get("emitida_en")
+    try:
+        base = datetime.fromisoformat(emitida) if emitida else datetime.now(UTC)
+    except ValueError:
+        base = datetime.now(UTC)
+    return (base + timedelta(seconds=cfg.session_max_age_s)).isoformat()
 
 
 def leer_sesion(token: str | None) -> dict | None:

backend/tests/test_revocacion_sesiones.py

@@ -0,0 +1,97 @@
+"""Revocación de sesiones (ARCHITECTURE_REVIEW §2.3).
+
+Las sesiones son cookies firmadas sin estado, y el logout se limitaba a borrar la cookie del
+navegador: el token seguía siendo VÁLIDO allá donde se hubiera copiado, hasta
+`session_max_age_s` (8h). No había forma de invalidar una sesión filtrada, ni de echar a nadie
+tras un incidente, salvo rotar `MORPHOS_SESSION_SECRET` y tirar a todos los usuarios a la vez.
+
+La prueba que importa no es «logout devuelve 200», sino que **la cookie de antes ya no sirve**.
+"""
+
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.main import app
+
+
+@pytest.fixture
+def cliente():
+    with TestClient(app) as c:
+        yield c
+
+
+def _alta(cliente, email):
+    r = cliente.post(
+        "/api/auth/registro",
+        json={"nombre": "V", "apellido": "Vet", "email": email, "password": "clave-segura-1"},
+    )
+    if r.status_code == 409:
+        r = cliente.post("/api/auth/login", json={"email": email, "password": "clave-segura-1"})
+    assert r.status_code == 200, r.text
+    return r
+
+
+def test_la_cookie_deja_de_valer_tras_el_logout(cliente, alta_abierta):
+    """El agujero concreto: una copia de la cookie sobrevivía al «cerrar sesión»."""
+    _alta(cliente, "rev1@example.com")
+    galleta = cliente.cookies.get("morphos_sesion")
+    assert cliente.get("/api/auth").json()["autenticado"] is True
+
+    cliente.post("/api/auth/logout")
+
+    # Se reenvía la cookie a mano, como haría quien la hubiera copiado.
+    r = cliente.get("/api/lab/pendientes", cookies={"morphos_sesion": galleta})
+    assert r.status_code == 401
+
+
+def test_logout_todas_corta_las_demas_sesiones(cliente, alta_abierta):
+    """«Me han robado el portátil»: cierra las sesiones abiertas en otros dispositivos."""
+    _alta(cliente, "rev2@example.com")
+    portatil = cliente.cookies.get("morphos_sesion")
+
+    # Segunda sesión (otro dispositivo) para la misma cuenta.
+    otro = TestClient(app)
+    r = otro.post("/api/auth/login", json={"email": "rev2@example.com", "password": "clave-segura-1"})
+    assert r.status_code == 200
+
+    otro.post("/api/auth/logout-todas")
+
+    r = cliente.get("/api/lab/pendientes", cookies={"morphos_sesion": portatil})
+    assert r.status_code == 401, "la sesión del otro dispositivo siguió viva"
+
+
+def test_revocar_una_no_afecta_a_las_de_otras_cuentas(cliente, alta_abierta):
+    """Aislar el corte: revocar no puede convertirse en una denegación de servicio ajena."""
+    _alta(cliente, "rev3@example.com")
+    ajena = TestClient(app)
+    _alta(ajena, "rev4@example.com")
+
+    cliente.post("/api/auth/logout-todas")
+
+    assert ajena.get("/api/auth").json()["autenticado"] is True
+
+
+def test_una_sesion_nueva_tras_el_corte_si_vale(cliente, alta_abierta):
+    """El corte es por fecha de emisión: volver a entrar tiene que funcionar."""
+    _alta(cliente, "rev5@example.com")
+    cliente.post("/api/auth/logout-todas")
+
+    r = cliente.post(
+        "/api/auth/login", json={"email": "rev5@example.com", "password": "clave-segura-1"}
+    )
+    assert r.status_code == 200
+    assert cliente.get("/api/auth").json()["autenticado"] is True
+
+
+def test_el_logout_borra_las_cookies_con_sus_atributos(cliente, alta_abierta):
+    """`delete_cookie()` a secas emite un Set-Cookie sin samesite/path y algunos navegadores lo
+    tratan como una cookie distinta: la sesión se quedaba en el navegador."""
+    _alta(cliente, "rev6@example.com")
+    r = cliente.post("/api/auth/logout")
+
+    borrados = [v for v in r.headers.get_list("set-cookie") if "morphos_sesion" in v]
+    assert borrados, "el logout no intentó borrar la cookie de sesión"
+    assert "Path=/" in borrados[0]
+    assert "samesite=strict" in borrados[0].lower()

backend/tests/test_session.py

@@ -14,7 +14,23 @@ from app.security import session as ses
 
 def test_ida_y_vuelta():
     token = ses.firmar_sesion({"email": "vet@example.com"})
-    assert ses.leer_sesion(token) == {"email": "vet@example.com"}
+    sesion = ses.leer_sesion(token)
+    assert sesion["email"] == "vet@example.com"
+
+
+def test_toda_sesion_nace_identificada_y_fechada():
+    """`jti` y `emitida_en` los pone `firmar_sesion`, no quien llama.
+
+    Son lo que hace revocable una sesión: sin `jti` no hay nada que nombrar para cerrar UNA, y
+    sin `emitida_en` no se pueden cortar TODAS las de una cuenta por fecha. Si se generaran en
+    quien llama, una ruta podría emitir por descuido una sesión irrevocable.
+    """
+    a = ses.leer_sesion(ses.firmar_sesion({"email": "vet@example.com"}))
+    b = ses.leer_sesion(ses.firmar_sesion({"email": "vet@example.com"}))
+
+    assert a["jti"] and b["jti"]
+    assert a["jti"] != b["jti"], "dos sesiones con el mismo jti se revocarían juntas"
+    assert a["emitida_en"]
 
 
 @pytest.mark.parametrize(