MD5-Generator

MD5 (Message-Digest Algorithm 5) ist eine weit verbreitete kryptographische Hash-Funktion, die einen 128-Bit (16-Byte) Hash-Wert erzeugt, typischerweise dargestellt als 32-stellige Hexadezimalzahl. Sie wurde 1991 von Ronald Rivest entworfen, um den früheren MD4-Algorithmus zu ersetzen, und im April 1992 in RFC 1321 spezifiziert.

Trotz seiner Sicherheitslücken wird MD5 noch häufig für nicht-sicherheitskritische Anwendungen wie Prüfsummen verwendet, um Datenintegrität zu verifizieren und unbeabsichtigte Datenkorruption zu erkennen. Es bleibt für andere nicht-kryptographische Zwecke geeignet aufgrund geringerer Rechenanforderungen im Vergleich zu neueren sicheren Hash-Algorithmen.

MD5 wurde von Professor Ronald Rivest vom MIT als sichererer Ersatz für MD4 entworfen. Der Algorithmus nimmt eine Eingabenachricht beliebiger Länge und erzeugt einen 128-Bit "Fingerabdruck" oder "Message Digest" als Ausgabe. Der MD5-Algorithmus ist so konzipiert, dass er auf 32-Bit-Maschinen recht schnell ist und keine großen Substitutions-Tabellen benötigt, was eine kompakte Implementierung ermöglicht.

Der Algorithmus verarbeitet eine Nachricht variabler Länge zu einer festen Ausgabelänge von 128 Bit, indem er die Eingabe in 512-Bit-Blöcke aufteilt. Er arbeitet mit einem 128-Bit-Zustand, der in vier 32-Bit-Worte (A, B, C und D) unterteilt ist, und durchläuft vier Runden von Operationen, wobei jede Runde 16 Operationen basierend auf nichtlinearen Funktionen, modularer Addition und Bit-Rotation ausführt.

// Variablen initialisieren
A = 0x67452301
B = 0xEFCDAB89
C = 0x98BADCFE
D = 0x10325476

// Funktionen vorbereiten
F(X,Y,Z) = (X AND Y) OR ((NOT X) AND Z)
G(X,Y,Z) = (X AND Z) OR (Y AND (NOT Z))
H(X,Y,Z) = X XOR Y XOR Z
I(X,Y,Z) = Y XOR (X OR (NOT Z))

// Nachricht verarbeiten (Nachricht muss ein Vielfaches von 512 Bit sein)
// Nachricht auffüllen bis ihre Länge ≡ 448 (mod 512)
// 64-Bit-Darstellung der ursprünglichen Nachrichtenlänge anhängen

// Hauptschleife
für jeden 512-Bit-Block der aufgefüllten Nachricht:
    // Block in sechzehn 32-Bit-Worte aufteilen (M[0..15])
    // Blockzustand kopieren
    AA = A
    BB = B
    CC = C
    DD = D
    
    // Runde 1
    für i von 0 bis 15:
        A = B + ((A + F(B,C,D) + M[i] + T[i]) <<< s[i])
        A, B, C, D rotieren
    
    // Runde 2
    für i von 16 bis 31:
        A = B + ((A + G(B,C,D) + M[(5*i + 1) mod 16] + T[i]) <<< s[i])
        A, B, C, D rotieren
    
    // Runde 3
    für i von 32 bis 47:
        A = B + ((A + H(B,C,D) + M[(3*i + 5) mod 16] + T[i]) <<< s[i])
        A, B, C, D rotieren
    
    // Runde 4
    für i von 48 bis 63:
        A = B + ((A + I(B,C,D) + M[(7*i) mod 16] + T[i]) <<< s[i])
        A, B, C, D rotieren
    
    // Blockverarbeitungsergebnis hinzufügen
    A = A + AA
    B = B + BB
    C = C + CC
    D = D + DD

// Ausgabe
MD5 = A || B || C || D // Zusammengefügt zu 128-Bit-Ergebnis

1996 wurde ein Fehler im Design von MD5 entdeckt, der damals jedoch nicht als fatal angesehen wurde. Bis 2004 wurden schwerwiegendere Schwachstellen gefunden, und Forscher demonstrierten praktische Kollisionsangriffe - Methoden, um Paare unterschiedlicher Eingaben zu erstellen, die denselben MD5-Hash-Wert erzeugen.

2008 nutzte eine Forschergruppe diese Schwachstellen, um ein gefälschtes SSL-Zertifikat zu erstellen, das legitim erschien. Die Flame-Malware nutzte MD5-Schwächen aus, um 2012 eine Microsoft-Digitalsignatur zu fälschen. Moderne Kollisionsangriffe können MD5-Kollisionen in Sekunden auf Standard-Computer-Hardware finden.