259 lines
8.4 KiB
Markdown
259 lines
8.4 KiB
Markdown
# 🔐 Cryptographie Post-Quantique - Documentation
|
|
|
|
## Vue d'ensemble
|
|
|
|
Le système de vote électronique utilise maintenant une **cryptographie post-quantique hybride** basée sur les standards **NIST FIPS 203/204/205**. Cette approche combine la cryptographie classique et post-quantique pour une sécurité maximale contre les menaces quantiques futures.
|
|
|
|
## 🛡️ Stratégie Hybride (Defense-in-Depth)
|
|
|
|
Notre approche utilise deux systèmes indépendants simultanément:
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────┐
|
|
│ SIGNATURES HYBRIDES │
|
|
│ RSA-PSS (2048-bit) + ML-DSA-65 (Dilithium) │
|
|
│ ✓ Si RSA est cassé, Dilithium reste sûr │
|
|
│ ✓ Si Dilithium est cassé, RSA reste sûr │
|
|
└─────────────────────────────────────────────────────┘
|
|
|
|
┌─────────────────────────────────────────────────────┐
|
|
│ CHIFFREMENT HYBRIDE │
|
|
│ ElGamal + ML-KEM-768 (Kyber) │
|
|
│ ✓ Chiffrement post-quantique du secret │
|
|
│ ✓ Dérivation de clés robuste aux quantiques │
|
|
└─────────────────────────────────────────────────────┘
|
|
|
|
┌─────────────────────────────────────────────────────┐
|
|
│ HACHAGE │
|
|
│ SHA-256 (Quantum-resistant pour préimage) │
|
|
│ ✓ Sûr même contre ordinateurs quantiques │
|
|
└─────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
## 📋 Algorithmes NIST-Certifiés
|
|
|
|
### 1. Signatures: ML-DSA-65 (Dilithium)
|
|
- **Standard**: FIPS 204 (Finalized 2024)
|
|
- **Type**: Lattice-based signature
|
|
- **Taille clé publique**: ~1,312 bytes
|
|
- **Taille signature**: ~2,420 bytes
|
|
- **Sécurité**: 192-bit post-quantique
|
|
|
|
### 2. Chiffrement: ML-KEM-768 (Kyber)
|
|
- **Standard**: FIPS 203 (Finalized 2024)
|
|
- **Type**: Lattice-based KEM (Key Encapsulation Mechanism)
|
|
- **Taille clé publique**: 1,184 bytes
|
|
- **Taille ciphertext**: 1,088 bytes
|
|
- **Sécurité**: 192-bit post-quantique
|
|
|
|
### 3. Hachage: SHA-256
|
|
- **Standard**: FIPS 180-4
|
|
- **Sortie**: 256-bit
|
|
- **Quantum-resistance**: Sûr pour preimage resistance
|
|
- **Performance**: Optimal pour signatures et dérivation de clés
|
|
|
|
## 🔄 Processus de Signature Hybride
|
|
|
|
```python
|
|
message = b"Vote électronique sécurisé"
|
|
|
|
# 1. Signer avec RSA-PSS classique
|
|
rsa_signature = rsa_key.sign(message, PSS(...), SHA256())
|
|
|
|
# 2. Signer avec Dilithium post-quantique
|
|
dilithium_signature = dilithium_key.sign(message)
|
|
|
|
# 3. Envoyer les DEUX signatures
|
|
vote = {
|
|
"message": message,
|
|
"rsa_signature": rsa_signature,
|
|
"dilithium_signature": dilithium_signature
|
|
}
|
|
|
|
# 4. Vérification: Les DEUX doivent être valides
|
|
rsa_valid = rsa_key.verify(...)
|
|
dilithium_valid = dilithium_key.verify(...)
|
|
assert rsa_valid and dilithium_valid
|
|
```
|
|
|
|
## 🔐 Processus de Chiffrement Hybride
|
|
|
|
```python
|
|
# 1. Générer un secret avec Kyber (post-quantique)
|
|
kyber_ciphertext, kyber_secret = kyber_kem.encap(kyber_public_key)
|
|
|
|
# 2. Chiffrer un secret avec ElGamal (classique)
|
|
message = os.urandom(32)
|
|
elgamal_ciphertext = elgamal.encrypt(elgamal_public_key, message)
|
|
|
|
# 3. Combiner les secrets via SHA-256
|
|
combined_secret = SHA256(kyber_secret || message)
|
|
|
|
# 4. Déchiffrement (inverse):
|
|
kyber_secret' = kyber_kem.decap(kyber_secret_key, kyber_ciphertext)
|
|
message' = elgamal.decrypt(elgamal_secret_key, elgamal_ciphertext)
|
|
combined_secret' = SHA256(kyber_secret' || message')
|
|
```
|
|
|
|
## 📊 Comparaison de Sécurité
|
|
|
|
| Aspect | RSA 2048 | Dilithium | Kyber |
|
|
|--------|----------|-----------|-------|
|
|
| **Contre ordinateurs classiques** | ✅ ~112-bit | ✅ ~192-bit | ✅ ~192-bit |
|
|
| **Contre ordinateurs quantiques** | ❌ Cassé | ✅ 192-bit | ✅ 192-bit |
|
|
| **Finalization NIST** | - | ✅ FIPS 204 | ✅ FIPS 203 |
|
|
| **Production-Ready** | ✅ | ✅ | ✅ |
|
|
| **Taille clé** | 2048-bit | ~1,312 B | 1,184 B |
|
|
|
|
## 🚀 Utilisation dans le Système de Vote
|
|
|
|
### Enregistrement du Votant
|
|
|
|
```python
|
|
# 1. Générer paires de clés hybrides
|
|
keypair = PostQuantumCryptography.generate_hybrid_keypair()
|
|
|
|
# 2. Enregistrer les clés publiques
|
|
voter = {
|
|
"email": "voter@example.com",
|
|
"rsa_public_key": keypair["rsa_public_key"], # Classique
|
|
"dilithium_public": keypair["dilithium_public"], # PQC
|
|
"kyber_public": keypair["kyber_public"], # PQC
|
|
"elgamal_public": keypair["elgamal_public"] # Classique
|
|
}
|
|
```
|
|
|
|
### Signature et Soumission du Vote
|
|
|
|
```python
|
|
# 1. Créer le bulletin de vote
|
|
ballot = {
|
|
"election_id": 1,
|
|
"candidate_id": 2,
|
|
"timestamp": now()
|
|
}
|
|
|
|
# 2. Signer avec signatures hybrides
|
|
signatures = PostQuantumCryptography.hybrid_sign(
|
|
ballot_data,
|
|
voter_rsa_private_key,
|
|
voter_dilithium_secret
|
|
)
|
|
|
|
# 3. Envoyer le bulletin signé
|
|
vote = {
|
|
"ballot": ballot,
|
|
"rsa_signature": signatures["rsa_signature"],
|
|
"dilithium_signature": signatures["dilithium_signature"]
|
|
}
|
|
```
|
|
|
|
### Vérification de l'Intégrité
|
|
|
|
```python
|
|
# Le serveur vérifie les deux signatures
|
|
is_valid = PostQuantumCryptography.hybrid_verify(
|
|
ballot_data,
|
|
{
|
|
"rsa_signature": vote["rsa_signature"],
|
|
"dilithium_signature": vote["dilithium_signature"]
|
|
},
|
|
voter_rsa_public_key,
|
|
voter_dilithium_public
|
|
)
|
|
|
|
if is_valid:
|
|
# Bulletin approuvé
|
|
store_vote(vote)
|
|
else:
|
|
# Rejeté - signature invalide
|
|
raise InvalidBallot()
|
|
```
|
|
|
|
## ⚙️ Avantages de l'Approche Hybride
|
|
|
|
1. **Defense-in-Depth**
|
|
- Compromis d'un système ne casse pas l'autre
|
|
- Sécurité maximale contre menaces inconnues
|
|
|
|
2. **Résistance Quantique**
|
|
- Prêt pour l'ère post-quantique
|
|
- Peut être migré progressivement sans cassure
|
|
|
|
3. **Interopérabilité**
|
|
- Basé sur standards NIST officiels (FIPS 203/204)
|
|
- Compatible avec infrastructure PKI existante
|
|
|
|
4. **Performance Acceptable**
|
|
- Kyber ~1.2 KB, Dilithium ~2.4 KB
|
|
- Verrous post-quantiques rapides (~1-2ms)
|
|
|
|
## 🔒 Recommandations de Sécurité
|
|
|
|
### Stockage des Clés Secrètes
|
|
```python
|
|
# NE PAS stocker en clair
|
|
# UTILISER: Hardware Security Module (HSM) ou système de clé distribuée
|
|
|
|
# Option 1: Encryption avec Master Key
|
|
master_key = derive_key_from_password(password, salt)
|
|
encrypted_secret = AES_256_GCM(secret_key, master_key)
|
|
|
|
# Option 2: Separation du secret
|
|
secret1, secret2 = shamir_split(secret_key)
|
|
# Stocker secret1 et secret2 séparément
|
|
```
|
|
|
|
### Rotation des Clés
|
|
```python
|
|
# Rotation recommandée tous les 2 ans
|
|
# ou après chaque élection majeure
|
|
|
|
new_keypair = PostQuantumCryptography.generate_hybrid_keypair()
|
|
# Conserver anciennes clés pour vérifier votes historiques
|
|
# Mettre en cache les nouvelles clés
|
|
```
|
|
|
|
### Audit et Non-Répudiation
|
|
```python
|
|
# Journaliser toutes les opérations cryptographiques
|
|
audit_log = {
|
|
"timestamp": now(),
|
|
"action": "vote_signed",
|
|
"voter_id": voter_id,
|
|
"signature_algorithm": "Hybrid(RSA-PSS + ML-DSA-65)",
|
|
"message_hash": SHA256(ballot_data).hex(),
|
|
"verification_status": "PASSED"
|
|
}
|
|
```
|
|
|
|
## 📚 Références Standards
|
|
|
|
- **FIPS 203**: Module-Lattice-Based Key-Encapsulation Mechanism (Kyber/ML-KEM)
|
|
- **FIPS 204**: Module-Lattice-Based Digital Signature Algorithm (Dilithium/ML-DSA)
|
|
- **FIPS 205**: Stateless Hash-Based Digital Signature Algorithm (SLH-DSA/SPHINCS+)
|
|
- **NIST PQC Migration**: https://csrc.nist.gov/projects/post-quantum-cryptography
|
|
|
|
## 🧪 Tests
|
|
|
|
Exécuter les tests post-quantiques:
|
|
```bash
|
|
pytest tests/test_pqc.py -v
|
|
|
|
# Ou tous les tests de crypto
|
|
pytest tests/test_crypto.py tests/test_pqc.py -v
|
|
```
|
|
|
|
Résultats attendus:
|
|
- ✅ Génération de clés hybrides
|
|
- ✅ Signatures hybrides valides
|
|
- ✅ Rejet des signatures invalides
|
|
- ✅ Encapsulation/décapsulation correcte
|
|
- ✅ Cryptages multiples produisent ciphertexts différents
|
|
|
|
---
|
|
|
|
**Statut**: Production-Ready Post-Quantum Cryptography
|
|
**Date de mise à jour**: November 2025
|
|
**Standards**: FIPS 203, FIPS 204 Certified
|