Filtre de chiffrement d'enregistrements PQC Kroxylicious

Un plugin de filtre Kroxylicious qui fournit un chiffrement transparent au niveau des enregistrements en cryptographie post-quantique (PQC) pour Apache Kafka, utilisant ML-KEM (FIPS 203) pour la encapsulation de clé avec un chiffrement symétrique AES-256-GCM.

Les producteurs et consommateurs Kafka ne nécessitent aucune modification de code. Le proxy Kroxylicious intercepte le trafic et chiffre lors du Produce / déchiffre lors du Fetch automatiquement.``` Producer ──plaintext──> Kroxylicious ──encrypted──> Kafka Broker Consumer <──plaintext── Kroxylicious <──encrypted── Kafka Broker

## Pourquoi la PQC pour Kafka ?

Les algorithmes classiques d'établissement de clés (RSA, ECDH) sont vulnérables aux futurs ordinateurs quantiques. Si les clés de chiffrement par enregistrement sont établies à l'aide d'un KEM classique, un adversaire quantique pourrait récupérer ces clés à partir des encapsulations stockées aux côtés du texte chiffré sur le broker.

Ce plugin utilise ML-KEM (FIPS 203) pour l'encapsulation de clés résistante aux ordinateurs quantiques, garantissant que les données au repos sur le broker Kafka ne peuvent pas être déchiffrées même par un adversaire disposant d'un ordinateur quantique cryptographiquement pertinent.

**Remarque :** Ce filtre protège **les données au repos sur le broker**, et non le canal TLS en transit. Voir [THREAT_MODEL.md](https://github.com/oscerd/kroxylicious-pqc-filter/blob/main/THREAT_MODEL.md) pour une analyse complète de ce qui est protégé et de ce qui ne l'est pas.

| Norme | Algorithme | Rôle dans ce plugin |
|----------|-----------|------------------------|
| FIPS 203 | ML-KEM (Kyber) | Encapsulation de clés - établit de manière sécurisée une clé AES par message |
| N/A | AES-256-GCM | Chiffrement authentifié symétrique de la charge utile de l'enregistrement |
| N/A | X25519 ECDH | Accord de clés classique pour la défense en profondeur du mode hybride |

## Fonctionnalités

- **Chiffrement/déchiffrement transparent** - aucune modification côté client requise
- **ML-KEM-512, ML-KEM-768 (défaut), ML-KEM-1024** ensembles de paramètres
- **Mode hybride** (défaut) - combine ML-KEM + X25519 ECDH de sorte que les deux doivent être cassés
- **Chiffrement par enregistrement** - chaque enregistrement reçoit une nouvelle encapsulation KEM + un IV aléatoire
- **Filtrage des topics** - les motifs regex sélectionnent les topics à chiffrer
- **Détection de falsification** - le chiffrement authentifié AES-GCM rejette tout texte chiffré modifié
- **Sécurité sémantique** - des textes clairs identiques produisent des textes chiffrés différents (IND-CCA2)
- **Génération automatique de clés** - génère et enregistre les clés ML-KEM au premier démarrage si elles sont absentes
- **En-tête `x-pqc-encrypted`** - marque les enregistrements chiffrés pour les composants en aval
- **Fournisseurs de clés enfichables** - le SPI `KeyProvider` prend en charge les backends filesystem (défaut) et HashiCorp Vault

## Prérequis

| Prérequis | Version |
|-------------|---------|
| JDK | 17+ (21+ recommandé) |
| Maven | 3.8+ |
| Kroxylicious | 0.19.0 |
| Apache Kafka | 3.9.x |

## Démarrage rapide

### 1. Construire le plugin```bash
git clone <this-repo>
cd kroxylicious-pqc-filter
mvn clean package -DskipTests

Le JAR fusionné situé à target/kroxylicious-pqc-filter-1.0.0-SNAPSHOT.jar embarque Bouncy Castle, de sorte qu'il peut être déposé dans Kroxylicious sans dépendances supplémentaires.

Pour inclure la prise en charge du fournisseur de clés HashiCorp Vault, construisez avec le profil vault :```bash mvn clean package -Pvault -DskipTests

Ceci regroupe `spring-vault-core` et le `VaultKeyProvider` dans le JAR.

### 2. Générer des clés ML-KEM```bash
java -cp target/kroxylicious-pqc-filter-1.0.0-SNAPSHOT.jar \
  io.kroxylicious.filter.pqc.PqcKeyGeneratorCli \
  ML_KEM_768 \
  /etc/kroxylicious/pqc/

The input content is empty — no source text was provided for chunk 9/33. Please re-send the chunk content so I can translate it into French.``` Generating ML-KEM-768 key pair... Public key: /etc/kroxylicious/pqc/pqc-public.der Size: 1206 bytes Format: X.509 Private key: /etc/kroxylicious/pqc/pqc-private.der Size: 2498 bytes Format: PKCS#8

Alternativement, omettez les chemins des clés dans la configuration et le filtre générera
automatiquement les clés au premier démarrage.

### 3. Configurer Kroxylicious

Ajoutez le filtre à votre configuration YAML du proxy Kroxylicious :```yaml
filterDefinitions:
  - name: pqc-encryption
    type: PqcRecordEncryptionFilterFactory
    config:
      kemAlgorithm: ML_KEM_768
      hybridMode: true
      publicKeyPath: /etc/kroxylicious/pqc/pqc-public.der
      privateKeyPath: /etc/kroxylicious/pqc/pqc-private.der
      topicPatterns:
        - "sensitive-.*"
        - "pii-.*"

defaultFilters:
  - pqc-encryption

4. Déployer

Placez le JAR dans un répertoire accessible à Kroxylicious et ajoutez-le au classpath via la variable d'environnement KROXYLICIOUS_CLASSPATH :```bash export KROXYLICIOUS_CLASSPATH="/opt/kroxylicious/plugins/*"

Lorsque vous utilisez Docker, définissez-le dans votre environnement de conteneur:```yaml
environment:
  KROXYLICIOUS_CLASSPATH: /opt/kroxylicious/plugins/*

Puis démarrez le proxy. Les producteurs et les consommateurs se connectent au port du proxy au lieu de se connecter directement au courtier.

Référence de configuration

Property	Type	Required	Default	Description
kemAlgorithm	enum	Non	ML_KEM_768	Ensemble de paramètres ML-KEM. Une valeur parmi ML_KEM_512, ML_KEM_768, ML_KEM_1024.
hybridMode	boolean	Non	true	Combine ML-KEM avec X25519 ECDH pour une défense en profondeur.
publicKeyPath	string	Système de fichiers uniquement	-	Chemin du système de fichiers vers la clé publique ML-KEM (encodée X.509 DER).
privateKeyPath	string	Système de fichiers uniquement	-	Chemin du système de fichiers vers la clé privée ML-KEM (encodée PKCS#8 DER).
topicPatterns	list<string>	Non	[".*"]	Expressions régulières Java. Seuls les enregistrements des sujets correspondants sont chiffrés/déchiffrés.
keyProviderType	string	Non	filesystem	Backend de stockage des clés. Une valeur parmi filesystem, vault.
keyProviderConfig	map<string, string>	Vault uniquement	{}	Configuration spécifique au backend (voir la section Vault ci-dessous).

Fournisseurs de clés

Filesystem (keyProviderType: filesystem, par défaut) : Charge les clés ML-KEM depuis des fichiers DER sur le disque. Si les fichiers n'existent pas, génère une nouvelle paire de clés et les enregistre. Requiert publicKeyPath et privateKeyPath.

HashiCorp Vault (keyProviderType: vault, requiert la compilation -Pvault) : Récupère les clés ML-KEM depuis un moteur de secrets Vault KV v2. Les clés sont stockées sous forme de DER encodé en base64 dans les champs publicKey et privateKey. Les versions des secrets Vault correspondent aux identifiants de clé pour la prise en charge de la rotation des clés.

Propriétés de keyProviderConfig pour Vault :