Programme Leçon 84 sur 156 · Un chiffrement que tu sais expliquer
Un chiffrement que tu sais expliquer

Vérifier une signature

Pourquoi c'est important Chaque mise à jour logicielle qu'installe ton téléphone, chaque certificat derrière un cadenas, et chaque connexion par passkey repose sur une vérification : « est-ce vraiment signé par la bonne clé ? » Faire cette vérification toi-même, une fois, transforme les signatures de magie en quelque chose que tu sais expliquer.

Une signature marche comme un sceau de cire frappé avec une bague que seul le propriétaire possède. Quiconque sait à quoi ressemble le motif de la bague peut vérifier le sceau, mais personne d'autre ne peut le faire. Et si la lettre est modifiée après le scellage, le sceau ne correspond plus.

Signature numérique : un nombre fabriqué à partir d'un message et d'une clé privée. Quiconque a la clé publique correspondante peut vérifier que le propriétaire l'a produit, et que le message n'a pas changé depuis.

Étape 1 : prendre l'empreinte du message avec un hash

Hash : une fonction qui transforme n'importe quelles données en une courte empreinte de taille fixe. La même entrée donne toujours la même empreinte, un tout petit changement en donne une complètement différente, et on ne peut pas la faire tourner à l'envers. SHA-256 est une fonction courante.

import hashlib
print(hashlib.sha256(b"Lunch at 1pm").hexdigest()[:16])
print(hashlib.sha256(b"Lunch at 2pm").hexdigest()[:16])
# two completely different fingerprints

Signer l'empreinte au lieu du message entier garde les choses petites et rapides. Pour faire des calculs dessus, transforme les 32 octets en un seul grand nombre entier avec int.from_bytes(digest, "big"), puis prends le reste de la division par n avec % n pour qu'il tienne dans la clé.

Étape 2 : défaire la signature avec la clé publique

Dans le RSA jouet de la leçon 81, le propriétaire signe en calculant pow(fingerprint, d, n) avec le d privé. Pour vérifier, tu calcules pow(signature, e, n) avec le e public. Si le résultat est égal à l'empreinte que tu as calculée toi-même, la signature est authentique.

En Python, une clé est une paire de nombres dans un tuple, comme public_key = (n, e). La ligne n, e = public_key la déballe : elle met le premier nombre dans n et le second dans e.

signer:   signature = pow(fingerprint, d, n)      # needs the private key
checker:  pow(signature, e, n) == fingerprint ?   # needs only the public key

Si quelqu'un modifie le message, son empreinte change et ne correspond plus. S'il modifie la signature, la défaire donne un autre nombre. Et si quelqu'un signe avec sa propre clé privée en se faisant passer pour Ana (l'expéditrice de cet exercice), ta vérification avec la clé publique d'Ana échoue. Les trois sont attrapés par une seule comparaison.

Important : c'est du RSA jouet avec de toutes petites clés et sans remplissage, pour apprendre uniquement. Les vraies signatures utilisent des bibliothèques éprouvées et des schémas comme Ed25519 ou RSA avec remplissage PSS. N'utilise jamais de cryptographie maison pour protéger de vraies données.

Une idée reçue : « une signature cache le message ». Non ; le message voyage en clair. Une signature prouve qui l'a produit et qu'il est inchangé. Le cacher, c'est le travail du chiffrement.

Dans d'autres langages

Le vrai code vérifie avec une bibliothèque. Chaque appel renvoie vrai ou faux (ou lève une erreur) au lieu de comparer des nombres à la main.

# Python, with the cryptography package (Ed25519)
from cryptography.exceptions import InvalidSignature
try:
    public_key.verify(signature, message)   # raises if it does not match
    ok = True
except InvalidSignature:
    ok = False
// JavaScript (browser Web Crypto, ECDSA)
const ok = await crypto.subtle.verify(
  { name: "ECDSA", hash: "SHA-256" }, publicKey, signature, messageBytes);
// Go (crypto/ed25519)
ok := ed25519.Verify(publicKey, message, signature)
// PHP (libsodium, built in)
$ok = sodium_crypto_sign_verify_detached($signature, $message, $publicKey);
// C# (.NET)
bool ok = ecdsa.VerifyData(message, signature, HashAlgorithmName.SHA256);

Récap

  • Une signature prouve qui a produit un message et qu'il n'a pas changé. Elle ne le cache pas.
  • Hache d'abord le message, puis vérifie la signature par rapport à cette empreinte.
  • Vérifier ne demande que la clé publique ; signer demande la clé privée.
  • Le RSA jouet sert à comprendre ; le vrai code utilise des bibliothèques éprouvées.
À ton tour

Ana signe ses messages avec du RSA jouet. Sa clé publique est PUBLIC_KEY = (n, e), et INBOX contient des paires (message, signature), dont certaines ont été trafiquées. Écris trois fonctions :

  1. message_number(message, n) : renvoie le condensé SHA-256 du message (en octets UTF-8), sous forme de nombre venant de int.from_bytes(digest, "big"), modulo n.
  2. verify(message, signature, public_key) : déballe n, e, et renvoie True seulement si pow(signature, e, n) est égal à message_number(message, n), sinon False.
  3. genuine_messages(inbox, public_key) : renvoie une liste des textes de messages dont les signatures se vérifient, dans l'ordre de la boîte de réception.
Les dernières lignes affichent les messages authentiques. Les tests utilisent de nouveaux messages et de nouvelles clés, donc la réponse ne peut pas être codée en dur.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.