Chapitre 5 : Chiffrement, hachage et signatures numériques

Accéder au laboratoire pratique et aux trois nouveaux exercices corrigés

Objectifs du chapitre

• Choisir la bonne opération cryptographique.
• Comprendre les limites d’une empreinte et d’un certificat.
• Calculer et vérifier une empreinte locale.

1. Quatre opérations à ne pas confondre

La cryptographie fournit des outils pour protéger ou vérifier des informations. Elle n’efface pas les erreurs de configuration et exige une bonne gestion des clés. Avant de choisir un algorithme, formulez le besoin : empêcher la lecture, détecter une modification, vérifier l’origine ou simplement représenter des octets sous une autre forme.

Encoder un mot de passe en Base64 ne le protège pas. Calculer une empreinte ne permet pas non plus de cacher une information prévisible : une personne peut calculer des empreintes de valeurs candidates et comparer. Les noms d’algorithmes ne suffisent donc pas à qualifier la sécurité d’un système.

2. Chiffrement symétrique et asymétrique

Le chiffrement symétrique utilise un secret partagé pour chiffrer et déchiffrer. Il convient au traitement de volumes de données. Le problème central est de transmettre, stocker et utiliser ce secret sans l’exposer. Les bibliothèques modernes proposent des constructions de chiffrement authentifié, qui vérifient aussi l’intégrité ; leurs paramètres doivent être respectés.

La cryptographie asymétrique utilise une paire de clés publique et privée. Les opérations possibles dépendent de l’algorithme : une clé de signature ne doit pas être présentée comme une clé de chiffrement universelle. Une clé publique peut être distribuée ; la clé privée doit rester protégée. Les protocoles combinent souvent plusieurs mécanismes, par exemple pour établir un secret puis protéger efficacement les échanges.

Chez GeniusCampus, une sauvegarde est chiffrée avant son stockage distant. La clé de récupération doit être disponible même si le serveur principal tombe en panne, mais elle ne doit pas être placée dans un fichier accessible à tous à côté de la sauvegarde. Définissez qui peut l’utiliser, où elle est conservée, comment son accès est journalisé et comment la restauration sera testée.

3. Une empreinte aide à comparer un contenu

Une fonction de hachage produit une empreinte de longueur déterminée à partir d’une entrée de taille variable. Pour SHA-256, l’empreinte fait 256 bits, soit 32 octets et 64 caractères dans une représentation hexadécimale. Deux copies identiques donnent la même empreinte ; une modification du fichier conduit normalement à une autre valeur. La résistance aux collisions ne signifie pas une impossibilité mathématique de toute collision.

Une empreinte téléchargée au même endroit qu’un fichier peut être remplacée en même temps que lui. Pour vérifier une provenance, il faut un canal de référence fiable ou une signature dont la clé est vérifiée. Comparer deux empreintes sans savoir laquelle est digne de confiance établit une égalité de contenus, pas l’honnêteté d’un fournisseur.

4. Atelier : calculer SHA-256 localement

Ce programme Python 3 complet utilise uniquement la bibliothèque standard. Enregistrez-le sous empreinte.py, créez un petit fichier exemple.txt, puis exécutez python empreinte.py exemple.txt. Il lit le fichier par morceaux pour éviter de charger un gros fichier entièrement en mémoire. Il ne contacte aucun service et ne modifie pas le fichier analysé.

import hashlib
import sys
from pathlib import Path

def sha256_fichier(chemin):
    empreinte = hashlib.sha256()
    with chemin.open("rb") as fichier:
        for bloc in iter(lambda: fichier.read(65536), b""):
            empreinte.update(bloc)
    return empreinte.hexdigest()

def main():
    if len(sys.argv) != 2:
        print("Usage : python empreinte.py fichier", file=sys.stderr)
        return 2
    chemin = Path(sys.argv[1])
    try:
        valeur = sha256_fichier(chemin)
    except OSError as erreur:
        print(f"Lecture impossible : {erreur}", file=sys.stderr)
        return 1
    print(f"{valeur}  {chemin}")
    return 0

if __name__ == "__main__":
    raise SystemExit(main())

Le point de difficulté est la lecture en mode rb : on hache les octets exacts, pas un texte réinterprété par un encodage. Un changement de fin de ligne peut donc modifier l’empreinte alors que le texte semble visuellement identique. Modifiez une lettre, relancez le programme et comparez ; restaurez ensuite exactement les mêmes octets pour retrouver l’empreinte initiale.

5. Signature, certificat et mots de passe

Une signature numérique est produite avec une clé privée et vérifiée avec la clé publique correspondante. La vérification relie la signature aux données et à cette clé. Pour conclure sur une identité, il faut aussi établir à qui la clé appartient. Un certificat peut contribuer à cette association selon une chaîne de confiance et des règles de validation.

Pour stocker des mots de passe, utilisez une fonction dédiée, telle qu’Argon2id avec des paramètres adaptés, via une bibliothèque éprouvée. Le sel distingue les calculs même si deux personnes choisissent le même secret ; le coût rend les essais plus chers. SHA-256 seul est trop rapide pour ce besoin. Ne construisez pas votre propre système de chiffrement à partir de l’atelier d’empreinte.

À retenir : chiffrement pour la confidentialité, empreinte pour comparer des contenus, signature pour vérifier des données signées avec une clé connue. La conservation des clés et la qualité des implémentations sont aussi importantes que le choix des mécanismes.

Exercices et corrigés

Essayez de répondre avant de déplier les corrigés. Les situations et données sont fictives.

Sources officielles et approfondissements

Repères consultés le 14 octobre 2026. Les cas GeniusCampus et les schémas sont des exemples pédagogiques originaux.

• CNIL : Chiffrement, hachage, signature
• OWASP : Stockage des mots de passe
• Python : hashlib

Laboratoire 5 : Vérifier une empreinte et comprendre HMAC

Objectif : Distinguer encodage, intégrité et authenticité à partir d’un message fictif. Durée indicative : 30 minutes.

Le message de démonstration porte un identifiant de dossier et un montant. Une empreinte SHA-256 permet de comparer les octets avant et après modification. Si un attaquant peut remplacer à la fois le fichier et son empreinte de référence, cette comparaison seule ne prouve plus son authenticité.

HMAC combine une fonction de hachage et une clé partagée. La vérification d’un message modifié échoue si l’on conserve l’ancien tag. Ce n’est pas une signature à clé publique : tout détenteur de la clé partagée peut calculer un nouveau tag. La clé présente dans le programme est délibérément publique et ne doit servir qu’à cet exercice.

Manipulations guidées

1. Prédire ce qui arrive à l’empreinte lorsque le montant passe de 15000 à 95000, puis lancer integrite.
2. Comparer les booléens : modification_detectee vaut true ; hmac_original_valide vaut true ; hmac_modifie_valide vaut false.
3. Lire le contrôle utilisant compare_digest et expliquer pourquoi on vérifie le tag attendu plutôt que comparer une saisie affichée dans le navigateur.
4. Repérer le test qui recalcule un tag avec la clé connue. Expliquer pourquoi un secret embarqué dans du code livré au public ne fournit pas cette garantie contre les lecteurs du code.
5. Observer que Base64 se décode sans secret. Produire un tableau « objectif, outil, limite » pour Base64, SHA-256 et HMAC. Ne pas en déduire une méthode de stockage des mots de passe.

python atelier.py --atelier integrite

Résultats attendus et preuves à conserver

Les trois résultats d’intégrité et une explication du lieu de confiance de l’empreinte ou de la clé. Les messages et la clé sont exclusivement ceux du fichier de démonstration.

Limites de la démonstration

Le programme n’effectue aucun chiffrement et ne fournit pas de gestion de clés. Il illustre un mécanisme ; les choix de stockage de mots de passe, de rotation de clés et de signature relèvent de dispositifs dédiés.

Télécharger les ateliers Python complets, le journal fictif et le modèle de rapport · Mode d’emploi et code complet

Trois exercices d’application corrigés

1. Empreinte remplaçable

Le fichier et le fichier .sha256 sont téléchargés depuis la même source compromise. Que prouve leur correspondance ?

Voir le corrigé 1

Elle prouve seulement la cohérence entre ces deux objets fournis ensemble. Si la référence peut aussi être remplacée, elle ne prouve pas l’origine légitime du fichier. Une référence authentifiée ou un mécanisme de signature est nécessaire selon le contexte.

2. Base64

Pourquoi une chaîne Base64 n’est-elle pas confidentielle ?

Voir le corrigé 2

Le décodage est public et ne demande aucune clé. Base64 représente des octets sous forme textuelle ; ce n’est ni un chiffrement ni un contrôle d’accès.

3. HMAC et signature

Deux partenaires partagent la même clé HMAC. Peut-on prouver lequel a créé un message ?

Voir le corrigé 3

Pas avec ce seul mécanisme : chacun peut calculer un tag valide. HMAC vérifie la possession du secret partagé ; il ne fournit pas l’attribution individuelle d’une signature asymétrique.

Références du laboratoire

• Module hmac de Python
• Module hashlib de Python

Complément original PandaCodeur, cas NKILItech fictif. Les interfaces de WebGoat peuvent évoluer : relever la version et le titre de la leçon suivie.