Convertire MD5 in SHA-256? Perché è impossibile e cosa fare online

Ci sono decine di pagine che promettono di farlo, e alcune sembrano perfino strumenti funzionanti. L’operazione che pubblicizzano non esiste, e il motivo conta, perché cambia quello che devi fare dopo.

La risposta breve: non puoi convertire MD5 in SHA-256 (né SHA-256 in MD5)

Un digest MD5 è composto da 128 bit di output che non contengono l’input che li ha prodotti, e SHA-256 ha bisogno proprio di quell’input per calcolare qualcosa. Senza i dati originali quel passaggio intermedio manca, e non c’è strumento o libreria che possa ricostruirlo.

Ecco lo stesso input passato a tre algoritmi:

Algoritmo	Digest di hello	Caratteri hex	Bit
MD5	5d41402abc4b2a76b9719d911017c592	32	128
SHA-1	aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d	40	160
SHA-256	2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824	64	256

Guardali come stringhe: non condividono un prefisso né una sottostringa, e non c’è aritmetica che porti dall’uno all’altro. L’unica cosa che li collega è la parola hello, e nessuno dei tre la contiene. Calcolali tu stesso con il generatore di hash MD5 e il generatore SHA-256 se vuoi vederli cambiare in modo indipendente mentre digiti.

Girare la freccia non aiuta. Passare da SHA-256 a MD5 fallisce per lo stesso motivo: entrambe le funzioni distruggono informazione di proposito, quindi nessuno dei due digest può essere riportato indietro fino all’input di cui l’altro avrebbe bisogno.

Quasi nessuno arriva qui per curiosità teorica sugli hash. Dietro la ricerca di solito c’è uno di quattro compiti, e ognuno ha una risposta concreta:

1. Verificare un download o confrontare checksum
2. Migrare un database di password via da MD5
3. Recuperare l’input originale dietro un hash
4. Ottenere l’hash degli stessi dati con un altro algoritmo

Ognuno ha la sua sezione più sotto. Prima però conviene capire cosa fanno le pagine che promettono la conversione, perché riconoscere lo schema ti evita di fidarti del loro output.

Cosa fa davvero una pagina “convertitore da MD5 a SHA-256”

Sotto quell’etichetta ci sono tre comportamenti, e nessuno converte niente.

La maggior parte delle pagine ti chiede il testo originale. Incolli una stringa, la pagina produce entrambi i digest e il testo di marketing chiama tutto questo una conversione. È un generatore di hash con un’etichetta fuorviante. Non ha convertito niente: l’input è passato per l’hash due volte.

Alcune cercano il digest in una tabella. La pagina tiene una tabella di coppie input-digest raccolte da wordlist e da dump di credenziali trapelate. Incolla un MD5 il cui input è in quella tabella e la pagina trova l’input, poi ne calcola l’hash con SHA-256 e ti mostra il risultato. Funziona per password, 123456 e una lunga coda di altre stringhe brevi. Su tutto il resto fallisce in silenzio, ed è per questo che queste pagine spesso restituiscono un risultato vuoto senza spiegazioni.

Altre non fanno niente. Si limitano a rimostrarti il tuo input, oppure emettono lo SHA-256 della stringa esadecimale che hai incollato lasciando intendere che sia lo SHA-256 dei tuoi dati originali. Quei due valori sono diversi, e la sezione sul doppio hashing più sotto mostra esattamente quanto.

La verifica è rapida. Dai alla pagina una stringa esadecimale di 32 caratteri e nient’altro, e chiediti se potrebbe mai conoscere l’input. Se restituisce comunque un risultato di 64 caratteri e lo chiama conversione, o sta interrogando una tabella o ti sta mentendo. Un convertitore di hash che non ti chiede mai i dati originali non ha modo di essere corretto, se non per coincidenza.

L’espressione sopravvive perché assomiglia a un’operazione vicina che invece funziona.

Hashing, codifica e cifratura: solo due dei tre sono reversibili

Incontri tutti e tre nella stessa settimana e li archivi nello stesso cassetto mentale. Si comportano in modo completamente diverso:

Operazione	Esempio	Reversibile?	Cosa ti serve
Codifica	Base64, hex, URL-encoding	Sì, sempre	Niente
Cifratura	AES, RSA	Sì	La chiave
Hashing	MD5, SHA-1, SHA-256	Mai	Niente aiuta

Base64 è quello che allena l’intuizione sbagliata. Chiunque può decodificare una stringa Base64 e riottenere i suoi byte senza chiave e senza permessi, e convertire Base64 in hex è un’operazione legittima e quotidiana. Sono solo due modi alternativi di scrivere gli stessi byte. Se hai visto funzionare questo, “MD5 in SHA-256” suona come lo stesso tipo di riscrittura.

Non lo è. La codifica conserva ogni bit dell’input, la cifratura lo conserva dietro una chiave, l’hashing ne butta via quasi tutto. Un digest MD5 occupa 16 byte sia che tu gli abbia dato in pasto una password sia un’immagine disco da 40 GB. Quei 40 GB non sono finiti in qualche posto ingegnoso: sono spariti. Le FAQ dello strumento MD5 trattano il confronto con la cifratura più in dettaglio, se ti interessa, ma qui basta la versione in una riga: non c’è nessuna chiave, quindi non c’è niente da decifrare.

”MD5 è rotto” non vuol dire “MD5 è reversibile”

Questo è il punto che sbagliano perfino gli articoli onesti. Il salto è da “MD5 è stato rotto anni fa” dritti a “quindi ormai qualcuno saprà pure disfarlo”.

Sono in gioco due attacchi diversi:

• Un attacco di collisione trova due input diversi che producono lo stesso digest. Chi attacca sceglie entrambi gli input e non gli importa quali siano.
• Un attacco di preimmagine parte da un digest e recupera un input che lo produce. È questo che ti permetterebbe di convertire MD5 in SHA-256, perché ti restituirebbe qualcosa da dare in pasto a SHA-256.

La resistenza alle collisioni di MD5 è caduta nel 2004, e oggi una collisione si costruisce su hardware comune in pochi secondi. Per questo MD5 è inadatto a firme, certificati e a qualsiasi cosa su cui un avversario possa influire.

La resistenza alla preimmagine di MD5 non è caduta. Il miglior attacco di preimmagine conosciuto resta teorico, con una complessità di 2^123.4 (Sasaki e Aoki, 2009). È più veloce della forza bruta per un soffio, e resta comunque fuori portata. Nessuno sta invertendo digest MD5 arbitrari, né nel 2004 né adesso.

Le due cose convivono senza contraddirsi: MD5 è rotto, e MD5 resta non invertibile. Se stai scegliendo tra i due algoritmi per un sistema nuovo invece di provare a convertire dall’uno all’altro, il confronto tra MD5 e SHA-256 affronta quella decisione come si deve.

I quattro compiti dietro la ricerca, e la risposta per ciascuno

Cosa stai facendo	La risposta
Verificare un download o confrontare checksum	Ricalcola dal file con l’algoritmo che ti serve
Migrare hash di password MD5	Avvolgili in bcrypt e aggiorna al login
Recuperare l’input originale	È cracking, non conversione, e dipende dall’entropia
Ricalcolare l’hash degli stessi dati con un altro algoritmo	Torna ai byte di partenza

Compito 1: stai confrontando checksum o verificando un download

Ricalcola, non convertire. Hai il file lì sul disco, quindi hai proprio la cosa che il digest ha perso. Passaci sopra l’algoritmo che ti serve:

# 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

Il caso che manda in crisi è quello di un distributore che pubblica solo un MD5 mentre la policy di sicurezza pretende SHA-256. Convertire l’MD5 pubblicato non dimostrerebbe niente nemmeno se fosse possibile, perché un digest che hai ricavato da un altro digest non è una dichiarazione del distributore sul file. Quello che ti serve è uno SHA-256 firmato dal distributore. Se non lo offre, calcolare il tuo SHA-256 con il generatore SHA-256 ti dà comunque un’impronta stabile per uso interno: puoi fissarla, confrontarla tra i vari mirror e rilevare cambiamenti in seguito. Quello che non può fare è sostituire l’attestazione del distributore.

Compito 2: stai migrando un database di password via da MD5

È il compito con la posta più alta, e ha una soluzione ormai collaudata: avvolgi i vecchi hash, poi aggiorna ogni account in modo trasparente al login. Applichi bcrypt a ogni hash MD5 memorizzato con un unico job batch, e da quel momento il percorso di login calcola prima l’MD5 della password inviata e lo confronta con il record bcrypt.

Prima un avvertimento, perché parecchi consigli datati prendono la cosa al contrario. Avvolgere MD5 in SHA-256 non rende sicura la conservazione delle password. SHA-256 è un hash veloce, la stessa categoria di problema di MD5, e le GPU macinano entrambi a ritmi enormi. Un consiglio che ti indirizza verso la funzione SHA2() integrata nel database come soluzione sta risolvendo il problema sbagliato. L’obiettivo è un hash deliberatamente lento: bcrypt, scrypt o Argon2. Memorizza bcrypt(md5(password)), mai sha256(md5(password)). Il confronto tra bcrypt, Argon2 e scrypt spiega come sceglierne uno tra i tre, e il generatore bcrypt ti permette di provare i cost factor prima di deciderti.

Ora la parte che rompe le migrazioni. “L’MD5 della password” è ambiguo, e le due letture producono risultati diversi:

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

Tre risultati, tutti corretti e tutti diversi: uno per la stringa esadecimale di 32 caratteri, uno per i 16 byte grezzi che quella stringa rappresenta, uno per la password originale. Scegli una convenzione, mettila per iscritto e usa la stessa nello script di migrazione e nel percorso di login. Sbagliare qui blocca fuori tutti gli utenti in un colpo solo, e il sintomo sembra un bug di bcrypt più che una decisione di codifica.

Per un wrapper bcrypt, l’esadecimale è la convenzione più sicura. I byte grezzi di un digest possono contenere un byte a zero, e diverse implementazioni di bcrypt trattano il proprio input come una stringa C e smettono di leggere lì. L’esadecimale evita del tutto il problema e, con i suoi 32 caratteri, resta ben sotto il limite di lunghezza dell’input di bcrypt. Normalizza anche maiuscole e minuscole, visto che 5D41402A... e 5d41402a... sono stringhe diverse per bcrypt anche se sono lo stesso digest.

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;
}

Gli account passano a bcrypt puro man mano che i rispettivi proprietari accedono. Fissa una scadenza per i ritardatari e dopo quella data forza un reset.

Compito 3: stai provando a recuperare l’input originale

Dillo chiaramente, almeno a te stesso, perché cambia gli strumenti e le aspettative. Recuperare un input a partire da un digest è cracking, non conversione, e che funzioni o meno non ha niente a che vedere con l’algoritmo che ha prodotto il digest. Dipende dall’input.

Le stringhe brevi e scelte da un essere umano cadono in fretta. Parole da dizionario, nomi con una cifra in fondo e qualsiasi cosa sia già comparsa in un archivio di dati violati cadono con una ricerca in tabella o con una breve sessione di forza bruta. Le stringhe lunghe e casuali non cadono affatto, e il divario tra i due casi non è una questione di comprare più hardware.

Sulle rainbow table gira una versione imprecisa dei fatti. Una rainbow table recupera un input solo quando quell’input è passato per l’hash senza salt (il valore casuale aggiunto all’input) ed è già presente nella tabella. Servono entrambe le condizioni. Aggiungi un salt diverso per ogni utente e la tabella precalcolata non vale niente, perché chi attacca avrebbe bisogno di una tabella separata per ogni salt. Dai in pasto all’hash un token casuale da 128 bit e nessuna tabella al mondo lo contiene. La guida all’entropia delle password mette dei numeri su dove passa il confine.

Se l’input era una password tua e non riesci a riprodurla, trattala come un reset, non come un recupero. Se appartiene a qualcun altro, il nome giusto resta quello di sopra.

Compito 4: ti servono gli stessi dati con un algoritmo diverso (“convertitore da md5 a sha1”)

Stessa forma del Compito 1, generalizzata. La coppia di algoritmi nella richiesta non conta, perché la risposta è sempre tornare ai byte di partenza e calcolarne di nuovo l’hash:

sha1sum   payload.bin
sha256sum payload.bin

Ogni “convertitore da md5 a sha1” che trovi ricalcola l’hash oppure consulta una tabella, per gli stessi motivi visti sopra. Se i dati originali non sono disponibili il compito non ha soluzione, e questo non è un limite degli strumenti a disposizione. Scegli l’algoritmo di destinazione con il confronto della famiglia SHA; il generatore SHA-1 è lì per i sistemi legacy che lo richiedono ancora, anche se nessun sistema nuovo dovrebbe.

L’unico caso in cui cercare un convertitore di hash porta a qualcosa

Certi tipi di dati finiscono in archivi centralizzati che li indicizzano sotto tutti i digest più comuni. I campioni di malware sono l’esempio classico. Servizi come VirusTotal conservano il campione stesso, quindi ne hanno calcolato MD5, SHA-1 e SHA-256 dagli stessi byte e hanno archiviato tutti e tre sotto un unico record. Cerca lì l’MD5 di un campione e ti torna indietro il suo SHA-256.

Quella è una join di database, non una conversione. Funziona perché qualcuno aveva il file originale e ne ha calcolato l’hash con ogni algoritmo: lo stesso passo di ricalcolo descritto sopra, solo fatto in anticipo da una terza parte. Le condizioni sono strette: l’oggetto deve essere già nell’indice, e devi fidarti di chi quell’indice l’ha costruito. I team di threat intelligence ci contano ogni giorno. Non dice però nulla sui digest MD5 arbitrari, e non ti servirà mai per un hash di dati tuoi.

Il meccanismo è lo stesso che usano le pagine di conversione poco raccomandabili. La differenza è che un repository di malware ti dice che si tratta di una ricerca in archivio e ti mostra il record.

Provalo tu stesso

Il modo più rapido per convincerti è guardare due digest dello stesso input cambiare insieme senza avere niente in comune:

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

Cambia un carattere e i due output cambiano completamente, ognuno per conto suo. Incolla lo stesso testo nel generatore di hash MD5 e nel generatore SHA-256 affiancati per vederlo dal vivo, oppure passa al generatore HMAC quando quello che ti serve è un digest con chiave per firmare una richiesta API. Tutti e tre girano interamente nel tuo browser.

FAQ

Puoi convertire MD5 in SHA-256?

No. Un digest MD5 non contiene l’input originale, e SHA-256 ha bisogno di quell’input per produrre qualcosa. Qualsiasi pagina che dichiari di convertire, o sta ricalcolando l’hash di un testo che le dai tu, o sta cercando il valore in un database di coppie precalcolate.

Perché così tanti siti offrono un “convertitore da MD5 a SHA-256”?

Si posizionano su una query che le persone digitano. Una volta arrivato lì, la pagina o ti chiede il testo originale, e allora è un ricalcolo dell’hash e non una conversione, oppure non restituisce nulla di utile. La formula resiste perché l’equivoco che ci sta dietro è diffuso.

Puoi riconvertire SHA-256 in MD5?

No, e il verso non cambia le cose. Sono entrambe funzioni a senso unico, quindi nessuno dei due digest può essere trasformato nell’altro senza l’input originale. Uno strumento che offre il viaggio inverso usa lo stesso trucco della ricerca in tabella o del ricalcolo.

MD5 è rotto: non vuol dire che si può invertire?

No. La resistenza alle collisioni di MD5 è caduta nel 2004, quindi due input possono essere forzati a condividere un digest. Invertire un digest è un attacco di preimmagine, e il migliore conosciuto costa ancora 2^123.4 operazioni. Rotto per le firme, ma sempre non invertibile.

Come faccio a migrare un database di hash MD5 di password verso qualcosa di più sicuro?

In MySQL la scorciatoia in una riga, UPDATE users SET password = SHA2(password, 256), è sbagliata: calcola l’hash del digest MD5 già memorizzato e non della password. Memorizza invece bcrypt(md5(password)) e verifica attraverso lo stesso wrapper, aggiornando ogni record al successivo login riuscito. Avvolgere MD5 in SHA-256 non aiuta, perché sono entrambi hash veloci e una GPU macina l’uno o l’altro allo stesso ritmo brutale.

Perché il doppio hashing mi ha dato un risultato diverso da quello che mi aspettavo?

Calcolare l’hash della stringa esadecimale MD5 e calcolarlo sui suoi 16 byte grezzi produce output SHA-256 diversi. Sono entrambi validi: sono semplicemente input diversi. Scegli una convenzione e applicala in modo identico nello script di migrazione e nel percorso di login.

Una rainbow table può recuperare l’input dietro un hash MD5?

Solo quando l’input era senza salt ed è già presente nella tabella, il che in pratica vuol dire stringhe brevi o comuni. Gli input lunghi e casuali non sono recuperabili in questo modo, e aggiungere un salt diverso per ogni utente vanifica del tutto le tabelle precalcolate.

Esiste un convertitore da MD5 a SHA-1?

No. La stessa proprietà a senso unico che blocca MD5 verso SHA-256 blocca anche MD5 verso SHA-1, quindi ogni “convertitore da MD5 a SHA-1” ricalcola l’hash oppure consulta una tabella. Se hai ancora l’input originale, rifai il calcolo con il generatore SHA-1; altrimenti non c’è niente da fare.