# Hash-Generator

URL: https://www.toolflux.app/hash-generator/
Stand: 2026-06-05

Hash-Generator für 8 Algorithmen gleichzeitig - SHA-2/3, BLAKE2/3, MD5. Mit Status-Badge, Avalanche-Demo und Datei-Hash bis 50 MiB.

Eine gute Hash-Funktion verhält sich wie eine Einbahnstraße: dieselbe Eingabe liefert immer denselben Digest, eine winzige Änderung an der Eingabe kippt im Mittel rund die Hälfte aller Output-Bits, und du kannst aus dem Digest die Eingabe nicht zurückrechnen. Der Generator unten zeigt acht Algorithmen gleichzeitig - mit Status-Badges, Tempo-Balken und einer Avalanche-Demo, die live zeigt, was "guter Diffusions-Effekt" eigentlich heißt. Ganz oben das größte Schild: Hashes sind nicht für Passwörter gedacht.

## Welche Hash-Funktion ist 2026 die richtige Wahl?

Für neue Anwendungen ist die Antwort einfach: **SHA-256** wenn du Standard willst, **BLAKE3** wenn du Tempo brauchst, **SHA3-256** wenn du Design-Diversität für Compliance brauchst.

| Algorithmus | Output | Status | Wann |
|---|---|---|---|
| MD5 | 128 Bit | Gebrochen (2004) | Datei-Integrität ohne Bedrohungsmodell, Cache-Keys |
| SHA-1 | 160 Bit | Gebrochen (2017) | Git-Object-IDs, Legacy-Schnittstellen |
| SHA-256 | 256 Bit | Aktuell | Standard für TLS, Signaturen, Bitcoin, fast alles |
| SHA-384 | 384 Bit | Aktuell | Höherer Sicherheits-Spielraum, CNSA-Profile |
| SHA-512 | 512 Bit | Aktuell | Wenn Output-Länge zählt oder 64-Bit-CPU |
| SHA3-256 | 256 Bit | Modern | Design-Diversität zu SHA-2, Compliance-Profile |
| BLAKE2b | 512 Bit | Modern | High-Throughput, Argon2-intern |
| BLAKE3 | 256 Bit | Modern | Schnell in nativen/SIMD-Implementierungen, parallelisierbar |

**Gebrochen** bedeutet: praktische Kollisionen sind gezeigt - zwei verschiedene Eingaben mit demselben Hash können konstruiert werden. Das macht den Algorithmus für Signaturen unbrauchbar, aber Datei-Integrität gegen Übertragungsfehler funktioniert noch. Pre-Image-Resistenz (aus Hash → Eingabe) gilt bei MD5 und SHA-1 weiterhin als praktisch unmöglich.

## Warum dürfen Hashes nicht für Passwörter verwendet werden?

Das oberste Schild im Tool ist die wichtigste Botschaft: **SHA-256 ist kein Passwort-Hasher.** Die Mathematik ist gleich, aber der Use-Case verlangt das Gegenteil von "schnell".

Eine Hash-Funktion ist auf Geschwindigkeit optimiert. Eine moderne GPU testet rund 10¹⁰ SHA-256-Werte pro Sekunde. Wenn deine Datenbank gestohlen wird und Passwörter als `SHA-256(password)` gespeichert sind, sind viele menschlich gewählte oder rein alphanumerische 8-Zeichen-Passwörter (62⁸ Kombinationen, ca. 6 Stunden im Worst Case) binnen Stunden brute-force-bar. Der volle ASCII-Raum (95⁸) hält länger durch, aber typische Passwörter haben weniger Entropie als ihre Länge suggeriert.

Passwort-Hasher sind das Gegenteil: absichtlich langsam (konfigurierbar in CPU- und Memory-Kosten) und mit Salt versehen. Drei aktuelle Empfehlungen:

- **bcrypt** - seit 1999, konfigurierbarer Cost-Faktor (typisch 12-14), 72-Byte-Limit für die Eingabe.
- **scrypt** - 2009, zusätzlich Memory-hart, schwer auf GPUs zu beschleunigen.
- **Argon2** - 2015 PHC-Wettbewerb-Sieger, drei Varianten (i/d/id), Memory- und Parallelitäts-Parameter.

Wenn du ein neues Login-System baust, nimm Argon2id oder bcrypt, nicht SHA-256.

## HMAC - der Hash mit Schlüssel

HMAC ist eine Konstruktion, die einen geheimen Schlüssel sauber in einen Hash einbindet. `HMAC-SHA-256(key, message)` liefert einen 256-Bit-Wert, den nur jemand mit dem Key reproduzieren kann.

Der naive Ansatz - einfach `SHA-256(key || message)` - ist anfällig für Length-Extension-Angriffe bei Merkle-Damgård-Hashes (MD5, SHA-1, SHA-2). HMAC umgeht das mit zwei verschachtelten Hash-Aufrufen und festgelegten Padding-Konstanten:

```
HMAC(K, m) = H((K' ⊕ opad) || H((K' ⊕ ipad) || m))
```

Praktisch heißt das: HMAC überall einsetzen, wo ein Hash mit Schlüssel gebraucht wird. AWS Signature v4, GitHub-Webhooks, Stripe-Webhooks, JWT-HS256, alle nutzen HMAC. Die `HMAC`-Funktion in @noble/hashes oder die `crypto.subtle.sign`-API im Browser haben die Konstruktion eingebaut - du übergibst nur Key und Message.

## Datei-Hashes lokal berechnen

Modus oben auf "Datei" stellen, dann Datei per Drag-Drop oder Klick auswählen. Limit liegt bei 50 MiB. Die Datei wird im Browser gelesen, gehasht durch alle 8 Algorithmen, und das Ergebnis erscheint in der Vergleichstabelle. Die Datei wird nicht hochgeladen - das ist der Vorteil gegenüber Online-Hash-Diensten, die genau das tun.

Typische Use-Cases:

- **ISO-Downloads verifizieren.** Ubuntu, Debian, NixOS und andere veröffentlichen SHA-256-Hashes ihrer Images. Lokal hashen, vergleichen, fertig.
- **Backup-Integrität.** Eine `.tar.gz` oder `.zip` regelmäßig hashen und mit dem ursprünglichen Wert vergleichen, um Bit-Rot zu erkennen.
- **Code-Signatur-Voraufbau.** Vor einer Signatur den Hash überprüfen, damit du weißt, dass der gleiche Wert signiert wird, den du im Repo hast.

## Avalanche - was "gute Diffusion" konkret heißt

Die Avalanche-Demo unten ändert das letzte Bit deiner Eingabe und vergleicht die zwei Digests. Bei einer guten Hash-Funktion ändern sich rund 50 % aller Output-Bits - 128 von 256 bei SHA-256, 64 von 128 bei MD5.

Das Interessante daran: auch das gebrochene MD5 erreicht ~50 % Avalanche. Avalanche allein ist kein Sicherheits-Maß. Es zeigt nur, dass die Bits auf der Output-Seite gut gemischt sind. Sicherheit verlangt zusätzlich, dass niemand zwei Eingaben mit demselben Hash konstruieren kann (Kollisions-Resistenz) - und genau dort sind MD5 und SHA-1 gebrochen.

Trotzdem ist die Demo lehrreich: sie zeigt, warum eine Hash-Funktion sich aus Sicht der Eingabe so anfühlt, als ob jede kleine Änderung den ganzen Output umwirft. Das ist die Eigenschaft, die Datei-Integrität robust macht: ein einziger geflippter Bit in einer 4-GB-Datei sorgt für einen komplett anderen Hash.

## SHA-3 - eine zweite Familie für den Notfall

NIST hat 2012 Keccak als SHA-3-Wettbewerbssieger ausgewählt und 2015 als FIPS 202 standardisiert - nicht weil SHA-2 unsicher wäre, sondern als Versicherung. SHA-2 nutzt das Merkle-Damgård-Schema (wie MD5 und SHA-1); SHA-3 nutzt eine Sponge-Konstruktion (Keccak). Sollte irgendwann ein Generations-Angriff auf Merkle-Damgård gefunden werden, ist mit SHA-3 ein komplett anderes Design schon im Standard.

In der Praxis ist SHA-3 langsamer als SHA-2 auf den meisten CPUs, weil moderne Prozessoren SHA-2-Beschleunigungs-Instruktionen haben (Intel SHA-NI, ARMv8 SHA). Wenn dein Code zukunftssicher gegen Merkle-Damgård-Angriffe sein soll, verwende SHA-3. Sonst SHA-256.

## BLAKE3 und der Tempo-Balken

BLAKE3 ist eine 2020 veröffentlichte Hash-Funktion mit einem ungewöhnlichen Trick: **Tree-Hashing**. Die Eingabe wird in 1024-Byte-Chunks aufgeteilt, jeder Chunk separat gehasht, dann werden die Chunk-Hashes selbst zu einem Baum kombiniert. Das macht BLAKE3 hochgradig parallelisierbar - moderne CPUs hashen mehrere Chunks gleichzeitig per SIMD oder über mehrere Kerne.

Wichtig zur Einordnung des Tempo-Balkens: dieser Generator nutzt für alle acht Algorithmen reines JavaScript (@noble/hashes). Der oft zitierte 5-10×-Vorsprung von BLAKE3 stammt aus nativen Implementierungen mit SIMD und Multithreading (Rust, C). Im Browser ist BLAKE3 kaum schneller als SHA-256, gelegentlich sogar langsamer - das architektonische Argument bleibt bestehen, sobald du BLAKE3 in einer optimierten Backend-Umgebung einsetzt.

## Häufige Fragen

### Welcher Hash-Algorithmus ist heute sicher?

SHA-256 als Standard, SHA-512 oder BLAKE3 für Tempo, SHA3-256 für Design-Diversität. SHA-1 und MD5 sind kollisionsanfällig (gebrochen 2017 bzw. 2004) und nicht mehr für Signaturen geeignet.

### Warum ist MD5 für Passwörter ungeeignet?

MD5 ist eine schnelle General-Purpose-Hash-Funktion. Ein Angreifer testet Milliarden Passwörter pro Sekunde. Passwort-Hasher wie bcrypt, scrypt oder Argon2 sind absichtlich langsam und mit Salt versehen.

### Was ist der Unterschied zwischen SHA-256 und SHA-3?

Gleiche Output-Länge (256 Bit), unterschiedliche Konstruktion. SHA-256 nutzt Merkle-Damgård, SHA-3 nutzt Keccak-Sponge. SHA-3 ist eine Diversitäts-Reserve gegen mögliche zukünftige Angriffe auf Merkle-Damgård.

### Wie berechne ich den Hash einer Datei lokal?

Im Generator oben Modus auf "Datei" stellen und die Datei per Drag-Drop hochladen. Die Datei wird einmal eingelesen, dann werden alle 8 Digests lokal berechnet. Limit: 50 MiB.

### FAQ

**Welcher Hash-Algorithmus ist heute sicher?**

Für neue Anwendungen: SHA-256 (Standard), SHA-512 oder BLAKE3. SHA3-256 als alternatives Design für Diversität. SHA-1 und MD5 sind kollisionsanfällig - SHA-1 seit 2017 (SHAttered), MD5 seit 2004 (Wang). Für Passwörter generell keine Hash-Funktion direkt nehmen, sondern bcrypt, scrypt oder Argon2.

**Warum ist MD5 für Passwörter ungeeignet?**

MD5 ist eine General-Purpose-Hash-Funktion: schnell und ohne Salt-Mechanismus. Ein moderner Angreifer testet damit Milliarden Passwörter pro Sekunde. Passwort-Hasher wie bcrypt, scrypt oder Argon2 sind absichtlich langsam (konfigurierbar), salzen jedes Passwort und erschweren Hardware-Beschleunigung deutlich - speziell die Memory-harten Verfahren reduzieren den GPU- und ASIC-Vorsprung stark. SHA-256 hat dasselbe Problem wie MD5: zu schnell. Der Avalanche-Effekt einer Hash-Funktion sagt nichts über ihre Eignung für Passwörter.

**Was ist der Unterschied zwischen SHA-256 und SHA-3?**

Beide haben 256 Bits Output, aber unterschiedliche Designs. SHA-256 nutzt Merkle-Damgård (wie MD5, SHA-1, SHA-2). SHA-3 nutzt eine Sponge-Konstruktion (Keccak); NIST wählte Keccak 2012 als SHA-3-Wettbewerbssieger und standardisierte SHA-3 dann 2015 als FIPS 202. SHA-3 ist kein Ersatz für SHA-256, sondern eine Diversitäts-Reserve - falls eines Tages ein praktischer Angriff auf Merkle-Damgård gefunden wird, gibt es SHA-3 mit einem komplett anderen Design.

**Wie berechne ich den Hash einer Datei lokal?**

Im Generator oben den Modus auf 'Datei' stellen, dann eine Datei in das Drop-Feld ziehen oder klicken. Die Datei wird in deinem Browser gelesen und gehasht, nicht hochgeladen. Limit liegt bei 50 MiB - die Datei wird einmal eingelesen, dann werden alle 8 Digests lokal berechnet. Praktisch zum Verifizieren von ISO-Downloads oder Backup-Archiven.

**Was bedeutet HMAC und wann brauche ich es?**

HMAC ist eine Konstruktion, die einen Hash plus einen geheimen Schlüssel zu einem Authentifizierungs-Token verknüpft. HMAC-SHA-256(key, message) liefert einen Wert, den nur jemand mit dem Key reproduzieren kann. Use-Cases: API-Signaturen (z. B. AWS Signature v4), Webhook-Authentifizierung (z. B. GitHub, Stripe), JWT-HS256-Tokens. Bei Merkle-Damgård-Hashes (MD5, SHA-1, SHA-2) ist der naive Ansatz `Hash(key || message)` anfällig für Length-Extension-Angriffe; HMAC schützt davor. SHA-3, BLAKE2 und BLAKE3 haben das Problem konstruktionsbedingt nicht - HMAC bleibt aber der portable, RFC-konforme Standard.

**Ist BLAKE3 wirklich schneller als SHA-256?**

In optimierten nativen Implementierungen ja - in nativen BLAKE3-Builds (Rust, C) skaliert das Tree-Hashing über mehrere CPU-Kerne und nutzt SIMD; in Backend-Benchmarks für GB-große Eingaben ist BLAKE3 dort oft 5-10× schneller als SHA-256. Im Browser sieht es anders aus: dieser Generator nutzt reines JavaScript (@noble/hashes), und SHA-256 ist dort ähnlich schnell - manchmal sogar schneller als BLAKE3. Der architektonische Vorteil von BLAKE3 wird also erst sichtbar, sobald du es in einer optimierten Backend-Umgebung einsetzt.

**Was ist der Avalanche-Effekt bei Hash-Funktionen?**

Der Avalanche-Effekt beschreibt, wie stark sich der Hash-Output ändert, wenn ein einziges Bit der Eingabe kippt. Eine gute Hash-Funktion flippt im Mittel rund 50 % aller Output-Bits. Die Demo unten flippt das letzte Bit deiner Eingabe und zählt die geänderten Bits per Hamming-Distanz. SHA-256 und BLAKE3 erreichen ~50 %, SHA-1 und sogar das gebrochene MD5 ebenfalls - der Avalanche-Effekt sagt nichts über Kollisions-Resistenz.