Der Diffie-Hellman-Algorithmus wird verwendet, um ein gemeinsames Geheimnis zwischen zwei Parteien einzurichten, das für die geheime Kommunikation zum Austausch von Daten über ein öffentliches Netzwerk verwendet werden kann.
Bildliche Erklärung:
Der Prozess beginnt damit, dass sich die beiden Parteien, Alice und Bob, auf eine willkürliche Startfarbe einigen, die nicht geheim gehalten werden muss (aber jedes Mal anders sein sollte); in diesem Beispiel ist die Farbe gelb. Jeder von ihnen wählt eine geheime Farbe – Rot bzw. Aqua – die er für sich behält. Der entscheidende Teil des Prozesses ist, dass Alice und Bob nun ihre geheime Farbe mit ihrer gemeinsamen Farbe mischen, was zu Orange- bzw. Blau-Mischungen führt, und dann die beiden gemischten Farben öffentlich austauschen. Schließlich mischt jeder der beiden die Farbe, die er vom Partner erhalten hat, mit seiner eigenen Privatfarbe zusammen. Das Ergebnis ist eine endgültige Farbmischung (braun), die mit der Farbmischung des Partners identisch ist.
Für die Lauscherin Eve wäre es unmöglich, die gemeinsame geheime Farbe zu bestimmen.
Kryptografische Erklärung:
Der Algorithmus an sich ist sehr einfach. Nehmen wir an, Alice möchte mit Bob ein gemeinsames Geheimnis ergründen. Hier ist ein Beispiel für das Protokoll mit geheimen Werten red.
- Alice und Bob einigen sich darauf, eine Primzahl zu verwenden p = 23 und Basis g = 5. (Diese beiden Werte werden so gewählt, um sicherzustellen, dass das resultierende gemeinsame Geheimnis jeden Wert von 1 bis annehmen kann p–1).
- Alice wählt eine geheime ganze Zahl a = 6, sendet dann Bob EIN = ga Mod p (EIN = 56 Mod 23 = 8)
- Bob wählt eine geheime ganze Zahl b = 15, sendet dann Alice B = gb Mod p (B = 515 Mod 23 = 19)
- Alice rechnet s = Ba Mod p (s = 196 Mod 23 = 2)
- Bob rechnet s = EINb Mod p (s = 815 Mod 23 = 2)
- Alice und Bob teilen nun ein Geheimnis (die Nummer 2).
Die Nummer, die Alice in Schritt 4 erhält, ist die gleiche wie Bob in Schritt 5
Bob rechnet
Ab mod p = (ga mod p)b mod p = gab mod p
Alice rechnet
Ba mod p = (gb mod p)a mod p = gba mod p
Der Diffie-Hellman-Algorithmus wird hauptsächlich zum Austausch von Kryptografieschlüsseln zur Verwendung in symmetrischen Verschlüsselungsalgorithmen wie AES verwendet. Bitte beachten Sie, dass während des Schlüsselaustauschs keine Informationen weitergegeben werden. Hier erstellen die beiden Parteien gemeinsam einen Schlüssel.
Implementierung:
C
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
#include <stdio.h> // Funktion zur Berechnung von `a^m mod n` int compute(int a, int m, int n) { int r; int y = 1; while (m > 0) { r = m % 2; // schnelle Exponent if (r == 1) { y = (y*a) % n; } a = a*a % n; m = m / 2; } return y; } // C-Programm zur Demonstration des Diffie-Hellman-Algorithmus int main() { int p = 23; // Modul int g = 5; // Basis int a, b; // `a` – Alices geheimer Schlüssel, `b` – Bobs geheimer Schlüssel. int A, B; // `A` – Alices öffentlicher Schlüssel, `B` – Bobs öffentlicher Schlüssel // wähle eine geheime Ganzzahl für Alices privaten Schlüssel (nur Alice bekannt) a = 6; // oder verwenden Sie `rand()` // Den öffentlichen Schlüssel von Alice berechnen (Alice sendet `A` an Bob) A = compute(g, a, p); // wähle eine geheime Ganzzahl für Bobs privaten Schlüssel (nur Bob bekannt) b = 15; // oder verwenden Sie `rand()` // Bobs öffentlichen Schlüssel berechnen (Bob sendet `B` an Alice) B = compute(g, b, p); // Alice und Bob tauschen ihre öffentlichen Schlüssel `A` und `B` miteinander aus // Geheimen Schlüssel finden int keyA = compute(B, a, p); int keyB = compute(A, b, p); printf("Alice's secret key is %d\nBob's secret key is %d", keyA, keyB); return 0; } |
Ergebnis:
Alice’s secret key is 2
Bob’s secret key is 2
Das ist alles über den Diffie-Hellman-Algorithmus.
Bezug: https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange