MD5 naar SHA-256 omzetten? Waarom dat niet kan en wat wel werkt

Genoeg pagina’s beloven het, en sommige zien er zelfs uit als werkende tools. De bewerking die ze adverteren bestaat niet. De reden daarvoor bepaalt meteen wat je wél moet doen.

Het korte antwoord: je kunt MD5 niet omzetten naar SHA-256 (en SHA-256 niet naar MD5)

Een MD5-hash is 128 bits uitvoer die de invoer waaruit hij ontstond niet bevat, en SHA-256 heeft precies die invoer nodig om überhaupt iets te kunnen uitrekenen. Zonder de oorspronkelijke gegevens ontbreekt de tussenstap permanent, en geen enkele tool of library vult hem alsnog in.

Hier is dezelfde invoer onder drie algoritmen:

Algoritme	Hash van hello	Hex-tekens	Bits
MD5	5d41402abc4b2a76b9719d911017c592	32	128
SHA-1	aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d	40	160
SHA-256	2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824	64	256

Bekijk de drie hashes als strings. Ze delen geen prefix of substring, en er loopt geen rekenkundig verband tussen. Het enige wat ze verbindt is het woord hello, en geen van drieën draagt dat woord in zich. Reken ze zelf uit met de MD5-hashgenerator en de SHA-256-generator als je wilt zien hoe ze allebei onafhankelijk van elkaar veranderen terwijl je typt.

De richting maakt ook niets uit. Van SHA-256 naar MD5 gaan mislukt om dezelfde reden: beide functies vernietigen bewust informatie, dus geen van beide hashes laat zich terugrekenen naar de invoer die de ander nodig zou hebben.

Niemand typt deze zoekopdracht uit nieuwsgierigheid naar hash-theorie, dus blijft de vraag wat je eigenlijk probeerde te doen. In de praktijk is het een van vier taken, en elk daarvan heeft een echt antwoord:

1. Een download controleren of checksums vergelijken
2. Een wachtwoorddatabase van MD5 af migreren
3. De oorspronkelijke invoer achter een hash terughalen
4. Van dezelfde gegevens een hash onder een ander algoritme berekenen

Eerst de converterpagina’s zelf, want wie hun patroon eenmaal herkent, vertrouwt hun uitvoer niet meer.

Wat een “MD5 naar SHA-256 converter” in werkelijkheid doet

Er zijn maar drie mogelijkheden, en geen ervan is een omzetting.

De eerste soort vraagt je om de oorspronkelijke tekst. Je plakt een string, de pagina produceert beide hashes, en de marketingtekst noemt dat een omzetting. Het is een hash-generator met een misleidend label: de pagina zet niets om, ze berekent twee keer een hash van dezelfde invoer.

De tweede zoekt je hash gewoon op. Zo’n pagina houdt een tabel bij met paren van invoer en hash, geoogst uit woordenlijsten en gelekte inloggegevens. Plak een MD5 waarvan de invoer in die tabel staat, en de pagina vindt de invoer, berekent daar een SHA-256-hash van en toont je het resultaat. Dat werkt voor password, 123456 en een lange staart aan andere korte strings. Voor al het overige mislukt het stilletjes, en daarom geven deze pagina’s vaak een leeg resultaat zonder enige uitleg.

En dan is er de soort die niets doet. Een verrassend aantal toont simpelweg je invoer opnieuw, of produceert een SHA-256 van de hex-string die je plakte terwijl de tekst suggereert dat het de SHA-256 van je oorspronkelijke gegevens is. Die twee waarden verschillen, en de sectie over dubbele hash-berekening hieronder laat zien hoeveel.

De test is snel gedaan. Geef de pagina een hex-string van 32 tekens en verder niets, en vraag je af of hij de invoer überhaupt zou kunnen kennen. Geeft hij toch een resultaat van 64 tekens terug en noemt hij dat een omzetting, dan raadpleegt hij een opzoektabel of liegt hij tegen je. Een hash-omzetter die nooit om je oorspronkelijke gegevens vraagt, kan alleen bij toeval gelijk hebben.

De formulering houdt stand omdat ze klinkt als iets wat er vlak naast ligt en wél werkt: encoderen en versleutelen.

Hash-berekening, codering en versleuteling: maar twee van de drie zijn omkeerbaar

Ontwikkelaars komen deze drie in dezelfde week tegen en stoppen ze in hetzelfde mentale laatje. Ze gedragen zich volstrekt verschillend:

Bewerking	Voorbeeld	Omkeerbaar?	Wat je nodig hebt
Codering	Base64, hex, URL-encoderen	Ja, altijd	Helemaal niets
Versleuteling	AES, RSA	Ja	De sleutel
Hash-berekening	MD5, SHA-1, SHA-256	Nooit	Niets helpt

Base64 is degene die de verkeerde intuïtie aanleert. Iedereen kan een Base64-string decoderen naar de oorspronkelijke bytes, zonder sleutel en zonder toestemming, en Base64 omzetten naar hex is een legitieme, alledaagse bewerking. Beide zijn niet meer dan alternatieve spellingen van dezelfde bytes. Als je dat hebt zien werken, klinkt “MD5 naar SHA-256” als hetzelfde soort herspelling.

Dat is het niet. Codering bewaart elke bit van de invoer, versleuteling bewaart die achter een sleutel, en een hash gooit er bijna alles van weg. Een MD5-hash is 16 bytes, of je hem nu een wachtwoord voerde of een schijfkopie van 40 GB. Die 40 GB is nergens slims heen gegaan; hij is weg. De FAQ van de MD5-tool behandelt de vergelijking met versleuteling uitgebreider, maar de versie van één regel volstaat hier: er is geen sleutel, dus valt er niets te ontsleutelen.

”MD5 is gebroken” betekent niet “MD5 is omkeerbaar”

Zelfs eerlijke artikelen gaan hier de mist in. Mensen redeneren van “MD5 is jaren geleden gebroken” rechtstreeks door naar “dan kan inmiddels toch wel iemand het ongedaan maken”.

Er zijn twee verschillende aanvallen in het spel:

• Een collision-aanval vindt twee verschillende invoeren die dezelfde hash opleveren. De aanvaller kiest beide invoeren en het maakt hem niet uit wat ze zijn.
• Een preimage-aanval begint bij een hash en haalt daar een invoer uit terug die hem produceert. Dit is de aanval waarmee je MD5 naar SHA-256 zou kunnen omzetten, want hij zou je iets teruggeven om aan SHA-256 te voeren.

De collision-bestendigheid van MD5 sneuvelde in 2004, en tegenwoordig laat een collision zich op gewone hardware in seconden construeren. Daarom is MD5 ongeschikt voor handtekeningen, certificaten en alles waar een aanvaller invloed op kan uitoefenen.

De preimage-bestendigheid van MD5 is niet gesneuveld. De best bekende preimage-aanval blijft theoretisch, met een complexiteit van 2^123.4 (Sasaki en Aoki, 2009). Dat is een haarbreedte sneller dan brute force en daarmee net zo onhaalbaar. Niemand inverteert willekeurige MD5-hashes, niet in 2004 en niet nu.

Zo staan de twee feiten zonder tegenspraak naast elkaar: MD5 is gebroken, en MD5 is nog steeds niet omkeerbaar. Kies je tussen de twee algoritmen voor een nieuw systeem in plaats van dat je ertussen wilt omzetten, dan gaat MD5 vs SHA-256 vergeleken op die beslissing in.

Wat je eigenlijk wilt: vier taken en het echte antwoord per taak

Wat je in werkelijkheid doet	Het echte antwoord
Een download controleren of checksums vergelijken	Herbereken vanaf het bestand met het algoritme dat je nodig hebt
MD5-wachtwoordhashes migreren	Wikkel ze in bcrypt en upgrade bij het inloggen
De oorspronkelijke invoer terughalen	Dat heet kraken en hangt af van de entropie van de invoer
Van dezelfde gegevens een hash onder een ander algoritme berekenen	Ga terug naar de bronbytes

Taak 1: je vergelijkt checksums of controleert een download

Herbereken, ga niet omzetten. Je hebt het bestand op schijf staan, dus je hebt nog datgene wat de hash kwijtraakte. Draai er het algoritme overheen dat je nodig hebt:

# GNU coreutils
md5sum    ubuntu-24.04-desktop-amd64.iso
sha256sum ubuntu-24.04-desktop-amd64.iso

# macOS
md5           ubuntu-24.04-desktop-amd64.iso
shasum -a 256 ubuntu-24.04-desktop-amd64.iso

Waar mensen tegenaan lopen is een aanbieder die alleen een MD5 publiceert terwijl jouw beveiligingsbeleid SHA-256 eist. De gepubliceerde MD5 omzetten zou niets bewijzen, zelfs als het kon, want een hash die je uit een andere hash afleidde is geen uitspraak van de aanbieder over het bestand. Wat je nodig hebt is een SHA-256 die de aanbieder heeft ondertekend. Biedt hij die niet, dan geeft je eigen SHA-256 berekenen met de SHA-256-generator je nog altijd een stabiele vingerafdruk voor intern gebruik: je kunt hem vastleggen en er later verschillen tussen mirrors mee opmerken. Alleen kan hij de verklaring van de aanbieder niet vervangen.

Taak 2: je migreert een wachtwoorddatabase van MD5 af

Hier staat het meest op het spel, en er is een uitgesleten oplossing voor: wikkel de oude hashes in, en upgrade daarna elk account transparant bij het inloggen. Je berekent in één batchtaak een bcrypt-hash van elke opgeslagen MD5-hash, en vanaf dat moment berekent het inlogpad eerst de MD5 van het ingestuurde wachtwoord en vergelijkt dat met het bcrypt-record.

Veel oudere adviezen draaien dit om, dus eerst de waarschuwing: MD5 in SHA-256 wikkelen maakt wachtwoordopslag niet veilig. SHA-256 is een snelle hashfunctie, dezelfde categorie probleem als MD5, en GPU’s malen door allebei heen met enorme snelheden. Advies dat je naar de ingebouwde SHA2()-functie van een database wijst als oplossing, lost het verkeerde probleem op. Het doel is een bewust trage hashfunctie: bcrypt, scrypt of Argon2. Sla bcrypt(md5(password)) op, nooit sha256(md5(password)). bcrypt vs Argon2 vs scrypt vergeleken behandelt hoe je uit die drie kiest, en met de bcrypt-generator test je kostenfactoren voordat je je op één vastlegt.

Het deel dat migraties daadwerkelijk sloopt zit hier: “de MD5 van het wachtwoord” is dubbelzinnig, en de twee lezingen leveren verschillende resultaten op:

const { createHash } = require('node:crypto');

const md5Hex = createHash('md5').update('hello').digest('hex');
const md5Raw = createHash('md5').update('hello').digest();   // the same value as 16 bytes

createHash('sha256').update(md5Hex).digest('hex');
// 4914e23374bb211e3dca0df7636fefffc7fedd94f1340ae81c7d6c07b7113e9b

createHash('sha256').update(md5Raw).digest('hex');
// 88e20f0abb88153e3f0a9683668ccb5b84ed771817dc448a2b73254ed02c8d8c

createHash('sha256').update('hello').digest('hex');
// 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

Drie resultaten, alle drie correct, alle drie verschillend. De hex-string van 32 tekens, de 16 ruwe bytes die die string voorstelt en het oorspronkelijke wachtwoord leveren elk een andere SHA-256 op. Kies één afspraak, schrijf hem op, en gebruik dezelfde in het migratiescript en in het inlogpad. Dit fout doen sluit al je gebruikers in één klap buiten, en het symptoom ziet eruit als een bug in bcrypt in plaats van als een beslissing over codering.

Voor een bcrypt-wikkel is hex de veiligere afspraak. Ruwe hashbytes kunnen een nulbyte bevatten, en verschillende bcrypt-implementaties behandelen hun invoer als een C-string en stoppen daar met lezen. Hex vermijdt dat volledig, en met 32 tekens blijft het ruim onder de limiet op de invoerlengte van bcrypt. Normaliseer ook de schrijfwijze, want 5D41402A... en 5d41402a... zijn voor bcrypt verschillende strings, ook al zijn het dezelfde hash.

const bcrypt = require('bcrypt');
const { createHash } = require('node:crypto');

const legacyDigest = (password) =>
  createHash('md5').update(password, 'utf8').digest('hex');   // lowercase hex

// Batch job, run once: wrap each stored MD5, then drop the old column.
async function wrapRow(row) {
  return bcrypt.hash(row.md5_hash.toLowerCase(), 12);
}

// Login path
async function verify(password, row) {
  if (row.scheme === 'bcrypt') {
    return bcrypt.compare(password, row.hash);
  }
  const ok = await bcrypt.compare(legacyDigest(password), row.hash);
  if (ok) {
    const upgraded = await bcrypt.hash(password, 12);
    await saveCredential(row.id, { scheme: 'bcrypt', hash: upgraded });  // your DB write
  }
  return ok;
}

Accounts gaan over op kale bcrypt zodra hun eigenaren inloggen. Stel een deadline voor de achterblijvers en forceer daarna een reset.

Taak 3: je probeert de oorspronkelijke invoer terug te halen

Zeg dat ronduit, in elk geval tegen jezelf, want het verandert de tooling en de verwachtingen. Een invoer terughalen uit een hash is kraken, geen omzetten, en of het lukt heeft niets te maken met welk algoritme die hash produceerde. Het hangt af van de invoer.

Korte strings die mensen zelf verzinnen vallen snel. Woordenboekwoorden, namen met een cijfer erachter en alles wat ooit in een datalek-corpus is opgedoken sneuvelen door een opzoekactie of een korte brute-force-run. Lange willekeurige strings vallen helemaal niet, en het gat tussen die twee gevallen is geen kwestie van meer hardware kopen.

De gebruikelijke omschrijving van rainbow tables is te slordig. Een rainbow table haalt een invoer alleen terug als van die invoer een hash is berekend zonder salt én die invoer al in de tabel staat. Beide voorwaarden zijn nodig. Voeg een salt per gebruiker toe en de voorberekende tabel is waardeloos, want de aanvaller zou een aparte tabel per salt nodig hebben. Voer de hashfunctie een willekeurig token van 128 bits en geen tabel ter wereld bevat het. De gids over wachtwoord-entropie zet er getallen bij waar die grens ligt.

Was de invoer een wachtwoord van jezelf en kun je het niet reproduceren, behandel dit dan als een reset, niet als een herstelactie. Hoort het bij iemand anders, dan is de eerlijke omschrijving die hierboven.

Taak 4: je hebt dezelfde gegevens nodig met een ander algoritme (“md5 to sha1 converter”)

Zelfde vorm als taak 1, algemener. Welk paar algoritmen in het verzoek staat maakt niet uit, want het antwoord is altijd om terug te gaan naar de bronbytes en daar opnieuw een hash van te berekenen:

sha1sum   payload.bin
sha256sum payload.bin

Elke “md5 to sha1 converter” die je vindt, berekent opnieuw een hash of raadpleegt een opzoektabel, om dezelfde redenen als hierboven. Zijn de oorspronkelijke gegevens niet beschikbaar, dan heeft de taak geen oplossing, en dat ligt niet aan de beschikbare tools. Kies het doelalgoritme met de SHA-familie vergeleken; de SHA-1-generator staat er voor legacysystemen die hem nog vereisen, al zou niets nieuws dat meer moeten doen.

Het ene geval waarin een opzoekactie in een hash-omzetter wél werkt

Bij sommige soorten gegevens verzamelt een centrale partij alles en indexeert dat meteen op elke gangbare hash. Malwaresamples zijn het standaardvoorbeeld. Diensten als VirusTotal bewaren de sample zelf, dus hebben ze de MD5, SHA-1 en SHA-256 uit dezelfde bytes berekend en alle drie onder één record gearchiveerd. Zoek daar de MD5 van een sample op en je krijgt de SHA-256 terug.

Dat is een database-join, geen omzetting. Het werkt omdat iemand het oorspronkelijke bestand had en er met elk algoritme een hash van berekende — precies de herberekenstap die hierboven staat, alleen vooraf gedaan door een derde partij. De voorwaarden zijn streng: het object moet al in de index staan, en je moet degene vertrouwen die de index bouwde. Workflows voor threat intelligence leunen hier dagelijks op. Het zegt niets over willekeurige MD5-hashes, en het gaat je nooit helpen bij een hash van je eigen gegevens.

Het mechanisme is hetzelfde als dat van de dubieuze omzetterpagina’s. Het verschil is dat een malwarerepository je vertelt dat het een opzoekactie is en je het record laat zien.

Probeer het zelf

Bereken beide hashes van dezelfde invoer en leg ze naast elkaar:

$ printf 'hello' | md5sum
5d41402abc4b2a76b9719d911017c592  -
$ printf 'hello' | sha256sum
2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824  -

Verander één teken en beide uitvoeren zien er compleet anders uit, elk op hun eigen manier. Plak dezelfde tekst naast elkaar in de MD5-hashgenerator en de SHA-256-generator om het live te zien, of pak de HMAC-generator als je een hash met sleutel nodig hebt om een API-verzoek te ondertekenen. Alle drie draaien volledig in je browser.

FAQ

Kun je MD5 omzetten naar SHA-256?

Nee. Een MD5-hash bevat de oorspronkelijke invoer niet, en SHA-256 heeft die invoer nodig om iets te produceren. Elke pagina die beweert om te zetten, berekent opnieuw een hash van tekst die jij aanlevert of zoekt de waarde op in een database met voorberekende paren.

Waarom bieden zoveel sites een “MD5 naar SHA-256 converter” aan?

Ze scoren op een zoekopdracht die mensen intypen. Eenmaal daar vraagt de pagina om je oorspronkelijke tekst, wat het een herberekening maakt in plaats van een omzetting, of ze geeft niets bruikbaars terug. De bewoording blijft rondgaan omdat het misverstand erachter zo gewoon is.

Kun je SHA-256 terug omzetten naar MD5?

Nee, en de richting doet er niet toe. Het zijn allebei eenrichtingsfuncties, dus geen van beide hashes laat zich in de andere veranderen zonder de oorspronkelijke invoer. Een tool die de omgekeerde reis aanbiedt, gebruikt dezelfde opzoek- of herberekentruc.

MD5 is gebroken, betekent dat niet dat hij omkeerbaar is?

Nee. De collision-bestendigheid van MD5 sneuvelde in 2004: een aanvaller kan twee invoeren dezelfde hash laten delen. Een hash omkeren is een preimage-aanval, en de best bekende kost nog altijd 2^123.4 operaties. MD5 is dus gebroken voor handtekeningen en nog steeds niet te inverteren.

Hoe migreer ik een database met MD5-wachtwoordhashes naar iets veiligers?

In MySQL lijkt de oneliner UPDATE users SET password = SHA2(password, 256) de oplossing, maar die berekent een hash van de opgeslagen MD5-hash en niet van het wachtwoord. Sla bcrypt(md5(password)) op en verifieer via dezelfde wikkel, waarbij je elk record upgradet bij de eerstvolgende geslaagde login. MD5 in SHA-256 wikkelen helpt niet, want het zijn allebei snelle hashfuncties en een GPU verwerkt ze even meedogenloos snel.

Waarom gaf dubbele hash-berekening een ander resultaat dan verwacht?

Een hash berekenen van de MD5-hex-string en er een berekenen van de 16 ruwe bytes leveren verschillende SHA-256-uitvoer op. Beide zijn geldig; het zijn simpelweg verschillende invoeren. Kies één afspraak en pas hem identiek toe in het migratiescript en in het inlogpad.

Kan een rainbow table de invoer achter een MD5-hash terughalen?

Alleen als van de invoer een hash is berekend zonder salt en die invoer al in de tabel staat, wat in de praktijk korte of veelvoorkomende strings betekent. Lange willekeurige invoeren zijn zo niet terug te halen, en een salt per gebruiker maakt voorberekende tabellen nutteloos.

Bestaat er een MD5 naar SHA-1 omzetter?

Nee. Wat MD5 naar SHA-256 tegenhoudt, houdt MD5 naar SHA-1 net zo goed tegen, want het is dezelfde eenrichtingsfunctie. Elke zogenaamde omzetter berekent dus opnieuw een hash of raadpleegt een opzoektabel. Heb je de oorspronkelijke invoer nog, reken hem dan opnieuw uit met de SHA-1-generator; zonder die invoer lukt het met geen enkele tool.