Isso agrupa `spring-vault-core` e o `VaultKeyProvider` no JAR.

### 2. Gerar chaves 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/

Alternativamente, omita os caminhos das chaves na configuração e o filtro gerará
chaves automaticamente na primeira inicialização.

### 3. Configurar o Kroxylicious

Adicione o filtro à sua configuração YAML do 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

Ao usar Docker, defina-o no ambiente do seu container:```yaml
environment:
  KROXYLICIOUS_CLASSPATH: /opt/kroxylicious/plugins/*

### Conjuntos de Parâmetros ML-KEM

| Algoritmo | Nível de Segurança | Chave Pública | Chave Privada | Sobrecarga do Cifrador | Caso de Uso |
|-----------|---------------|------------|-------------|--------------------:|----------|
| ML-KEM-512 | 128-bit | 822 B | 1.730 B | ~854 B | Leve, IoT |
| ML-KEM-768 | 192-bit | 1.206 B | 2.498 B | ~1.174 B | **Padrão recomendado** |
| ML-KEM-1024 | 256-bit | 1.590 B | 3.266 B | ~1.654 B | Dados classificados / de longa duração |

### Modos de Criptografia

**Apenas PQC** (`hybridMode: false`):
Usa exclusivamente ML-KEM. A chave AES-256 é derivada do segredo compartilhado do ML-KEM
através de `SHA-256(0x01 || "kroxylicious-pqc-v1" || secret)`.

**Híbrido** (`hybridMode: true`, padrão):
Combina ML-KEM + X25519. A chave AES-256 é derivada de ambos os segredos através de
`SHA-256(0x02 || "kroxylicious-pqc-hybrid-v1" || pqcSecret || x25519Secret)`.
Isso garante segurança mesmo se um algoritmo for quebrado.

## Formato do Envelope Criptografado

Cada valor de registro criptografado é substituído por um envelope binário:```
PQC-only (version 0x01):
+--------+-----------+--------------------+--------+---------------------------+
| 1 byte | 2 bytes   | N bytes            | 12 B   | remaining                 |
| 0x01   | encap len | ML-KEM encapsulat. | AES IV | AES-GCM ciphertext + tag  |
+--------+-----------+--------------------+--------+---------------------------+

Hybrid (version 0x02):
+--------+-----------+--------------------+---------+--------+-----------------+
| 1 byte | 2 bytes   | N bytes            | 32 B    | 12 B   | remaining       |
| 0x02   | encap len | ML-KEM encapsulat. | X25519  | AES IV | AES-GCM ct+tag |
|        |           |                    | eph pub |        |                 |
+--------+-----------+--------------------+---------+--------+-----------------+

### Fluxo de dados

#### O que é armazenado no Vault

O Vault KV v2 armazena o par de chaves ML-KEM em `secret/<secretPath>` (por exemplo, `secret/kroxylicious/pqc`):

| Campo | Conteúdo | Formato |
|-------|----------|---------|
| `publicKey` | Chave pública ML-KEM (usada para encapsulamento) | Base64-encoded X.509 DER |
| `privateKey` | Chave privada ML-KEM (usada para desencapsulamento) | Base64-encoded PKCS#8 DER |

Cada versão do segredo no Vault atua como um ID de chave, permitindo a rotação de chaves. Novas versões
criptografam novos registos; versões antigas ainda podem descriptografar registos criptografados com elas.

#### Fluxo de inicialização```
┌─────────────────────────────────────────────────────────────────────┐
│                           STARTUP                                   │
│                                                                     │
│  1. Vault starts (dev mode, port 8200)                              │
│         │                                                           │
│  2. vault-init container:                                           │
│         │  • Reads pre-generated ML-KEM DER key files from disk     │
│         │  • Base64-encodes them                                    │
│         │  • POST /v1/secret/data/kroxylicious/pqc                  │
│         │  • Stores publicKey + privateKey in Vault KV v2           │
│         │  • Exits                                                  │
│         │                                                           │
│  3. Kafka starts (KRaft mode, port 9092)                            │
│         │                                                           │
│  4. Kroxylicious starts (port 9192):                                │
│         │                                                           │
│         │  FilterFactory.initialize()                                │
│         │    → PqcKeyManager resolves VaultKeyProvider               │
│         │      via ServiceLoader (matches keyProviderType: "vault")  │
│         │    → VaultKeyProvider.configure()                          │
│         │      connects to Vault (token/approle/kubernetes auth)     │
│         │    → Fetches ML-KEM key pair from Vault KV v2              │
│         │      (GET /v1/secret/data/kroxylicious/pqc)                │
│         │    → Decodes: base64 → DER bytes → Java Key objects        │
│         │    → PqcCryptoEngine initialized with key pair             │
│         ▼                                                           │
│       Proxy ready — Vault is NOT contacted again per-message         │
└─────────────────────────────────────────────────────────────────────┘

                     Kroxylicious (:9192)
                    ┌───────────────────────────────────────────┐

#### Fluxo de busca (descriptografia)```
                                  Kafka Broker (:9092)
                                  returns encrypted blob
                                         │
                                         ▼
                        ┌────────────────┴──────────────────────────┐
                        │ PqcRecordEncryptionFilter                 │
                        │   .onFetchResponse()                      │
                        │                                           │
                        │ For each record with x-pqc-encrypted:     │
                        │   1. Parse envelope → extract encap +     │
                        │      ciphertext                           │
                        │   2. ML-KEM decapsulate (private key)     │
                        │      → recover shared secret              │
                        │   3. SHA-256(shared secret) → AES-256 key │
                        │   4. AES-GCM decrypt → plaintext          │
                        │   5. Remove x-pqc-encrypted header        │
Consumer <──plaintext── │                                           │
                        └───────────────────────────────────────────┘
                         Kroxylicious (:9192)

### Classes Principais

**`PqcRecordEncryptionFilterFactory`** implementa `FilterFactory<PqcEncryptionConfig, SharedPqcContext>`.
Anotada com `@Plugin(configType = PqcEncryptionConfig.class)`.
Registrada via `META-INF/services/io.kroxylicious.proxy.filter.FilterFactory`.
Chamada uma vez na inicialização (`initialize`) e uma vez por conexão de cliente (`createFilter`).

**`PqcRecordEncryptionFilter`** implementa `ProduceRequestFilter` e `FetchResponseFilter`.
Intercepta `onProduceRequest` para criptografar e `onFetchResponse` para descriptografar.
Uma instância por conexão; nenhuma sincronização necessária (modelo de thread do Kroxylicious).

**`PqcCryptoEngine`** realiza todas as operações criptográficas.
Sem estado, exceto pelo material de chave e `SecureRandom`.
`encrypt()` retorna um envelope auto-descritivo; `decrypt()` o analisa.
Registra os provedores Bouncy Castle (`BC`, `BCPQC`) em um inicializador estático.

**`PqcKeyManager`** resolve um `KeyProvider` via `ServiceLoader`, correspondendo pelo
`keyProviderType`. Delega todas as operações de chave para o provedor resolvido.

**`KeyProvider`** é a interface SPI para backends de armazenamento de chaves plugáveis.
Implementações são descobertas via `META-INF/services`. Provedores embutidos:
`FileSystemKeyProvider` (padrão) e `VaultKeyProvider` (com `-Pvault`).

**`PqcEncryptionConfig`** é um POJO anotado com Jackson.
Desserializado do bloco `config:` no YAML do proxy Kroxylicious.
Suporta `keyProviderType` e `keyProviderConfig` para seleção de backend.

## Construção e Testes```bash
# Compile
mvn compile

# Run unit tests (38 core tests)
mvn test

# Package (creates shaded JAR with Bouncy Castle bundled)
mvn package

# Build with Vault support (55 tests: 38 core + 17 vault)
mvn package -Pvault

# Install to local Maven repository
mvn install