# 🔐 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