Kroxylicious PQC रिकॉर्ड एन्क्रिप्शन फ़िल्टर

एक Kroxylicious फ़िल्टर प्लगइन जो Apache Kafka के लिए पारदर्शी Post-Quantum Cryptography (PQC) रिकॉर्ड-स्तरीय एन्क्रिप्शन प्रदान करता है, जो ML-KEM (FIPS 203) key encapsulation के साथ AES-256-GCM सममित एन्क्रिप्शन का उपयोग करता है।

Kafka प्रोड्यूसर और कंज़्यूमर को शून्य कोड परिवर्तन की आवश्यकता होती है। Kroxylicious प्रॉक्सी ट्रैफ़िक को इंटरसेप्ट करता है और Produce पर एन्क्रिप्ट / Fetch पर डिक्रिप्ट स्वचालित रूप से करता है।``` Producer ──plaintext──> Kroxylicious ──encrypted──> Kafka Broker Consumer <──plaintext── Kroxylicious <──encrypted── Kafka Broker

## Kafka के लिए PQC क्यों?

शास्त्रीय कुंजी स्थापना एल्गोरिदम (RSA, ECDH) भविष्य के क्वांटम कंप्यूटरों के प्रति संवेदनशील हैं। यदि प्रति-रिकॉर्ड एन्क्रिप्शन कुंजियाँ किसी शास्त्रीय KEM का उपयोग करके स्थापित की जाती हैं, तो एक क्वांटम प्रतिद्वंद्वी उन कुंजियों को ब्रोकर पर सिफरटेक्स्ट के साथ संग्रहीत एनकैप्सुलेशन से पुनर्प्राप्त कर सकता है।

यह प्लगइन क्वांटम-प्रतिरोधी कुंजी एनकैप्सुलेशन के लिए ML-KEM (FIPS 203) का उपयोग करता है, जिससे यह सुनिश्चित होता है कि Kafka ब्रोकर पर विश्राम अवस्था (data at rest) में मौजूद डेटा को क्रिप्टोग्राफिक रूप से प्रासंगिक क्वांटम कंप्यूटर वाले प्रतिद्वंद्वी द्वारा भी डिक्रिप्ट नहीं किया जा सकता।

**नोट:** यह फ़िल्टर **ब्रोकर पर विश्राम अवस्था में डेटा (data at rest)** की सुरक्षा करता है, न कि ट्रांज़िट में TLS चैनल की। पूर्ण विश्लेषण के लिए देखें [THREAT_MODEL.md](https://github.com/oscerd/kroxylicious-pqc-filter/blob/HEAD/THREAT_MODEL.md) कि किस चीज़ से बचाव होता है और किससे नहीं।

| Standard | Algorithm | इस प्लगइन में उद्देश्य |
|----------|-----------|------------------------|
| FIPS 203 | ML-KEM (Kyber) | कुंजी एनकैप्सुलेशन - प्रति-संदेश AES कुंजी सुरक्षित रूप से स्थापित करता है |
| N/A | AES-256-GCM | रिकॉर्ड पेलोड की सममित प्रमाणित एन्क्रिप्शन |
| N/A | X25519 ECDH | हाइब्रिड मोड रक्षा-गहराई के लिए शास्त्रीय कुंजी समझौता |

## विशेषताएँ

- **पारदर्शी एन्क्रिप्शन/डिक्रिप्शन** - क्लाइंट-साइड में कोई बदलाव आवश्यक नहीं
- **ML-KEM-512, ML-KEM-768 (डिफ़ॉल्ट), ML-KEM-1024** पैरामीटर सेट
- **हाइब्रिड मोड** (डिफ़ॉल्ट) - ML-KEM + X25519 ECDH को जोड़ता है ताकि दोनों को तोड़ना आवश्यक हो
- **प्रति-रिकॉर्ड एन्क्रिप्शन** - प्रत्येक रिकॉर्ड को एक नया KEM एनकैप्सुलेशन + यादृच्छिक IV मिलता है
- **टॉपिक फ़िल्टरिंग** - रेगेक्स पैटर्न चुनते हैं कि कौन से टॉपिक एन्क्रिप्ट करने हैं
- **छेड़छाड़ का पता लगाना** - AES-GCM प्रमाणित एन्क्रिप्शन संशोधित सिफरटेक्स्ट को अस्वीकार करता है
- **सिमेंटिक सुरक्षा** - समान प्लेनटेक्स्ट अलग-अलग सिफरटेक्स्ट उत्पन्न करते हैं (IND-CCA2)
- **कुंजी स्वतः-जनरेशन** - अनुपलब्ध होने पर पहले स्टार्टअप पर ML-KEM कुंजियाँ जनरेट और सेव करता है
- **`x-pqc-encrypted` हेडर** - डाउनस्ट्रीम जागरूकता के लिए एन्क्रिप्टेड रिकॉर्ड को चिह्नित करता है
- **प्लग करने योग्य कुंजी प्रदाता** - `KeyProvider` SPI फ़ाइलसिस्टम (डिफ़ॉल्ट) और HashiCorp Vault बैकएंड का समर्थन करता है

## आवश्यक शर्तें

| आवश्यकता | संस्करण |
|-------------|---------|
| JDK | 17+ (21+ अनुशंसित) |
| Maven | 3.8+ |
| Kroxylicious | 0.19.0 |
| Apache Kafka | 3.9.x |

## त्वरित आरंभ

### 1. प्लगइन बनाएं```bash
git clone <this-repo>
cd kroxylicious-pqc-filter
mvn clean package -DskipTests

target/kroxylicious-pqc-filter-1.0.0-SNAPSHOT.jar पर स्थित shaded JAR, Bouncy Castle को बंडल करता है ताकि इसे बिना किसी अतिरिक्त निर्भरता के Kroxylicious में डाला जा सके।

HashiCorp Vault key provider समर्थन शामिल करने के लिए, vault प्रोफ़ाइल के साथ बिल्ड करें:```bash mvn clean package -Pvault -DskipTests

यह `spring-vault-core` और `VaultKeyProvider` को JAR में बंडल करता है।

### 2. 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 for chunk 9 is empty — no content was provided to translate.``` 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

वैकल्पिक रूप से, कॉन्फ़िगरेशन में कुंजी पथों को छोड़ दें और फ़िल्टर
पहली बार प्रारंभ होने पर कुंजियाँ स्वचालित रूप से उत्पन्न करेगा।

### 3. Kroxylicious को कॉन्फ़िगर करें

अपने Kroxylicious प्रॉक्सी YAML कॉन्फ़िगरेशन में फ़िल्टर जोड़ें:```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. तैनाती

JAR को Kroxylicious के लिए सुलभ निर्देशिका में रखें और इसे KROXYLICIOUS_CLASSPATH पर्यावरण चर के माध्यम से क्लासपाथ में जोड़ें:```bash export KROXYLICIOUS_CLASSPATH="/opt/kroxylicious/plugins/*"

Docker का उपयोग करते समय, इसे अपने कंटेनर वातावरण में सेट करें:```yaml
environment:
  KROXYLICIOUS_CLASSPATH: /opt/kroxylicious/plugins/*

फिर प्रॉक्सी शुरू करें। प्रोड्यूसर और कंज़्यूमर ब्रोकर से सीधे जुड़ने के बजाय प्रॉक्सी पोर्ट से जुड़ते हैं।

कॉन्फ़िगरेशन संदर्भ

कुंजी प्रदाता

Filesystem (keyProviderType: filesystem, डिफ़ॉल्ट): डिस्क पर DER फ़ाइलों से ML-KEM कुंजियाँ लोड करता है। यदि फ़ाइलें मौजूद नहीं हैं, तो एक नई कुंजी जोड़ी उत्पन्न करके उन्हें सहेजता है। इसके लिए publicKeyPath और privateKeyPath आवश्यक हैं।

HashiCorp Vault (keyProviderType: vault, -Pvault बिल्ड की आवश्यकता है): Vault KV v2 secrets engine से ML-KEM कुंजियाँ प्राप्त करता है। कुंजियाँ publicKey और privateKey फ़ील्ड्स में base64-एन्कोडेड DER के रूप में संग्रहीत होती हैं। कुंजी रोटेशन समर्थन के लिए Vault secret संस्करण, कुंजी IDs में मैप होते हैं।

Vault keyProviderConfig गुण:

Vault कॉन्फ़िगरेशन का उदाहरण:```yaml filterDefinitions:

name: pqc-encryption type: PqcRecordEncryptionFilterFactory config: kemAlgorithm: ML_KEM_768 hybridMode: false keyProviderType: vault keyProviderConfig: vaultAddress: http://vault:8200 vaultToken: my-token secretPath: kroxylicious/pqc topicPatterns: - "sensitive-.*"

### ML-KEM पैरामीटर सेट

| एल्गोरिथ्म | सुरक्षा स्तर | सार्वजनिक कुंजी | निजी कुंजी | सिफरटेक्स्ट ओवरहेड | उपयोग परिदृश्य |
|-----------|---------------|------------|-------------|--------------------:|----------|
| ML-KEM-512 | 128-bit | 822 B | 1,730 B | ~854 B | हल्का, IoT |
| ML-KEM-768 | 192-bit | 1,206 B | 2,498 B | ~1,174 B | **अनुशंसित डिफ़ॉल्ट** |
| ML-KEM-1024 | 256-bit | 1,590 B | 3,266 B | ~1,654 B | गोपनीय / दीर्घकालिक डेटा |

### एन्क्रिप्शन मोड

**केवल PQC** (`hybridMode: false`):
केवल ML-KEM का उपयोग करता है। AES-256 कुंजी ML-KEM साझा रहस्य से व्युत्पन्न की जाती है
`SHA-256(0x01 || "kroxylicious-pqc-v1" || secret)` के माध्यम से।

**हाइब्रिड** (`hybridMode: true`, डिफ़ॉल्ट):
ML-KEM + X25519 को संयोजित करता है। AES-256 कुंजी दोनों रहस्यों से व्युत्पन्न की जाती है
`SHA-256(0x02 || "kroxylicious-pqc-hybrid-v1" || pqcSecret || x25519Secret)`।
यह सुनिश्चित करता है कि भले ही एक एल्गोरिथ्म टूट जाए, सुरक्षा बनी रहे।

## एन्क्रिप्टेड एनवेलप प्रारूप

प्रत्येक एन्क्रिप्टेड रिकॉर्ड मान को एक बाइनरी एनवेलप से बदल दिया जाता है:```
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 |        |                 |
+--------+-----------+--------------------+---------+--------+-----------------+

वर्शन बाइट डिक्रिप्टर को बिना कॉन्फ़िगरेशन के मोड निर्धारित करने में सक्षम बनाता है।

आर्किटेक्चर

मॉड्यूल संरचना```

kroxylicious-pqc-filter/ src/main/java/io/kroxylicious/filter/pqc/ PqcRecordEncryptionFilterFactory.java # FilterFactory entry point (@Plugin) PqcRecordEncryptionFilter.java # ProduceRequestFilter + FetchResponseFilter PqcKeyGeneratorCli.java # CLI key generation utility config/ PqcEncryptionConfig.java # Jackson-deserialized configuration POJO crypto/ KeyProvider.java # SPI interface for pluggable key backends FileSystemKeyProvider.java # Default: loads/generates keys from disk PqcCryptoEngine.java # ML-KEM encapsulation + AES-256-GCM PqcKeyManager.java # Resolves KeyProvider via ServiceLoader src/main/java-vault/ # (vault profile only) .../crypto/ VaultKeyProvider.java # HashiCorp Vault KV v2 key provider src/main/resources/ META-INF/services/ io.kroxylicious.proxy.filter.FilterFactory # ServiceLoader: filter registration io.kroxylicious.filter.pqc.crypto.KeyProvider # ServiceLoader: key provider src/main/resources-vault/ # (vault profile only) META-INF/services/ io.kroxylicious.filter.pqc.crypto.KeyProvider # Registers both FS + Vault providers src/test/java/... # Unit tests (49 tests) src/test/java-vault/... # Vault provider tests (17 tests) examples/ standalone/ # Runs without Kafka (crypto engine demo) docker/ # Docker Compose: Kafka + Vault + Kroxylicious

### डेटा प्रवाह

#### वॉल्ट में क्या संग्रहीत होता है

Vault KV v2 `secret/<secretPath>` (जैसे, `secret/kroxylicious/pqc`) पर ML-KEM कुंजी जोड़ी रखता है:

| फ़ील्ड | सामग्री | प्रारूप |
|-------|---------|--------|
| `publicKey` | ML-KEM सार्वजनिक कुंजी (एन्कैप्सुलेशन के लिए उपयोग) | Base64-encoded X.509 DER |
| `privateKey` | ML-KEM निजी कुंजी (डिकैप्सुलेशन के लिए उपयोग) | Base64-encoded PKCS#8 DER |

प्रत्येक Vault सीक्रेट संस्करण एक कुंजी ID के रूप में कार्य करता है, जो कुंजी रोटेशन सक्षम बनाता है। नए संस्करण नए रिकॉर्ड को एन्क्रिप्ट करते हैं; पुराने संस्करण अभी भी उनके साथ एन्क्रिप्ट किए गए रिकॉर्ड को डिक्रिप्ट कर सकते हैं।

#### स्टार्टअप प्रवाह```
┌─────────────────────────────────────────────────────────────────────┐
│                           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)
                    ┌───────────────────────────────────────────┐

Producer ──plaintext──> │ PqcRecordEncryptionFilter │ │ .onProduceRequest() │ │ │ │ For each record in matching topic: │ │ 1. ML-KEM encapsulate (public key) │ │ → fresh shared secret │ │ → encapsulation blob │ │ 2. SHA-256(shared secret) → AES-256 key │ │ 3. AES-GCM encrypt record value │ │ 4. Build binary envelope: │ │ [ver|encap_len|encap|IV|ciphertext] │ │ 5. Add x-pqc-encrypted header │ └────────────────┬──────────────────────────┘ │ ▼ Kafka Broker (:9092) stores encrypted blob

#### फ़ेच प्रवाह (डिक्रिप्शन)```
                                  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)

मुख्य डिज़ाइन निर्णय

Vault से केवल स्टार्टअप पर संपर्क किया जाता है, प्रति-संदेश नहीं। कोई प्रति-रिकॉर्ड विलंबता नहीं।
स्टार्टअप के बाद यदि Vault डाउन हो जाता है, तो एन्क्रिप्शन/डिक्रिप्शन बिना किसी प्रभाव के जारी रहता है।
प्रत्येक रिकॉर्ड को एक नया ML-KEM encapsulation मिलता है (नया साझा रहस्य + यादृच्छिक IV), जो सिमेंटिक सुरक्षा (IND-CCA2) सुनिश्चित करता है, भले ही एक ही कुंजी जोड़ी पुनः उपयोग की जाए।
कुंजी रोटेशन Vault secret का नया संस्करण लिखकर और प्रॉक्सी को पुनः प्रारंभ करके किया जाता है।

फ़िल्टर जीवनचक्र```

Startup: FilterFactory.initialize() -> PqcKeyManager loads/generates ML-KEM key pair -> PqcCryptoEngine created with key pair -> Topic patterns compiled -> SharedPqcContext returned

Per connection: FilterFactory.createFilter() -> New PqcRecordEncryptionFilter instance -> Shares the same PqcCryptoEngine (thread-safe)

Produce request: onProduceRequest() -> For each topic matching topicPatterns: -> For each partition: -> For each record: -> ML-KEM encapsulate (fresh shared secret + encapsulation) -> Derive AES-256 key from shared secret -> AES-GCM encrypt the record value -> Replace value with encrypted envelope -> Add x-pqc-encrypted header -> Forward to broker

Fetch response: onFetchResponse() -> For each topic matching topicPatterns: -> For each partition: -> For each record with x-pqc-encrypted header: -> Read version + encapsulation from envelope -> ML-KEM decapsulate (recover shared secret) -> Derive AES-256 key -> AES-GCM decrypt -> Replace value with plaintext -> Remove x-pqc-encrypted header -> Forward to client

### मुख्य कक्षाएं

**`PqcRecordEncryptionFilterFactory`** `FilterFactory<PqcEncryptionConfig, SharedPqcContext>` को लागू करता है।
`@Plugin(configType = PqcEncryptionConfig.class)` से एनोटेट किया गया है।
`META-INF/services/io.kroxylicious.proxy.filter.FilterFactory` के माध्यम से पंजीकृत।
स्टार्टअप पर एक बार (`initialize`) और प्रत्येक क्लाइंट कनेक्शन पर एक बार (`createFilter`) कॉल किया जाता है।

**`PqcRecordEncryptionFilter`** `ProduceRequestFilter` और `FetchResponseFilter` को लागू करता है।
एन्क्रिप्ट करने के लिए `onProduceRequest` और डिक्रिप्ट करने के लिए `onFetchResponse` को इंटरसेप्ट करता है।
प्रति कनेक्शन एक इंस्टेंस; किसी सिंक्रनाइज़ेशन की आवश्यकता नहीं (Kroxylicious थ्रेड मॉडल)।

**`PqcCryptoEngine`** सभी क्रिप्टोग्राफ़िक ऑपरेशन करता है।
की सामग्री और `SecureRandom` को छोड़कर स्टेटलेस है।
`encrypt()` एक स्व-वर्णनात्मक लिफाफा लौटाता है; `decrypt()` इसे पार्स करता है।
स्टैटिक इनिशियलाइज़र में Bouncy Castle प्रोवाइडर (`BC`, `BCPQC`) पंजीकृत करता है।

**`PqcKeyManager`** `ServiceLoader` के माध्यम से एक `KeyProvider` को रिज़ॉल्व करता है, मिलान करके
`keyProviderType` द्वारा। सभी कुंजी ऑपरेशन रिज़ॉल्व किए गए प्रोवाइडर को सौंपता है।

**`KeyProvider`** प्लग करने योग्य कुंजी भंडारण बैकएंड के लिए SPI इंटरफ़ेस है।
कार्यान्वयन `META-INF/services` के माध्यम से खोजे जाते हैं। अंतर्निहित प्रोवाइडर:
`FileSystemKeyProvider` (डिफ़ॉल्ट) और `VaultKeyProvider` (`-Pvault` के साथ)।

**`PqcEncryptionConfig`** एक Jackson-एनोटेटेड POJO है।
Kroxylicious प्रॉक्सी YAML में `config:` ब्लॉक से डिसीरियलाइज़ किया गया।
बैकएंड चयन के लिए `keyProviderType` और `keyProviderConfig` का समर्थन करता है।

## निर्माण और परीक्षण```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

परीक्षण कवरेज

कुल: 55 परीक्षण (38 कोर + 17 Vault)

निर्भरताएँ

रनटाइम

परीक्षण

JUnit 5.11.4, Mockito 5.15.2, AssertJ 3.27.3, Jackson Databind 2.18.3.

प्रदर्शन

स्टैंडअलोन डेमो पर मापा गया (JVM गर्म, 1,000 पुनरावृत्तियाँ, 1 KB संदेश):

एल्गोरिदम	एन्क्रिप्ट	डिक्रिप्ट
ML-KEM-512	~7,700 msg/s (0.13 ms/msg)	~7,800 msg/s (0.13 ms/msg)
ML-KEM-768

प्रति-संदेश ओवरहेड सब-मिलीसेकंड है। सामान्य Kafka वर्कलोड (KB-MB रेंज में संदेश) के लिए, एन्क्रिप्शन लागत नेटवर्क और डिस्क I/O की तुलना में नगण्य है।

सुरक्षा संबंधी विचार

यह फ़िल्टर किन चीज़ों से सुरक्षा करता है और किनसे नहीं, यह कवर करने वाला पूर्ण थ्रेट मॉडल देखने के लिए THREAT_MODEL.md देखें।

कुंजी सुरक्षा (फाइलसिस्टम): निजी कुंजी फ़ाइल केवल Kroxylicious प्रक्रिया द्वारा पठनीय होनी चाहिए। फाइलसिस्टम अनुमतियों (chmod 600) का उपयोग करें।
कुंजी सुरक्षा (Vault): सीक्रेट पथ तक पहुँच प्रतिबंधित करने के लिए Vault पॉलिसियों का उपयोग करें। प्रोडक्शन में स्थैतिक टोकन की तुलना में approle या kubernetes प्रमाणीकरण को प्राथमिकता दें। Vault टोकन को संस्करण नियंत्रण में कभी कमिट न करें।
कुंजी रोटेशन: Vault कुंजी प्रदाता Vault सीक्रेट संस्करणों के माध्यम से कुंजी संस्करणीकरण का समर्थन करता है। नए संस्करण एन्क्रिप्ट करते हैं; पुराने संस्करण अभी भी डिक्रिप्ट कर सकते हैं।
टॉम्बस्टोन: null मान वाले रिकॉर्ड (Kafka टॉम्बस्टोन) बिना एन्क्रिप्शन के पास किए जाते हैं।
हेडर: रिकॉर्ड हेडर एन्क्रिप्ट नहीं होते, केवल मान। हेडर में संवेदनशील डेटा न डालें।
कंप्रेशन: फ़िल्टर एन्क्रिप्टेड बैचों को Compression.NONE के साथ लिखता है क्योंकि एन्क्रिप्टेड डेटा अच्छी तरह कंप्रेस नहीं होता।

लाइसेंस

Apache लाइसेंस 2.0. विवरण के लिए LICENSE देखें।

`kemAlgorithm`	enum	No	`ML_KEM_768`	ML-KEM पैरामीटर सेट। इनमें से एक: `ML_KEM_512`, `ML_KEM_768`, `ML_KEM_1024`।
`hybridMode`	boolean	No	`true`	गहन सुरक्षा (defense-in-depth) के लिए ML-KEM को X25519 ECDH के साथ संयोजित करें।
`publicKeyPath`	string	Filesystem only	-	ML-KEM सार्वजनिक कुंजी (X.509 DER एन्कोडेड) के लिए फ़ाइल सिस्टम पथ।
`privateKeyPath`	string	Filesystem only	-	ML-KEM निजी कुंजी (PKCS#8 DER एन्कोडेड) के लिए फ़ाइल सिस्टम पथ।
`topicPatterns`	list<string>	No	`[".*"]`	Java regex पैटर्न। मेल खाने वाले टॉपिक्स में केवल रिकॉर्ड ही एन्क्रिप्ट/डिक्रिप्ट होते हैं।
`keyProviderType`	string	No	`filesystem`	कुंजी भंडारण बैकएंड। इनमें से एक: `filesystem`, `vault`।
`keyProviderConfig`	map<string, string>	Vault only	`{}`	बैकएंड-विशिष्ट कॉन्फ़िगरेशन (नीचे Vault अनुभाग देखें)।

`vaultAddress`	हाँ	`VAULT_ADDR` पर्यावरण चर	Vault सर्वर URL (उदाहरण: `http://vault:8200`)
`vaultToken`	`token` प्रमाणीकरण के लिए	`VAULT_TOKEN` पर्यावरण चर	Vault प्रमाणीकरण टोकन
`secretPath`	हाँ	--	secrets engine के भीतर पथ (उदाहरण: `kroxylicious/pqc`)
`secretEngine`	नहीं	`secret`	KV v2 secrets engine माउंट नाम
`authMethod`	नहीं	`token`	प्रमाणीकरण विधि: `token`, `approle`, या `kubernetes`
`roleId`	`approle` के लिए	--	AppRole भूमिका ID
`secretId`	`approle` के लिए	--	AppRole गुप्त ID
`kubeRole`	`kubernetes` के लिए	--	Kubernetes प्रमाणीकरण भूमिका नाम
`kubeTokenPath`	नहीं	`/var/run/secrets/.../token`	सर्विस अकाउंट टोकन फ़ाइल पथ

`PqcCryptoEngineTest`	12	सभी 3 ML-KEM वेरिएंट के लिए एन्क्रिप्ट/डिक्रिप्ट राउंडट्रिप, null हैंडलिंग, खाली और 1MB पेलोड, सिमेंटिक सुरक्षा, छेड़छाड़ पहचान, अमान्य संस्करण अस्वीकृति, कुंजी निर्माण, लिफाफा संस्करण बाइट्स
`PqcEncryptionConfigTest`	9	डिफ़ॉल्ट मान, स्पष्ट मान, null अस्वीकृति, JSON डिसीरियलाइज़ेशन, अपरिवर्तनीयता, enum गुण, keyProviderConfig डिसीरियलाइज़ेशन
`PqcKeyManagerTest`	6	KeyProvider रिज़ॉल्यूशन, इंजन निर्माण, प्रदाताओं को प्रत्यायोजन, फाइलसिस्टम प्रकार के लिए फ़ॉलबैक
`FileSystemKeyProviderTest`	11	कुंजी निर्माण, मौजूदा कुंजियाँ लोड करना, डिफ़ॉल्ट कुंजी ID, अज्ञात कुंजी ID अस्वीकृति, null पथ सत्यापन, ServiceLoader डिस्कवरी, क्रिप्टो राउंडट्रिप
`VaultKeyProviderTest`	17	कॉन्फ़िग सत्यापन (लापता path/address/token/approle/kube), Vault से कुंजी प्राप्त करना, संस्करणित कुंजी पुनर्प्राप्ति, कैश्ड कुंजियाँ, अमान्य संस्करण, सीक्रेट में लापता फ़ील्ड, क्रिप्टो राउंडट्रिप, बंद होने का व्यवहार

`io.kroxylicious:kroxylicious-api`	0.19.0	provided	फ़िल्टर API इंटरफेस
`org.apache.kafka:kafka-clients`	3.9.0	provided	Kafka प्रोटोकॉल संदेश प्रकार
`com.fasterxml.jackson.core:jackson-annotations`	2.18.3	provided	कॉन्फ़िगरेशन बाइंडिंग
`org.bouncycastle:bcprov-jdk18on`	1.83	compile	ML-KEM, AES-GCM, X25519 (शेडेड JAR में बंडल)
`org.bouncycastle:bcutil-jdk18on`	1.83	compile	Bouncy Castle उपयोगिताएँ (शेडेड JAR में बंडल)
`org.slf4j:slf4j-api`	2.0.17	provided	लॉगिंग
`org.springframework.vault:spring-vault-core`	3.1.2	compile (vault profile)	Vault KV v2 क्लाइंट (`-Pvault` के साथ बनाने पर बंडल)

kroxylicious-pqc-filter

सबसे लोकप्रिय