MD5 vs SHA-256: welk hash-algoritme moet je gebruiken?
Een hash berekenen is een van de meest fundamentele operaties in de informatica — maar het verkeerde algoritme kiezen kan je systeem blootstellen aan collision-aanvallen, gegevenscorruptie of onnodige prestatieoverhead. Deze gids vergelijkt de vier meest gebruikte hash-algoritmen en geeft je een helder beslisschema.
Wat is een hashfunctie?
Een cryptografische hashfunctie neemt willekeurige invoergegevens en produceert een uitvoer van vaste grootte (de “digest” of “hash”). Goede hashfuncties hebben drie eigenschappen:
- Deterministisch: dezelfde invoer levert altijd dezelfde uitvoer op.
- Eenrichtingsverkeer: je kunt de hash niet terug omzetten naar de oorspronkelijke invoer.
- Collision-bestendig: het moet computationeel onhaalbaar zijn om twee verschillende invoeren te vinden die dezelfde hash opleveren.
Wanneer eigenschap 3 wegvalt, wordt het algoritme als “cryptografisch gebroken” beschouwd — precies dat is er met MD5 en SHA-1 gebeurd.
Algoritmen in één oogopslag vergeleken
| Eigenschap | MD5 | SHA-1 | SHA-256 | SHA-512 |
|---|---|---|---|---|
| Uitvoergrootte | 128 bits (32 hex-tekens) | 160 bits (40 hex-tekens) | 256 bits (64 hex-tekens) | 512 bits (128 hex-tekens) |
| Blokgrootte | 512 bits | 512 bits | 512 bits | 1024 bits |
| Jaar van introductie | 1991 | 1995 | 2001 | 2001 |
| Ontwerper | Ron Rivest | NSA / NIST | NSA / NIST | NSA / NIST |
| Collision-bestendigheid | Gebroken (2004) | Gebroken (2017) | Veilig | Veilig |
| Snelheid (relatief) | Snelst | Snel | Gemiddeld | Gemiddeld (sneller op 64-bit) |
| NIST-status | Afgeschreven | Afgeschreven | Aanbevolen | Aanbevolen |
MD5: snel maar gebroken
MD5 (Message-Digest Algorithm 5) werd in 1991 ontworpen door Ronald Rivest en werd in de jaren negentig en begin jaren 2000 de feitelijke standaard voor checksums. Het produceert een 128-bits hash in 32 hexadecimale tekens.
Waarom MD5 gebroken is
In 2004 demonstreerde Xiaoyun Wang praktische collision-aanvallen op MD5. In 2008 maakten onderzoekers een frauduleus SSL-certificaat met MD5-collisions, wat aantoonde dat de aanval niet louter theoretisch was. Tegenwoordig kunnen MD5-collisions binnen enkele seconden op consumentenhardware worden gegenereerd.
// Generate an MD5 hash (for non-security use only)
// Using the Web Crypto API is not available for MD5 — use a library
import { md5 } from 'hash-wasm';
const hash = await md5('Hello, World!');
console.log(hash);
// → 'bea8252ff4e80f41719ea13cdf007273' (32 hex chars)Wanneer MD5 nog acceptabel is
Hoewel MD5 cryptografisch gebroken is, blijft het nuttig voor toepassingen zonder beveiligingseisen:
- Bestandsdeduplicatie: dubbele bestanden detecteren in opslagsystemen
- Cache-sleutels: korte, deterministische sleutels genereren voor cache-opzoekingen
- Integriteits-checksums voor gegevens: snelle verificatie dat gegevens niet per ongeluk beschadigd zijn (niet bewust gemanipuleerd)
- Compatibiliteit met oudere systemen: samenwerken met oudere systemen die MD5 vereisen
Het cruciale onderscheid: MD5 beschermt tegen toevallige corruptie, maar niet tegen bewuste manipulatie.
SHA-1: afgeschreven maar nog in omloop
SHA-1 (Secure Hash Algorithm 1) werd ontworpen door de NSA en in 1995 gepubliceerd door NIST. Het produceert een 160-bits hash in 40 hexadecimale tekens.
In 2017 demonstreerden Google en CWI Amsterdam de eerste praktische SHA-1-collision (de “SHAttered”-aanval), waarbij ze twee verschillende PDF-bestanden met dezelfde SHA-1-hash genereerden. Grote browsers en certificaatautoriteiten weigerden SHA-1-certificaten al sinds 2016.
Gebruik SHA-1 alleen voor compatibiliteit met systemen die het vereisen (Git gebruikt bijvoorbeeld SHA-1 voor commit-hashes, al is de overstap naar SHA-256 in gang gezet). Kies bij nieuwe ontwikkeling voor SHA-256 of sterker.
SHA-256: de huidige standaard
SHA-256 maakt deel uit van de SHA-2-familie, ontworpen door de NSA en in 2001 gepubliceerd door NIST. Het produceert een 256-bits hash in 64 hexadecimale tekens en is in 2026 het aanbevolen algoritme voor vrijwel alle hash-toepassingen.
// Generate a SHA-256 hash using the Web Crypto API (browser-native)
async function sha256(text) {
const data = new TextEncoder().encode(text);
const hash = await crypto.subtle.digest('SHA-256', data);
return Array.from(new Uint8Array(hash))
.map(b => b.toString(16).padStart(2, '0'))
.join('');
}
const hash = await sha256('Hello, World!');
console.log(hash);
// → 'dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f'Waarom SHA-256 de standaardkeuze is
- Geen bekende aanvallen: vanaf 2026 bestaan er geen praktische collision- of preimage-aanvallen
- Ingebouwd in de browser: beschikbaar via de Web Crypto API in alle moderne browsers — geen bibliotheken nodig
- Industriestandaard: gebruikt door TLS-certificaten, Bitcoin, pakketbeheerders (npm, pip), image-digests van Docker en de meeste systemen voor integriteitscontrole
- Goedgekeurd door NIST: aanbevolen voor alle beveiligingsgevoelige toepassingen
SHA-512: wanneer je meer nodig hebt
SHA-512 produceert een 512-bits hash in 128 hexadecimale tekens. Het gebruikt een blokgrootte van 1024 bits (tegenover 512 bits bij SHA-256), wat het sneller maakt dan SHA-256 op 64-bits processors omdat het meer gegevens per cyclus verwerkt.
# Python: SHA-512 is just as easy as SHA-256
import hashlib
hash_256 = hashlib.sha256(b'Hello, World!').hexdigest()
hash_512 = hashlib.sha512(b'Hello, World!').hexdigest()
print(f"SHA-256: {hash_256}") # 64 chars
print(f"SHA-512: {hash_512}") # 128 charsGebruik SHA-512 wanneer:
- Je een grotere veiligheidsmarge nodig hebt (256-bits collision-bestendigheid tegenover 128-bits bij SHA-256)
- Je platform 64-bits is en prestaties belangrijk zijn (SHA-512 kan op x86-64 tot 1,5 keer sneller zijn dan SHA-256)
- Het protocol of de specificatie het voorschrijft (sommige certificaatschema’s, specifieke compliance-eisen)
Voor de meeste toepassingen volstaat SHA-256. De extra lengte van SHA-512-hashes verdubbelt de opslag en bandbreedte zonder dat dit bij typisch gebruik een praktisch beveiligingsvoordeel oplevert.
Beslisschema: welke hash gebruik je?
Voor bestandsintegriteit en checksums
Gebruik SHA-256. Het is de standaard voor het verifiëren van downloads, het vergelijken van bestandsinhoud en het controleren of gegevens niet beschadigd zijn. Vervang je een bestaand MD5-gebaseerd systeem, dan is SHA-256 de rechtstreekse upgrade.
# Verify a download's integrity
sha256sum downloaded-file.tar.gz
# Compare output against the published hashVoor wachtwoordopslag
Gebruik geen MD5 of SHA-256 rechtstreeks. Algemene hashfuncties zijn te snel voor wachtwoord-hashing — een aanvaller kan miljarden pogingen per seconde doen. Gebruik in plaats daarvan een speciaal algoritme voor wachtwoord-hashing:
| Algoritme | Status | Opmerkingen |
|---|---|---|
| Argon2id | Aanbevolen | Winnaar van de Password Hashing Competition van 2015; memory-hard |
| bcrypt | Goed | Breed ondersteund; ingebouwde salt; aanpasbare workfactor |
| scrypt | Goed | Memory-hard; gebruikt door sommige cryptovaluta-systemen |
| PBKDF2 | Acceptabel | Goedgekeurd door NIST maar niet memory-hard; gebruik ≥600.000 iteraties |
| SHA-256 | Onvoldoende | Te snel; geen ingebouwde salt; kwetsbaar voor GPU-aanvallen |
| MD5 | Gevaarlijk | Gebroken + te snel; triviaal te kraken |
// WRONG: Don't hash passwords with SHA-256
const hash = await sha256(password); // Crackable at billions/sec
// RIGHT: Use bcrypt (Node.js example)
import bcrypt from 'bcrypt';
const hash = await bcrypt.hash(password, 12); // 12 rounds = ~250ms
const isValid = await bcrypt.compare(input, hash);Voor HMAC en berichtauthenticatie
Gebruik SHA-256 met HMAC. HMAC (Hash-based Message Authentication Code) combineert een hashfunctie met een geheime sleutel om zowel integriteit als authenticiteit te verifiëren:
// HMAC-SHA256 for webhook signature verification
async function verifyWebhook(payload, signature, secret) {
const key = await crypto.subtle.importKey(
'raw', new TextEncoder().encode(secret),
{ name: 'HMAC', hash: 'SHA-256' }, false, ['verify']
);
const sig = Uint8Array.from(atob(signature), c => c.charCodeAt(0));
return crypto.subtle.verify('HMAC', key, sig, new TextEncoder().encode(payload));
}Voor content-addressable opslag
Gebruik SHA-256. Git, Docker en IPFS gebruiken allemaal content-addressable opslag, waarbij de hash van de inhoud dient als adres. SHA-256 biedt voldoende collision-bestendigheid om uniciteit te garanderen over miljarden objecten.
Prestatiebenchmarks
Relatieve hashsnelheid op een moderne x86-64-processor (hoger = sneller):
| Algoritme | Doorvoer (MB/s) | Relatieve snelheid |
|---|---|---|
| MD5 | ~3.200 | 1,0x (basislijn) |
| SHA-1 | ~2.400 | 0,75x |
| SHA-256 | ~1.500 | 0,47x |
| SHA-512 | ~2.100 | 0,66x |
Let op: SHA-512 is sneller dan SHA-256 op 64-bits processors dankzij zijn bredere interne toestand. Op 32-bits systemen keert de situatie om. Voor de meeste toepassingen is het snelheidsverschil irrelevant — een hash berekenen van een bestand van 1 MB duurt binnen 1 milliseconde met elk van deze algoritmen.
Veelgemaakte fouten om te vermijden
1. MD5 gebruiken voor beveiliging
MD5-collisions zijn triviaal te genereren. Gebruik MD5 nooit voor digitale handtekeningen, certificaatvalidatie of elk scenario waarin een aanvaller kwaadaardige invoer kan fabriceren.
2. SHA-256 gebruiken voor wachtwoordopslag
SHA-256 is geen wachtwoord-hash. Het is te snel, heeft geen ingebouwde salt en is kwetsbaar voor rainbow-tabellen en GPU-versnelde brute-force-aanvallen. Gebruik Argon2id of bcrypt. Wil je begrijpen waarom, lees dan onze gids over wachtwoord-entropie — die legt de wiskunde achter brute-force-bestendigheid uit.
3. Aannemen dat hash-lengte gelijkstaat aan beveiliging
Een 512-bits hash is niet automatisch “veiliger” dan een 256-bits hash wat collision-bestendigheid betreft. De veiligheidsmarge van SHA-256 (128-bits collision-bestendigheid) overstijgt ruim wat brute force aankan. Kies op basis van je werkelijke eisen, niet op basis van hash-lengte.
4. Zelf hash-combinaties bedenken
Patronen als SHA256(MD5(data)) of MD5(data + salt) lossen een gebroken algoritme niet op magische wijze op. Gebruik één grondig beproefd algoritme (SHA-256) of een correcte constructie (HMAC).
Probeer het zelf
Genereer en vergelijk direct MD5-, SHA-1-, SHA-256- en SHA-512-hashes met onze hash-generator — plak tekst of sleep een bestand en zie alle vier de digests naast elkaar. 100% in je browser, je data verlaat nooit je apparaat.
Wil je een breder beeld van webbeveiliging, inclusief authenticatie, invoervalidatie en beveiligings-headers, lees dan onze gids essentiële webbeveiliging. Je kunt ook al onze onmisbare ontwikkeltools verkennen voor codering, hash-berekening en gegevensconversie.
Veelgestelde vragen
Is MD5 nog veilig voor checksums?
MD5 is veilig voor het detecteren van toevallige bestandscorruptie — als een bestand tijdens het downloaden beschadigd raakt, zal de MD5-hash vrijwel zeker veranderen. MD5 is echter niet veilig tegen bewuste manipulatie, omdat een aanvaller een gewijzigd bestand met dezelfde MD5-hash kan fabriceren. Gebruik voor integriteitsverificatie waar aanvallers een rol kunnen spelen (zoals softwaredistributie) SHA-256.
Hoeveel trager is SHA-256 vergeleken met MD5?
SHA-256 is in ruwe doorvoer ongeveer twee keer zo traag als MD5. Op moderne hardware haalt MD5 ongeveer 3.200 MB/s en SHA-256 ongeveer 1.500 MB/s. In de praktijk is dit verschil verwaarloosbaar voor de meeste toepassingen — een hash berekenen van een bestand van 100 MB duurt met SHA-256 ongeveer 70 milliseconden. De prestatiekloof is alleen van belang bij scenario’s met zeer hoge doorvoer, zoals inspectie van netwerkpakketten of opslagdeduplicatie op schaal.
Moet ik SHA-256 of SHA-512 gebruiken voor mijn applicatie?
Gebruik SHA-256 voor de meeste toepassingen — het biedt 128-bits collision-bestendigheid, ruim meer dan wat brute force aankan. Kies SHA-512 als: (a) je platform 64-bits is en je maximale doorvoer nodig hebt, (b) een specificatie of compliance-eis dit verplicht, of (c) je een grotere veiligheidsmarge wilt voor langdurige gegevensintegriteit. De extra hash-lengte van SHA-512 verdubbelt de opslag en is zelden noodzakelijk.
Kan SHA-256 worden gekraakt of omgekeerd?
SHA-256 kan niet worden omgekeerd — het is een eenrichtingsfunctie. Vanaf 2026 bestaan er geen praktische preimage- of collision-aanvallen tegen SHA-256. De best bekende aanval vereist 2^128 operaties voor collisions, wat computationeel onhaalbaar is met de huidige of voorzienbare technologie. SHA-256 is goedgekeurd door NIST en wordt gebruikt in kritieke infrastructuur, waaronder TLS, Bitcoin en federale systemen.
Waarom gebruiken sommige systemen nog steeds MD5 als het gebroken is?
De belangrijkste reden is compatibiliteit met oudere software. Veel bestaande systemen, protocollen en bestandsformaten zijn rond MD5 ontworpen voordat de zwakheden ervan bekend waren. Overstappen vereist gecoördineerde wijzigingen in alle componenten. Voor toepassingen zonder beveiligingseisen, zoals cache-sleutels en deduplicatie, maken de snelheid en kortere uitvoer van MD5 het een pragmatische keuze waar collision-aanvallen niet tot het dreigingsmodel behoren.