Was ist SHA-384?
SHA-384 ist eine kryptografische Hashfunktion aus der SHA-2-Familie. Sie verarbeitet Daten beliebiger Länge und erzeugt daraus einen Hashwert mit einer festen Länge von 384 Bit.
Das entspricht:
- 48 Byte
- 96 hexadezimalen Zeichen
SHA-384 ist eng mit SHA-512 verwandt. Beide Algorithmen verwenden dieselbe grundlegende 64-Bit-Struktur, verarbeiten Nachrichten in 1024-Bit-Blöcken und führen für jeden Block 80 Kompressionsrunden aus.
Trotzdem ist SHA-384 nicht einfach ein SHA-512-Hash, bei dem die letzten 128 Bit entfernt werden.
Wie schon bei SHA-224 und SHA-256 beginnt der Unterschied bereits vor der ersten Kompressionsrunde: SHA-384 verwendet eigene Initial Hash Values.
SHA-384 gehört zur SHA-2-Familie
SHA-2 ist keine einzelne Hashfunktion, sondern eine Familie mehrerer verwandter Algorithmen:
- SHA-224
- SHA-256
- SHA-384
- SHA-512
- SHA-512/224
- SHA-512/256
In Was ist SHA-2? haben wir gesehen, dass sich diese Algorithmen grob in zwei Gruppen einteilen lassen.
SHA-224 und SHA-256 arbeiten mit 32-Bit-Wörtern und 512-Bit-Nachrichtenblöcken.
SHA-384 und SHA-512 sowie SHA-512/224 und SHA-512/256 verwenden dagegen 64-Bit-Wörter und 1024-Bit-Nachrichtenblöcke.
Damit ist SHA-384 intern wesentlich enger mit SHA-512 verwandt als mit SHA-256.
Wie lang ist ein SHA-384-Hash?
Ein SHA-384-Hash besitzt immer:
384 Bit
Das sind:
48 Byte
In hexadezimaler Darstellung werden vier Bit durch ein Zeichen repräsentiert. Ein SHA-384-Hash besteht deshalb aus:
384 / 4 = 96
hexadezimalen Zeichen.
Die Größe der Eingabe ändert daran nichts.
Ein kurzer Text und eine große Datei erzeugen beide einen SHA-384-Hash mit exakt 384 Bit.
Wie funktioniert SHA-384?
Der grundlegende Aufbau entspricht weitgehend SHA-512.
SHA-384 verwendet:
| Eigenschaft | SHA-384 |
|---|---|
| Hashlänge | 384 Bit |
| Wortgröße | 64 Bit |
| Blockgröße | 1024 Bit |
| Message Schedule | 80 Wörter |
| Runden pro Block | 80 |
Vereinfacht läuft die Berechnung folgendermaßen ab:
- Die Nachricht wird gepaddet.
- Die vorbereitete Nachricht wird in 1024-Bit-Blöcke aufgeteilt.
- Jeder Block beginnt mit sechzehn 64-Bit-Wörtern.
- Daraus wird ein Message Schedule mit insgesamt 80 Wörtern erzeugt.
- Die Kompressionsfunktion verarbeitet den Block über 80 Runden.
- Der interne Hashzustand wird aktualisiert.
- Aus dem finalen Zustand werden 384 Bit als Hashwert ausgegeben.
Wenn dir dieser Ablauf bekannt vorkommt, liegt das daran, dass SHA-384 und SHA-512 dieselbe grundlegende 64-Bit-Struktur verwenden.
Ist SHA-384 einfach ein gekürzter SHA-512-Hash?
Nein.
Man könnte zunächst vermuten, dass SHA-384 ungefähr so funktioniert:
SHA-512
↓
512-Bit-Hash
↓
letzte 128 Bit entfernen
↓
384-Bit-Hash
Das wäre eine einfache Trunkierung von SHA-512.
SHA-384 funktioniert jedoch anders.
SHA-384 und SHA-512 verwenden zwar dieselbe grundlegende Kompressionsfunktion, beginnen ihre Berechnungen aber mit unterschiedlichen Initial Hash Values.
Der interne Zustand ist deshalb bereits unterschiedlich, bevor der erste Nachrichtenblock verarbeitet wird.
Für dieselbe Nachricht gilt daher im Allgemeinen:
SHA-384(message)
≠
erste 384 Bit von SHA-512(message)
Die Ausgabe von SHA-384 besteht zwar am Ende aus den ersten sechs 64-Bit-Wörtern des finalen internen Zustands. Dieser Zustand wurde aber mit den SHA-384-spezifischen Initialwerten berechnet.
Die Initial Hash Values machen den Unterschied
Sowohl SHA-384 als auch SHA-512 arbeiten intern mit acht 64-Bit-Wörtern als Hashzustand.
Der Secure Hash Standard definiert für SHA-384 jedoch eigene Initialwerte.
Vereinfacht sieht der Unterschied so aus:
Nachricht
│
▼
Padding / Blöcke
│
┌─────────────┴─────────────┐
│ │
SHA-384 SHA-512
│ │
SHA-384 Initialwerte SHA-512 Initialwerte
│ │
▼ ▼
80 Runden 80 Runden
│ │
▼ ▼
anderer interner anderer interner
Zustand Zustand
│ │
▼ ▼
384 Bit 512 Bit
Die beiden Algorithmen verwenden also weitgehend dieselbe Maschine, starten sie aber mit unterschiedlichen Zuständen.
Das ist derselbe grundlegende Gedanke, den wir bereits bei SHA-224 und SHA-256 gesehen haben.
Probier den Unterschied selbst aus
Auch diesen Unterschied kann man direkt sichtbar machen.
Gib einen beliebigen Text ein. Das Tool berechnet daraus:
- den SHA-384-Hash,
- den SHA-512-Hash,
- und die ersten 384 Bit des SHA-512-Hashes.
Damit kannst du SHA-384 direkt mit einem auf 384 Bit gekürzten SHA-512-Hash vergleichen.
SHA-384 und SHA-512 vergleichen
Ist SHA-384 einfach nur ein SHA-512-Hash, dem die letzten 128 Bit fehlen? Probiere es mit deinem eigenen Text aus.
Diese Implementierung dient der Veranschaulichung. Für produktive Kryptografie sollten geprüfte kryptografische Bibliotheken verwendet werden.
Beide Vergleichswerte sind exakt 384 Bit lang. Trotzdem unterscheiden sie sich bei deiner Eingabe.
Das Tool kann zusätzlich anzeigen, wie viele der 384 Bit unterschiedlich sind. Diese Zahl beschreibt nur den Unterschied bei dieser konkreten Eingabe und ist kein Maß für die kryptografische Sicherheit.
Entscheidend ist die Ursache: SHA-384 beginnt die Berechnung mit anderen Initial Hash Values als SHA-512.
SHA-384 und SHA-512 im Vergleich
Die beiden Algorithmen besitzen sehr viele Gemeinsamkeiten:
| Eigenschaft | SHA-384 | SHA-512 |
|---|---|---|
| Hashlänge | 384 Bit | 512 Bit |
| Wortgröße | 64 Bit | 64 Bit |
| Blockgröße | 1024 Bit | 1024 Bit |
| Wörter im Message Schedule | 80 | 80 |
| Kompressionsrunden | 80 | 80 |
| Initial Hash Values | eigene | eigene |
Der offensichtlichste Unterschied ist die Länge des fertigen Hashwerts:
SHA-384 → 384 Bit
SHA-512 → 512 Bit
Aber wie wir gesehen haben, entsteht SHA-384 nicht dadurch, dass man einfach einen normalen SHA-512-Hash berechnet und anschließend kürzt.
Wie sicher ist SHA-384?
Die Länge des Hashwerts beeinflusst die generische Sicherheitsstärke einer kryptografischen Hashfunktion.
Für eine idealisierte Hashfunktion mit n Bit Ausgabe liegt der Aufwand für das Finden einer Collision aufgrund des Birthday-Effekts ungefähr in der Größenordnung:
2^(n/2)
Bei 384 Bit ergibt das:
2^192
Für einen generischen Preimage-Angriff liegt die Größenordnung dagegen bei:
2^384
NIST gibt für SHA-384 entsprechend folgende Sicherheitsstärken an:
| Eigenschaft | Sicherheitsstärke |
|---|---|
| Collision Resistance | 192 Bit |
| Preimage Resistance | 384 Bit |
| Second-Preimage Resistance | 384 Bit |
Damit liegt SHA-384 bei der Collision Resistance zwischen SHA-256 mit 128 Bit und SHA-512 mit 256 Bit Sicherheitsstärke.
Eine Besonderheit bei Second-Preimage Resistance
Bei einigen SHA-2-Varianten hängt die von NIST angegebene Second-Preimage-Sicherheitsstärke auch von der Länge der verarbeiteten Nachricht ab.
Bei SHA-384 ist das anders.
NIST gibt für SHA-384 eine Second-Preimage Resistance Strength von 384 Bit an.
Das ist interessant, weil SHA-384 intern auf der 512-Bit-Struktur arbeitet, aber nur 384 Bit des finalen Zustands ausgibt.
Für das grundlegende Verständnis reicht an dieser Stelle die Erkenntnis:
SHA-384
Collision Resistance → 192 Bit
Preimage Resistance → 384 Bit
Second-Preimage Resistance → 384 Bit
Was diese drei Sicherheitseigenschaften genau voneinander unterscheidet, erklären die Artikel zu Collision Resistance, Preimage Resistance und Second-Preimage Resistance ausführlicher.
Warum gibt es SHA-384?
Eine naheliegende Frage lautet:
Warum brauche ich SHA-384, wenn es bereits SHA-256 und SHA-512 gibt?
SHA-384 bietet eine Sicherheits- und Ausgabelänge zwischen diesen beiden Varianten.
Der Hashwert benötigt:
48 Byte
statt:
SHA-256 → 32 Byte
SHA-512 → 64 Byte
Gleichzeitig basiert SHA-384 auf der 64-Bit-Struktur von SHA-512.
Welche Hashfunktion verwendet werden sollte, hängt allerdings nicht allein von der gewünschten Zahl an Bits ab. Standards und Protokolle legen häufig fest, welche Hashfunktion beziehungsweise welche Sicherheitsstärke erforderlich ist.
NIST führt SHA-384 weiterhin als zugelassene SHA-2-Hashfunktion. Die SHA-2-Familie kann für Anwendungen eingesetzt werden, die sichere Hashalgorithmen benötigen.
Sollte ich SHA-384 oder SHA-512 verwenden?
Es gibt darauf keine allgemeingültige Antwort, die nur von der Zahl 384 oder 512 abhängt.
Wenn ein Standard, Protokoll oder kryptografisches Verfahren SHA-384 vorgibt, sollte genau diese Variante verwendet werden.
Bei einer eigenen Auswahl spielen unter anderem eine Rolle:
- benötigte Sicherheitsstärke,
- Interoperabilität,
- Vorgaben des verwendeten Protokolls,
- Größe des Hashwerts,
- und die eingesetzte kryptografische Konstruktion.
NIST empfiehlt für Anwendungen von Hashfunktionen, bei denen Interoperabilität erforderlich ist, mindestens SHA-256 zu implementieren.
SHA-384 und SHA-512 sind damit nicht automatisch „besser“, nur weil ihre Hashwerte länger sind. Entscheidend ist, welche Anforderungen die jeweilige Anwendung stellt.
SHA-384 ist nicht SHA3-384
Neben SHA-384 existiert auch:
SHA3-384
Beide erzeugen einen Hashwert mit einer Länge von 384 Bit.
Sie gehören jedoch zu unterschiedlichen Hashfamilien:
SHA-384 → SHA-2
SHA3-384 → SHA-3
SHA-384 basiert auf der SHA-512-artigen 64-Bit-Struktur von SHA-2.
SHA3-384 basiert dagegen auf der Keccak-Konstruktion, die dem SHA-3-Standard zugrunde liegt.
Die identische Ausgabelänge bedeutet deshalb nicht, dass die Algorithmen intern miteinander verwandt sind oder für dieselbe Eingabe denselben Hashwert erzeugen.
SHA-3 werden wir später als eigenen Themenbereich behandeln.
Das Wichtigste in Kürze
SHA-384 ist eine kryptografische Hashfunktion aus der SHA-2-Familie und erzeugt einen 384 Bit langen Hashwert.
Sie ist eng mit SHA-512 verwandt:
- beide arbeiten mit 64-Bit-Wörtern,
- beide verarbeiten 1024-Bit-Blöcke,
- beide verwenden ein Message Schedule mit 80 Wörtern,
- beide führen 80 Kompressionsrunden pro Block aus.
SHA-384 ist trotzdem nicht einfach ein gekürzter SHA-512-Hash.
SHA-384 und SHA-512 verwenden unterschiedliche Initial Hash Values. Deshalb unterscheiden sich ihre internen Zustände bereits während der Berechnung.
NIST gibt für SHA-384 eine Collision Resistance Strength von 192 Bit, eine Preimage Resistance Strength von 384 Bit und eine Second-Preimage Resistance Strength von 384 Bit an.
Damit haben wir nach SHA-224 nun beide verkürzten Varianten der zwei grundlegenden SHA-2-Strukturen kennengelernt.
Als Nächstes lohnt sich Was sind SHA-512/224 und SHA-512/256?: Der Artikel zeigt, warum mit SHA-512/224 und SHA-512/256 noch zwei weitere Varianten existieren – und warum insbesondere SHA-512/256 trotz seiner 256-Bit-Ausgabe nicht dasselbe wie SHA-256 ist.
Quellen und weiterführende Standards
-
National Institute of Standards and Technology (NIST), FIPS 180-4 – Secure Hash Standard (SHS) Normative Spezifikation von SHA-384, SHA-512 und den übrigen Algorithmen der SHA-2-Familie. Enthält Padding, Initial Hash Values, Funktionen, Konstanten, Message Schedule und Kompressionsfunktion.
-
National Institute of Standards and Technology (NIST), Hash Functions Übersicht der von NIST zugelassenen Hashfunktionen sowie ihrer Collision-, Preimage- und Second-Preimage-Sicherheitsstärken.
-
National Institute of Standards and Technology (NIST), Policy on Hash Functions Empfehlung, SHA-256 mindestens zu implementieren, wenn Anwendungen oder Protokolle Interoperabilität von Hashfunktionen benötigen.