Secure Hash Algorithm: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
Nessun oggetto della modifica Etichetta: Ripristino manuale |
|||
| (108 versioni intermedie di 83 utenti non mostrate) | |||
Riga 1:
Con il termine '''SHA''' ([[acronimo]] dell'[[Lingua inglese|inglese]] '''Secure Hash Algorithm''') si indica una famiglia di cinque diverse
Come ogni [[algoritmo]] di ''hash'', l'SHA produce un ''message digest'', o "impronta del [[messaggio]]", di lunghezza fissa partendo da un messaggio di lunghezza variabile. La sicurezza di un [[algoritmo]] di ''hash'' risiede nel fatto che la funzione non sia
La sicurezza di SHA-1 è stata
Un concorso aperto per la realizzazione di una nuova funzione '''SHA-3'''
Il 23 febbraio 2017 un team di Google ha annunciato la prima tecnica pratica per generare una [[collisione hash]].<ref>{{Cita web|https://security.googleblog.com/2017/02/announcing-first-sha1-collision.html|Announcing the first SHA1 collision|17 marzo 2017|data=23 febbraio 2017|lingua=en}}</ref><ref>{{Cita web|https://shattered.it|Shattered|17 marzo 2017|citazione=We have broken SHA-1 in practice.|lingua=en}}</ref>
== SHA-0 e SHA-1 ==
[[File:SHA-1.svg|thumb|Un'iterazione all'interno della funzione di compressione di SHA-1. A, B, C, D ed E sono parole di stato a 32 bit; F è una funzione non lineare che varia; [[File:lll.png|left shift]]<sub>''n''</sub> denota una rotazione del bit di sinistra di ''n'' posti; ''n'' varia per ogni operazione. [[File:Boxplus.png|Addition]] denota l'addizione modulo 2<sup>32</sup>. K<sub>t</sub> è una costante.]]
La specifica originale dell'algoritmo fu pubblicata nel 1993 come ''Secure Hash Standard'', [[Federal Information Processing Standard|FIPS]] PUB 180, dal [[National Institute of Standards and Technology|NIST]]. Ci si riferisce spesso a questa versione come '''SHA-0''' per distinguerla dalle successive versioni. Fu ritirata dall'[[National Security Agency|NSA]] breve tempo dopo la pubblicazione e fu soppiantata da una versione rivista, pubblicata nel 1995 (FIPS PUB 180-1) e solitamente nota come '''SHA-1'''. L'SHA-1 differisce dall'SHA-0 unicamente per una sola rotazione di bit nel processo di preparazione del messaggio della sua funzione di compressione ad una via; ciò fu fatto, secondo l'NSA, per correggere un difetto nell'algoritmo originale, il quale riduceva la sicurezza crittografica di SHA-0. Ad ogni modo, l'NSA non fornì nessuna ulteriore spiegazione chiarificante. Sono state in seguito riportate debolezze sia nel codice dell'SHA-0 sia in quello dell'SHA-1. L'SHA-1 pare offrire maggiore resistenza agli attacchi, a supporto dell'asserzione dell'NSA che il cambiamento aumentò la sicurezza.
L'SHA-1 (così come l'SHA-0) produce un ''digest'' di 160 bit da un messaggio con una lunghezza massima di 2<sup>64</sup>-1 bit, essendo fondato sulla schema di Merkel-Damgard si basa su principi simili a quelli usati da [[Ronald Rivest|Ronald L. Rivest]] del [[Massachusetts Institute of Technology|MIT]] nel ''design'' degli algoritmi [[MD4]] e [[MD5]].
=== Funzionamento ===
''Passo 1'' (Imbottitura): Al messaggio originale vengono aggiunti dei bit di "imbottitura" affinché la lunghezza finale del messaggio risulti congruente a 448 modulo 512, così facendo la lunghezza in bit di "messaggio+imbottitura" divisa per 512 darà resto 448.
''Passo 2'' (Aggiunta lunghezza): Alla sequenza di
''Passo 3'' (Inizializzazione del buffer MD): Un buffer di
# A = 67452301
# B = EFCDAB89
Line 27 ⟶ 28:
''Passo 4'' (Elaborazione dei blocchi da 512bit): La sequenza di bit "messaggio+imbottitura+lunghezzaMessaggio" viene divisa in blocchi da 512bit, che identificheremo con B<sub>n</sub> con n che va da 0 a L.
Il fulcro dell'algoritmo SHA-1 è chiamato ''compression function'' ed è formato da 4 cicli di 20 passi cadauno. I cicli hanno una struttura molto simile tra di loro se non per il fatto che utilizzano una differente funzione logica primitiva. Ogni blocco viene preso come parametro di input da tutti e 4 i cicli insieme ad una costante K e i valori dei 5 registri. Alla fine della computazione otterremo dei nuovi valori per A,B,C,D,E che useremo per la computazione del blocco successivo sino ad arrivare al blocco finale
== L'insieme SHA-2 ==
[[
Nel [[2001]] il NIST pubblicò quattro funzioni di ''hash'' addizionali facenti parte della famiglia SHA, ognuna con un ''digest'' più lungo di quello originale, collettivamente denominate '''SHA-2''' (anche se questo termine non è mai stato ufficialmente standardizzato). Queste varianti sono note, come detto, con la lunghezza in bit del ''digest'' generato a seguire la sigla ufficiale dell<nowiki>'</nowiki>''hash'': '''SHA-224''', '''SHA-256''',
Tutte queste varianti sono brevettate dal governo
Gli algoritmi SHA-256 e SHA-512 lavorano, rispettivamente, con [[word]] di 32 e 64 bit
Gli algoritmi SHA-2 non hanno ricevuto, a differenza dell'SHA-1, molta attenzione dalla comunità dei crittoanalisti per cui la loro sicurezza in campo crittografico non è stata del tutto provata. Gilbert e Handschuh ([[2003]]) hanno studiato queste nuove varianti e non hanno trovato vulnerabilità
== SHA-3
{{Vedi anche|SHA-3}}
La [[Competizione NIST per funzioni hash|competizione]] che ha portato al rilascio del nuovo standard '''SHA-3''' è stata ufficialmente lanciata il 2 novembre [[2007]]<ref name=autogenerato1 />. Il 2 ottobre 2012 la [[National Institute of Standards and Technology|NIST]] ha proclamato come vincitore l'algoritmo di [[Keccak]] [[SHA-3]].
== Comparazione delle funzioni SHA ==
Nella tabella sottostante sono riportate le caratteristiche principali degli algoritmi della famiglia SHA (Per ''Stato interno'' si intende la somma interna dopo ogni compressione di un blocco di dati).
{| border=1 class="wikitable"
! colspan="2" | Algoritmo e
!Dimensione dell'output (bit)
!Dimensione dello stato interno (bit)
Line 56 ⟶ 58:
!Collisioni trovate
|- align="center"
| colspan="2" | '''SHA-0''' || 160 || 160 || 512 || 2<sup>64</sup>
|- align="center"
| colspan="2" | '''SHA-1''' || 160 || 160 || 512 || 2<sup>64</sup> − 1 || 32 || 80 || +,and,or,xor, rotl || Attacco 2<sup>53</sup><ref>{{Cita web |url=https://www.debian-administration.org/users/dkg/weblog/48 |titolo=Weblog for dkg - HOWTO prep for migration off of SHA-1 in OpenPGP<!-- Titolo generato automaticamente --> |accesso=4 maggio 2019 |dataarchivio=3 maggio 2019 |urlarchivio=https://web.archive.org/web/20190503073509/https://debian-administration.org/users/dkg/weblog/48 |urlmorto=sì }}</ref>
|- align="center"
| rowspan="2" | '''SHA-
|- align="center"
| ''SHA-512/384'' || 512/384 || 512 || 1024 || 2<sup>128</sup> − 1 || 64 || 80 || +,and,or,xor,shr, rotr || Nessuna
|}
== Applicazioni ==
SHA-1 è l'algoritmo più utilizzato della famiglia SHA. Costituisce la base di numerose applicazioni e protocolli, inclusi il [[Transport Layer Security|TLS ed SSL]], il [[Pretty Good Privacy|PGP]], l'[[Secure Shell|SSH]], l'[[S/MIME]] e l'[[IPsec]]. L'SHA-1 è anche utilizzato in sistemi di [[controllo versione]], come il [[Git (software)|Git]], per identificare la revisione dei software e come somma di controllo per verificare l'integrità di file di grosse dimensioni in cataloghi online.
Gli algoritmi SHA sono anche utilizzati negli algoritmi per la [[firma digitale]] dei documenti, quali ad esempio l'[[HMAC]], e sono stati presi come base per i [[cifrario a blocchi|cifrari a blocchi]] [[SHACAL]].
== Esempi e pseudocodice ==
=== Hash di esempio ===
Questo è un esempio di ''digest'' generato dall'SHA-1 (tutti i messaggi sono codificati in [[ASCII]]):
SHA1("Cantami o diva del pelide Achille l'ira funesta")
= 1f8a690b7366a2323e2d5b045120da7e93896f47
Anche una minima variazione nel messaggio genera, ineluttabilmente, un ''hash'' completamente differente a causa di una [[reazione a catena]] nota come ''effetto valanga''. Ad esempio, sostituendo <code>
SHA1("C'''o'''ntami o diva del pelide Achille l'ira funesta")
= e5f08d98bf18385e2f26b904cad23c734d530ffb
Il ''digest'' corrispondente alla stringa
SHA1("")
= da39a3ee5e6b4b0d3255bfef95601890afd80709
=== Pseudocodice
[[Pseudocodice]] dell'algoritmo SHA-1:
<span style="color: green;">''Note: All variables are unsigned 32 bits and wrap modulo 2<sup>32</sup> when calculating''</span>
<span style="color: green;">''Initialize variables:''</span>
h0 = 0x67452301
Line 99 ⟶ 100:
h3 = 0x10325476
h4 = 0xC3D2E1F0
<span style="color: green;">''Pre-processing:''</span>
append the bit '1' to the message
Line 105 ⟶ 106:
length (in ''bits'') is [[aritmetica modulare|congruent]] to 448 (mod 512)
append length of message (before pre-processing), in ''bits'', as 64-bit [[Endianness|big-endian]] integer
<span style="color: green;">''Process the message in successive 512-bit chunks:''</span>
break message into 512-bit chunks
'''for''' each chunk
break chunk into sixteen 32-bit big-endian words w[i], 0 <= i <= 15
<span style="color: green;">''Extend the sixteen 32-bit words into eighty 32-bit words:''</span>
'''for''' i '''from''' 16 to 79
w
<span style="color: green;">''Initialize hash value for this chunk:''</span>
a = h0
Line 121 ⟶ 122:
d = h3
e = h4
<span style="color: green;">''Main loop:''</span>
'''for''' i '''from''' 0 to 79
Line 136 ⟶ 137:
f = b '''xor''' c '''xor''' d
k = 0xCA62C1D6
temp = (a '''leftrotate''' 5) + f + e + k + w[i]
e = d
Line 143 ⟶ 144:
b = a
a = temp
<span style="color: green;">''Add this chunk's hash to result so far:''</span>
h0 = h0 + a
h1 = h1 + b
h2 = h2 + c
h3 = h3 + d
h4 = h4 + e
<span style="color:green;">''Produce the final hash value (big-endian):''</span>
digest = hash = h0 '''append''' h1 '''append''' h2 '''append''' h3 '''append''' h4
Line 165 ⟶ 166:
(40 ≤ i ≤ 59): f = (b '''and''' c) '''xor''' (b '''and''' d) '''xor''' (c '''and''' d) <span style="color: green;">''(alternative 4)''</span>
=== Pseudocodice
Pseudocode dell'algoritmo SHA-256. Notare l'incremento nel mescolamento dei bit delle word <code>w[16..63]</code> rispetto all'SHA-1.
<span style="color: green;">''Note: All variables are unsigned 32 bits and wrap modulo 2<sup>32</sup> when calculating''</span>
<span style="color:green;">''Initialize variables''</span>
<span style="color:green;">(first 32 bits of the <em>fractional parts</em> of the square roots of the first 8 primes 2..19):</span>
h0 := 0x6a09e667
h1 := 0xbb67ae85
Line 180 ⟶ 181:
h6 := 0x1f83d9ab
h7 := 0x5be0cd19
<span style="color:green;">''Initialize table of round constants''</span>
<span style="color:green;">(first 32 bits of the
k[0..63] :=
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
Line 192 ⟶ 193:
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
<span style="color:green;">''Pre-processing:''</span>
append the bit '1' to the message
Line 198 ⟶ 199:
length (in ''bits'') is [[aritmetica modulare|congruent]] to 448 (mod 512)
append length of message (before pre-processing), in ''bits'', as 64-bit big-endian integer
<span style="color:green;">''Process the message in successive 512-bit chunks:''</span>
break message into 512-bit chunks
'''for''' each chunk
break chunk into sixteen 32-bit big-endian words w[0..15]
<span style="color:green;">''Extend the sixteen 32-bit words into sixty-four 32-bit words:''</span>
'''for''' i '''from''' 16 to 63
Line 209 ⟶ 210:
s1 := (w[i-2] '''rightrotate''' 17) '''xor''' (w[i-2] '''rightrotate''' 19) '''xor''' (w[i-2] '''rightshift''' 10)
w[i] := w[i-16] '''+''' s0 '''+''' w[i-7] '''+''' s1
<span style="color:green;">''Initialize hash value for this chunk:''</span>
a := h0
Line 219 ⟶ 220:
g := h6
h := h7
<span style="color:green;">''Main loop:''</span>
'''for''' i '''from''' 0 to 63
Line 228 ⟶ 229:
ch := (e '''and''' f) '''xor''' (('''not''' e) '''and''' g)
t1 := h + s1 + ch + k[i] + w[i]
h := g
g := f
Line 237 ⟶ 238:
b := a
a := t1 + t2
<span style="color:green;">''Add this chunk's hash to result so far:''</span>
h0 := h0 + a
h1 := h1 + b
h2 := h2 + c
h3 := h3 + d
h4 := h4 + e
h5 := h5 + f
h6 := h6 + g
h7 := h7 + h
<span style="color:green;">''Produce the final hash value (big-endian):''</span>
digest = hash = h0 '''append''' h1 '''append''' h2 '''append''' h3 '''append''' h4 '''append''' h5 '''append''' h6 '''append''' h7
Line 261 ⟶ 262:
* sono eseguiti 80 passaggi invece di 64,
* i valori iniziali e le costanti da addizionare sono estesi a 64 bit e
* le quantità delle rotazioni (''rotate'') e degli spostamenti (''shift'') sono differenti.
L'SHA-384 è identico all'SHA-512 tranne che:
Line 267 ⟶ 268:
* l'output è costruito omettendo <code>h6</code> e <code>h7</code>.
== Note ==
<references/>
==
* Florent Chabaud, Antoine Joux: Differential Collisions in SHA-0. [[CRYPTO]] 1998. pp56–71
* [[Eli Biham]], Rafi Chen, Near-Collisions of SHA-0, Cryptology ePrint Archive, Report 2004/146, 2004 (appeared on CRYPTO 2004) [https://eprint.iacr.org/2004/146/]
* Joux, Carribault, Lemuet, Jalby: Collision for the full SHA-0 algorithm, CRYPTO 2004 [https://www.mail-archive.com/cryptography@metzdowd.com/msg02554.html]
* [[Xiaoyun Wang]], Hongbo Yu and Yiqun Lisa Yin, Efficient Collision Search Attacks on SHA-0, CRYPTO 2005 [https://web.archive.org/web/20070925185053/http://www.infosec.sdu.edu.cn/paper/Efficient%20Collision%20Search%20Attacks%20on%20SHA-0.pdf]
* [[Xiaoyun Wang]], Yiqun Lisa Yin and Hongbo Yu, Finding Collisions in the Full SHA-1, CRYPTO 2005 [https://web.archive.org/web/20070925185047/http://www.infosec.sdu.edu.cn/paper/sha1-crypto-auth-new-2-yao.pdf]
* [[Henri Gilbert]], [[Helena Handschuh]]: Security Analysis of SHA-256 and Sisters. [[Selected Areas in Cryptography]] 2003: pp175–193
* {{Cita pubblicazione|titolo=Proposed Revision of Federal Information Processing Standard (FIPS) 180, Secure Hash Standard|rivista=Federal Register|data=11 luglio 1994|nome=|cognome=|volume=59|numero=131|pp=35317-35318|url=http://frwebgate1.access.gpo.gov/cgi-bin/waisgate.cgi?WAISdocID=5963452267+0+0+0&WAISaction=retrieve|accesso=26 aprile 2007|urlmorto=sì}}
== Voci correlate ==
* [[Funzione di hash]]
* [[SHA-3]]
== Collegamenti esterni ==
* {{FOLDOC}}
=== Siti Internet per il calcolo degli hash ===
* [http://www.hashemall.com Hash'em all!]
* [https://www.web4human.it/utility/online-SHA1-encrypt Web4Human] — Hashing online con algoritmi SHA1, SHA224, SHA256 e SHA512
* https://web.archive.org/web/20071216092901/http://www.johnmaguire.us/tools/hashcalc/index.php – Consente l'encoding di stringhe di lunghezza nulla
* [https://web.archive.org/web/20090422125354/http://www.sha1-lookup.com/ SHA-1 Lookup] – Database with several millions SHA-1 hashes. Implemented as an online reverse search.
* {{cita web | 1 = http://www.hash.spugesoft.com | 2 = Simple hash calculator | accesso = 5 maggio 2019 | urlarchivio = https://web.archive.org/web/20120628110601/http://www.hash.spugesoft.com/ | dataarchivio = 28 giugno 2012 | urlmorto = sì }}
* [https://web.archive.org/web/20160804151123/http://www.sha1-file.com/ SHA-1 Text file line per line] – Allows to sha1-hash every line of a text file.
=== Standard: SHA-0, SHA-1, SHA-2, SHA-3... ===
* [https://web.archive.org/web/20070929104512/http://www.eff.org/Privacy/Digital_signature/?f=fips_sha_shs.standard.txt Specifications for a Secure Hash Standard (SHS)]
* [https://web.archive.org/web/20070929104954/http://www.eff.org/Privacy/Digital_signature/?f=fips_sha_shs.info.txt Secure Hash Standard (SHS)]
* RFC 3174, “US Secure Hash Algorithm 1 (SHA-1)”
* RFC 4634, “US Secure Hash Algorithms (SHA and HMAC-SHA)”
* [https://web.archive.org/web/20070113064108/http://csrc.nist.gov/CryptoToolkit/tkhash.html CSRC Cryptographic Toolkit]
** [http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf FIPS 180-2: Secure Hash Standard (SHS)] {{Webarchive|url=https://web.archive.org/web/20120312101511/http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf |date=12 marzo 2012 }} ([[Portable Document Format|PDF]], 236 kB)
** [
* [https://web.archive.org/web/20100505162618/http://csrc.nist.gov/groups/ST/hash/index.html NIST Cryptographic Hash Project] SHA-3 competition
=== Crittoanalisi ===
*
*
* [http://www.heise-security.co.uk/articles/75686 Explanation of the successful attacks on SHA-1] (3 pages, 2006)
=== Implementazioni ===
* [
* [
* [
=== Tutorial e codici d'esempio ===
* [[Wikia:Code:SHA checksum|Comparazione della funzione SHA in differenti linguaggi]]
* [http://www.packetizer.com/security/sha1/ Implementazioni in C e C++ dell'SHA-1, inclusi binari per Win32 e Linux] di Paul E. Jones (RFC Co-Author)
* [https://web.archive.org/web/20080118135855/http://fp.gladman.plus.com/cryptography_technology/sha/index.htm Implementazione in C dell'SHA] di Brian Gladman
* [http://www.tayloredge.com/utilities/vbapps/SHA1_VBSource.txt Implementazione in Visual Basic dell'SHA-1] di John Taylor
* [http://www.movable-type.co.uk/scripts/sha1.html Implementazione in JavaScript dell'SHA-1] di Chris Veness
* {{cita web|http://cryptojs.altervista.org/hash.html|Implementazione in JavaScript delle funzioni di HASH (md4, md5, sha-1, sha-2)}}
=== Vettori di test ===
The [[NESSIE]] project [https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/index.html test vectors] for [https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/Sha-1-160.test-vectors SHA-1], [https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/Sha-2-256.unverified.test-vectors SHA-256], [https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/Sha-2-384.unverified.test-vectors SHA-384], and [https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/Sha-2-512.unverified.test-vectors SHA-512].
{{Hash e MAC}}
{{Portale|crittografia|Sicurezza informatica}}
[[Categoria:Hash crittografici]]
| |||