SHA-256 Hash Generator

Wat is SHA-256-hashing?

SHA-256 (Secure Hash Algorithm 256-bit) is een cryptografische hashfunctie uit de SHA-2-familie, gepubliceerd door NIST in 2001 als onderdeel van FIPS 180-2 (bijgewerkt in FIPS 180-4). Ongeacht de invoer — een enkel teken, een bestand van meerdere gigabytes of een lege reeks — produceert SHA-256 een vaste 256-bit (32-byte) digest, die conventioneel wordt weergegeven als 64 hexadecimale tekens. SHA-256 is de meest gebruikte hashfunctie in productiesystemen van vandaag en vormt de basis voor TLS-certificaatketens, Bitcoin’s proof-of-work, Subresource Integrity (SRI) en code-signing-workflows.

SHA-256 is een eenrichtingsfunctie: het berekenen van een hash vanuit een invoer gaat snel (honderden megabytes per seconde op moderne hardware), maar het omgekeerde — een invoer vinden die een bepaalde hash oplevert — is rekenkundig onhaalbaar. Deze eigenschap, preimage-resistentie genaamd, maakt SHA-256 geschikt voor wachtwoordhashing (in combinatie met een salt en key-stretching), digitale handtekeningen en verificatie van gegevensintegriteit. In tegenstelling tot MD5 en SHA-1 is er geen botsings- of preimage-aanval aangetoond tegen volledig SHA-256.

De SHA-2-familie omvat zes varianten: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 en SHA-512/256. SHA-256 werkt met 32-bit woorden en 64 ronden per blok, geoptimaliseerd voor 32-bit processors. SHA-512 gebruikt 64-bit woorden en 80 ronden, wat op 64-bit platforms sneller kan zijn. Voor de meeste toepassingen waarbij een 256-bit digest volstaat, blijft SHA-256 de standaardaanbeveling van NIST, IETF en het CA/Browser Forum.

Waarom een online SHA-256-generator gebruiken?

Een SHA-256-hash genereren vereist normaal gesproken een terminalopdracht of een paar regels code. Met dit browsergebaseerde hulpmiddel berekent u SHA-256-digests zonder iets te installeren, van context te wisselen of een script te schrijven.

SHA-256-gebruiksscenario’s

Vergelijking SHA-2-familievarianten

SHA-256 maakt deel uit van de SHA-2-familie zoals gedefinieerd in FIPS 180-4. Elke variant maakt een afweging tussen digestgrootte, prestaties en veiligheidsmarge. De onderstaande tabel vergelijkt alle SHA-2-varianten die u waarschijnlijk zult tegenkomen.

SHA-256 vs. SHA-1 vs. MD5 vs. SHA-3

Het kiezen van het juiste hashalgoritme hangt af van uw beveiligingsvereisten en compatibiliteitsbeperkingen. SHA-256 bezet het praktische optimum: het is veilig, universeel ondersteund (inclusief de Web Crypto API) en snel genoeg voor de meeste workloads. De onderstaande vergelijkingstabel behandelt de eigenschappen die het meest relevant zijn bij het kiezen van een hashfunctie.

Hoe SHA-256 intern werkt

SHA-256 verwerkt invoer in 512-bit (64-byte) blokken via een Merkle–Damgård-constructie. Het algoritme initialiseert acht 32-bit toestandswoorden (H0–H7), afgeleid van de fractionele delen van de vierkantswortels van de eerste acht priemgetallen. Elk blok doorloopt 64 mengrondes waarbij bitsgewijze bewerkingen (AND, XOR, NOT, rechtsom draaien, rechtsverschuiving) en 64 rondeconstanten worden gebruikt die zijn afgeleid van de derdemachtswortels van de eerste 64 priemgetallen.

Het lawine-effect zorgt ervoor dat het omdraaien van één bit in de invoer ongeveer 50% van de uitvoerbits verandert. Deze eigenschap, gecombineerd met een botsingsresistentie van 2^128, is de reden waarom SHA-256 in 2026 de basisaanbeveling blijft voor beveiligingsgevoelige toepassingen.

SHA-256-codevoorbeelden

SHA-256 is native beschikbaar in elke grote taal en runtime. De Web Crypto API biedt het in browsers zonder bibliotheek. De onderstaande voorbeelden tonen gebruikspatronen uit de praktijk, inclusief Unicode-invoerverwerking en bestandshashing.

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

await sha256('hello world')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

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

import hashlib

# Basic SHA-256 hash
result = hashlib.sha256(b'hello world').hexdigest()
print(result)  # → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

# Hash a string (encode to bytes first)
text = 'café ☕'
hashlib.sha256(text.encode('utf-8')).hexdigest()
# → "3eb53e00aa1bb4b1e8aab1ab38e56e6b8fb0b20e1cf7e1d19f36e4fad2537445"

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

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha256.Sum256(data)
    fmt.Printf("%x\n", hash)
    // → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
}

# Using sha256sum (Linux) or shasum (macOS)
echo -n "hello world" | sha256sum
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# macOS
echo -n "hello world" | shasum -a 256
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# Verify a file checksum
echo "b94d27b...  myfile.bin" | sha256sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha256
# → SHA2-256(stdin)= b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

Veelgestelde vragen