Lehrplan Lektion 84 von 156 · Verschlüsselung, die du erklären kannst
Verschlüsselung, die du erklären kannst

Eine Signatur überprüfen

Warum das wichtig ist Jedes Software-Update, das dein Telefon installiert, jedes Zertifikat hinter einem Vorhängeschloss und jeder Passkey-Login beruht auf einer Prüfung: "wurde dies wirklich vom richtigen Schlüssel signiert?" Diese Prüfung selbst einmal durchzuführen, macht Signaturen von Magie zu etwas, das du erklären kannst.

Eine

A Signatur funktioniert wie ein Wachssiegel, das mit einem Ring gestempelt wurde, den nur der Besitzer hat. Jeder, der weiß, wie das Muster des Rings aussieht, kann das Siegel prüfen, aber niemand sonst kann es erstellen. Und wenn der Brief nach dem Versiegeln geändert wird, passt das Siegel nicht mehr.

Digitale Signatur: eine Zahl aus einer Nachricht und einem privaten Schlüssel. Jeder mit dem passenden öffentlichen Schlüssel kann prüfen, dass der Besitzer sie erstellt hat und dass die Nachricht seither nicht geändert wurde.

Schritt 1: Fingerabdruck der Nachricht mit einem hash erstellen

Hash: eine Funktion, die jede Datenmenge in einen kurzen Fingerabdruck mit fester Größe umwandelt. Der gleiche Input ergibt immer den gleichen Fingerabdruck, eine winzige Änderung ergibt einen völlig anderen, und du kannst sie nicht rückwärts ausführen. SHA-256 ist eine gängige.

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

Das Signieren des Fingerabdrucks anstatt der ganzen Nachricht hält die Dinge klein und schnell. Um damit Rechnungen zu machen, wandle die 32 Bytes mit int.from_bytes(digest, "big") in eine große ganze Zahl um, dann nimm den Rest nach der Division durch n mit % n, damit es zum Schlüssel passt.

Schritt 2: die Signatur mit dem öffentlichen Schlüssel rückgängig machen

In der Spielerei RSA von Lektion 81 signiert der Besitzer durch das Berechnen von pow(fingerprint, d, n) mit dem privaten d. Zum Prüfen berechnest du pow(signature, e, n) mit dem öffentlichen e. Wenn das Ergebnis dem Fingerabdruck entspricht, den du selbst berechnet hast, ist die Signatur echt.

In Python ist ein key ein Paar von Zahlen in einem tuple, wie zum Beispiel public_key = (n, e). Die Zeile n, e = public_key unpacks es: sie legt die erste Zahl in n und die zweite in e.

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

Wenn jemand die Nachricht ändert, ändert sich ihr Fingerabdruck und passt nicht mehr. Wenn sie die Signatur ändern, ergibt das Rückgängigmachen eine andere Zahl. Und wenn jemand mit seinem eigenen privaten Schlüssel unterschreibt und dabei vorgibt, Ana (der Absender in dieser Übung) zu sein, schlägt deine Prüfung mit Anas öffentlichem Schlüssel fehl. Alle drei werden durch einen Vergleich erwischt.

Wichtig: dies ist ein Spielzeug-RSA mit winzigen Schlüsseln und ohne Padding, nur zum Lernen. Echte Signaturen nutzen geprüfte Bibliotheken und Verfahren wie Ed25519 oder RSA mit PSS Padding. Nutze niemals selbstgemachte Kryptographie zum Schutz echter Daten.

A häufiges Missverständnis: "eine Signatur verbirgt die Nachricht". Das tut sie nicht; die Nachricht ist offen sichtbar. Eine Signatur beweist wer sie erstellt hat und dass sie unverändert ist. Sie zu verbergen ist die Aufgabe der Verschlüsselung.

In anderen Sprachen

Echter Code wird mit einer Bibliothek verifiziert. Jeder Aufruf gibt true oder false zurück (oder wirft einen Fehler), anstatt Zahlen manuell zu vergleichen.

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

Zusammenfassung

    Eine
  • A Signatur beweist, wer eine Nachricht erstellt hat und dass sie sich nicht verändert hat. Sie verbirgt sie nicht.
  • Hashe die Nachricht zuerst, dann prüfe die Signatur gegen diesen Fingerabdruck.
  • Prüfen benötigt nur den öffentlichen Schlüssel; Signieren benötigt den privaten Schlüssel.
  • Toy RSA ist zum Verstehen; echter Code nutzt geprüfte Bibliotheken.
Du bist dran

Ana signiert ihre Nachrichten mit toy RSA. Ihr öffentlicher Schlüssel ist PUBLIC_KEY = (n, e), und INBOX enthält (message, signature) Paare, einige davon manipuliert. Schreibe drei Funktionen:

  1. message_number(message, n): gib den SHA-256 Digest der Nachricht (UTF-8 Bytes) als eine Zahl von int.from_bytes(digest, "big"), modulo n.
  2. zurück.
  3. verify(message, signature, public_key): packe n, e aus und gib True nur zurück, wenn pow(signature, e, n) gleich message_number(message, n) ist, ansonsten False.
  4. genuine_messages(inbox, public_key): gib eine Liste der Nachrichtentexte zurück, deren Signaturen verifiziert werden, in der Reihenfolge des Posteingangs.
Die letzten Zeilen drucken die echten Nachrichten. Tests verwenden neue Nachrichten und Schlüssel, also kann die Antwort nicht hart codiert werden.

Ein Problem in dieser Lektion entdeckt? Melde es · Frage zu dieser Lektion

Diese Übung öffnet bald

Beende die vorherige Lektion, damit diese freigeschaltet wird. Der ganze Kurs ist kostenlos, kein Konto erforderlich, und du kannst diese Lektion jetzt direkt lesen.