Caractéristiques :

• Nécessite 2 allers-retours (2-RTT) avant de pouvoir envoyer des données
• Messages ServerKeyExchange et ServerHelloDone explicites
• Message ChangeCipherSpec distinct
• Support des chiffrements statiques (non-PFS)
• Négociation d'algorithmes complexe

Vulnérabilités connues : BEAST, POODLE, Heartbleed, Lucky 13, CRIME, BREACH

Améliorations majeures :

• Un seul aller-retour (1-RTT) avant l'envoi de données
• Key shares envoyées directement dans le ClientHello
• Perfect Forward Secrecy (PFS) obligatoire
• Chiffrement plus précoce des messages
• Suppression des algorithmes obsolètes et non sécurisés
• Support optionnel du mode 0-RTT (risques de rejeu)

Avantages de sécurité :

• Simplification du protocole (moins de surface d'attaque)
• Résistance aux attaques de rétrogradation
• Meilleure protection de la vie privée

server {
    listen 443 ssl http2;
    server_name example.com;

    # Certificats
    ssl_certificate     /path/to/example.com.crt;
    ssl_certificate_key /path/to/example.com.key;

    # Versions et ciphersuites
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';

    # Paramètres Diffie-Hellman
    ssl_dhparam /path/to/dhparam.pem;

    # OCSP Stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_trusted_certificate /path/to/ca-chain.crt;
    resolver 8.8.8.8 8.8.4.4 valid=300s;

    # Autres paramètres de sécurité
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:50m;
    ssl_session_tickets off;

    # HSTS (15768000 secondes = 6 mois)
    add_header Strict-Transport-Security "max-age=15768000; includeSubDomains; preload" always;

    # ...autres directives...
}

Points clés :

• Support exclusif de TLS 1.2/1.3
• Ciphersuites modernes avec Perfect Forward Secrecy
• OCSP Stapling pour vérification de révocation efficace
• HSTS pour forcer les connexions HTTPS

<VirtualHost *:443>
    ServerName example.com

    # Certificats
    SSLEngine on
    SSLCertificateFile      /path/to/example.com.crt
    SSLCertificateKeyFile   /path/to/example.com.key
    SSLCertificateChainFile /path/to/ca-chain.crt

    # Versions et ciphersuites
    SSLProtocol             -all +TLSv1.2 +TLSv1.3
    SSLHonorCipherOrder     on
    SSLCipherSuite          ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256

    # Paramètres Diffie-Hellman
    SSLOpenSSLConfCmd DHParameters "/path/to/dhparam.pem"

    # OCSP Stapling
    SSLUseStapling on
    SSLStaplingCache "shmcb:logs/stapling-cache(150000)"
    SSLStaplingResponderTimeout 5
    SSLStaplingReturnResponderErrors off

    # Autres paramètres de sécurité
    SSLSessionCache         shmcb:/var/run/apache2/ssl_scache(512000)
    SSLSessionTickets       off
    SSLSessionTimeout       300

    # HSTS
    Header always set Strict-Transport-Security "max-age=15768000; includeSubDomains; preload"

    # ...autres directives...
</VirtualHost>

Bonnes pratiques supplémentaires :

• Désactivation des tickets de session pour une meilleure PFS
• Génération régulière de nouveaux paramètres DH
• Validation des certificats clients (pour mTLS)
• Redirection automatique des requêtes HTTP vers HTTPS

Client HTTPS

import requests

response = requests.get('https://example.com', 
                       verify=True)  # Vérification SSL/TLS
print(response.status_code)

# Configuration avancée
import urllib3
import ssl

# Créer un contexte SSL personnalisé
context = ssl.create_default_context()
context.minimum_version = ssl.TLSVersion.TLSv1_2
context.verify_mode = ssl.CERT_REQUIRED
context.check_hostname = True
context.load_verify_locations('/path/to/ca-certs.pem')

# Adapter pour requests
adapter = requests.adapters.HTTPAdapter(
    pool_connections=10, 
    pool_maxsize=10,
    pool_block=False, 
    max_retries=3)
session = requests.Session()
session.mount('https://', adapter)

Serveur HTTPS

from flask import Flask
import ssl

app = Flask(__name__)

@app.route('/')
def index():
    return 'Secure Flask Server'

if __name__ == '__main__':
    context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
    context.load_cert_chain('server.crt', 'server.key')
    context.minimum_version = ssl.TLSVersion.TLSv1_2
    context.set_ciphers('ECDHE+AESGCM:ECDHE+CHACHA20')
    context.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
    
    app.run(host='0.0.0.0', port=443, 
            ssl_context=context, debug=False)

Client HTTPS

const https = require('https');
const fs = require('fs');

// Options TLS
const options = {
  ca: fs.readFileSync('/path/to/ca-bundle.crt'),
  checkServerIdentity: (host, cert) => {
    // Vérification personnalisée du nom d'hôte
    // Retourne undefined si valide, Error si invalide
  },
  minVersion: 'TLSv1.2',
  maxVersion: 'TLSv1.3',
};

// Requête HTTPS
https.get('https://example.com', options, (res) => {
  console.log('statusCode:', res.statusCode);
  console.log('headers:', res.headers);

  res.on('data', (d) => {
    process.stdout.write(d);
  });
}).on('error', (e) => {
  console.error(e);
});

Serveur HTTPS

const https = require('https');
const fs = require('fs');
const express = require('express');

const app = express();

app.get('/', (req, res) => {
  res.send('Secure Express Server');
});

// Configuration TLS
const options = {
  key: fs.readFileSync('server.key'),
  cert: fs.readFileSync('server.crt'),
  ca: fs.readFileSync('ca-chain.crt'),
  minVersion: 'TLSv1.2',
  ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384',
  honorCipherOrder: true,
  requestCert: false,  // true pour mTLS
  rejectUnauthorized: true
};

// Créer serveur HTTPS
const server = https.createServer(options, app);

server.listen(443, () => {
  console.log('Server running on https://localhost:443');
});

Client HTTPS

import java.net.URL;
import javax.net.ssl.*;
import java.security.*;
import java.io.*;

public class SecureClient {
    public static void main(String[] args) throws Exception {
        // Configurer le TrustStore
        System.setProperty("javax.net.ssl.trustStore", 
                          "/path/to/truststore.jks");
        System.setProperty("javax.net.ssl.trustStorePassword", 
                          "password");
        
        // Configurer les protocoles et suites 
        SSLContext sslContext = SSLContext.getInstance("TLSv1.2");
        sslContext.init(null, null, new SecureRandom());
        
        // Créer une connexion HTTPS
        URL url = new URL("https://example.com");
        HttpsURLConnection conn = 
            (HttpsURLConnection) url.openConnection();
        conn.setSSLSocketFactory(sslContext.getSocketFactory());
        
        // Vérifier le hostname
        conn.setHostnameVerifier((hostname, session) -> {
            // Vérification du hostname
            return true; // Remplacer par une vérification réelle
        });
        
        // Lire la réponse
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(conn.getInputStream()))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

Client HTTPS

using System;
using System.Net.Http;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // Configurer le HttpClient avec TLS
        var handler = new HttpClientHandler
        {
            // Forcer TLS 1.2 ou supérieur
            SslProtocols = System.Security.Authentication.SslProtocols.Tls12 | 
                          System.Security.Authentication.SslProtocols.Tls13,
            
            // Vérification de certificat personnalisée
            ServerCertificateCustomValidationCallback = (message, cert, chain, errors) =>
            {
                // Ici, vous pouvez implémenter une logique 
                // de validation personnalisée
                if (errors == SslPolicyErrors.None)
                    return true;
                
                // Vérifier le certificat
                var serverCert = new X509Certificate2(cert);
                // Logique de vérification
                
                return false; // Rejet par défaut si erreurs
            }
        };
        
        using (var client = new HttpClient(handler))
        {
            var response = await client.GetAsync("https://example.com");
            response.EnsureSuccessStatusCode();
            
            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

# N'IMPLÉMENTEZ PAS VOTRE PROPRE CHIFFREMENT
# Exemple de mauvaise pratique : "chiffrement" maison

def my_encrypt(message, key):
    """Une fonction de chiffrement maison non sécurisée"""
    result = ""
    # Simple XOR avec répétition de la clé
    for i in range(len(message)):
        result += chr(ord(message[i]) ^ ord(key[i % len(key)]))
    return result.encode('base64')

def my_decrypt(cipher_text, key):
    """Déchiffrement correspondant"""
    message = cipher_text.decode('base64')
    result = ""
    for i in range(len(message)):
        result += chr(ord(message[i]) ^ ord(key[i % len(key)]))
    return result

# N'INVENTEZ PAS VOS PROPRES PROTOCOLES
# Mauvais: Protocole d'authentification maison

def login_custom(username, password):
    stored_hash = database.get_hash(username)
    # Mauvais: Hachage simple sans sel
    if hashlib.md5(password).hexdigest() == stored_hash:
        return generate_session_token()
    return None

Problèmes :

• Vulnérabilités cryptographiques non anticipées
• Absence de tests cryptanalytiques rigoureux
• Implémentations vulnérables aux attaques par canal auxiliaire
• Propriétés de sécurité non garanties

# UTILISER DES BIBLIOTHÈQUES CRYPTOGRAPHIQUES RECONNUES
# Exemple avec Python et la bibliothèque cryptography

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

def encrypt_data(message, key=None):
    """Chiffrement AES-GCM sécurisé"""
    if key is None:
        # Générer une clé aléatoire si non fournie
        key = AESGCM.generate_key(bit_length=256)
    
    # Générer un nonce aléatoire
    nonce = os.urandom(12)
    
    # Créer un chiffreur AEAD
    aes = AESGCM(key)
    
    # Associer des données d'authentification (optionnel)
    associated_data = b"authenticated but not encrypted"
    
    # Chiffrer et authentifier
    ciphertext = aes.encrypt(nonce, message, associated_data)
    
    return {
        "ciphertext": ciphertext,
        "nonce": nonce,
        "key": key,
        "aad": associated_data
    }

Avantages :

• Utilisation d'algorithmes standardisés et éprouvés
• Implémentations examinées par des experts en sécurité
• Protection contre les vulnérabilités connues
• Maintenance et mises à jour de sécurité régulières
• Documentation complète et exemples d'utilisation

# Python avec Argon2 (fonction de hachage recommandée)
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError

# Initialiser le hasheur avec des paramètres sécurisés
ph = PasswordHasher(
    time_cost=3,       # Nombre d'itérations
    memory_cost=65536, # Utilisation mémoire en KiB (64 MB)
    parallelism=4,     # Degré de parallélisme
    hash_len=32,       # Taille du hash en octets
    salt_len=16        # Taille du sel en octets
)

def hash_password(password):
    """Hache un mot de passe avec Argon2id"""
    return ph.hash(password)

def verify_password(stored_hash, password):
    """Vérifie un mot de passe contre un hash stocké"""
    try:
        # Vérifie et gère automatiquement le rehashage si nécessaire
        ph.verify(stored_hash, password)
        
        # Vérifier si le hash doit être mis à jour
        # (si les paramètres ont changé)
        if ph.check_needs_rehash(stored_hash):
            return {"valid": True, "needs_rehash": True}
        return {"valid": True, "needs_rehash": False}
    except VerifyMismatchError:
        return {"valid": False}

Meilleures pratiques :

• Utiliser des fonctions de hachage spécialisées pour les mots de passe (Argon2, bcrypt, PBKDF2)
• Intégrer un sel unique pour chaque mot de passe
• Définir des paramètres de coût adaptés à l'environnement
• Implémenter un mécanisme de rehashage
• Ne jamais stocker les mots de passe en clair

# Utilisation d'une solution de gestion de secrets (HashiCorp Vault)
import hvac

# Initialiser le client Vault
client = hvac.Client(url='https://vault.example.com:8200')

# Authentification
client.auth.approle.login(
    role_id='app-role-id',
    secret_id='app-secret-id'
)

def get_database_credentials():
    """Récupère les identifiants de base de données depuis Vault"""
    response = client.secrets.kv.v2.read_secret_version(
        path='database/credentials',
        mount_point='secrets'
    )
    return response['data']['data']

def get_api_key(service_name):
    """Récupère une clé API pour un service spécifique"""
    response = client.secrets.kv.v2.read_secret_version(
        path=f'api-keys/{service_name}',
        mount_point='secrets'
    )
    return response['data']['data']['key']

def generate_dynamic_credential():
    """Génère des identifiants éphémères pour une base de données"""
    # Pour les bases de données PostgreSQL
    response = client.secrets.database.generate_credentials(
        name='postgres-role',
        mount_point='database'
    )
    return {
        'username': response['data']['username'],
        'password': response['data']['password'],
        'ttl': response['lease_duration']
    }

Bonnes pratiques :

• Utiliser un gestionnaire de secrets centralisé
• Privilégier les secrets éphémères à durée limitée
• Mettre en place une rotation régulière et automatisée
• Séparer les environnements (dev, staging, prod)
• Mettre en œuvre un contrôle d'accès strict
• Auditer l'accès aux secrets

Conséquences pratiques :

• Pour les algorithmes symétriques : doubler la taille des clés (AES-256 au lieu d'AES-128)
• Pour les fonctions de hachage : utiliser des tailles de sortie doubles (SHA-512 au lieu de SHA-256)
• Pour les algorithmes asymétriques : remplacer par des alternatives résistantes aux attaques quantiques

Chronologie approximative :

Risques actuels :

• Attaques "Harvest now, decrypt later" : Des adversaires peuvent collecter des données chiffrées aujourd'hui pour les déchiffrer dans le futur avec des ordinateurs quantiques
• Durée de vie des secrets : Si vos données doivent rester confidentielles pendant plus de 10 ans, la menace quantique est déjà pertinente
• Systèmes à longue durée de vie : Les infrastructures déployées aujourd'hui pourraient être toujours en service lorsque les ordinateurs quantiques deviendront une menace réelle

• Projet de standardisation PQC du NIST - Informations officielles sur le processus de standardisation
• Open Quantum Safe - Projet open-source fournissant des implémentations de PQC
• PQCrypto - Conférence internationale dédiée à la cryptographie post-quantique
• Computer Security Resource Center du NIST - Publications et recommandations sur la sécurité informatique
• Groupe de travail PQC de l'IETF - Standardisation des protocoles post-quantiques

• liboqs - Bibliothèque C d'implémentations de référence d'algorithmes PQC
• liboqs-go - Implémentation Go de liboqs
• BouncyCastle - Bibliothèque Java/C# avec support PQC
• CIRCL - Bibliothèque Go de Cloudflare incluant des implémentations PQC
• OQS-OpenSSL - Fork d'OpenSSL avec support des algorithmes PQC