T
security hash sha2 sha3 cryptography

Der ultimative Leitfaden zu SHA-2- und SHA-3-Hash-Familien

Eine detaillierte technische Analyse und ein Vergleich der SHA-2- und SHA-3-Hash-Varianten, einschließlich SHAKE und BLAKE2.

2026-04-11 Dieses Tool verwenden

Einführung in das Hashing in der modernen Ära

Kryptografische Hash-Funktionen sind die stillen Helden der digitalen Sicherheit. Vom Sichern von Passwörtern bis hin zur Überprüfung der Integrität von Multi-Gigabyte-Softwareverteilungen liefern sie einen „digitalen Fingerabdruck“ für Daten. Da die Rechenleistung wächst und sich kryptoanalytische Techniken weiterentwickeln, hat sich die Branche von veralteten Algorithmen wie MD5 und SHA-1 zu robusteren Standards verlagert: SHA-2 und dem neueren SHA-3.

In diesem Leitfaden werden wir die Feinheiten der SHA-2- und SHA-3-Familien untersuchen, ihre zugrunde liegenden Architekturen vergleichen und moderne Alternativen wie BLAKE2 betrachten.

Die SHA-2-Familie: Das Arbeitstier des Internets

Die von der NSA entwickelte und 2001 vom NIST veröffentlichte SHA-2-Familie (Secure Hash Algorithm 2) ersetzte das anfällige SHA-1. SHA-2 basiert auf der Merkle-Damgård-Konstruktion, einer Methode zum Erstellen kollisionsresistenter Hash-Funktionen aus Einweg-Kompressionsfunktionen.

Varianten von SHA-2

Die SHA-2-Familie besteht aus sechs Hash-Funktionen mit unterschiedlichen Digest-Größen:

  1. SHA-256: Die am weitesten verbreitete Variante. Sie erzeugt einen 256-Bit-Hash (32 Byte). Sie ist das Rückgrat von Bitcoin und vielen SSL/TLS-Zertifikaten.
  2. SHA-512: Entwickelt für 64-Bit-Prozessoren, erzeugt sie einen 512-Bit-Hash (64 Byte). Sie ist auf 64-Bit-Hardware im Allgemeinen schneller als SHA-256.
  3. SHA-224: Eine gekürzte Version von SHA-256.
  4. SHA-384: Eine gekürzte Version von SHA-512.
  5. SHA-512/224 und SHA-512/256: Dies sind gekürzte Versionen von SHA-512, die sicherer gegen „Length-Extension-Angriffe“ sind als SHA-256 und gleichzeitig eine hohe Leistung auf 64-Bit-Systemen beibehalten.

Die Merkle-Damgård-Struktur

Die Merkle-Damgård-Konstruktion funktioniert wie folgt:

  1. Auffüllen (Padding) der Nachricht, sodass ihre Länge ein Vielfaches einer festen Blockgröße ist.
  2. Aufteilen der Nachricht in Blöcke.
  3. Sequenzielle Verarbeitung jedes Blocks mit einer Kompressionsfunktion, die die Ausgabe des vorherigen Blocks als Eingabe verwendet.

Hinweis zur Sicherheitsanfälligkeit: Eine inhärente Schwäche dieser Struktur ist der Length-Extension-Angriff, bei dem ein Angreifer Hash(Nachricht || Erweiterung) berechnen kann, wenn er Hash(Nachricht) und die Länge der Nachricht kennt, ohne die ursprüngliche Nachricht zu kennen.

Die SHA-3-Familie: Ein Paradigmenwechsel

Während SHA-2 weiterhin sicher ist, startete das NIST 2007 einen Wettbewerb, um einen grundlegend anderen Algorithmus als Backup zu finden. Der Gewinner war Keccak, das 2015 zum SHA-3-Standard wurde.

Die Sponge-Konstruktion (Schwamm-Konstruktion)

Im Gegensatz zu SHA-2 verwendet SHA-3 die Sponge-Konstruktion. Diese Architektur umfasst zwei Phasen:

  1. Absorbieren (Absorbing): Die Nachrichtenblöcke werden mittels XOR in einen Teilbereich des internen Zustands eingearbeitet.
  2. Auspressen (Squeezing): Der Zustand wird transformiert, und die Ausgabebits werden daraus gelesen (ausgepresst).

Da der interne Zustand viel größer ist als der Ausgabe-Hash, ist SHA-3 von Natur aus resistent gegen Length-Extension-Angriffe, wodurch ein wesentlicher Designfehler von SHA-2 behoben wurde.

Varianten von SHA-3

SHA-3 spiegelt zur besseren Kompatibilität die Ausgabegrößen von SHA-2 wider:

  • SHA-3-224
  • SHA-3-256
  • SHA-3-384
  • SHA-3-512

SHAKE: Extendable-Output Functions (XOF)

Eines der innovativsten Merkmale des SHA-3-Standards ist die Einführung von SHAKE (Secure Hash Algorithm and Keccak). Im Gegensatz zu herkömmlichen Hash-Funktionen, die eine feste Ausgabelänge erzeugen, können Sie bei SHAKE128 und SHAKE256 jede beliebige Ausgabelänge angeben.

  • SHAKE128: Bietet 128 Bit Sicherheit gegen alle Angriffe, sofern die Ausgabe lang genug ist.
  • SHAKE256: Bietet 256 Bit Sicherheit.

Diese sind äußerst nützlich für die Generierung großer Mengen pseudozufälliger Daten oder für Padding-Schemata mit variabler Länge.

BLAKE2: Die Hochleistungsalternative

Obwohl es kein NIST-Standard ist, genießt BLAKE2 (basierend auf dem BLAKE-Algorithmus aus dem SHA-3-Wettbewerb) in der Branche hohes Ansehen.

  • BLAKE2b: Optimiert für 64-Bit-Plattformen.
  • BLAKE2s: Optimiert für 8-Bit- bis 32-Bit-Plattformen.

Warum BLAKE2 verwenden? Es ist auf den meisten modernen CPUs schneller als SHA-3 und sogar SHA-2, während es eine gleichwertige Sicherheit bietet. Es wird in Projekten wie Argon2 (Passwort-Hashing) und WireGuard verwendet.

Sicherheitsanalyse: Warum auf SHA-3 umsteigen?

Wenn SHA-2 nicht geknackt ist, warum sollte man sich dann mit SHA-3 beschäftigen?

  1. Diversität: Wenn ein Durchbruch in der Kryptoanalyse die Merkle-Damgård-Struktur bricht, fällt SHA-2. SHA-3 (Sponge) bietet eine völlig andere mathematische Grundlage.
  2. Resistenz gegen Length-Extension: SHA-3 ist sicherer für bestimmte MAC-Konstruktionen (Message Authentication Code).
  3. Zukunftssicherheit: Angesichts des aufkommenden Quantencomputings bieten größere Zustände und andere Strukturen eine bessere „Defense in Depth“.

Code-Beispiele

Node.js (unter Verwendung des crypto-Moduls)

const crypto = require('crypto');

// SHA-256 (SHA-2)
const sha256 = crypto.createHash('sha256').update('Hallo Welt').digest('hex');
console.log(`SHA-256: ${sha256}`);

// SHA3-256 (SHA-3)
const sha3 = crypto.createHash('sha3-256').update('Hallo Welt').digest('hex');
console.log(`SHA3-256: ${sha3}`);

// SHAKE256 mit 64 Byte Ausgabe
const shake = crypto.createHash('shake256', { outputLength: 64 })
                    .update('Hallo Welt')
                    .digest('hex');
console.log(`SHAKE256: ${shake}`);

Python (unter Verwendung von hashlib)

import hashlib

# SHA-256
print(f"SHA-256: {hashlib.sha256(b'Hallo Welt').hexdigest()}")

# SHA3-256
print(f"SHA3-256: {hashlib.sha3_256(b'Hallo Welt').hexdigest()}")

# SHAKE256
s = hashlib.shake_256(b'Hallo Welt')
print(f"SHAKE256 (16 Byte): {s.hexdigest(16)}")

FAQ: Häufige Missverständnisse

1. Ist SHA-3 „sicherer“ als SHA-2?

In Bezug auf die Widerstandsfähigkeit gegen bekannte Angriffe sind beide derzeit sehr sicher. Die Struktur von SHA-3 ist jedoch theoretisch robuster gegen bestimmte Arten von Angriffen (wie Length-Extension).

2. Ist SHA-512 immer besser als SHA-256?

Nicht unbedingt. Obwohl es einen längeren Digest hat, kann es auf 32-Bit-Systemen langsamer sein. Auf 64-Bit-Systemen ist SHA-512 jedoch aufgrund der Verwendung von 64-Bit-Arithmetik oft schneller.

3. Sollte ich MD5 oder SHA-1 für Aufgaben verwenden, die nichts mit Sicherheit zu tun haben?

Im Allgemeinen nein. Selbst bei Aufgaben ohne Sicherheitsrelevanz (wie Git-Objekt-IDs) können Kollisionen Fehler verursachen. Verwenden Sie mindestens SHA-256 oder BLAKE2, es sei denn, Sie haben eine Legacy-Anforderung.

4. Was ist der Unterschied zwischen SHAKE und SHA-3?

SHA-3 hat eine feste Ausgabelänge. SHAKE ist eine XOF (Extendable-Output Function), die dieselbe Keccak-Engine verwendet, aber es Ihnen ermöglicht, eine beliebige Anzahl von Bits anzufordern.

Fazit

Die Wahl der richtigen Hash-Funktion hängt von Ihren spezifischen Anforderungen ab. Für den allgemeinen Gebrauch und die Kompatibilität bleibt SHA-256 der Industriestandard. Wenn Sie ein neues System aufbauen und die höchste architektonische Sicherheit wünschen, ist SHA-3 der Weg in die Zukunft. Für Hochleistungsanwendungen ist BLAKE2 eine hervorragende Wahl.

Zurück zum Blog Hash-Generator →