SHA-512 Hash Generator

Wat is SHA-512-hashing?

SHA-512 is een cryptografische hashfunctie gedefinieerd in NIST FIPS 180-4 als het grootste lid van de SHA-2-familie. De functie accepteert invoer van willekeurige lengte en produceert een vaste 512-bits (64 bytes) berichtoverzicht, weergegeven als een hexadecimale reeks van 128 tekens. SHA-512 wordt gebruikt in digitale handtekeningen (Ed25519 maakt intern gebruik van SHA-512), HMAC-constructies, bestandsintegriteitsverificatie en cryptografische protocollen die baat hebben bij een grote veiligheidsmarge.

SHA-512 werkt op 1024-bits (128 bytes) blokken met behulp van 64-bits woordaritmetiek en 80 compressieronden. De acht initiële hashwaarden zijn afgeleid van de gebroken delen van de kwadraatswortels van de eerste acht priemgetallen, en de 80 rondeconstanten komen van de kubusrwortels van de eerste 80 priemgetallen. Omdat SHA-512 native 64-bits bewerkingen gebruikt, is het vaak sneller dan SHA-256 op moderne 64-bits processors, ondanks dat het een langere digest produceert.

SHA-384, SHA-512/224 en SHA-512/256 zijn alle afgekapte varianten van SHA-512 die dezelfde interne structuur delen, maar andere initiële hashwaarden gebruiken en minder bits als uitvoer geven. Wanneer je de maximale digestlengte van de SHA-2-familie nodig hebt, of wanneer een protocol specifiek SHA-512 vereist (zoals Ed25519 of bepaalde HMAC-gebaseerde sleutelafleiding), is SHA-512 de juiste keuze. Het biedt 256 bits botsingsresistentie, vergelijkbaar met SHA-3-512 en ruim boven de 128-bits grens van SHA-256.

Waarom een online SHA-512 Generator gebruiken?

Een SHA-512-hash berekenen vereist doorgaans een terminalopdracht of een paar regels code. Dit browsergebaseerde hulpmiddel laat je SHA-512-digests direct genereren zonder software te installeren, naar een terminal te wisselen of wegwerpscripts te schrijven.

Toepassingen van de SHA-512 Hash Generator

Vergelijking van SHA-2-familievarianten

SHA-512 behoort tot de SHA-2-familie zoals gedefinieerd in FIPS 180-4. De onderstaande tabel vergelijkt de SHA-2-varianten die de interne 64-bits architectuur van SHA-512 delen, met SHA-256 als referentie.

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

Het juiste hashalgoritme hangt af van je beveiligingseisen, prestatiebeperkingen en protocolspecificaties. SHA-512 biedt de breedste digest in de SHA-2-familie en is vaak sneller dan SHA-256 op 64-bits hardware. Deze vergelijking behandelt de eigenschappen die het meest relevant zijn bij het kiezen tussen deze algoritmen.

Hoe SHA-512 intern werkt

SHA-512 verwerkt invoer via een Merkle–Damgård-constructie met 1024-bits blokken. Het initialiseert acht 64-bits toestandswoorden (H0–H7) afgeleid van de gebroken delen van de kwadraatswortels van de eerste acht priemgetallen. Elk blok doorloopt 80 mengingsronden die bitsgewijze bewerkingen (AND, XOR, NOT, rechtsrotatie, rechtsschuif) op 64-bits woorden gebruiken, gecombineerd met 80 rondeconstanten afgeleid van de kubusrwortels van de eerste 80 priemgetallen.

De bredere 64-bits woordgrootte is het belangrijkste onderscheid ten opzichte van SHA-256. Op 64-bits CPU's verwerkt elke bewerking twee keer zoveel bits per cyclus, waardoor SHA-512 in benchmarks vaak beter presteert dan SHA-256, ondanks dat het 80 ronden uitvoert in plaats van 64. Het lawine-effect zorgt ervoor dat het omdraaien van één invoerbit ongeveer 50% van alle 512 uitvoerbits verandert.

SHA-512 codevoorbeelden

SHA-512 wordt native ondersteund in elke grote taal en runtime. De Web Crypto API biedt het in browsers zonder bibliotheek. De onderstaande voorbeelden behandelen veelvoorkomende patronen, waaronder Unicode-verwerking en het hashen van bestanden.

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

await sha512('hello world')
// → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f"

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

import hashlib

# Basic SHA-512 hash
result = hashlib.sha512(b'hello world').hexdigest()
print(result)
# → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee..."

# Hash a string with Unicode (encode to bytes first)
text = 'café ☕'
hashlib.sha512(text.encode('utf-8')).hexdigest()
# → 128-character hex string

# Hash a large file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha512()
    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")
    hash := sha512.Sum512(data)
    fmt.Printf("%x\n", hash)
    // → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f...
}

# Using sha512sum (Linux) or shasum (macOS)
echo -n "hello world" | sha512sum
# → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee...  -

# macOS
echo -n "hello world" | shasum -a 512
# → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee...  -

# Verify a file checksum
echo "309ecc48...  myfile.bin" | sha512sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha512
# → SHA2-512(stdin)= 309ecc489c12d6eb4cc40f50c902f2b4...

Veelgestelde vragen