SHA-384 Hash Generator

Wat is SHA-384-hashing?

SHA-384 is een cryptografische hashfunctie gedefinieerd in NIST FIPS 180-4 als onderdeel van de SHA-2-familie. De functie accepteert invoer van willekeurige lengte en produceert een vaste 384-bits (48 byte) berichtoverzicht, doorgaans weergegeven als een hexadecimale reeks van 96 tekens. SHA-384 wordt veelvuldig gebruikt in TLS-cipher suites, digitale certificaathandtekeningen en overheidssystemen waarvoor een grotere botsingsresistentiemarge vereist is dan SHA-256 biedt.

Intern is SHA-384 een afgekapte variant van SHA-512. Het gebruikt dezelfde 1024-bits blokgrootte, 80 compressieronden en 64-bits woordaritmetiek als SHA-512, maar begint met een andere set initiële hashwaarden (afgeleid van de 9e t/m 16e priemgetallen) en geeft alleen de eerste 384 bits van de eindtoestand terug. Door deze afkapping produceert SHA-384 een andere digest dan SHA-512 voor identieke invoer, ondanks het gebruik van hetzelfde kernalgoritme.

Omdat SHA-384 werkt met 64-bits woorden, draait het sneller dan SHA-256 op moderne 64-bits processors en levert het tegelijkertijd een grotere digest. Dit maakt het een praktisch compromis: sterker dan SHA-256 (192-bits botsingsresistentie vs. 128-bits) zonder de opslagoverhead van de 128-tekens hex-uitvoer van SHA-512. SHA-384 is de standaardhash voor TLS 1.3-certificaatverificatiehandtekeningen en is vereist door NSA Suite B (nu CNSA) voor TOP SECRET-gegevens.

Waarom een online SHA-384 Generator gebruiken?

SHA-384-hashes genereren vereist doorgaans een terminalopdracht of het schrijven van code. Met dit browsergebaseerde hulpmiddel bereken je SHA-384-digests direct zonder iets te installeren of gegevens naar een server te sturen. Of je nu een SRI-hash voor een CDN-bestand wilt genereren, een bestandschecksum wilt verifiëren of SHA-384-uitvoer wilt vergelijken met SHA-256 voor dezelfde invoer — dit hulpmiddel geeft je een directe, installatievrije manier om met SHA-384-digests te werken in elke moderne browser.

Toepassingen van de SHA-384 Hash Generator

Vergelijking van SHA-2-familievarianten

SHA-384 behoort tot de SHA-2-familie, samen met diverse andere varianten. De onderstaande tabel laat zien hoe ze verschillen in digestgrootte, uitvoerlengte en typische toepassingen.

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

De keuze tussen SHA-384 en andere hashalgoritmen hangt af van je beveiligingseisen, platformbeperkingen en prestatiebehoeften. Deze vergelijking behandelt de meest relevante eigenschappen.

Hoe SHA-384 intern werkt

SHA-384 verwerkt invoer via dezelfde Merkle–Damgård-constructie als SHA-512. De invoer wordt aangevuld tot een veelvoud van 1024 bits, opgedeeld in blokken en elk blok wordt verwerkt via 80 mengingsronden met behulp van de functies Ch, Maj en twee Sigma-functies met 64-bits woordaritmetiek. Het belangrijkste verschil met SHA-512 zijn de initiële hashwaarden: SHA-384 gebruikt waarden afgeleid van de gebroken delen van de kwadraatswortels van de 9e t/m 16e priemgetallen, terwijl SHA-512 de eerste 8 priemgetallen gebruikt. Na verwerking van alle blokken kapt SHA-384 de interne 512-bits toestand af tot de eerste 384 bits.

De afkapping en de andere initialisatie zorgen ervoor dat SHA-384 en SHA-512 altijd verschillende digests produceren voor dezelfde invoer. Dit maakt SHA-384 ook inherent bestand tegen length-extension-aanvallen, in tegenstelling tot SHA-256 en SHA-512, waarbij een aanvaller data kan toevoegen en een geldige hash kan berekenen zonder het originele bericht te kennen.

SHA-384 codevoorbeelden

SHA-384 wordt native ondersteund in alle grote talen en runtimes. Hieronder staan werkende voorbeelden die je direct in je projecten kunt gebruiken.

// 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

Veelgestelde vragen