Google rompe lo SHA-1

3

Esistono diversi algoritmi di hashing e, per definizione, questi devono fare una cosa sola: fornendo in ingresso dati di dimensione arbitraria, restituiscono dati di dimensione fissa e valore preciso; questa semplice logica ha permesso di utilizzare algoritmi di questo tipo per diverse cose: dalla verifica di genuinità di un file (avete mai verificato la iso scaricata di una distribuzione?), alla possibilità di verificare l’autenticazione di un utente senza doversi salvare la password, fino alla ricerca di pattern ripetuti nel DNA umano.

Insomma, che sia l’md5, lo sha-1 o lo sha-256 questi algoritmi per funzionare devono garantire due cose: se passo un file ottengo una stringa di caratteri (chiamato hash o checksum):

  • Quello stesso file, dato in pasto allo stesso algoritmo, genererà sempre la stessa stringa di caratteri;
  • Non esiste alcun altro file che generi la stessa stringa di caratteri

Ora, tra i vari algoritmi, lo SHA-1 è uno dei più conosciuti, anche perchè sono più di 20 anni che è stato pubblicato; certo, oramai è “quasi” in disuso, dopo che nel 2005 alcuni criptoanalisti lo dichiararono non sicuro trovando attacchi di tipo bruteforce (tentando ovvero tutte le possibili combinazioni) in grado di determinare i dati sorgenti di uno specifico hash. Questo ha spinto Mozilla, Microsoft, Google e Apple a definire che entro la fine di quest’anno i loro rispettivi browser non avrebbero più accettato autenticazioni con questo algoritmo.

Ma, in che senso Google ha rotto l’algoritmo? In parole povere, dopo 2 anni di ricerca intensiva (e grazie alla potenza di calcolo a cui pochi hanno accesso) è riuscita a trovare due file PDF differenti che, dati in pasto a quell’algoritmo, generano lo stesso hash.

Il risultato, come accennavamo poco fa, è stato raggiunto anche grazie alla potenza di calcolo che hanno potuto sfruttare i ricercatori:

  • Nove quintiglioni (si, avete letto bene, 9.223.372.036.854.775.808) di calcoli di hash SHA-1 in totale
  • 6.500 anni di computazione CPU per portare a termine il primo attacco
  • 110 anni di computazione GPU per portare a termine il secondo

Il che, se paragonati ai circa 12 milioni di anni di computazione GPU necessaria per portare l’attacco di tipo bruteforce scoperto nel 2005, fa si di poter rompere l’algoritmo 100.000 volte più velocemente.

Insomma, numeri da far girare la testa [cit.]
Per l’analisi completa (con tanto di pdf che causano il problema), vi rimandiamo all’annuncio ufficiale di Google.

Molti hanno discusso su questo, ed essendo questo algoritmo ancora largamente utilizzato nel sistema di versionamento git, ha detto la sua anche il buon Torvalds:

I haven’t seen the attack yet, but git doesn’t actually just hash the data, it does prepend a type/length field to it. That usually tends to make collision attacks much harder

Non ho ancora visto l’attacco, ma git non esegue l’hash solo dei dati, aggiunge un campo tipo/lunghezza prima dei dati stessi. Questo tendenzialmente rende la realizzazione di attacchi a collisione più difficile

Quindi, possiamo dormire sonni tranquilli? O no?

Utente Linux/Unix da più di 20 anni, cerco sempre di condividere il mio know-how; occasionalmente, litigo con lo sviluppatore di Postfix e risolvo piccoli bug in GNOME. Adoro tutto ciò che può essere automatizzato e reso dinamico, l’HA e l’universo container. Autore dal 2011, provo a condividere quei piccoli tips&tricks che migliorano il lavoro e la giornata.

3 risposte a “Google rompe lo SHA-1”

  1. Avatar giomba
    giomba

    Come scritto nell’articolo, per definizione, l’hash prende in ingresso dei dati di tipologia e lunghezza arbitraria, e poi fornisce in uscita un codice di dimensione fissa basato sul contenuto dei dati in ingresso. Per una lunghezza di n bit del codice di uscita, si hanno 2^n possibili hash diversi. È evidente che io potrò sempre produrre più di 2^n dati diversi in ingresso, perché questi hanno lunghezza arbitraria. Mi basta, per esempio, generare tutti i dati di lunghezza 2^(n+1) per trovare sicuramente una collisione, quindi, non c’è proprio da stupirsi che sha1 (e prima md5, e in futuro anche sha256) possano essere non sicuri. Il fatto che un algoritmo di hash garantisca che due diversi dati di ingresso diano sempre due diversi hash, è semplicemente impossibile per definizione: al limite, si possono rendere le collisioni difficili da trovare, ma si sa fin dal principio che queste ci sono. Quindi, animo in pace, fin’ora abbiamo sempre usato md5 e sha1, e tra qualche anno, quando avremo sufficiente capacità di calcolo, anche sha256 farà la stessa fine, e ce ne sarà uno nuovo, che reggerà il compromesso finché i computer non saranno diventati abbastanza potenti da rendere obsoleto pure quello, e così via.

  2. Avatar Tullio Andreatta
    Tullio Andreatta

    In realtà il testo dell’articolo è sbagliato, quando dice che un algoritmo di hash debba garantire che “Non esiste alcun altro file che generi la stessa stringa di caratteri”, proprio perchè matematicamente non avrebbe senso dire che possa esistere una funzione che trasforma ogni numero di 1000 cifre in uno di 32 cifre senza produrre duplicati (dopo che ho esaurito i numeri di 32 cifre, dovrò ripetermi).
    In realtà l’hash dovrebbe garantire invece che non sia FACILE, dato un certo file, creare un altro file con il medesimo hash.
    Google ha “solo” dimostrato che SHA-1 consente di trovare un file con lo stesso hash di un file dato con un algoritmo 100.000 volte più semplice di quelli ipotizzati finora.

  3. Avatar matteocappadonna
    matteocappadonna

    Premettendo che non entro nelle ‘definizioni’ matematiche semplicemente perché -probabilmente- non sarei in grado di discuterne appieno, il punto di vista con cui ho affrontato la stesura di questo articolo è stato prettamente pratico.

    E’ vero che matematicamente è impossibile esprimere in maniera univoca con un numero limitato di caratteri l’intero spettro dei possibili file (soprattutto se consideriamo l’infinito come “campione” di input), è anche vero che, praticamente parlando, quello che ci si aspetta da un algoritmo di hashing è che due file producano sempre due risultati diversi.

    Quello che determina, IMHO, l’usabilità o meno di un metodo piuttosto che un altro è quindi il tempo necessario a rompere lo stesso; se è fattibile in un periodo di tempo “umano”, allora è da valutare un cambio.

    Google, come dici tu, ha fatto questo; non ha dimostrato che con lo SHA-1 è possibile avere collisioni, questo si sapeva già, ha solo dimostrato che è possibile averle (o generarle, come nel loro caso) in un tempo umanamente accettabile, cosa che rende automaticamente necessario valutare, dove possibile, il passaggio allo SHA-256 (o altri tipi di hash).

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *