feat(backend): authentifie par mot de passe et refuse les routes par défaut
Connexion, lecture du compte connecté, RBAC à trois rôles ordonnés et limitation de débit à fenêtre glissante. Ajoute `login_attempt`, le compteur de la limitation, et `audit_log`, en ajout seul. Trois ordres d'exécution portent la sécurité de ce commit, et chacun a son test : - les compteurs sont lus AVANT le hachage Argon2, sinon chaque requête rejetée coûterait quand même 17 ms et 19 Mio, et la protection serait l'amplificateur de déni de service qu'elle doit empêcher ; - un haché leurre est vérifié quand l'adresse est inconnue, sinon l'écart entre 2 ms et 17 ms est un oracle d'existence de compte ; - la tentative échouée est validée en base avant que l'erreur ne soit levée, `get_session()` ne validant pas de lui-même. Pas de verrouillage de compte : il suffirait de cinq requêtes pour mettre un administrateur dehors, et il ne fait rien contre le bourrage d'identifiants horizontal. Trois seuils le remplacent, dont un par couple (identifiant, IP) qui garantit qu'un attaquant ne peut pas empêcher la victime de se connecter depuis sa propre adresse. `audit_log` est en ajout seul au niveau de PostgreSQL, par deux déclencheurs. Le second n'est pas redondant : TRUNCATE ne passe pas par les déclencheurs de ligne. `test_route_protection.py` interroge réellement chaque route sans jeton. Rendre une route publique impose donc de modifier une liste dans un fichier de test, ce qui se voit en revue. Le gestionnaire de 422 arrive ici et non plus tard : la réponse par défaut de FastAPI contient la valeur rejetée, donc le mot de passe. Le test qui le prouve serait rouge sans lui.
This commit is contained in:
Johan LEROY
@@ -1,10 +1,174 @@
|
||||
# Piège : `get_current_principal()` relit le compte en base à chaque requête au lieu de faire
|
||||
# confiance aux claims. C'est le renoncement assumé à la propriété « sans état » : sur un seul
|
||||
# service et une seule base, elle n'achetait rien, et la lecture par clé primaire coûte moins
|
||||
# d'un pour cent du budget d'une requête. Ce qu'elle achète, c'est la révocation immédiate.
|
||||
# Piège : le `Principal` est construit depuis la ligne, jamais depuis le claim `role`. Un claim
|
||||
# périmé ne peut donc pas provoquer d'élévation de privilège.
|
||||
|
||||
from collections.abc import Callable
|
||||
from datetime import timedelta
|
||||
from functools import lru_cache
|
||||
from typing import Annotated
|
||||
|
||||
from fastapi import Depends
|
||||
from fastapi import Depends, HTTPException, Request, status
|
||||
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core.config import Settings, get_settings
|
||||
from app.core.hashing import Argon2Hasher, build_hasher
|
||||
from app.core.principal import Principal
|
||||
from app.core.roles import AccountKind, Role, has_at_least
|
||||
from app.core.security import TokenExpiredError, TokenInvalidError, TokenPolicy
|
||||
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.user import UserRepository
|
||||
from app.services.auth import AuthService, LoginPolicy
|
||||
|
||||
SessionDep = Annotated[AsyncSession, Depends(get_session)]
|
||||
SettingsDep = Annotated[Settings, Depends(get_settings)]
|
||||
|
||||
CODE_CHANGEMENT_REQUIS = "password_change_required"
|
||||
|
||||
_porteur = HTTPBearer(auto_error=False, scheme_name="Jeton d'accès")
|
||||
CredentialsDep = Annotated[HTTPAuthorizationCredentials | None, Depends(_porteur)]
|
||||
|
||||
|
||||
def _non_authentifie(description: str) -> HTTPException:
|
||||
return HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="Authentification requise",
|
||||
headers={"WWW-Authenticate": f'Bearer error="{description}"'},
|
||||
)
|
||||
|
||||
|
||||
def get_token_policy(settings: SettingsDep) -> TokenPolicy:
|
||||
return TokenPolicy(
|
||||
secret=settings.secret_key.get_secret_value(),
|
||||
issuer=settings.jwt_issuer,
|
||||
audience=settings.jwt_audience,
|
||||
access_ttl=timedelta(seconds=settings.access_token_ttl_seconds),
|
||||
)
|
||||
|
||||
|
||||
# Construire un `Argon2Hasher` calcule un haché leurre, donc 17 ms : il est mis en cache sur
|
||||
# les paramètres plutôt que reconstruit à chaque requête.
|
||||
@lru_cache
|
||||
def _hasher_cache(
|
||||
time_cost: int, memory_cost_kib: int, parallelism: int, max_concurrency: int
|
||||
) -> Argon2Hasher:
|
||||
return build_hasher(
|
||||
time_cost=time_cost,
|
||||
memory_cost_kib=memory_cost_kib,
|
||||
parallelism=parallelism,
|
||||
max_concurrency=max_concurrency,
|
||||
)
|
||||
|
||||
|
||||
def get_hasher(settings: SettingsDep) -> Argon2Hasher:
|
||||
return _hasher_cache(
|
||||
settings.argon2_time_cost,
|
||||
settings.argon2_memory_cost_kib,
|
||||
settings.argon2_parallelism,
|
||||
settings.argon2_max_concurrency,
|
||||
)
|
||||
|
||||
|
||||
def get_client_ip(request: Request, settings: SettingsDep) -> str | None:
|
||||
# Derrière un proxy, `request.client.host` vaut l'IP du proxy : le compteur par IP
|
||||
# deviendrait global, donc un déni de service auto-infligé. Le dernier élément est le seul
|
||||
# qu'un proxy de confiance ait écrit, les précédents sont fournis par le client.
|
||||
if settings.trust_proxy_headers:
|
||||
transmis = request.headers.get("x-forwarded-for")
|
||||
if transmis:
|
||||
return transmis.split(",")[-1].strip()
|
||||
return request.client.host if request.client else None
|
||||
|
||||
|
||||
def get_auth_service(
|
||||
session: SessionDep,
|
||||
settings: SettingsDep,
|
||||
hasher: Annotated[Argon2Hasher, Depends(get_hasher)],
|
||||
token_policy: Annotated[TokenPolicy, Depends(get_token_policy)],
|
||||
) -> AuthService:
|
||||
return AuthService(
|
||||
users=UserRepository(session),
|
||||
attempts=LoginAttemptRepository(session),
|
||||
audit=AuditLogRepository(session),
|
||||
hasher=hasher,
|
||||
transaction=session,
|
||||
token_policy=token_policy,
|
||||
login_policy=LoginPolicy(
|
||||
window_seconds=settings.login_window_seconds,
|
||||
max_failures_per_identifier_and_ip=(settings.login_max_failures_per_identifier_and_ip),
|
||||
max_failures_per_ip=settings.login_max_failures_per_ip,
|
||||
max_failures_per_identifier=settings.login_max_failures_per_identifier,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
AuthServiceDep = Annotated[AuthService, Depends(get_auth_service)]
|
||||
|
||||
|
||||
async def get_current_principal(
|
||||
credentials: CredentialsDep,
|
||||
session: SessionDep,
|
||||
token_policy: Annotated[TokenPolicy, Depends(get_token_policy)],
|
||||
) -> Principal:
|
||||
if credentials is None:
|
||||
raise _non_authentifie("invalid_request")
|
||||
|
||||
try:
|
||||
claims = decode_token(token_policy, credentials.credentials)
|
||||
except TokenExpiredError as erreur:
|
||||
raise _non_authentifie("expired") from erreur
|
||||
except TokenInvalidError as erreur:
|
||||
raise _non_authentifie("invalid_token") from erreur
|
||||
|
||||
compte = await UserRepository(session).get_by_id(claims.subject)
|
||||
if compte is None or not compte.is_active:
|
||||
raise _non_authentifie("invalid_token")
|
||||
if claims.issued_at < compte.credentials_changed_at:
|
||||
raise _non_authentifie("token_stale")
|
||||
if claims.role != compte.role:
|
||||
raise _non_authentifie("token_stale")
|
||||
|
||||
return Principal(
|
||||
id=compte.id,
|
||||
email=compte.email,
|
||||
role=Role(compte.role),
|
||||
kind=AccountKind(compte.kind),
|
||||
must_change_password=compte.must_change_password,
|
||||
)
|
||||
|
||||
|
||||
CurrentPrincipalDep = Annotated[Principal, Depends(get_current_principal)]
|
||||
|
||||
|
||||
def require_role(minimum: Role) -> Callable[[Principal], Principal]:
|
||||
def garde(principal: CurrentPrincipalDep) -> Principal:
|
||||
if principal.must_change_password:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_403_FORBIDDEN, detail=CODE_CHANGEMENT_REQUIS
|
||||
)
|
||||
if not has_at_least(principal.role, minimum):
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Droits insuffisants")
|
||||
return principal
|
||||
|
||||
return garde
|
||||
|
||||
|
||||
LecteurDep = Annotated[Principal, Depends(require_role(Role.LECTEUR))]
|
||||
OperateurDep = Annotated[Principal, Depends(require_role(Role.OPERATEUR))]
|
||||
AdminDep = Annotated[Principal, Depends(require_role(Role.ADMIN))]
|
||||
|
||||
|
||||
def require_trusted_origin(request: Request, settings: SettingsDep) -> None:
|
||||
# Un navigateur envoie toujours `Origin` sur une requête non sûre. Son absence signale un
|
||||
# client hors navigateur, qui ne détient aucun cookie de victime : rien à protéger.
|
||||
origine = request.headers.get("origin")
|
||||
if origine is None:
|
||||
return
|
||||
if origine not in settings.allowed_origins:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Origine refusée")
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
# Piège : la réponse 422 par défaut de FastAPI contient la clé `input`, c'est-à-dire la valeur
|
||||
# rejetée. Sur `/auth/login`, un corps malformé renverrait donc le mot de passe au client et le
|
||||
# déposerait dans les journaux d'erreur. `validation_error_handler()` ne laisse passer que le
|
||||
# champ fautif et le type d'erreur.
|
||||
|
||||
import uuid
|
||||
from typing import Any
|
||||
|
||||
from fastapi import FastAPI, Request, status
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
from app.core.logging import get_logger
|
||||
|
||||
logger = get_logger(__name__)
|
||||
|
||||
|
||||
async def validation_error_handler(_: Request, exception: RequestValidationError) -> JSONResponse:
|
||||
champs: list[dict[str, Any]] = [
|
||||
{
|
||||
"champ": ".".join(str(element) for element in erreur["loc"]),
|
||||
"type": erreur["type"],
|
||||
}
|
||||
for erreur in exception.errors()
|
||||
]
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, content={"detail": champs}
|
||||
)
|
||||
|
||||
|
||||
async def unhandled_error_handler(request: Request, exception: Exception) -> JSONResponse:
|
||||
correlation = uuid.uuid4().hex
|
||||
logger.exception(
|
||||
"erreur non gérée correlation=%s methode=%s chemin=%s",
|
||||
correlation,
|
||||
request.method,
|
||||
request.url.path,
|
||||
)
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
content={"detail": "Erreur interne", "correlation": correlation},
|
||||
)
|
||||
|
||||
|
||||
def register_error_handlers(application: FastAPI) -> None:
|
||||
application.add_exception_handler(RequestValidationError, validation_error_handler) # type: ignore[arg-type]
|
||||
application.add_exception_handler(Exception, unhandled_error_handler)
|
||||
@@ -0,0 +1,56 @@
|
||||
from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
|
||||
|
||||
from app.api.deps import AuthServiceDep, CurrentPrincipalDep, get_client_ip
|
||||
from app.core.logging import get_logger
|
||||
from app.schemas.auth import LoginRequest, PrincipalResponse, TokenResponse
|
||||
from app.services.auth import InvalidCredentialsError, RateLimitedError
|
||||
|
||||
router = APIRouter()
|
||||
logger = get_logger(__name__)
|
||||
|
||||
DETAIL_IDENTIFIANTS = "Identifiants invalides"
|
||||
|
||||
|
||||
@router.post("/login", response_model=TokenResponse, summary="Ouvre une session")
|
||||
async def login(
|
||||
payload: LoginRequest,
|
||||
request: Request,
|
||||
response: Response,
|
||||
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,
|
||||
)
|
||||
except RateLimitedError as erreur:
|
||||
logger.warning("auth.rate_limited email=%s ip=%s", payload.email, client_ip)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_429_TOO_MANY_REQUESTS,
|
||||
detail="Trop de tentatives, réessayez plus tard",
|
||||
headers={"Retry-After": str(erreur.retry_after)},
|
||||
) from erreur
|
||||
except InvalidCredentialsError as erreur:
|
||||
logger.warning("auth.login.failure email=%s ip=%s", payload.email, client_ip)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED, detail=DETAIL_IDENTIFIANTS
|
||||
) 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),
|
||||
)
|
||||
|
||||
|
||||
@router.get("/me", response_model=PrincipalResponse, summary="Décrit le compte connecté")
|
||||
async def me(principal: CurrentPrincipalDep) -> PrincipalResponse:
|
||||
return PrincipalResponse.from_principal(principal)
|
||||
@@ -1,6 +1,7 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from app.api.v1.endpoints import health
|
||||
from app.api.v1.endpoints import auth, health
|
||||
|
||||
api_router = APIRouter()
|
||||
api_router.include_router(health.router, prefix="/health")
|
||||
api_router.include_router(health.router, prefix="/health", tags=["health"])
|
||||
api_router.include_router(auth.router, prefix="/auth", tags=["auth"])
|
||||
|
||||
Reference in New Issue
Block a user