Authentification déléguée
de SAML à OIDC.

"""
═══════════════════════════════════════════════════════════════════════════════
POC OIDC avec Google — flow Authorization Code + PKCE, à la main.
═══════════════════════════════════════════════════════════════════════════════

Aucune librairie OIDC de haut niveau : on écrit chaque étape pour
comprendre exactement ce qui se passe sur le fil.

Vue d'ensemble du flow :

    1. User clique "Sign in with Google" → GET /auth/login
       → On génère state + nonce + PKCE
       → On redirige vers accounts.google.com avec ces paramètres

    2. Google authentifie l'user, lui demande son consentement
       → Google redirige vers GET /auth/callback?code=...&state=...

    3. On vérifie state (CSRF), on échange le code contre des tokens,
       on vérifie le id_token (signature + claims), on crée la session.

    4. L'user a un cookie de session signé → /dashboard l'identifie via /auth/me

Endpoints :
    GET  /                  → page d'accueil (HTML statique)
    GET  /auth/login        → redirige vers Google
    GET  /auth/callback     → reçoit le code, échange, crée session
    GET  /auth/me           → renvoie l'utilisateur courant en JSON
    POST /auth/logout       → détruit la session
    GET  /dashboard         → page protégée (HTML statique)
    GET  /concepts          → page de synthèse théorique (HTML statique)
"""

# ─── Imports ─────────────────────────────────────────────────────────────────
import os
import secrets  # génération de tokens cryptographiquement aléatoires
import hashlib  # SHA256 pour PKCE
import base64  # encodage base64url
from urllib.parse import urlencode  # construire les query strings d'URL

import httpx  # client HTTP async (pour appeler Google)
from fastapi import FastAPI, Request, HTTPException, Response
from fastapi.responses import RedirectResponse, JSONResponse, FileResponse
from itsdangerous import URLSafeSerializer, BadSignature  # signer les cookies
from jose import jwt  # décoder et vérifier les JWT (id_token)
from dotenv import load_dotenv  # charger les variables d'environnement depuis .env

# Charge les variables définies dans le fichier .env dans os.environ.
# Doit être appelé AVANT de lire os.environ ci-dessous.
load_dotenv()


# ─── Configuration ───────────────────────────────────────────────────────────
# On lit les secrets dans l'environnement (jamais en dur dans le code).
# Si une variable est manquante, le programme plante au démarrage : c'est
# voulu, on veut détecter tout de suite une mauvaise configuration.
CLIENT_ID = os.environ["GOOGLE_CLIENT_ID"]
CLIENT_SECRET = os.environ["GOOGLE_CLIENT_SECRET"]
SESSION_SECRET = os.environ["SESSION_SECRET"]

# URL exacte vers laquelle Google va rediriger après authentification.
# DOIT correspondre à la lettre à celle déclarée dans la console Google.
REDIRECT_URI = "http://localhost:8000/auth/callback"

# Endpoints de Google.
# En production, on les découvre dynamiquement via le document de discovery :
# https://accounts.google.com/.well-known/openid-configuration
# Ici on les met en dur pour rester pédagogique.
GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth"
GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token"
GOOGLE_JWKS_URL = "https://www.googleapis.com/oauth2/v3/certs"
GOOGLE_ISSUER = "https://accounts.google.com"

# Instance de l'application FastAPI.
app = FastAPI()

# Sérialiseurs pour signer (mais pas chiffrer) les cookies.
# On en utilise DEUX, avec des `salt` distincts, pour séparer logiquement
# les usages : le cookie de session ne doit pas pouvoir être interchangé
# avec le cookie temporaire `oauth_tmp` posé entre /login et /callback.
# Même clé secrète sous-jacente (SESSION_SECRET) mais signatures dérivées
# différentes grâce aux salts.
session_serializer = URLSafeSerializer(SESSION_SECRET, salt="session")
oauth_tmp_serializer = URLSafeSerializer(SESSION_SECRET, salt="oauth-tmp")

# Cache mémoire pour les clés publiques de Google (JWKS).
# En production il faudrait un TTL et un refresh périodique : Google peut
# faire tourner ses clés à tout moment.
_jwks_cache = None


# ─── Helpers PKCE ────────────────────────────────────────────────────────────
def gen_pkce_pair():
    """
    Génère une paire (code_verifier, code_challenge) pour PKCE (RFC 7636).

    PKCE protège contre l'interception du code d'autorisation : même si
    quelqu'un récupère le `code` dans l'URL de redirection, il ne pourra
    pas l'échanger contre un token sans le `code_verifier` original.

    - code_verifier  : chaîne aléatoire de 43 à 128 caractères, on la garde
                       côté serveur dans un cookie temporaire.
    - code_challenge : SHA256(verifier), encodé en base64url sans padding.
                       C'est ce qu'on envoie à Google dans l'URL d'auth.

    Plus tard, on enverra le verifier à Google lors de l'échange du code,
    et Google vérifiera que SHA256(verifier) == challenge reçu initialement.
    """
    verifier = secrets.token_urlsafe(64)
    challenge = (
        base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest())
        .rstrip(b"=")
        .decode()
    )
    return verifier, challenge


# ─── Helpers session ─────────────────────────────────────────────────────────
def set_session(response: Response, data: dict):
    """
    Pose un cookie de session signé sur la réponse.

    Le cookie est signé (pas chiffré) : son contenu est lisible par le
    navigateur, mais ne peut pas être modifié sans la clé SESSION_SECRET.
    → Donc on n'y met JAMAIS de secret, juste des données d'identification
      (sub, email, name…).

    Options du cookie :
      - httponly=True  : le cookie n'est pas accessible en JavaScript
                         (protection XSS — un attaquant qui injecte du JS
                         ne peut pas voler la session).
      - samesite="lax" : le cookie n'est pas envoyé sur les requêtes
                         cross-site sauf navigation top-level (protection
                         CSRF de base).
      - max_age=3600   : valable 1h.
      - secure=True    : à ajouter en prod (cookie envoyé uniquement en
                         HTTPS). En local sur http://localhost, on l'omet.
    """
    response.set_cookie(
        key="session",
        value=session_serializer.dumps(data),
        httponly=True,
        samesite="lax",
        max_age=3600,
        # secure=True,  # à activer en production (HTTPS only)
    )


def get_session(request: Request) -> dict | None:
    """
    Récupère et vérifie le cookie de session.

    Retourne le dict d'origine si le cookie est présent ET sa signature
    est valide. Retourne None sinon (pas de cookie, ou cookie trafiqué).
    """
    raw = request.cookies.get("session")
    if not raw:
        return None
    try:
        return session_serializer.loads(raw)
    except BadSignature:
        # Le cookie a été modifié ou signé avec une autre clé :
        # on l'ignore comme s'il n'existait pas.
        return None


# ─── Routes statiques ────────────────────────────────────────────────────────
@app.get("/")
def index():
    """Page d'accueil avec le bouton 'Sign in with Google'."""
    return FileResponse("static/index.html")


@app.get("/dashboard")
def dashboard():
    """
    Page protégée. Pas de vérification d'auth côté serveur ici : la page
    fait elle-même un fetch sur /auth/me et redirige si 401. C'est un
    choix pédagogique pour bien séparer les responsabilités.

    ATTENTION : le HTML lui-même est public — n'importe qui peut le
    télécharger. Ce qui est protégé, c'est uniquement l'endpoint
    /auth/me qui renvoie les données utilisateur. En production, les
    routes qui exposent des données sensibles doivent vérifier la
    session côté serveur AVANT de répondre, pas après côté client.
    """
    return FileResponse("static/dashboard.html")


@app.get("/concepts")
def concepts():
    """Page de synthèse théorique sur OAuth/OIDC/SAML/SSO/Kerberos."""
    return FileResponse("static/concepts.html")


# ─── Route : démarrage du flow d'authentification ────────────────────────────
@app.get("/auth/login")
def login(response: Response):
    """
    Étape 1 du flow OIDC : on prépare et on redirige vers Google.

    On génère trois valeurs aléatoires :

      - state         : valeur anti-CSRF qu'on va comparer au retour.
                        Si l'attaquant nous redirige vers /auth/callback
                        avec son propre code, son state ne matchera pas
                        le nôtre → on rejette.

      - nonce         : valeur anti-replay qui sera incluse dans le
                        id_token. Si un attaquant rejoue un ancien
                        id_token, son nonce ne matchera pas → on rejette.

      - code_verifier : secret PKCE qu'on garde côté serveur, et dont
                        on envoie le hash (challenge) à Google.

    Les trois valeurs sont stockées dans un cookie temporaire signé,
    qu'on relit au callback pour vérifier la cohérence.
    """
    state = secrets.token_urlsafe(32)
    nonce = secrets.token_urlsafe(32)
    code_verifier, code_challenge = gen_pkce_pair()

    # Paramètres de l'URL d'autorisation Google.
    # Référence : https://developers.google.com/identity/openid-connect/openid-connect
    params = {
        "client_id": CLIENT_ID,
        "redirect_uri": REDIRECT_URI,
        "response_type": "code",  # on veut un code d'autorisation
        "scope": "openid email profile",  # openid = obligatoire pour OIDC
        "state": state,
        "nonce": nonce,
        "code_challenge": code_challenge,
        "code_challenge_method": "S256",  # SHA256 (alternatif : "plain", à éviter)
        "access_type": "online",  # 'offline' si on veut un refresh_token
        "prompt": "select_account",  # force le sélecteur de compte Google
    }
    auth_url = f"{GOOGLE_AUTH_URL}?{urlencode(params)}"

    # On construit la réponse de redirection.
    resp = RedirectResponse(auth_url)

    # Cookie temporaire pour conserver state/nonce/verifier entre /login et /callback.
    # Durée : 10 min, suffisant pour que l'user se connecte sur Google.
    # On utilise oauth_tmp_serializer (salt="oauth-tmp") pour qu'un cookie
    # `oauth_tmp` ne puisse pas être interchangé avec un cookie `session`.
    resp.set_cookie(
        "oauth_tmp",
        oauth_tmp_serializer.dumps(
            {
                "state": state,
                "nonce": nonce,
                "verifier": code_verifier,
            }
        ),
        httponly=True,
        samesite="lax",
        max_age=600,
    )
    return resp


# ─── Helper : récupération des clés publiques de Google ──────────────────────
async def fetch_jwks(force_refresh: bool = False):
    """
    Récupère les JWKS (JSON Web Key Set) de Google : les clés publiques
    qui servent à vérifier la signature des id_token.

    `force_refresh=True` : ignore le cache et re-télécharge le JWKS.
    Utile quand on rencontre un `kid` inconnu (cas où Google a fait
    tourner ses clés depuis notre dernier fetch).

    En production, on ajouterait aussi un TTL (par exemple 1h) et un
    refresh périodique en tâche de fond. Google fait tourner ses clés
    sans préavis ; si on cache trop longtemps, on rejette des tokens
    valides signés avec une nouvelle clé.
    """
    global _jwks_cache
    if force_refresh or _jwks_cache is None:
        async with httpx.AsyncClient() as client:
            r = await client.get(GOOGLE_JWKS_URL)
            _jwks_cache = r.json()
    return _jwks_cache


def _find_key(jwks: dict, kid: str):
    """Retourne la clé du JWKS qui matche le kid demandé, ou None."""
    return next((k for k in jwks["keys"] if k["kid"] == kid), None)


# ─── Route : callback OAuth/OIDC ─────────────────────────────────────────────
@app.get("/auth/callback")
async def callback(
    request: Request,
    code: str | None = None,
    state: str | None = None,
    error: str | None = None,
):
    """
    Étape 2 du flow OIDC : Google nous redirige ici avec un `code`
    d'autorisation, qu'on va échanger contre des tokens.

    Étapes :
      1. Vérifier qu'on a bien `code` et `state` (et pas une erreur).
      2. Récupérer le cookie temporaire et vérifier le state (anti-CSRF).
      3. POST sur l'endpoint /token de Google avec code + verifier + secret.
      4. Récupérer access_token + id_token.
      5. Vérifier la signature du id_token avec les JWKS de Google.
      6. Vérifier les claims (iss, aud, exp — faits par jwt.decode).
      7. Vérifier le nonce (anti-replay).
      8. Créer la session utilisateur.
    """
    # ─── 1. Gestion des erreurs renvoyées par Google ─────────────────────────
    if error:
        # Exemples : access_denied (user a refusé), invalid_request, etc.
        raise HTTPException(400, f"Erreur Google : {error}")
    if not code or not state:
        raise HTTPException(400, "Paramètres code ou state manquants")

    # ─── 2. Vérification du state (anti-CSRF) ────────────────────────────────
    # On relit le cookie temporaire posé au /login.
    tmp_raw = request.cookies.get("oauth_tmp")
    if not tmp_raw:
        # Pas de cookie : soit l'user n'est pas passé par /login,
        # soit le cookie a expiré (>10 min sur l'écran Google).
        raise HTTPException(400, "Cookie oauth_tmp manquant")
    try:
        tmp = oauth_tmp_serializer.loads(tmp_raw)
    except BadSignature:
        raise HTTPException(400, "Signature du cookie oauth_tmp invalide")

    if tmp["state"] != state:
        # Le state reçu de Google ne correspond pas à celui qu'on avait posé.
        # Probablement une tentative de CSRF : on rejette.
        raise HTTPException(400, "State incohérent (possible CSRF)")

    # ─── 3. Échange du code contre des tokens ────────────────────────────────
    # On POST sur l'endpoint /token de Google. C'est ici que notre
    # client_secret est utilisé — il ne quitte JAMAIS le serveur.
    async with httpx.AsyncClient() as client:
        token_resp = await client.post(
            GOOGLE_TOKEN_URL,
            data={
                "client_id": CLIENT_ID,
                "client_secret": CLIENT_SECRET,
                "code": code,
                "code_verifier": tmp["verifier"],  # le PKCE
                "grant_type": "authorization_code",
                "redirect_uri": REDIRECT_URI,
            },
        )

    if token_resp.status_code != 200:
        # Échec : code expiré, redirect_uri qui ne matche pas, etc.
        raise HTTPException(400, f"Échec de l'échange du code : {token_resp.text}")

    tokens = token_resp.json()
    # `tokens` contient typiquement :
    #   - access_token  : token opaque pour appeler les APIs Google
    #   - expires_in    : durée de validité de l'access_token (~3600s)
    #   - id_token      : JWT signé contenant l'identité de l'user
    #   - scope         : scopes effectivement accordés
    #   - token_type    : "Bearer"

    # ─── 4. Récupération et vérification du id_token ─────────────────────────
    id_token = tokens["id_token"]

    # On récupère les clés publiques de Google.
    jwks = await fetch_jwks()

    # On lit le header du JWT (sans vérifier la signature) pour savoir
    # quelle clé (kid) il faut utiliser pour la vérification.
    # ATTENTION : on lit le header pour récupérer le `kid` uniquement.
    # On NE LIT PAS l'algorithme dans le header pour le passer à
    # jwt.decode() — ce serait une faille classique (« alg confusion »).
    # On force l'algorithme attendu à RS256, conforme au discovery
    # document de Google qui publie id_token_signing_alg_values_supported.
    header = jwt.get_unverified_header(id_token)
    key = _find_key(jwks, header["kid"])

    # Si le `kid` est introuvable, Google a probablement fait tourner ses
    # clés depuis notre dernier fetch. On refresh le JWKS une fois et on
    # réessaie avant de rejeter.
    if not key:
        jwks = await fetch_jwks(force_refresh=True)
        key = _find_key(jwks, header["kid"])

    if not key:
        # Même après refresh : la clé qui a signé le token n'existe pas
        # chez Google. Possible attaque ou bug.
        raise HTTPException(400, "Clé de signature introuvable dans le JWKS")

    # ─── 5. Décodage et validation du id_token ───────────────────────────────
    # jwt.decode() fait beaucoup de choses d'un coup :
    #   - vérifie la signature avec la clé publique
    #   - vérifie que l'algorithme correspond à RS256 (on ne fait PAS
    #     confiance au header.alg du token : on force la valeur attendue)
    #   - vérifie que `aud` (audience) == notre CLIENT_ID
    #   - vérifie que `iss` (issuer) == Google
    #   - vérifie que `exp` (expiration) n'est pas dépassée
    #   - vérifie at_hash si access_token fourni (lien id_token ↔ access_token)
    try:
        claims = jwt.decode(
            id_token,
            key,
            algorithms=["RS256"],
            audience=CLIENT_ID,
            issuer=GOOGLE_ISSUER,
            access_token=tokens["access_token"],
        )
    except Exception as e:
        raise HTTPException(400, f"id_token invalid: {e}")

    # ─── 6. Vérification du nonce (anti-replay) ──────────────────────────────
    # jwt.decode() ne vérifie pas le nonce, c'est à nous de le faire.
    if claims.get("nonce") != tmp["nonce"]:
        # Quelqu'un essaie de rejouer un ancien id_token.
        raise HTTPException(400, "Nonce incohérent (possible rejeu de token)")

    # ─── 7. Construction de la session ───────────────────────────────────────
    # Les claims OIDC standards qu'on récupère :
    #   - sub             : identifiant stable et unique de l'user chez Google
    #                       (NE PAS utiliser l'email comme identifiant : il
    #                       peut changer).
    #   - email           : adresse email
    #   - email_verified  : Google a vérifié cette adresse (généralement true)
    #   - name            : nom complet
    #   - picture         : URL de l'avatar
    user = {
        "sub": claims["sub"],
        "email": claims.get("email"),
        "name": claims.get("name"),
        "picture": claims.get("picture"),
    }

    # ─── 8. Redirection vers le dashboard avec le cookie de session ──────────
    resp = RedirectResponse("/dashboard")
    set_session(resp, user)
    # On nettoie le cookie temporaire : il a fait son office.
    resp.delete_cookie("oauth_tmp")
    return resp


# ─── Route : récupération de l'utilisateur courant ───────────────────────────
@app.get("/auth/me")
def me(request: Request):
    """
    Endpoint JSON qui renvoie l'utilisateur connecté, ou 401 si personne.
    Le dashboard l'appelle en AJAX pour s'afficher.
    """
    user = get_session(request)
    if not user:
        return JSONResponse({"authenticated": False}, status_code=401)
    return {"authenticated": True, "user": user}


# ─── Route : déconnexion ─────────────────────────────────────────────────────
@app.post("/auth/logout")
def logout():
    """
    Détruit la session locale (supprime le cookie).

    Note : ça ne déconnecte PAS l'user de Google. Si on voulait un
    'single logout' complet, il faudrait aussi rediriger vers l'endpoint
    de déconnexion Google — ce qui en pratique n'est presque jamais
    fait (l'user veut souvent rester connecté à Google).
    """
    resp = JSONResponse({"ok": True})
    resp.delete_cookie("session")
    return resp


# ─── Démarrage du serveur en standalone ──────────────────────────────────────
if __name__ == "__main__":
    import uvicorn

    # host="::" : écoute en IPv6 ET IPv4 (dual-stack).
    # Important sous Linux moderne où `localhost` résout d'abord en IPv6.
    uvicorn.run(app, host="::", port=8000)