SHA-384 Hash Generator

Was ist SHA-384-Hashing?

SHA-384 ist eine kryptografische Hashfunktion, die in NIST FIPS 180-4 als Teil der SHA-2-Familie definiert ist. Sie akzeptiert eine Eingabe beliebiger Länge und erzeugt einen festen 384-Bit-Digest (48 Byte), der üblicherweise als 96 hexadezimale Zeichen dargestellt wird. SHA-384 wird häufig in TLS-Cipher-Suites, digitalen Zertifikatssignaturen und Behördensystemen eingesetzt, die eine höhere Kollisionsresistenz benötigen als SHA-256 bietet.

Intern ist SHA-384 eine gekürzte Variante von SHA-512. Es verwendet dieselbe 1024-Bit-Blockgröße, 80 Kompressionsdurchläufe und 64-Bit-Wortarithmetik wie SHA-512, startet jedoch mit einem anderen Satz initialer Hashwerte (abgeleitet von der 9. bis 16. Primzahl) und gibt nur die ersten 384 Bit des Endzustands aus. Diese Kürzung bewirkt, dass SHA-384 für identische Eingaben einen anderen Digest als SHA-512 erzeugt, obwohl beiden derselbe Kernalgorithmus zugrunde liegt.

Da SHA-384 mit 64-Bit-Wörtern arbeitet, läuft es auf modernen 64-Bit-Prozessoren schneller als SHA-256 und liefert dabei einen größeren Digest. Das macht es zu einem praktischen Mittelweg: sicherer als SHA-256 (192-Bit-Kollisionsresistenz gegenüber 128-Bit), ohne den Speicheraufwand der 128-Zeichen-Hex-Ausgabe von SHA-512. SHA-384 ist der Standard-Hash für TLS-1.3-Zertifikatsverifizierungssignaturen und wird von NSA Suite B (jetzt CNSA) für streng geheime Daten gefordert.

Wozu ein Online-SHA-384-Generator?

Die Erzeugung von SHA-384-Hashes erfordert normalerweise einen Terminalbefehl oder das Schreiben von Code. Dieses browserbasierte Werkzeug ermöglicht die sofortige Berechnung von SHA-384-Digests, ohne etwas installieren oder Daten an einen Server übertragen zu müssen. Ob für SRI-Hashes von CDN-Assets, die Überprüfung einer Prüfsumme oder den Vergleich von SHA-384- und SHA-256-Ausgaben für dieselbe Eingabe — dieses Werkzeug bietet einen direkten, abhängigkeitsfreien Zugang zu SHA-384-Digests in jedem modernen Browser.

SHA-384 Hash Generator — Anwendungsfälle

SHA-2-Familienvarianten im Vergleich

SHA-384 gehört zur SHA-2-Familie zusammen mit mehreren anderen Varianten. Die folgende Tabelle zeigt, wie sie sich in Digest-Größe, Ausgabelänge und typischen Anwendungsbereichen unterscheiden.

SHA-384 vs. SHA-256 vs. SHA-512 vs. SHA-3-384

Die Wahl zwischen SHA-384 und anderen Hash-Algorithmen hängt von den Sicherheitsanforderungen, Plattformbeschränkungen und Performance-Anforderungen ab. Dieser Vergleich deckt die wichtigsten Eigenschaften ab.

Wie SHA-384 intern funktioniert

SHA-384 verarbeitet Eingaben über dieselbe Merkle-Damgård-Konstruktion wie SHA-512. Die Eingabe wird auf ein Vielfaches von 1024 Bit aufgefüllt, in Blöcke aufgeteilt, und jeder Block durchläuft 80 Mischdurchläufe mit den Funktionen Ch, Maj und zwei Sigma-Funktionen mit 64-Bit-Wortarithmetik. Der wesentliche Unterschied zu SHA-512 liegt in den initialen Hashwerten: SHA-384 verwendet Werte, die aus den Nachkommastellen der Quadratwurzeln der 9. bis 16. Primzahl abgeleitet werden, während SHA-512 die ersten 8 Primzahlen verwendet. Nach der Verarbeitung aller Blöcke kürzt SHA-384 den 512-Bit-Internen-Zustand auf die ersten 384 Bit.

Die Kürzung und die unterschiedliche Initialisierung bewirken, dass SHA-384 und SHA-512 für dieselbe Eingabe stets verschiedene Digests erzeugen. Dies macht SHA-384 außerdem inhärent resistent gegen Längenerweiterungsangriffe — im Gegensatz zu SHA-256 und SHA-512, bei denen ein Angreifer Daten anhängen und einen gültigen Hash berechnen kann, ohne die ursprüngliche Nachricht zu kennen.

SHA-384 Code-Beispiele

SHA-384 ist in allen gängigen Sprachen und Laufzeitumgebungen nativ verfügbar. Die folgenden Beispiele lassen sich direkt in eigene Projekte übernehmen.

// Works in all modern browsers and Node.js 18+
async function sha384(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-384', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha384('hello world')
// → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha384').update('hello world').digest('hex')
// → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

import hashlib

# Basic SHA-384 hash
result = hashlib.sha384(b'hello world').hexdigest()
print(result)
# → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

# Hash a string with Unicode characters
text = 'café ☕'
hashlib.sha384(text.encode('utf-8')).hexdigest()
# → 96-character hex string

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha384()
    for chunk in iter(lambda: f.read(8192), b''):
        sha.update(chunk)
    print(sha.hexdigest())

package main

import (
    "crypto/sha512"
    "fmt"
)

func main() {
    data := []byte("hello world")
    // SHA-384 lives in the crypto/sha512 package
    hash := sha512.Sum384(data)
    fmt.Printf("%x\n", hash)
    // → fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd
}

# Using sha384sum (Linux)
echo -n "hello world" | sha384sum
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# macOS
echo -n "hello world" | shasum -a 384
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha384
# → SHA2-384(stdin)= fdbd8e75a67f29f701a4e040385e2e23986303ea...

# Verify a file checksum
sha384sum myfile.bin > checksum.txt
sha384sum -c checksum.txt
# → myfile.bin: OK

Häufig gestellte Fragen