# Attaques courantes sur les mots de passe
Brute force        : tester toutes les combinaisons possibles
Dictionary attack   : tester une liste de mots de passe courants (rockyou.txt, etc.)
Credential stuffing : réutiliser des paires email/mot de passe issues de fuites (breaches) sur d'autres sites
Password spraying   : tester UN mot de passe courant sur BEAUCOUP de comptes (évite le lockout par compte)
Rainbow table       : table précalculée de hachages pour retrouver un mot de passe en clair

# Mauvaise pratique : stocker le mot de passe en clair ou avec un hash faible
password_bad = "monMotDePasse123"  # JAMAIS stocker ceci tel quel en base

# Bonne pratique : hachage avec sel, avec un algorithme lent conçu pour les mots de passe
# bcrypt, scrypt ou argon2 - PAS md5/sha1/sha256 seuls (trop rapides = brute-forçables)
import bcrypt

def hash_password(plain_password: str) -> bytes:
    salt = bcrypt.gensalt(rounds=12)  # coût ajustable, 12 = bon compromis 2024
    return bcrypt.hashpw(plain_password.encode("utf-8"), salt)

def verify_password(plain_password: str, hashed: bytes) -> bool:
    return bcrypt.checkpw(plain_password.encode("utf-8"), hashed)

hashed = hash_password("Tr0ub4dor&3")
assert verify_password("Tr0ub4dor&3", hashed) is True
assert verify_password("mauvais_mdp", hashed) is False

# Encore mieux : argon2id (vainqueur du Password Hashing Competition), résistant GPU/ASIC
from argon2 import PasswordHasher

ph = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=4)  # 64 Mo de RAM par hash
hashed = ph.hash("Tr0ub4dor&3")

try:
    ph.verify(hashed, "Tr0ub4dor&3")
    print("mot de passe valide")
except Exception:
    print("mot de passe invalide")

# Politique de mot de passe moderne (NIST SP 800-63B) : privilégier la LONGUEUR
# plutôt que la complexité imposée (majuscule+chiffre+symbole = mots de passe prévisibles "P@ssw0rd1")
import re

def is_password_acceptable(pw: str, breached_list: set[str]) -> tuple[bool, str]:
    if len(pw) < 12:
        return False, "au moins 12 caractères recommandés"
    if pw.lower() in breached_list:  # vérifier contre une liste de mots de passe compromis (HaveIBeenPwned)
        return False, "ce mot de passe est présent dans des fuites connues"
    if re.fullmatch(r"(.)
+", pw):  # rejette "aaaaaaaaaaaa"
        return False, "mot de passe trop simple"
    return True, "ok"

# Vérifier un mot de passe contre HaveIBeenPwned SANS jamais envoyer le mot de passe en clair
# (k-anonymity: on envoie seulement les 5 premiers caractères du hash SHA1)
PASSWORD="Tr0ub4dor&3"
HASH=$(printf '%s' "$PASSWORD" | sha1sum | tr 'a-z' 'A-Z' | cut -c1-40)
PREFIX=${HASH:0:5}
SUFFIX=${HASH:5}
curl -s "https://api.pwnedpasswords.com/range/$PREFIX" | grep -i "$SUFFIX"

# Protection contre le brute force côté application
1. Rate limiting sur /login (ex: 5 tentatives / 15 min / IP+compte)
2. Verrouillage progressif du compte (backoff exponentiel)
3. CAPTCHA après N échecs
4. Alerte / notification sur connexion depuis un nouvel appareil ou pays
5. Journalisation des échecs d'authentification pour détection d'anomalie

# Exemple simplifié de rate limiting sur une route de login (FastAPI + dépendance mémoire/Redis)
from fastapi import FastAPI, HTTPException, Request
from collections import defaultdict
from time import time

app = FastAPI()
attempts: dict[str, list[float]] = defaultdict(list)
WINDOW_SECONDS = 900  # 15 minutes
MAX_ATTEMPTS = 5

@app.post("/login")
async def login(request: Request):
    ip = request.client.host
    now = time()
    attempts[ip] = [t for t in attempts[ip] if now - t < WINDOW_SECONDS]
    if len(attempts[ip]) >= MAX_ATTEMPTS:
        raise HTTPException(status_code=429, detail="Trop de tentatives, réessayez plus tard")
    attempts[ip].append(now)
    # ... vérification des identifiants ...