Cryptologie : comprendre le chiffrement de A à Z

La cryptologie est la science du secret. Elle englobe la cryptographie (concevoir des systèmes de protection) et la cryptanalyse (les attaquer). Omniprésente dans notre vie numérique — HTTPS, Signal, SSH, Bitcoin, cartes bancaires — elle reste pourtant mal comprise. Ce guide démystifie les concepts fondamentaux, du chiffrement de César à AES-256.

Cryptographie, cryptanalyse, cryptologie — les définitions

• Cryptologie : la science globale du secret — contient les deux disciplines suivantes
• Cryptographie : l'art de concevoir des systèmes de communication sécurisés (chiffrement, signatures, hachage)
• Cryptanalyse : l'art de casser ces systèmes — trouver des failles, forcer des clés, attaquer les implémentations
• Stéganographie : cacher l'existence même du message (≠ cryptographie qui cache son contenu)
• Chiffrement : transformer un message lisible (clair) en message illisible (chiffré) via une clé

Une brève histoire : du César à AES

L'Antiquité : le chiffre de César

Jules César utilisait un chiffrement par décalage : chaque lettre est remplacée par la lettre 3 positions plus loin dans l'alphabet. A devient D, B devient E... C'est un chiffrement par substitution monoalphabétique — vulnérable à l'analyse de fréquence (le E est la lettre la plus fréquente en français).

# Chiffrement César en Python
def cesar(texte, decalage):
    resultat = ""
    for char in texte.upper():
        if char.isalpha():
            resultat += chr((ord(char) - 65 + decalage) % 26 + 65)
        else:
            resultat += char
    return resultat

print(cesar("BONJOUR", 3))   # → ERQMRXU
print(cesar("ERQMRXU", -3))  # → BONJOUR (déchiffrement)

La machine Enigma et la Seconde Guerre mondiale

La machine Enigma allemande utilisait des rotors électromécaniques pour produire une substitution polyalphabétique (la même lettre donne un chiffré différent selon sa position dans le message). Alan Turing et l'équipe de Bletchley Park ont développé les Bombes — machines de déchiffrement mécaniques — pour la casser, écourtant probablement la guerre de 2 ans.

1976 : la révolution Diffie-Hellman

Whitfield Diffie et Martin Hellman publient le premier protocole de cryptographie à clé publique. Avant eux, deux parties devaient s'échanger une clé secrète en amont (problème de distribution des clés). Diffie-Hellman permet d'établir un secret commun sur un canal non sécurisé — la fondation de tout HTTPS moderne.

Chiffrement symétrique — Une seule clé

Dans le chiffrement symétrique, la même clé est utilisée pour chiffrer et déchiffrer. C'est rapide et efficace pour les grandes quantités de données — mais le problème reste : comment transmettre la clé en toute sécurité ?

AES — Advanced Encryption Standard

AES (adopté comme standard US en 2001) est l'algorithme symétrique de référence. Il opère sur des blocs de 128 bits avec des clés de 128, 192 ou 256 bits. Il effectue 10 à 14 tours de substitutions et permutations. En 2024, aucune attaque pratique n'existe contre AES bien implémenté.

# Chiffrement AES en Python avec la bibliothèque PyCryptodome
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
import base64

def chiffrer_aes(message: str, cle: bytes) -> str:
    # Mode GCM : chiffrement authentifié (intégrité + confidentialité)
    cipher = AES.new(cle, AES.MODE_GCM)
    texte_chiffre, tag = cipher.encrypt_and_digest(message.encode())
    # nonce + tag + chiffré encodés en base64
    return base64.b64encode(cipher.nonce + tag + texte_chiffre).decode()

def dechiffrer_aes(chiffre_b64: str, cle: bytes) -> str:
    data = base64.b64decode(chiffre_b64)
    nonce, tag, texte_chiffre = data[:16], data[16:32], data[32:]
    cipher = AES.new(cle, AES.MODE_GCM, nonce=nonce)
    return cipher.decrypt_and_verify(texte_chiffre, tag).decode()

cle = get_random_bytes(32)  # AES-256
chiffre = chiffrer_aes("Message secret", cle)
print(f"Chiffré : {chiffre}")
print(f"Déchiffré : {dechiffrer_aes(chiffre, cle)}")

Chiffrement asymétrique — La paire de clés

La cryptographie asymétrique utilise deux clés mathématiquement liées : une clé publique (partageable avec tout le monde) et une clé privée (gardée secrète). Ce que la clé publique chiffre, seule la clé privée peut le déchiffrer — et vice versa.

• Chiffrement : chiffrer avec la clé publique du destinataire → seul lui peut déchiffrer avec sa clé privée
• Signature numérique : signer avec sa propre clé privée → tout le monde peut vérifier avec la clé publique
• Algorithmes principaux : RSA (2048/4096 bits), ECC (256 bits), Ed25519
• Inconvénient : beaucoup plus lent que le symétrique — utilisé pour échanger une clé symétrique, pas pour chiffrer les données en masse

Les fonctions de hachage — L'empreinte digitale

Une fonction de hachage transforme une donnée de taille arbitraire en une empreinte de taille fixe (hash). Elle est à sens unique (impossible de retrouver les données depuis le hash) et déterministe (la même entrée donne toujours le même hash).

import hashlib

message = "Bonjour le monde"

# SHA-256 — le plus utilisé
sha256 = hashlib.sha256(message.encode()).hexdigest()
print(f"SHA-256 : {sha256}")
# → a93d4f8e2c1b... (64 caractères hex = 256 bits)

# SHA-3 (Keccak) — résistant à des attaques différentes de SHA-2
sha3 = hashlib.sha3_256(message.encode()).hexdigest()

# Pour les mots de passe — NE PAS utiliser SHA-256 directement !
# Utiliser bcrypt, Argon2 ou PBKDF2 (résistants au bruteforce)
import bcrypt
mdp = "mot_de_passe_utilisateur"
hash_mdp = bcrypt.hashpw(mdp.encode(), bcrypt.gensalt(rounds=12))
print(f"bcrypt : {hash_mdp}")

# Vérification
print(bcrypt.checkpw(mdp.encode(), hash_mdp))  # True

Comment fonctionne HTTPS en pratique

HTTPS combine le symétrique et l'asymétrique via le protocole TLS. Voici ce qui se passe en quelques millisecondes quand vous accédez à un site en HTTPS :

1. 1Le serveur envoie son certificat TLS (contient sa clé publique + signature d'une autorité de certification)
2. 2Votre navigateur vérifie que le certificat est signé par une CA de confiance
3. 3Diffie-Hellman permet d'établir une clé de session commune sans la transmettre
4. 4Toutes les communications sont ensuite chiffrées avec AES-256-GCM (symétrique, rapide)
5. 5HMAC garantit l'intégrité de chaque paquet

Cryptanalyse — Comment on casse le chiffrement

• Attaque par force brute : tester toutes les clés possibles — impossible pour AES-256 (2^256 combinaisons)
• Attaque par dictionnaire : tester des listes de mots courants (mots de passe faibles)
• Attaque par texte clair connu : si on connaît texte clair + chiffré correspondant, peut-on retrouver la clé ?
• Attaque par canal auxiliaire (side-channel) : mesurer la consommation électrique ou le temps d'exécution pour inférer la clé
• Cryptanalyse différentielle : analyser comment de légères modifications du clair affectent le chiffré
• Attaque sur l'implémentation : la vulnérabilité est rarement dans l'algorithme mais dans son implémentation (Heartbleed, ROBOT...)

La menace quantique et la post-quantum cryptography

Un ordinateur quantique suffisamment puissant pourrait casser RSA et ECC en temps polynomial via l'algorithme de Shor. AES-256 resterait sûr (Grover réduit la sécurité de 256 à 128 bits — encore suffisant). Le NIST a standardisé en 2024 les premiers algorithmes post-quantiques : CRYSTALS-Kyber (chiffrement) et CRYSTALS-Dilithium (signature).