# Hash Generator — Anwendungsbeispiele

> Praxisnahe Durchläufe mit dem Hash Generator: Text über mehrere Algorithmen hashen, Datei-Integrität prüfen, Hashes vergleichen und HMAC erzeugen.

Source: https://www.jpkc.com/db/tools/hash/examples/

Zurück zur Übersicht: [Hash Generator](https://www.jpkc.com/db/tools/hash/) · Tool live öffnen: [www.jpkc.com/tools/hash/](https://www.jpkc.com/tools/hash/)

Das [Manual](https://www.jpkc.com/db/tools/hash/manual/) erklärt jeden Algorithmus und jede Option im Detail. Diese Seite ergänzt das um **konkrete Arbeitsabläufe**. Die Hash-Werte unten sind echte Beispielwerte für die gezeigten Eingaben — du kannst sie zur Probe nachstellen. Die Oberfläche ist auf Englisch; Feld- und Button-Namen stehen deshalb im Original.

## Beispiel 1: Einen Text über mehrere Algorithmen hashen

Du willst sehen, wie sich derselbe Text in verschiedenen Verfahren darstellt.

1. Öffne den [Hash Generator](https://www.jpkc.com/tools/hash/) und tippe in das **Message**-Feld den Text `hello`.
2. Klick auf **MD5**. Im **Output** erscheint:
   ```
   5d41402abc4b2a76b9719d911017c592
   ```
3. Klick auf **SHA-1** (grüner Button). Die Ausgabe wird länger:
   ```
   aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
   ```
4. Klick auf **256** (SHA-256). Jetzt 64 Hex-Zeichen:
   ```
   2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
   ```
5. Mit **Copy** legst du den jeweils angezeigten Wert in die Zwischenablage.

Beobachtung: Gleiche Eingabe, völlig unterschiedliche Hashes — und je „größer" der Algorithmus, desto länger der Wert. Ändere ein einziges Zeichen (`hello` → `Hello`) und hash erneut: Der gesamte Hash ändert sich, nicht nur ein Teil (der sogenannte Lawineneffekt).

## Beispiel 2: Die Integrität eines Downloads prüfen

Der häufigste Praxisfall — ein heruntergeladenes Image oder Archiv gegen den vom Anbieter veröffentlichten Wert abgleichen.

1. Der Anbieter nennt für seine Datei z. B. eine **SHA-256-Prüfsumme** (oft auf der Download-Seite oder in einer `.sha256`-Datei).
2. Zieh deine heruntergeladene Datei in den **File Hash**-Bereich (oder klick die Ablagefläche an und wähle sie aus). Name und Größe werden angezeigt.
3. Klick auf **Hash File**. Nach kurzer Berechnung füllt sich die Tabelle **File Checksums** mit acht Werten.
4. Such die Zeile **SHA-256** und vergleiche sie mit dem veröffentlichten Wert — am besten per Auge Zeichen für Zeichen oder, sicherer, indem du beide Werte in einen Text-Vergleich kopierst.
5. **Stimmen sie exakt überein**, ist die Datei unverändert und vollständig. **Schon ein abweichendes Zeichen** bedeutet: beschädigter Download oder manipulierte Datei — nicht verwenden, neu laden.

Tipp: Die Tabelle liefert auch MD5 und SHA-1 mit. Falls der Anbieter (noch) nur einen MD5-Wert angibt, kannst du den genauso vergleichen — auch wenn SHA-256 die bessere Wahl wäre (mehr dazu in den [Tipps](https://www.jpkc.com/db/tools/hash/tips/)).

## Beispiel 3: Zwei Hashes sicher vergleichen

Manchmal hast du zwei Werte und willst wissen, ob sie zu derselben Eingabe gehören.

1. Hash die erste Quelle — etwa eine Konfigurationsdatei — über **File Hash** und kopiere den **SHA-256**-Wert mit dem Zeilen-Kopier-Button.
2. Hash die zweite Quelle genauso.
3. Vergleiche die beiden Hex-Strings. Sind sie identisch, ist der Inhalt bit-genau gleich; weichen sie ab, unterscheiden sich die Dateien — egal wie ähnlich sie aussehen.

Das funktioniert auch für Text: Tippe denselben Satz in das **Message**-Feld, hash ihn mit SHA-256 und vergleiche mit einem erwarteten Wert. So prüfst du z. B., ob eine kopierte Zeichenkette unterwegs unverändert geblieben ist.

## Beispiel 4: Einen HMAC mit Schlüssel erzeugen

Für API-Signaturen oder Webhooks brauchst du einen HMAC — einen Hash, der zusätzlich von einem geheimen Schlüssel abhängt.

1. Trag deinen Nachrichten-Inhalt in das **Message**-Feld ein (z. B. den zu signierenden Payload).
2. Trag deinen geheimen Schlüssel in das Feld **HMAC Secret Key** ein. Hast du noch keinen, klick auf den **Schlüssel-Button** daneben — er füllt das Feld mit einer zufälligen 64-Zeichen-Passphrase.
3. Klick auf den **HMAC**-Button der gewünschten Familie, üblicherweise **HMAC neben SHA-256** (HMAC-SHA-256 ist der De-facto-Standard für Signaturen).
4. Das **Output**-Feld zeigt den HMAC als Hex. **Copy** kopiert ihn.

Wichtig: Derselbe Schlüssel + dieselbe Nachricht ergeben immer denselben HMAC. Der Empfänger kann mit demselben Schlüssel nachrechnen und so prüfen, dass die Nachricht echt und unverändert ist.

## Beispiel 5: SHA-3 ausprobieren — der modernere Standard

Du willst den modernen Keccak-basierten Standard nutzen.

1. Tippe deinen Text in das **Message**-Feld.
2. Im Block **SHA-3** klickst du auf **256** für SHA-3 (256) oder auf **512** für SHA-3 (512).
3. Der Hash erscheint im **Output**. SHA-3 (256) liefert wie SHA-256 einen 64-Zeichen-Wert, ist aber ein technisch anderes Verfahren — die Ausgabe unterscheidet sich also komplett von SHA-256 für dieselbe Eingabe.

Auch beim **File Hash** sind SHA-3 (256) und SHA-3 (512) in der Tabelle dabei, falls du eine Datei gegen einen SHA-3-Prüfwert abgleichen willst.

## Beispiel 6: Eine große Datei verarbeiten

Du willst die Prüfsumme eines großen Archivs oder ISO-Images bilden.

1. Zieh die Datei in den **File Hash**-Bereich. Solange sie **100 MB oder kleiner** ist, wird sie akzeptiert (größere lehnt das Tool mit einer Fehlermeldung ab).
2. Klick auf **Hash File**. Bei großen Dateien dauert die Berechnung spürbar länger — die Fortschrittsanzeige läuft, bis alle acht Werte berechnet sind.
3. Da alles **lokal im Browser** rechnet, verlässt die Datei deinen Rechner nicht — auch nicht bei 100 MB. Das ist der entscheidende Unterschied zu Online-Diensten, die deine Datei erst hochladen.

---

Noch tiefer: die [Übersicht](https://www.jpkc.com/db/tools/hash/) zum großen Bild, das [Manual](https://www.jpkc.com/db/tools/hash/manual/) für jeden Algorithmus und die [Tipps & Tricks](https://www.jpkc.com/db/tools/hash/tips/) für die Sicherheits-Einordnung. Ausprobieren kannst du alles direkt im [Tool](https://www.jpkc.com/tools/hash/).