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

Symmetrischer und öffentlicher Schlüssel

Warum das wichtig istFast jedes Datenschutzversprechen, das du begegnen wirst, vom Vorhängeschloss in deiner Adressleiste bis hin zu "ende-zu-ende verschlüsselten" Chats, basiert auf zwei Ideen. Sobald du sie in einfachen Worten erklären kannst, kannst du diese Versprechen selbst beurteilen, anstatt ihnen zu vertrauen.

Stell dir vor, du reichst einen Zettel durch ein Klassenzimmer. Jeder dazwischen kann ihn lesen. Verschlüsselung ist eine Methode, den Zettel zu verzerren, damit nur die richtige Person ihn wieder entschlüsseln kann. Alles in diesem Modul kommt auf eine Frage an: wer hält den Schlüssel, der ihn entschlüsselt?

Encryption: Umwandlung von lesbaren Daten (den plaintext) in verschlüsselte Daten (den ciphertext) unter Verwendung eines geheimen key. Entschlüsselung macht es wieder rückgängig.

Idee 1: symmetrische Verschlüsselung, ein gemeinsamer Schlüssel

Stell dir eine mit einem Vorhängeschloss gesicherte Box vor, bei der du und ein Freund jeweils eine Kopie desselben Schlüssels habt. Du schließt die Box ab, versendest sie und dein Freund schließt sie mit seiner Kopie auf. Derselbe Schlüssel schließt und öffnet. Das ist symmetric Verschlüsselung.

Symmetrische Verschlüsselung: Verschlüsselung, bei der derselbe geheime Schlüssel zum Verschlüsseln und zum Entschlüsseln verwendet wird. Sie ist sehr schnell, also trägt sie fast alle echten Daten. Der heutige Standard ist AES.

Hier ist eine Toy-Version in Python. Das b"..." vor einem String macht es zu bytes: der Text als eine Reihe kleiner Zahlen von 0 bis 255, eine pro Zeichen. Der Code kombiniert jedes Byte der Nachricht mit einem Byte des Keys mit XOR, geschrieben ^ in Python: es dreht die Bits der Nachricht dort um, wo der Key eine 1 hat, also dreht es sie bei zweimaliger Ausführung mit demselben Key zurück. zip geht die zwei Reihen nebeneinander durch, und .hex() druckt die Bytes als Hexadezimalziffern. Führe den gleichen Schritt mit demselben Key aus und die Nachricht kommt zurück.

message = b"hi bob"
key     = b"k3y!9Z"     # shared secret, same length

scrambled = bytes(m ^ k for m, k in zip(message, key))
print(scrambled.hex())     # 035a59435638

unscrambled = bytes(c ^ k for c, k in zip(scrambled, key))
print(unscrambled)         # b'hi bob'

Der Haken ist offensichtlich, sobald man ihn laut ausspricht: Du und dein Freund müsst den Schlüssel bereits teilen. Wie bekommst du ihn zu ihnen, ohne dass jemand ihn unterwegs kopiert? Für zwei Fremde im Internet, wie du und ein Laden, den du noch nie besucht hast, gab es keinen sicheren Weg dazu. Das ist die Problemidee, die 2 löst.

Idee 2: public key, ein Schlüsselpaar

Stell dir einen Briefkasten mit einem Schlitz vor. Jeder kann einen Brief hineinwerfen, aber nur der Besitzer hat den Schlüssel, der die Rückseite öffnet. Der Schlitz ist der public key: du kannst ihn der ganzen Welt geben. Der Schlüssel zur Rückseite ist der private key: er verlässt den Besitzer niemals.

Public-Key-Kryptographie: ein System, in dem jede Person ein Paar verknüpfter Schlüssel hat. Was ein Schlüssel schließt, kann nur der andere öffnen. Du veröffentlichst einen (den öffentlichen Schlüssel) und bewahrst den anderen (den privaten Schlüssel) auf. Auch als asymmetrische Kryptographie bezeichnet.

A kleine Version verwendet die klassischen Lehrbuchzahlen für RSA, eines der ersten Public-Key-Systeme. Der Public Key ist (n, e) = (3233, 17); die private Zahl ist d = 2753. Diese sind viel zu klein, um sicher zu sein und sind nur zum Lernen da.

n, e = 3233, 17   # public: anyone may know these
d = 2753          # private: only the owner

secret = 65                    # a message, written as a number
locked = pow(secret, e, n)     # anyone can do this
print(locked)                  # 2790

print(pow(locked, d, n))       # 65, only the owner can do this

pow(a, b, n) bedeutet "a hoch b, dann behalte nur den Rest nach der Division durch n". Weiterzugehen mit e ist einfach für jeden. Zurückzugehen braucht d, und d aus n und e zu berechnen braucht die zwei geheimen Primzahlen, die n bilden. Mit echten Schlüsseln, die hunderte Ziffern lang sind, kennt niemand einen praktischen Weg, das zu tun.

Das gleiche Paar, rückwärts ausführen: signatures

Public-Key-Systeme bieten ein zweites Geschenk. Wenn der Besitzer den private key auf eine Nachricht anwendet, kann jeder den public key nutzen, um sie zu prüfen. Nur der Besitzer hätte sie erstellt, also funktioniert es wie ein Wachssiegel. Dies ist eine digital signature, und du wirst eine selbst in Lektion 84 verifizieren.

Wie reale Systeme sie kombinieren

You                                        shopa.example
 |  1. public key magic: agree a fresh       |
 |     shared secret, no one in between     |
 |     can work it out                       |
 |-------------------------------------------|
 |  2. symmetric encryption with that        |
 |     secret for every byte after           |
 |==========================================>|

Public-Key-Operationen sind langsam, also werden sie kurz genutzt, um ein gemeinsames Geheimnis zu vereinbaren und Identitäten zu prüfen. Dann überträgt eine schnelle symmetrische Verschlüsselung die eigentlichen Daten. HTTPS, Messaging-Apps und verschlüsselte Backups folgen alle diesem Muster.

A häufiges Missverständnis: "der öffentliche Schlüssel ist eine Schwachstelle, weil er öffentlich ist". Er ist dafür ausgelegt, öffentlich zu sein. Ihn zu kennen lässt Leute Dinge für dich sperren oder deine Signaturen prüfen, aber niemals entsperren oder fälschen. Die Gefahr ist das Leaken des privaten Schlüssels oder dass jemand dich dazu bringt, ihren öffentlichen Schlüssel anstelle des echten zu verwenden. Dieses zweite Problem kommt in den Lektionen 82 und 83 wieder vor.

In anderen Sprachen

JavaScript hat eine echte, sichere Verschlüsselung eingebaut, die Web Crypto API genannt wird. Schreibe niemals deine eigene für echte Daten; verwende diese.

// JavaScript (browser): a real AES key and encryption
const key = await crypto.subtle.generateKey(
  { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
const iv = crypto.getRandomValues(new Uint8Array(12));
const data = new TextEncoder().encode("hi bob");
const locked = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, data);
// Go: the toy RSA step with big numbers
locked := new(big.Int).Exp(big.NewInt(65), big.NewInt(17), big.NewInt(3233))
fmt.Println(locked) // 2790

Zusammenfassung

  • Symmetrische Verschlüsselung: ein gemeinsamer Schlüssel sperrt und entsperrt. Schnell, aber der Schlüssel muss zuerst sicher geteilt werden.
  • Öffentlicher Schlüssel: ein öffentlicher Schlüssel, den jeder nutzen kann, und ein privater Schlüssel, den nur der Besitzer besitzt.
  • Gehe rückwärts, der private key erstellt Signaturen, die jeder mit dem public key prüfen kann.
  • Reale Systeme nutzen öffentliche Schlüssel, um ein Geheimnis zu vereinbaren, und dann symmetrische Verschlüsselung für die Daten.

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.