Programma Les 84 van 156 · Encryptie die je kunt uitleggen
Encryptie die je kunt uitleggen

Verifieer een handtekening

Waarom dit ertoe doet Elke softwareupdate die je telefoon installeert, elk certificaat achter een hangslot en elke passkey login rust op één check: "is dit echt ondertekend door de juiste sleutel?" Die check zelf één keer uitvoeren maakt van handtekeningen magie naar iets dat je kunt uitleggen.

Een

A signatuur werkt als een waszegel dat is gestempeld met een ring die alleen de eigenaar heeft. Iedereen die weet hoe het patroon van de ring eruitziet kan het zegel controleren, maar niemand anders kan het maken. En als de brief na het verzegelen wordt veranderd, komt het zegel niet meer overeen.

Digitale handtekening: een getal gemaakt uit een bericht en een private key. Iedereen met de bijbehorende public key kan controleren of de eigenaar het heeft gemaakt, en of het bericht sindsdien niet is veranderd.

Stap 1: fingerprint de message met een hash

Hash: een functie die elke data omzet in een korte vingerafdruk met een vaste grootte. Dezelfde input geeft altijd dezelfde vingerafdruk, een kleine verandering geeft een volledig andere, en je kunt het niet terugdraaien. SHA-256 is een veelgebruikte.

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

Het ondertekenen van de vingerafdruk in plaats van de hele boodschap houdt alles klein en snel. Om er berekeningen op uit te voeren, zet je de 32 bytes met int.from_bytes(digest, "big") om naar één groot geheel getal, en neem dan de restwaarde na deling door n met % n zodat het in de sleutel past.

Stap 2: ongedaan maken van de handtekening met de publieke sleutel

In de speelgoed RSA van les 81 tekent de eigenaar door pow(fingerprint, d, n) te berekenen met de private d. Om te controleren bereken je pow(signature, e, n) met de publieke e. Als het resultaat gelijk is aan de vingerafdruk die je zelf hebt berekend is de handtekening echt.

In Python is een key een paar getallen in een tuple, zoals public_key = (n, e). De regel n, e = public_key unpacks het: het zet het eerste getal in n en het tweede in e.

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

Als iemand het bericht aanpast, verandert de vingerafdruk en komt het niet meer overeen. Als ze de handtekening aanpassen, geeft het ongedaan maken een ander getal. En als iemand met hun eigen private key tekent terwijl ze zich voordoen als Ana (de verzender in deze oefening), faalt je controle met de public key van Ana. Alle drie worden ontdekt door één vergelijking.

Belangrijk: dit is speelgoed RSA met kleine sleutels en geen padding, alleen voor educatieve doeleinden. Echte handtekeningen gebruiken geteste bibliotheken en schema's zoals Ed25519 of RSA met PSS padding. Gebruik nooit zelfgemaakte cryptografie om echte data te beschermen.

Een veelvoorkomende misvatting: "een handtekening verbergt het bericht". Dat doet het niet; het bericht reist in het volle zicht. Een handtekening bewijst wie het heeft gemaakt en dat het onveranderd is. Het verbergen is de taak van encryptie.

In andere talen

Echte code verifieert met een library. Elke call geeft true of false terug (of geeft een error) in plaats van nummers handmatig te vergelijken.

# 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);

Samenvatting

  • A signatuur bewijst wie een bericht heeft gemaakt en dat het niet is veranderd. Het verbergt het niet.
  • Hash de boodschap eerst, dan controleer je de signature tegen die fingerprint.
  • Controleren heeft alleen de publieke sleutel nodig; ondertekenen heeft de privésleutel nodig.
  • Toy RSA is om te begrijpen; echte code gebruikt getoetste bibliotheken.
Jij bent aan de beurt

Ana ondertekent haar berichten met toy RSA. Haar publieke sleutel is PUBLIC_KEY = (n, e), en INBOX bevat (message, signature) paren, waarvan sommige zijn aangepast. Schrijf drie functies:

  1. message_number(message, n): geef de SHA-256 digest van de boodschap (UTF-8 bytes) terug, als een getal van int.from_bytes(digest, "big"), modulo n.
  2. verify(message, signature, public_key): pak n, e uit, en geef True alleen terug als pow(signature, e, n) gelijk is aan message_number(message, n), anders False.
  3. genuine_messages(inbox, public_key): geef een lijst van de berichtsteksten waarvan de signaturen verifiëren, in inbox volgorde.
De laatste regels printen de echte berichten. Tests gebruiken nieuwe berichten en sleutels, dus het antwoord kan niet hard-coded zijn.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.