baobab-auth-security 0.1.0__py3-none-any.whl

baobab_auth_security/__init__.py

@@ -0,0 +1,10 @@
+"""Librairie de sécurité pour l'écosystème ``baobab-auth``.
+
+Fournit les primitives de hash de mots de passe, JWT, JWKS, clés cryptographiques,
+refresh tokens opaques et révocation abstraite, sans couplage HTTP ni persistance.
+"""
+
+from baobab_auth_security.exceptions import BaobabAuthSecurityError
+from baobab_auth_security.version import VERSION
+
+__all__ = ["VERSION", "BaobabAuthSecurityError"]

baobab_auth_security/config/__init__.py

@@ -0,0 +1,7 @@
+"""Configuration typée de la librairie de sécurité."""
+
+from baobab_auth_security.config.jwt_security_settings import JwtSecuritySettings
+from baobab_auth_security.config.key_settings import KeySettings
+from baobab_auth_security.config.refresh_token_settings import RefreshTokenSettings
+
+__all__ = ["JwtSecuritySettings", "KeySettings", "RefreshTokenSettings"]

baobab_auth_security/config/jwt_security_settings.py

@@ -0,0 +1,44 @@
+"""Configuration JWT (issuer, audience, TTL)."""
+
+from dataclasses import dataclass
+
+from baobab_auth_security.exceptions import BaobabAuthSecurityError
+
+
+@dataclass(frozen=True)
+class JwtSecuritySettings:
+    """Paramètres de sécurité pour l'émission et la validation JWT.
+
+    :param issuer: émetteur attendu (``iss``).
+    :param audience: audiences acceptées (``aud``).
+    :param access_token_ttl_seconds: durée de vie recommandée des access tokens.
+    :param algorithm: algorithme de signature attendu.
+    :param require_kid: exige un ``kid`` dans le header.
+    :param require_exp: exige et valide ``exp``.
+    :param require_iat: exige et valide ``iat``.
+    :param require_nbf: exige ``nbf`` dans le payload.
+    :param clock_skew_seconds: tolérance horaire en secondes.
+    :raises BaobabAuthSecurityError: si un paramètre est invalide.
+    :spec: FEAT-006.3
+    """
+
+    issuer: str = "baobab-auth"
+    audience: tuple[str, ...] = ("baobab-app",)
+    access_token_ttl_seconds: int = 900
+    algorithm: str = "RS256"
+    require_kid: bool = True
+    require_exp: bool = True
+    require_iat: bool = True
+    require_nbf: bool = False
+    clock_skew_seconds: int = 30
+
+    def __post_init__(self) -> None:
+        """Valide les paramètres de configuration."""
+        if not self.issuer:
+            raise BaobabAuthSecurityError("issuer ne doit pas être vide")
+        if not self.audience:
+            raise BaobabAuthSecurityError("audience ne doit pas être vide")
+        if self.access_token_ttl_seconds <= 0:
+            raise BaobabAuthSecurityError("access_token_ttl_seconds doit être positif")
+        if self.clock_skew_seconds < 0:
+            raise BaobabAuthSecurityError("clock_skew_seconds doit être >= 0")

baobab_auth_security/config/key_settings.py

@@ -0,0 +1,32 @@
+"""Configuration des clés cryptographiques."""
+
+from dataclasses import dataclass
+
+from baobab_auth_security.exceptions import BaobabAuthSecurityError
+
+
+@dataclass(frozen=True)
+class KeySettings:
+    """Paramètres de génération et gestion des clés.
+
+    :param default_algorithm: algorithme par défaut (``RS256`` MVP).
+    :param key_size: taille RSA en bits.
+    :param active_key_id: identifiant de clé active optionnel.
+    :param private_key_path: chemin PEM privé optionnel.
+    :param public_key_path: chemin PEM public optionnel.
+    :param jwks_cache_ttl_seconds: TTL cache JWKS en secondes.
+    :raises BaobabAuthSecurityError: si ``key_size`` est invalide.
+    :spec: FEAT-004.2
+    """
+
+    default_algorithm: str = "RS256"
+    key_size: int = 2048
+    active_key_id: str | None = None
+    private_key_path: str | None = None
+    public_key_path: str | None = None
+    jwks_cache_ttl_seconds: int = 300
+
+    def __post_init__(self) -> None:
+        """Valide les paramètres."""
+        if self.key_size < 2048:
+            raise BaobabAuthSecurityError("key_size doit être >= 2048 pour RSA")

baobab_auth_security/config/refresh_token_settings.py

@@ -0,0 +1,34 @@
+"""Configuration des refresh tokens opaques."""
+
+from dataclasses import dataclass
+
+from baobab_auth_security.exceptions import BaobabAuthSecurityError
+
+_HMAC_SHA256 = "hmac-sha256"
+
+
+@dataclass(frozen=True)
+class RefreshTokenSettings:
+    """Paramètres de génération et hash des refresh tokens.
+
+    :param refresh_token_ttl_seconds: durée de vie du token en secondes.
+    :param refresh_token_bytes: entropie du token opaque (octets).
+    :param hash_algorithm: algorithme de hash pour stockage (``hmac-sha256`` MVP).
+    :param rotate_on_use: indique la rotation applicative recommandée.
+    :param hmac_secret: secret HMAC requis si ``hash_algorithm`` est ``hmac-sha256``.
+    :raises BaobabAuthSecurityError: si un paramètre est invalide.
+    :spec: FEAT-003.1
+    """
+
+    refresh_token_ttl_seconds: int = 2_592_000
+    refresh_token_bytes: int = 64
+    hash_algorithm: str = _HMAC_SHA256
+    rotate_on_use: bool = True
+    hmac_secret: str | None = None
+
+    def __post_init__(self) -> None:
+        """Valide les paramètres de configuration."""
+        if self.refresh_token_ttl_seconds <= 0:
+            raise BaobabAuthSecurityError("refresh_token_ttl_seconds doit être positif")
+        if self.refresh_token_bytes <= 0:
+            raise BaobabAuthSecurityError("refresh_token_bytes doit être positif")

baobab_auth_security/exceptions/__init__.py

@@ -0,0 +1,5 @@
+"""Hiérarchie d'exceptions de ``baobab-auth-security``."""
+
+from baobab_auth_security.exceptions.baobab_auth_security_error import BaobabAuthSecurityError
+
+__all__ = ["BaobabAuthSecurityError"]

baobab_auth_security/exceptions/baobab_auth_security_error.py

@@ -0,0 +1,10 @@
+"""Exception racine de la librairie ``baobab-auth-security``."""
+
+
+class BaobabAuthSecurityError(Exception):
+    """Erreur générique de la librairie de sécurité ``baobab-auth``.
+
+    Toutes les exceptions publiques de ce package héritent de cette classe.
+
+    :spec: FEAT-001.1
+    """

baobab_auth_security/integration/__init__.py

@@ -0,0 +1,17 @@
+"""Adaptateurs vers les ports de ``baobab-auth-core``."""
+
+from baobab_auth_security.integration.claims_mapper import ClaimsMapper
+from baobab_auth_security.integration.core_integration_gaps import CoreIntegrationGaps
+from baobab_auth_security.integration.core_password_hasher_adapter import (
+    CorePasswordHasherAdapter,
+)
+from baobab_auth_security.integration.core_token_provider_adapter import (
+    CoreTokenProviderAdapter,
+)
+
+__all__ = [
+    "ClaimsMapper",
+    "CoreIntegrationGaps",
+    "CorePasswordHasherAdapter",
+    "CoreTokenProviderAdapter",
+]

baobab_auth_security/integration/claims_mapper.py

@@ -0,0 +1,48 @@
+"""Mapping entre claims JWT et value objects ``baobab-auth-core``."""
+
+from baobab_auth_core.domain.value_objects.auth_subject import AuthSubject
+from baobab_auth_core.domain.value_objects.session_id import SessionId
+from baobab_auth_core.domain.value_objects.token_id import TokenId
+
+from baobab_auth_security.tokens.token_claims import TokenClaims
+
+
+class ClaimsMapper:
+    """Convertit ``TokenClaims`` vers les value objects du core.
+
+    :spec: FEAT-009.1
+    """
+
+    def to_auth_subject(self, claims: TokenClaims) -> AuthSubject:
+        """Extrait le sujet métier depuis les claims JWT.
+
+        :param claims: claims typés security.
+        :returns: ``AuthSubject`` du core.
+        """
+        return AuthSubject(value=claims.subject)
+
+    def to_token_id(self, claims: TokenClaims) -> TokenId:
+        """Extrait le ``jti`` depuis les claims JWT.
+
+        :param claims: claims typés security.
+        :returns: ``TokenId`` du core.
+        """
+        return TokenId(value=claims.token_id)
+
+    def to_session_id(self, claims: TokenClaims) -> SessionId | None:
+        """Extrait le ``sid`` optionnel depuis les claims JWT.
+
+        :param claims: claims typés security.
+        :returns: ``SessionId`` ou ``None`` si absent.
+        """
+        if claims.session_id is None:
+            return None
+        return SessionId(value=claims.session_id)
+
+    def subject_from_auth_subject(self, subject: AuthSubject) -> str:
+        """Convertit un ``AuthSubject`` en claim ``sub`` string.
+
+        :param subject: sujet core.
+        :returns: valeur ``sub`` pour ``TokenClaims``.
+        """
+        return str(subject.value)

baobab_auth_security/integration/core_integration_gaps.py

@@ -0,0 +1,25 @@
+"""Écarts documentés entre security et ``baobab-auth-core``."""
+
+
+class CoreIntegrationGaps:
+    """Liste les écarts connus d'intégration avec ``baobab-auth-core``.
+
+    :spec: FEAT-009.1
+    """
+
+    GAPS: tuple[str, ...] = (
+        "Le port core ``TokenProvider`` n'expose que ``generate_refresh_token_id`` "
+        "(pas de création/validation JWT access token).",
+        "Le port core ``PasswordHasher`` utilise les VO ``Password``/``PasswordHash`` "
+        "alors que security expose des API string typées.",
+        "Aucun port core dédié au JWKS, à la rotation de clés ou à la révocation JWT "
+        "en v0.4 — ces capacités restent propres à baobab-auth-security.",
+    )
+
+    @classmethod
+    def documented_gaps(cls) -> tuple[str, ...]:
+        """Renvoie les écarts documentés pour revue PO/architecte.
+
+        :returns: tuple de descriptions d'écarts.
+        """
+        return cls.GAPS

baobab_auth_security/integration/core_password_hasher_adapter.py

@@ -0,0 +1,50 @@
+"""Adaptateur ``PasswordHasher`` security → port core."""
+
+from baobab_auth_core.domain.value_objects.password import Password
+from baobab_auth_core.domain.value_objects.password_hash import PasswordHash
+from baobab_auth_core.exceptions.validation import ValidationError
+
+from baobab_auth_security.password.exceptions import (
+    EmptyPasswordError,
+    InvalidPasswordHashError,
+)
+from baobab_auth_security.password.password_hasher import PasswordHasher
+
+
+class CorePasswordHasherAdapter:
+    """Implémente le port core ``PasswordHasher`` via security.
+
+    :param hasher: implémentation security injectée.
+    :spec: FEAT-009.1
+    """
+
+    def __init__(self, hasher: PasswordHasher) -> None:
+        """Initialise l'adaptateur."""
+        self._hasher = hasher
+
+    def hash(self, password: Password) -> PasswordHash:
+        """Hache un mot de passe core en déléguant à security.
+
+        :param password: VO ``Password`` du core.
+        :returns: VO ``PasswordHash`` du core.
+        :raises ValidationError: si le mot de passe est vide côté security.
+        """
+        try:
+            result = self._hasher.hash_password(password.value)
+        except EmptyPasswordError as exc:
+            raise ValidationError(str(exc)) from exc
+        return PasswordHash(value=result.hashed_password)
+
+    def verify(self, password: Password, hashed: PasswordHash) -> bool:
+        """Vérifie un mot de passe core contre un hash core.
+
+        :param password: VO ``Password`` du core.
+        :param hashed: VO ``PasswordHash`` du core.
+        :returns: ``True`` si valide.
+        :raises ValidationError: si les entrées sont invalides côté security.
+        """
+        try:
+            result = self._hasher.verify_password(password.value, hashed.value)
+        except (EmptyPasswordError, InvalidPasswordHashError) as exc:
+            raise ValidationError(str(exc)) from exc
+        return result.is_valid

baobab_auth_security/integration/core_token_provider_adapter.py

@@ -0,0 +1,25 @@
+"""Adaptateur refresh token → port core ``TokenProvider``."""
+
+from baobab_auth_core.domain.value_objects.token_id import TokenId
+
+from baobab_auth_security.refresh_tokens.refresh_token_generator import RefreshTokenGenerator
+
+
+class CoreTokenProviderAdapter:
+    """Implémente le port core ``TokenProvider`` via ``RefreshTokenGenerator``.
+
+    :param generator: générateur de refresh tokens security.
+    :spec: FEAT-009.1
+    """
+
+    def __init__(self, generator: RefreshTokenGenerator) -> None:
+        """Initialise l'adaptateur."""
+        self._generator = generator
+
+    def generate_refresh_token_id(self) -> TokenId:
+        """Génère un identifiant de refresh token pour le core.
+
+        :returns: ``TokenId`` encapsulant le ``token_id`` security.
+        """
+        result = self._generator.generate_refresh_token()
+        return TokenId(value=result.token_id)

baobab_auth_security/keys/__init__.py

@@ -0,0 +1,51 @@
+"""Clés cryptographiques, JWKS et rotation."""
+
+from baobab_auth_security.keys.exceptions import (
+    InvalidKeyFormatError,
+    JwkNotFoundError,
+    JwksGenerationError,
+    JwksSecurityError,
+    KeyGenerationError,
+    KeyNotFoundError,
+    KeyRotationError,
+    KeySecurityError,
+    NoActiveSigningKeyError,
+    PrivateKeyRequiredError,
+    RevokedKeyError,
+)
+from baobab_auth_security.keys.in_memory_key_provider import InMemoryKeyProvider
+from baobab_auth_security.keys.jwk import JWK
+from baobab_auth_security.keys.jwks import JWKS
+from baobab_auth_security.keys.jwks_provider import JwksProvider
+from baobab_auth_security.keys.key_algorithm import KeyAlgorithm
+from baobab_auth_security.keys.key_generator import KeyGenerator
+from baobab_auth_security.keys.key_pair import KeyPair
+from baobab_auth_security.keys.key_provider import KeyProvider
+from baobab_auth_security.keys.key_rotation_service import KeyRotationService
+from baobab_auth_security.keys.key_status import KeyStatus
+from baobab_auth_security.keys.pem_loader import PemLoader
+
+__all__ = [
+    "JWK",
+    "JWKS",
+    "InMemoryKeyProvider",
+    "InvalidKeyFormatError",
+    "JwkNotFoundError",
+    "JwksGenerationError",
+    "JwksProvider",
+    "JwksSecurityError",
+    "KeyAlgorithm",
+    "KeyGenerationError",
+    "KeyGenerator",
+    "KeyNotFoundError",
+    "KeyPair",
+    "KeyProvider",
+    "KeyRotationError",
+    "KeyRotationService",
+    "KeySecurityError",
+    "KeyStatus",
+    "NoActiveSigningKeyError",
+    "PemLoader",
+    "PrivateKeyRequiredError",
+    "RevokedKeyError",
+]

baobab_auth_security/keys/exceptions.py

@@ -0,0 +1,80 @@
+"""Exceptions du sous-package ``keys``."""
+
+from baobab_auth_security.exceptions.baobab_auth_security_error import BaobabAuthSecurityError
+
+
+class KeySecurityError(BaobabAuthSecurityError):
+    """Erreur liée aux clés cryptographiques.
+
+    :spec: FEAT-004.2
+    """
+
+
+class KeyGenerationError(KeySecurityError):
+    """Erreur lors de la génération d'une clé.
+
+    :spec: FEAT-004.2
+    """
+
+
+class KeyNotFoundError(KeySecurityError):
+    """Clé introuvable pour l'identifiant demandé.
+
+    :spec: FEAT-004.2
+    """
+
+
+class NoActiveSigningKeyError(KeySecurityError):
+    """Aucune clé active disponible pour la signature.
+
+    :spec: FEAT-004.2
+    """
+
+
+class InvalidKeyFormatError(KeySecurityError):
+    """Format PEM ou structure de clé invalide.
+
+    :spec: FEAT-004.2
+    """
+
+
+class PrivateKeyRequiredError(KeySecurityError):
+    """Clé privée requise pour l'opération demandée.
+
+    :spec: FEAT-004.2
+    """
+
+
+class KeyRotationError(KeySecurityError):
+    """Erreur lors de la rotation ou activation d'une clé.
+
+    :spec: FEAT-007.1
+    """
+
+
+class RevokedKeyError(KeySecurityError):
+    """Clé révoquée ou compromise — opération refusée.
+
+    :spec: FEAT-007.1
+    """
+
+
+class JwksSecurityError(BaobabAuthSecurityError):
+    """Erreur liée au JWKS.
+
+    :spec: FEAT-005.1
+    """
+
+
+class JwksGenerationError(JwksSecurityError):
+    """Erreur lors de la conversion ou génération JWKS.
+
+    :spec: FEAT-005.1
+    """
+
+
+class JwkNotFoundError(JwksSecurityError):
+    """JWK introuvable pour l'identifiant demandé.
+
+    :spec: FEAT-005.1
+    """

baobab_auth_security/keys/in_memory_key_provider.py

@@ -0,0 +1,131 @@
+"""Fournisseur de clés en mémoire pour tests et développement."""
+
+from datetime import UTC, datetime
+
+from baobab_auth_security.keys.exceptions import (
+    KeyNotFoundError,
+    NoActiveSigningKeyError,
+    RevokedKeyError,
+)
+from baobab_auth_security.keys.key_pair import KeyPair
+from baobab_auth_security.keys.key_status import KeyStatus
+
+
+class InMemoryKeyProvider:
+    """Stocke des clés en mémoire — non destiné à la production.
+
+    :spec: FEAT-004.2
+    """
+
+    def __init__(self) -> None:
+        """Initialise un registre vide."""
+        self._keys: dict[str, KeyPair] = {}
+        self._active_key_id: str | None = None
+
+    def register_key(self, key_pair: KeyPair, *, set_active: bool = False) -> None:
+        """Enregistre une paire de clés.
+
+        :param key_pair: clé à enregistrer.
+        :param set_active: active cette clé pour la signature.
+        """
+        self._keys[key_pair.key_id] = key_pair
+        if set_active:
+            self._active_key_id = key_pair.key_id
+
+    def revoke_key(self, key_id: str) -> None:
+        """Révoque logiquement une clé.
+
+        :param key_id: identifiant de la clé.
+        :raises KeyNotFoundError: si la clé n'existe pas.
+        """
+        pair = self._keys.get(key_id)
+        if pair is None:
+            raise KeyNotFoundError(f"clé introuvable : {key_id!r}")
+        revoked = KeyPair(
+            key_id=pair.key_id,
+            algorithm=pair.algorithm,
+            status=KeyStatus.REVOKED,
+            public_key_pem=pair.public_key_pem,
+            private_key_pem=pair.private_key_pem,
+            created_at=pair.created_at,
+            activated_at=pair.activated_at,
+            expires_at=pair.expires_at,
+            revoked_at=datetime.now(UTC),
+        )
+        self._keys[key_id] = revoked
+        if self._active_key_id == key_id:
+            self._active_key_id = None
+
+    def get_active_signing_key(self) -> KeyPair:
+        """Renvoie la clé active pour signer.
+
+        :returns: paire avec clé privée.
+        :raises NoActiveSigningKeyError: si aucune clé active.
+        """
+        if self._active_key_id is None:
+            raise NoActiveSigningKeyError("aucune clé active pour la signature")
+        pair = self._keys.get(self._active_key_id)
+        if pair is None or pair.private_key_pem is None:
+            raise NoActiveSigningKeyError("clé active sans clé privée")
+        if pair.status != KeyStatus.ACTIVE:
+            raise NoActiveSigningKeyError("aucune clé active pour la signature")
+        return pair
+
+    def get_stored_key_pair(self, key_id: str) -> KeyPair:
+        """Renvoie une paire stockée avec clé privée si présente.
+
+        :param key_id: identifiant de clé.
+        :returns: paire complète du registre.
+        :raises KeyNotFoundError: si introuvable.
+        """
+        pair = self._keys.get(key_id)
+        if pair is None:
+            raise KeyNotFoundError(f"clé introuvable : {key_id!r}")
+        return pair
+
+    def update_key_pair(self, key_pair: KeyPair) -> None:
+        """Remplace une paire enregistrée.
+
+        :param key_pair: nouvelle version de la paire.
+        :raises KeyNotFoundError: si la clé n'existe pas.
+        """
+        if key_pair.key_id not in self._keys:
+            raise KeyNotFoundError(f"clé introuvable : {key_pair.key_id!r}")
+        self._keys[key_pair.key_id] = key_pair
+        if self._active_key_id == key_pair.key_id and key_pair.status != KeyStatus.ACTIVE:
+            self._active_key_id = None
+
+    def get_public_key(self, key_id: str) -> KeyPair:
+        """Renvoie une clé publique par ``kid``.
+
+        :param key_id: identifiant de clé.
+        :returns: paire sans clé privée.
+        :raises KeyNotFoundError: si introuvable.
+        """
+        pair = self._keys.get(key_id)
+        if pair is None:
+            raise KeyNotFoundError(f"clé introuvable : {key_id!r}")
+        if pair.status == KeyStatus.REVOKED:
+            raise RevokedKeyError(f"clé révoquée : {key_id!r}")
+        return KeyPair(
+            key_id=pair.key_id,
+            algorithm=pair.algorithm,
+            status=pair.status,
+            public_key_pem=pair.public_key_pem,
+            private_key_pem=None,
+            created_at=pair.created_at,
+            activated_at=pair.activated_at,
+            expires_at=pair.expires_at,
+            revoked_at=pair.revoked_at,
+        )
+
+    def list_public_keys(self) -> tuple[KeyPair, ...]:
+        """Liste les clés publiques actives ou retraitées.
+
+        :returns: tuple de paires publiques (``ACTIVE`` et ``RETIRED``).
+        """
+        return tuple(
+            self.get_public_key(key_id)
+            for key_id in self._keys
+            if self._keys[key_id].status in (KeyStatus.ACTIVE, KeyStatus.RETIRED)
+        )

baobab_auth_security/keys/jwk.py

@@ -0,0 +1,67 @@
+"""Modèle JSON Web Key."""
+
+from dataclasses import dataclass
+from typing import Any
+
+from baobab_auth_security.keys.exceptions import JwksSecurityError
+
+
+@dataclass(frozen=True)
+class JWK:
+    """Représente une clé publique au format JWK.
+
+    Pour RSA, ``n`` et ``e`` sont obligatoires.
+
+    :param kty: type de clé (``RSA``, ``EC``, …).
+    :param use: usage (``sig``, ``enc``, …).
+    :param kid: identifiant de clé.
+    :param alg: algorithme de signature.
+    :param n: module RSA (base64url).
+    :param e: exposant RSA (base64url).
+    :param crv: courbe pour EC.
+    :param x: coordonnée x pour EC.
+    :param y: coordonnée y pour EC.
+    :param key_ops: opérations de clé optionnelles.
+    :spec: FEAT-005.1
+    """
+
+    kty: str
+    use: str
+    kid: str
+    alg: str
+    n: str | None = None
+    e: str | None = None
+    crv: str | None = None
+    x: str | None = None
+    y: str | None = None
+    key_ops: tuple[str, ...] | None = None
+
+    def __post_init__(self) -> None:
+        """Valide les champs obligatoires selon le type de clé."""
+        if self.kty == "RSA" and (self.n is None or self.e is None):
+            raise JwksSecurityError("n et e sont obligatoires pour une JWK RSA")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Sérialise la JWK en dictionnaire JSON-compatible.
+
+        :returns: représentation dict sans clé privée.
+        """
+        data: dict[str, Any] = {
+            "kty": self.kty,
+            "use": self.use,
+            "kid": self.kid,
+            "alg": self.alg,
+        }
+        if self.n is not None:
+            data["n"] = self.n
+        if self.e is not None:
+            data["e"] = self.e
+        if self.crv is not None:
+            data["crv"] = self.crv
+        if self.x is not None:
+            data["x"] = self.x
+        if self.y is not None:
+            data["y"] = self.y
+        if self.key_ops is not None:
+            data["key_ops"] = list(self.key_ops)
+        return data

baobab_auth_security/keys/jwks.py

@@ -0,0 +1,24 @@
+"""Modèle JSON Web Key Set."""
+
+from dataclasses import dataclass
+from typing import Any
+
+from baobab_auth_security.keys.jwk import JWK
+
+
+@dataclass(frozen=True)
+class JWKS:
+    """Document JWKS contenant des clés publiques.
+
+    :param keys: tuple de JWK publiques.
+    :spec: FEAT-005.1
+    """
+
+    keys: tuple[JWK, ...]
+
+    def to_dict(self) -> dict[str, Any]:
+        """Sérialise le JWKS en dictionnaire JSON-compatible.
+
+        :returns: structure ``{"keys": [...]}`` conforme RFC 7517.
+        """
+        return {"keys": [jwk.to_dict() for jwk in self.keys]}