# QuarkDash : Protocole hybride post-quantique en TypeScript pour systèmes à forte charge
QuarkDash combine Ring-LWE pour l'échange de clés post-quantique, les chiffrements de flux ChaCha20 ou Gimli, SHAKE-256 pour la dérivation de clés et le MAC, avec une protection contre les attaques de relecture et temporelles. Taille de la clé publique ~2 Ko, privée ~1 Ko. Mise en place de session ~8-9 ms sur des CPU standards. Idéal pour les systèmes client-serveur sans verrouillage architectural.
Sélection des primitives dans QuarkDash
Ring-LWE pour l'échange de clés
Ring-LWE utilise des anneaux polynomiaux avec les paramètres N=256, Q=7681, ω=7. Offre une sécurité post-quantique de 128 bits. Multiplication polynomiale via NTT en O(N log N). Génération de clé : ~12 ms, encapsulation/décapsulation ~8-9 ms.
Chiffrement symétrique
- ChaCha20 : 20 tours, clé 256 bits, nonce 12 octets. Extrêmement rapide en logiciel, résistant aux attaques temporelles.
- Gimli : 24 tours, état 384 bits, sécurité 256 bits. Surpasse ChaCha20 sur architectures 32 bits, code plus compact pour l'IoT.
KDF et MAC avec SHAKE-256
SHAKE-256 (basé sur Keccak) pour une dérivation de clés et une authentification résistantes au quantique. KDF : SHAKE256(salt || sharedSecret || "session-key", 64) → sessionKey (32 octets) + macKey (32 octets). MAC : SHAKE256(macKey || header || ciphertext, 32) avec vérification en temps constant.
Déroulement étape par étape du protocole
Génération de clés
- Choisir a ∈ Z_Q^N.
- Petits s, e avec coefficients {-1,0,1}.
- b = a ⊗ s + e (NTT).
- Publique : (a, b), privée : s.
KEM pour la session
Initiateur :
- u = a ⊗ s' + e'.
- sharedSecret issu de b ⊗ s'.
Destinataire : sharedSecret issu de u ⊗ s.
Chiffrement des messages
- header = timestamp (8 octets) || séquence (4 octets).
- ciphertext = streamCipher.encrypt(plaintext, sessionKey, nonce).
- mac = SHAKE256(macKey || header || ciphertext, 32).
- Paquet : header || ciphertext || mac.
Déchiffrement des messages
- Analyser le paquet.
- Vérifier le MAC (temps constant).
- Vérifier le timestamp dans les 5 minutes.
- S'assurer que la séquence est unique (fenêtre de 1000).
- plaintext = streamCipher.decrypt(ciphertext).
Mesures de sécurité
- Résistance post-quantique : Ring-LWE sans attaques quantiques connues, SHAKE-256 résiste à l'algorithme de Grover.
- Protection contre canaux auxiliaires : Comparaisons en temps constant, effacement sécurisé des clés, pas de branches dépendantes des secrets.
- Secret en avant : Clés de session éphémères.
- Protection contre relecture : Timestamp + séquence.
Sécurité globale : 128-256 bits contre les menaces classiques/quantiques.
Benchmarks de performance
Mise en place de session (ms, moyenne sur 1000 exécutions)
| Opération | QuarkDash (ChaCha20) | QuarkDash (Gimli) | ECDH P-256 | RSA-2048 |
|----------|----------------------|-------------------|------------|----------|
| Génération de clé | 12.3 | 12.1 | 1.2 | 48 |
| Encapsulation KEM | 8.7 | 8.5 | 3.4 | 42 |
| Décapsulation KEM | 9.2 | 9.0 | 3.4 | 0.1 |
Débit (Mo/s)
| Taille | ChaCha20 | Gimli | AES-256-GCM | ECIES |
|--------|----------|-------|-------------|-------|
| 1 Ko | 125 | 132 | 117 | 10 |
| 1 Mo | 2380 | 2630 | 1176 | 48 |
| 10 Mo | 2450 | 2710 | 1200 | 50 |
Surcharge : clé publique 2 Ko, privée 1 Ko, surcharge paquet 44 octets.
Comparaison avec les alternatives
- Vs AES : QuarkDash intègre KEM, secret en avant, protection contre relecture. ChaCha20 surpasse AES en logiciel sans accélération matérielle.
- Vs ECC : Résistant à Shor, surcharge paquet moindre (44 vs 61 octets), plus rapide pour gros volumes de données.
Le protocole est optimisé pour TypeScript dans les applications web, avec émulation de SHAKE-256 sur Keccak.
Points clés
- Ring-LWE (N=256, Q=7681) pour 128 bits PQC avec multiplication NTT.
- Deux chiffrements : ChaCha20 pour logiciel, Gimli pour IoT.
- KDF/MAC SHAKE-256 en temps constant.
- Protection relecture via timestamp + séquence (fenêtre 1000).
- Benchmarks : jusqu'à 2710 Mo/s chiffrement, sessions ~9 ms.
— Editorial Team
Aucun commentaire pour le moment.