Serveur Rust : socle (config, base, auth, sessions, journaux, cache FF, SPA)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LG2LLJuswrrTTPKJmunEVf

server/src/auth/authz.rs

@@ -0,0 +1,155 @@
+//! Contrôle d'accès commun aux actions, routes et pages.
+//!
+//! Le jeton de session seul ne suffit pas : il reste valide jusqu'à son
+//! expiration, même si le compte a été supprimé ou rétrogradé entre-temps. On
+//! relit donc l'utilisateur dans `users` (cache court), et le rôle en base
+//! l'emporte sur celui du jeton.
+//!
+//! Base injoignable : on se contente du jeton (mode dégradé), sans quoi le
+//! compte de secours `data/users.json` ne pourrait plus rien faire — y compris
+//! configurer la base.
+
+use super::session::{from_headers, Claims};
+use crate::error::AppError;
+use axum::extract::FromRequestParts;
+use axum::http::request::Parts;
+use parking_lot::Mutex;
+use serde::Serialize;
+use sqlx::Row;
+use std::collections::HashMap;
+use std::sync::LazyLock;
+use std::time::{Duration, Instant};
+
+pub const MESSAGE_SESSION: &str = "Session expirée : reconnectez-vous.";
+pub const MESSAGE_ADMIN: &str = "Action réservée aux administrateurs.";
+
+const CACHE_TTL: Duration = Duration::from_secs(60);
+const PAUSE_BASE_INJOIGNABLE: Duration = Duration::from_secs(15);
+
+#[derive(Debug, Clone, Serialize)]
+pub struct UtilisateurCourant {
+    pub id: String,
+    pub username: String,
+    pub role: String,
+}
+
+impl UtilisateurCourant {
+    pub fn is_admin(&self) -> bool {
+        self.role == "admin"
+    }
+    /// Identifiant numérique (`users.id`), `None` pour le compte de secours.
+    pub fn id_numerique(&self) -> Option<i32> {
+        self.id.parse::<i32>().ok().filter(|v| *v > 0)
+    }
+}
+
+#[derive(Clone)]
+struct Fiche {
+    exists: bool,
+    role: String,
+    username: String,
+    at: Instant,
+}
+
+struct CacheState {
+    fiches: HashMap<String, Fiche>,
+    injoignable_depuis: Option<Instant>,
+}
+
+static CACHE: LazyLock<Mutex<CacheState>> =
+    LazyLock::new(|| Mutex::new(CacheState { fiches: HashMap::new(), injoignable_depuis: None }));
+
+/// Oublie la fiche d'un utilisateur (après modification de son compte).
+pub fn invalider(id: &str) {
+    CACHE.lock().fiches.remove(id);
+}
+
+/// Fiche de l'utilisateur en base, ou `None` si la base n'a pas pu répondre.
+async fn lire_fiche(id: &str) -> Option<Fiche> {
+    {
+        let c = CACHE.lock();
+        if let Some(f) = c.fiches.get(id) {
+            if f.at.elapsed() < CACHE_TTL {
+                return Some(f.clone());
+            }
+        }
+        if c.injoignable_depuis.map(|t| t.elapsed() < PAUSE_BASE_INJOIGNABLE).unwrap_or(false) {
+            return None;
+        }
+    }
+    let id_num: i32 = if id.chars().all(|c| c.is_ascii_digit()) && !id.is_empty() {
+        id.parse::<i32>().unwrap_or(-1)
+    } else {
+        -1
+    };
+    let res = async {
+        let pool = crate::db::pool().map_err(|e| anyhow::anyhow!(e.message))?;
+        let row = sqlx::query("SELECT username, role FROM users WHERE id = $1 LIMIT 1")
+            .bind(id_num)
+            .fetch_optional(&pool)
+            .await?;
+        anyhow::Ok(row)
+    }
+    .await;
+    match res {
+        Ok(row) => {
+            let fiche = match row {
+                Some(r) => Fiche {
+                    exists: true,
+                    username: r.try_get("username").unwrap_or_default(),
+                    role: r.try_get("role").unwrap_or_default(),
+                    at: Instant::now(),
+                },
+                None => Fiche { exists: false, username: String::new(), role: String::new(), at: Instant::now() },
+            };
+            CACHE.lock().fiches.insert(id.to_string(), fiche.clone());
+            Some(fiche)
+        }
+        Err(e) => {
+            CACHE.lock().injoignable_depuis = Some(Instant::now());
+            tracing::warn!("[authz] Base injoignable, contrôle sur le seul jeton de session : {}", crate::error::short(&e, 200));
+            None
+        }
+    }
+}
+
+/// Utilisateur connecté, relu en base. 401 sinon.
+pub async fn require_session(token: Option<&Claims>) -> Result<UtilisateurCourant, AppError> {
+    let jeton = token.ok_or_else(|| AppError::unauthorized(MESSAGE_SESSION))?;
+    match lire_fiche(&jeton.id).await {
+        None => Ok(UtilisateurCourant { id: jeton.id.clone(), username: jeton.name.clone(), role: jeton.role.clone() }),
+        Some(f) if !f.exists => Err(AppError::unauthorized(MESSAGE_SESSION)),
+        Some(f) => Ok(UtilisateurCourant { id: jeton.id.clone(), username: f.username, role: f.role }),
+    }
+}
+
+/// Administrateur connecté. 401 ou 403 sinon.
+pub async fn require_admin(token: Option<&Claims>) -> Result<UtilisateurCourant, AppError> {
+    let u = require_session(token).await?;
+    if !u.is_admin() {
+        return Err(AppError::forbidden(MESSAGE_ADMIN));
+    }
+    Ok(u)
+}
+
+/// Extracteur : utilisateur connecté (sinon 401 JSON `{ error }`).
+pub struct SessionUser(pub UtilisateurCourant);
+
+impl<S: Send + Sync> FromRequestParts<S> for SessionUser {
+    type Rejection = AppError;
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
+        let claims = from_headers(&parts.headers);
+        Ok(SessionUser(require_session(claims.as_ref()).await?))
+    }
+}
+
+/// Extracteur : administrateur connecté (sinon 401/403 JSON `{ error }`).
+pub struct AdminUser(pub UtilisateurCourant);
+
+impl<S: Send + Sync> FromRequestParts<S> for AdminUser {
+    type Rejection = AppError;
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
+        let claims = from_headers(&parts.headers);
+        Ok(AdminUser(require_admin(claims.as_ref()).await?))
+    }
+}