feat(backend): fait tourner les jetons de rafraîchissement et détecte leur réutilisation

Le jeton de rafraîchissement est une chaîne opaque de 256 bits, jamais un
JWT. Il doit être révocable, donc sa ligne en base existe de toute façon,
et le JWT n'ajouterait qu'un second chemin de signature. Surtout, la
séparation d'avec le jeton d'accès devient structurelle : un JWT ne
figure dans aucune ligne, une chaîne opaque échoue au décodage. La
confusion refresh-vers-accès, qui transforme une fenêtre de 15 minutes en
fenêtre de 7 jours, est impossible même si quelqu'un oublie le test.

Seule l'empreinte SHA-256 est stockée. Pas d'Argon2 : l'entrée fait
256 bits de CSPRNG, aucun dictionnaire ne l'atteint, et une KDF coûterait
17 ms à chaque rafraîchissement.

La rotation ne protège de rien par elle-même : elle rend la réutilisation
détectable, et c'est la détection qui termine le vol. Un jeton déjà
tourné révoque donc toute sa famille et laisse une trace dans
`audit_log` ; un jeton expiré, lui, ne révoque rien, ce n'est pas une
preuve de compromission. Les deux cas ont leur test.

La revendication est une seule instruction SQL avec RETURNING. Un SELECT
puis un UPDATE laisseraient une fenêtre où deux onglets réussissent la
même rotation ; le test d'intégration le prouve, ce qui est
indémontrable sur un double.

`expires_at` est absolu et hérité du prédécesseur : s'il glissait, la
promesse de sept jours serait fictive.

Corrige au passage un défaut trouvé par un test : une `HTTPException`
construit sa propre réponse, donc l'effacement du cookie posé sur la
`Response` injectée était perdu. Un navigateur gardait un cookie mort
après une détection de réutilisation.

apps/backend/app/api/deps.py

@@ -23,6 +23,7 @@ from app.core.security import decode_access_token as decode_token
 from app.db.session import get_session
 from app.repositories.audit_log import AuditLogRepository
 from app.repositories.login_attempt import LoginAttemptRepository
+from app.repositories.refresh_token import RefreshTokenRepository
 from app.repositories.user import UserRepository
 from app.services.auth import AuthService, LoginPolicy
 
@@ -95,6 +96,7 @@ def get_auth_service(
     return AuthService(
         users=UserRepository(session),
         attempts=LoginAttemptRepository(session),
+        refresh_tokens=RefreshTokenRepository(session),
         audit=AuditLogRepository(session),
         hasher=hasher,
         transaction=session,
@@ -105,6 +107,7 @@ def get_auth_service(
             max_failures_per_ip=settings.login_max_failures_per_ip,
             max_failures_per_identifier=settings.login_max_failures_per_identifier,
         ),
+        refresh_ttl=timedelta(seconds=settings.refresh_token_ttl_seconds),
     )
 
 

apps/backend/app/api/v1/endpoints/auth.py

@@ -1,14 +1,59 @@
+# Piège : le jeton de rafraîchissement ne quitte jamais le cookie httpOnly, et le jeton
+# d'accès ne va jamais dans un cookie. C'est ce qui réduit la surface CSRF aux trois routes de
+# ce module : partout ailleurs, le navigateur n'attache rien de lui-même.
+
 from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
 
-from app.api.deps import AuthServiceDep, CurrentPrincipalDep, get_client_ip
+from app.api.deps import (
+    AuthServiceDep,
+    CurrentPrincipalDep,
+    SettingsDep,
+    get_client_ip,
+    require_trusted_origin,
+)
+from app.core.cookies import RefreshCookie, cookie_name
 from app.core.logging import get_logger
 from app.schemas.auth import LoginRequest, PrincipalResponse, TokenResponse
-from app.services.auth import InvalidCredentialsError, RateLimitedError
+from app.services.auth import (
+    AuthenticatedSession,
+    InvalidCredentialsError,
+    RateLimitedError,
+    SessionRejectedError,
+)
 
 router = APIRouter()
 logger = get_logger(__name__)
 
 DETAIL_IDENTIFIANTS = "Identifiants invalides"
+DETAIL_SESSION = "Session invalide"
+
+
+def repond(
+    response: Response, settings: SettingsDep, session: AuthenticatedSession
+) -> TokenResponse:
+    response.headers["Cache-Control"] = "no-store"
+    response.set_cookie(**RefreshCookie.build(settings, session.refresh_secret).as_kwargs())
+    return TokenResponse(
+        access_token=session.access_token,
+        expires_in=session.expires_in,
+        principal=PrincipalResponse.from_principal(session.principal),
+    )
+
+
+# Piège : une `HTTPException` construit sa propre réponse, donc tout en-tête posé sur la
+# `Response` injectée est perdu. L'effacement du cookie doit voyager avec l'exception,
+# sans quoi un navigateur garderait un cookie mort après une détection de réutilisation.
+def entete_de_suppression(settings: SettingsDep) -> str:
+    temoin = Response()
+    temoin.delete_cookie(**RefreshCookie.expired(settings).as_deletion_kwargs())
+    return temoin.headers["set-cookie"]
+
+
+def lit_le_cookie(request: Request, settings: SettingsDep) -> str:
+    secret = request.cookies.get(cookie_name(settings))
+    if not secret:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=DETAIL_SESSION)
+    return secret
 
 
 @router.post("/login", response_model=TokenResponse, summary="Ouvre une session")
@@ -16,19 +61,16 @@ async def login(
     payload: LoginRequest,
     request: Request,
     response: Response,
+    settings: SettingsDep,
     service: AuthServiceDep,
     client_ip: str | None = Depends(get_client_ip),
 ) -> TokenResponse:
-    # Une réponse d'authentification ne doit jamais être conservée par un intermédiaire.
     response.headers["Cache-Control"] = "no-store"
     agent = request.headers.get("user-agent")
 
     try:
         session = await service.authenticate(
-            email=payload.email,
-            password=payload.password,
-            client_ip=client_ip,
-            user_agent=agent,
+            email=payload.email, password=payload.password, client_ip=client_ip, user_agent=agent
         )
     except RateLimitedError as erreur:
         logger.warning("auth.rate_limited email=%s ip=%s", payload.email, client_ip)
@@ -44,11 +86,76 @@ async def login(
         ) from erreur
 
     logger.info("auth.login.success user_id=%s ip=%s", session.principal.id, client_ip)
-    return TokenResponse(
-        access_token=session.access_token,
-        expires_in=session.expires_in,
-        principal=PrincipalResponse.from_principal(session.principal),
-    )
+    return repond(response, settings, session)
+
+
+@router.post(
+    "/refresh",
+    response_model=TokenResponse,
+    summary="Fait tourner la session",
+    dependencies=[Depends(require_trusted_origin)],
+)
+async def refresh(
+    request: Request,
+    response: Response,
+    settings: SettingsDep,
+    service: AuthServiceDep,
+    client_ip: str | None = Depends(get_client_ip),
+) -> TokenResponse:
+    response.headers["Cache-Control"] = "no-store"
+
+    try:
+        session = await service.refresh(
+            secret=lit_le_cookie(request, settings),
+            client_ip=client_ip,
+            user_agent=request.headers.get("user-agent"),
+        )
+    except SessionRejectedError as erreur:
+        logger.warning("auth.refresh.rejected ip=%s", client_ip)
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=DETAIL_SESSION,
+            headers={
+                "Set-Cookie": entete_de_suppression(settings),
+                "Cache-Control": "no-store",
+            },
+        ) from erreur
+
+    return repond(response, settings, session)
+
+
+@router.post(
+    "/logout",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Ferme la session courante",
+    dependencies=[Depends(require_trusted_origin)],
+)
+async def logout(
+    request: Request, response: Response, settings: SettingsDep, service: AuthServiceDep
+) -> None:
+    response.headers["Cache-Control"] = "no-store"
+    secret = request.cookies.get(cookie_name(settings))
+    if secret:
+        await service.logout(secret=secret)
+    response.delete_cookie(**RefreshCookie.expired(settings).as_deletion_kwargs())
+
+
+@router.post(
+    "/logout-all",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Ferme toutes les sessions du compte",
+    dependencies=[Depends(require_trusted_origin)],
+)
+async def logout_all(
+    principal: CurrentPrincipalDep,
+    response: Response,
+    settings: SettingsDep,
+    service: AuthServiceDep,
+) -> None:
+    response.headers["Cache-Control"] = "no-store"
+    revoquees = await service.logout_all(principal)
+    logger.info("auth.logout_all user_id=%s sessions=%s", principal.id, revoquees)
+    response.delete_cookie(**RefreshCookie.expired(settings).as_deletion_kwargs())
 
 
 @router.get("/me", response_model=PrincipalResponse, summary="Décrit le compte connecté")