|
Con il termine '''SHA''' si indica una famiglia di cinque diverse funzioni [[crittografia|crittografiche]] di [[hash]] sviluppate a partire dal [[1993]] dalla [[National Security Agency]] (NSA) e pubblicate dal [[National Institute of Standards and Technology|NIST]] come [[Federal Information Processing Standard|standard federale]] dal governo degli [[Stati Uniti d'America|USA]]. La sigla SHA sta per '''Secure Hash Algorithm'''.
[[Categoria:Algoritmi]]{{t|lingua=inglese|argomento=matematica}}
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 di non sia reversibile (non sia cioè possibile risalire al messaggio originale conoscendo solo questo dato) e che 2 messaggi diversi non devono mai fornire lo stesso ''digest''. Gli algoritmi della famiglia sono denominati '''SHA-1''', '''SHA-224''', '''SHA-256''', '''SHA-384''' e '''SHA-512''': le ultime 4 varianti sono spesso indicate genericamente come '''SHA-2''', per distinguerle dal primo. Quest'ultimo produce un ''digest'' del messaggio di soli 160 [[bit]], mentre gli altri producono ''digest'' di lunghezza in bit pari al numero indicato nella loro sigla (SHA-256 produce un ''digest'' di 256 bit). L'SHA-1 è il più diffuso algoritmo della famiglia SHA ed è utilizzato in numerose applicazioni e protocolli.
Gli '''Algoritmi SHA''' sono cinque [[funzioni crittografiche di hash]] sviluppate dalla [[National Security Agency]] (NSA) e pubblicate dal [[National Institute of Standards and Technology|NIST]] come un [[Federal Information Processing Standard]] degli USA.
SHA sta per '''Secure Hash Algorithm'''. <br/>
Un [[algoritmo di hash]] calcola una rappresentazione digitale di lunghezza fissa (nota come ''message digest'') di una sequenza di dati in ingresso (il ''messaggio'') di lunghezza qualunque. <br/>
Un tale algoritmo è chiamato “sicuro” quando (citando lo standard),
“è computazionalmente impraticabile:
# trovare un messaggio che corrisponda ad un dato ''message digest'', oppure
# trovare due messaggi distinti che producano lo stesso ''message digest''.
Ogni cambiamento del messaggio porterà, con probabilità molto alte, ad un diverso ''message digest''.”
I cinque algoritmi sono chiamati ''SHA-1'', ''SHA-224'', ''SHA-256'', ''SHA-384'', e ''SHA-512''. <br/>
Le ultime quattro varianti sono talvolta chiamate tutte insieme ''SHA-2''. <br/>
SHA-1 produce un ''message digest'' di 160 bits; il numero nel nome delle altre quattro varianti (p.e. '''SHA-''224''''') indica il numero di bit prodotti.
SHA-1 viene impegato in diverse applicazioni e protocolli ampiamente diffusi, inclusi [[Transport Layer Security|TLS and SSL]], [[Pretty Good Privacy|PGP]], [[Secure Shell|SSH]], [[S/MIME]], e [[IPsec]]. Viene considerato il successore di [[MD5]], una funzione di hash molto utilizzata in passato.
La sicurezza di SHA-1 è stata in parte compromessa dai crittoanalisti. <ref>http://www.schneier.com/blog/archives/2005/02/cryptanalysis_o.html</ref> Sebbene non siano ancora noti attacchi alle varianti SHA-2, esse hanno un algoritmo simile a quello di SHA-1 per cui sono in atto sforzi per sviluppare algoritmi di hashing alternativi e migliorati.<ref>http://www.schneier.com/blog/archives/2005/11/nist_hash_works_4.html</ref><ref>http://www.heise-security.co.uk/articles/75686/2</ref>
Un concorso aperto per la realizzazione di una nuova funzione SHA-3 è stato formalmente annunciato nel ''[[Federal Register]]'' il 2 novembre 2007.<ref>http://csrc.nist.gov/groups/ST/hash/documents/FR_Notice_Nov07.pdf</ref> "La NIST sta avviando un concorso per lo sviluppo di uno o più algoritmi di hashing aggiuntivi attraverso una competizione pubblica, come per il [[Advanced Encryption Standard process|processo di sviluppo]] dell' [[Advanced Encryption Standard]] (AES)."<ref>http://www.csrc.nist.gov/pki/HashWorkshop/index.html</ref> Le iscrizioni si concluderanno il 31 ottobre 2008 e la proclamazione del vincitore e la pubblicazione del nuovo standard sono previste per il 2012.
La sicurezza di SHA-1 è stata in parte compromessa dai crittoanalisti. <ref>[http://www.schneier.com/blog/archives/2005/02/cryptanalysis_o.html Crittoanalisi dell'SHA-1 (Schneier)]</ref> Sebbene non siano ancora noti attacchi alle varianti SHA-2, esse hanno un algoritmo simile a quello di SHA-1 per cui sono in atto sforzi per sviluppare algoritmi di hashing alternativi e migliorati.<ref>[http://www.schneier.com/blog/archives/2005/11/nist_hash_works_4.html</ref><ref>http://www.heise-security.co.uk/articles/75686/2</ref>
Un concorso aperto per la realizzazione di una nuova funzione '''SHA-3''' è stato formalmente annunciato nel ''Federal Register'' il 2 novembre 2007.<ref>http://csrc.nist.gov/groups/ST/hash/documents/FR_Notice_Nov07.pdf</ref> "Il NIST sta avviando un concorso per lo sviluppo di uno o più algoritmi di hashing aggiuntivi attraverso una competizione pubblica, come per il processo di sviluppo dell'[[Advanced Encryption Standard|AES]]."<ref>http://www.csrc.nist.gov/pki/HashWorkshop/index.html</ref> Le iscrizioni si concluderanno il 31 ottobre 2008 e la proclamazione del vincitore e la pubblicazione del nuovo standard sono previste per il 2012.
==SHA-0 e SHA-1==
[[Immagine:SHA-1.svg|thumbnail|right|300px|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; [[Immagine:lll.png|left shift]]<sub>''n''</sub> denota una rotazione del bit di sinistra di ''n'' posti; ''n'' varia per ogni operazione. [[Immagine:Boxplus.png|Addition]] denota l'addizione modulo 2<sup>32</sup>. K<sub>t</sub> è una costante.]]
</div>
[[Immagine:SHA-1.svg|thumbnail|right|300px|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 e' una funzione nonlineare che varia; [[Immagine:lll.png|left shift]]<sub>''n''</sub> denota una rotazione del bit di sinistra di ''n'' posti; ''n'' varia per ogni operazione. [[Immagine:Boxplus.png|Addition]] denota l' addizione modulo-2<sup>32</sup>. K<sub>t</sub> e' una costante.]]
La specifica originale dell' algoritmo fu pubblicata nel 1993 come ''Secure Hash Standard'', [[Federal Information Processing Standard|FIPS]] PUB 180, dall' agenzia governativa USA per gli standarddal [[NIST]] (National Institute of Standards and Technology). Ci si riferisce spesso a questa versione come '''SHA-0''' per distinguerla dalle successive versioni. Fu ritirata dall' [[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 da dall'SHA-0 solamenteunicamente per una sola rotazione di bit nel processo di preparazione del messaggio della sua funzione di compressione ad una via; cio'ciò fu fatto, secondo l' NSA, per correggere un difetto nell' algoritmo originale, il quale ridusseriduceva la sicurezza crittografica di SHA-0. Ad ogni modo, l' NSA non forni'fornì nessuna ulteriore spiegazione chiarificante. Sono state in seguito riportate debolezze sia innel codice dell'SHA-0 sia in quello dell'SHA-1. L'SHA-1 appare offrire maggiore resistenza agli attacchi, a supporto dell' asserzione dell' NSA che il cambiamento aumento'aumentò la sicurezza.
L'SHA-1 (cosi'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 ed e'è basato su principi simili a quelli usati da [[Ron Rivest|Ronald L. Rivest]] del [[Massachusetts Institute of Technology|MIT]] nel ''design'' degli algoritmi [[MD4]] ande [[MD5]].
==L'insieme SHA-2==
<!--
[[Immagine:SHA-2.svg|thumbnail|right|400px|Una iterazione della funzione di compressione negli algoritmi della famiglia SHA-2.]]
==Cryptanalysis==
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'hash: '''SHA-224''', '''SHA-256''', ''''SHA-384''' e '''SHA-512''', con, rispettivamente, hash di 224, 256, 384 e 512 bit. Da notare che gli ultimi tre algoritmi furono ufficializzati come standard nel [[2002]] mentre l'SHA-224 fu introdotto nel febbraio del [[2004]]: quest'ultimo presenta un hash di lunghezza identica a quella di 2 chiavi del [[Triple DES]].
For an ideal hash function, violating the first criterion listed above, finding a message that corresponds to a given message digest, can always be done using a brute force search in 2<sup>''L''</sup> evaluations, where ''L'' is the number of bits in the message digest. This is called a [[preimage attack]]. The second criterion, finding two different messages that produce the same message digest, known as a ''collision,'' requires only 2<sup>''L''/2</sup> evaluations using a [[birthday attack]]. For the latter reason the strength of a hash function is usually compared to a symmetric cipher of half the message digest length. Thus SHA-1 was originally considered to have 80-bit strength.
Tutte queste varianti sono brevettate dal governo americano ma rilasciate con licenza libera.<ref>{{cite journal |title=Licensing Declaration for US patent 6829355.|url=https://datatracker.ietf.org/ipr/858/|accessdate=2008-02-17}}</ref>.
Cryptographers have produced collision pairs for SHA-0 and have found algorithms that should produce SHA-1 collisions in far fewer than the intended 2<sup>80</sup> evaluations.
Gli algoritmi SHA-256 e SHA-512 lavorano, rispettivamente, con [[word]] di 32 e 64 bit rispettivamente: utilizzano un numero differente di rotazioni e di costanti addizionali ma la loro struttura è sostanzialmente identica. Gli algoritmi SHA-224 e SHA-384 sono semplicemente versioni troncate dei precedenti due, con hash calcolati con differenti valori iniziali.
In terms of practical security, a major concern about these new attacks is that they might pave the way to more efficient ones. Whether this is the case has yet to be seen, but a migration to stronger hashes is believed to be prudent. Some of the applications that use cryptographic hashes, such as password storage, are only minimally affected by a collision attack. Constructing a password that works for a given account requires a preimage attack, and access to the hash of the original password (typically in the ''shadow'' file) which may or may not be trivial. Reversing password encryption (e.g. to obtain a password to try against a user's account elsewhere) is not made possible by the attacks.
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à <ref>{{cite journal |title=Security analysis of SHA-256 and sisters |author=Henri Gilbert |coauthors=Helena Handschuh |journal=Lecture notes in computer science |publisher=Springer, Berlin |issn=0302-9743 |url=http://cat.inist.fr/?aModele=afficheN&cpsidt=15735289 |format=fee required |accessdate=2008-01-30}}</ref>.
In the case of document signing, an attacker could not simply fake a signature from an existing document—the attacker would have to produce a pair of documents, one innocuous and one damaging, and get the private key holder to sign the innocuous document. There are practical circumstances where this is possible.
==SHA-3 (in sviluppo)==
La competizione che porterà al rilascio del nuovo standard '''SHA-3''' è stata ufficialmente lancianta il 2 novembre [[2007]]<ref>http://csrc.nist.gov/groups/ST/hash/documents/FR_Notice_Nov07.pdf</ref>. Gli algoritmi potranno essere inviati fino al 31 ottobre 2008 e porteranno alla selezione dell'algoritmo nel [[2012]].
==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 <br />variante
!Dimensione dell'output (bit)
===Cryptanalysis of SHA-0===
!Dimensione dello stato interno (bit)
At [[CRYPTO (conference)|CRYPTO]] 98, two French researchers, [[Florent Chabaud]] and [[Antoine Joux]], presented an attack on SHA-0 ([http://fchabaud.free.fr/English/Publications/sha.pdf Chabaud and Joux, 1998]): [[hash collision|collisions]] can be found with complexity 2<sup>61</sup>, fewer than the 2<sup>80</sup> for an ideal hash function of the same size.
!Dimensione del blocco (bit)
!Max. dimensione del messaggio (bit)
In 2004, [[Eli Biham|Biham]] and Chen found near-collisions for SHA-0 — two messages that hash to nearly the same value; in this case, 142 out of the 160 bits are equal. They also found full collisions of SHA-0 reduced to 62 out of its 80 rounds.
!Dimensione della ''word'' (bit)
!Passaggi
Subsequently, on [[12 August]] [[2004]], a collision for the full SHA-0 algorithm was announced by Joux, Carribault, Lemuet, and Jalby. This was done by using a generalization of the Chabaud and Joux attack. Finding the collision had complexity 2<sup>51</sup> and took about 80,000 CPU hours on a [[supercomputer]] with 256 [[Itanium 2]] processors.
!Operazioni
!Collisioni trovate
On [[17 August]] [[2004]], at the Rump Session of CRYPTO 2004, preliminary results were announced by [[Xiaoyun Wang|Wang]], Feng, Lai, and Yu, about an attack on [[MD5]], SHA-0 and other hash functions. The complexity of their attack on SHA-0 is 2<sup>40</sup>, significantly better than the attack by Joux ''et al.'' <ref>http://www.freedom-to-tinker.com/archives/000664.html</ref><ref>http://groups.google.com/groups?selm=fgrieu-05A994.05060218082004%40individual.net</ref>
In February 2005, an attack by Xiaoyun Wang, Yiqun Lisa Yin, and Hongbo Yu was announced which could find collisions in SHA-0 in 2<sup>39</sup> operations.<ref>http://www.schneier.com/blog/archives/2005/02/sha1_broken.html</ref><ref>http://www.infosec.sdu.edu.cn/paper/sha0-crypto-author-new.pdf</ref>
===Cryptanalysis of SHA-1===
In light of the results on SHA-0, some experts suggested that plans for the use of SHA-1 in new [[cryptosystem]]s should be reconsidered. After the CRYPTO 2004 results were published, NIST announced that they planned to phase out the use of SHA-1 by 2010 in favor of the SHA-2 variants.<ref>http://csrc.nist.gov/hash_standards_comments.pdf</ref>
In early 2005, [[Vincent Rijmen|Rijmen]] and [[Elisabeth Oswald|Oswald]] published an attack on a reduced version of SHA-1 — 53 out of 80 rounds — which finds collisions with a complexity of fewer than 2<sup>80</sup> operations.<ref>http://eprint.iacr.org/2005/010</ref>
In February 2005, an attack by [[Xiaoyun Wang]], [[Yiqun Lisa Yin]], and [[Hongbo Yu]] was announced.<ref>http://www.schneier.com/blog/archives/2005/02/sha1_broken.html</ref> The attacks can find collisions in the full version of SHA-1, requiring fewer than 2<sup>69</sup> operations. (A [[brute-force search]] would require 2<sup>80</sup> operations.)
The authors write:
"In particular, our analysis is built upon the original differential attack on SHA0 [''sic''], the near collision attack on SHA0, the multiblock collision techniques, as well as the message modification techniques used in the collision search attack on MD5. Breaking SHA1 would not be possible without these powerful analytical techniques."<ref>http://theory.csail.mit.edu/~yiqun/shanote.pdf</ref>. The authors have presented a collision for 58-round SHA-1, found with 2<sup>33</sup> hash operations.
The paper with the full attack description was published in August 2005 at the CRYPTO conference.
In an interview, Yin states that, "Roughly, we exploit the following two weaknesses: One is that the file preprocessing step is not complicated enough; another is that certain math operations in the first 20 rounds have unexpected security problems."<ref>http://news.zdnet.com/2100-1009_22-5598536.html</ref>
On [[17 August]] [[2005]], an improvement on the SHA-1 attack was announced on behalf of Xiaoyun Wang, Andrew Yao and Frances Yao at the CRYPTO 2005 rump session, lowering the complexity required for finding a collision in SHA-1 to 2<sup>63</sup>.<ref>http://www.schneier.com/blog/archives/2005/08/new_cryptanalyt.html</ref>
Christophe De Cannière and Christian Rechberger further improved the attack on SHA-1 in "Finding SHA-1 Characteristics: General Results and Applications,"<ref>http://dx.doi.org/10.1007/11935230_1</ref> receiving the Best Paper Award at [[ASIACRYPT]] [[2006]]. A two-block collision for 64-round SHA-1 was presented, found using unoptimized methods with 2<sup>35</sup> compression function evaluations.
As this attack requires the equivalent of about 2<sup>35</sup> evaluations, it is considered to be a theoretical break.<ref>http://www.iaik.tugraz.at/research/krypto/collision/SHA1Collision_Description.php</ref> To find an actual collision, however, a massive distributed computing effort or very large parallel supercomputer such as those possessed by the [[NSA]] would be required. To that end, a collision search for SHA-1 using the distributed computing platform [[BOINC]] is currently being made.<ref>http://boinc.iaik.tugraz.at/sha1_coll_search/</ref>
At the Rump Session of CRYPTO 2006, Christian Rechberger and Christophe De Cannière claimed to have discovered a collision attack on SHA-1 that would allow an attacker to select at least parts of the message.<ref>http://www.heise-security.co.uk/news/77244</ref><ref>http://www.iacr.org/conferences/crypto2006/rumpsched.html</ref>
==SHA-2==
[[Immagine:SHA-2.svg|thumbnail|right|400px|A round of the SHA-2]]
NIST has published four additional hash functions in the SHA family, each with longer digests, collectively known as SHA-2. The individual variants are named after their digest lengths (in bits): SHA-224, SHA-256, SHA-384, and SHA-512. The latter three were first published in 2001 in the draft FIPS PUB 180-2, at which time review and comment were accepted. FIPS PUB 180-2, which also includes SHA-1, was released as an official standard in 2002. In February 2004, a change notice was published for FIPS PUB 180-2, specifying an additional variant, SHA-224, defined to match the key length of two-key [[Triple DES]]. These variants are patented in {{cite patent|US|6829355}}.
SHA-256 and SHA-512 are novel hash functions computed with 32- and 64-bit words, respectively. They use different shift amounts and additive constants, but their structures are otherwise virtually identical, differing only in the number of rounds. SHA-224 and SHA-384 are simply truncated versions of the first two, computed with different initial values.
These new hash functions have not received as much scrutiny by the public cryptographic community as SHA-1 has, and so their cryptographic security is not yet as well-established. Gilbert and Handschuh (2003) have studied the newer variants and found no weaknesses.{{Fact|date=December 2007}}
== SHA sizes ==
In the table below, ''internal state'' means the “internal hash sum” after each compression of a data block; see [[Merkle-Damgård hash function|Merkle-Damgård construction]] for more details.
{| class="wikitable"
!Algorithm
!Output size (bits)
!Internal state size (bits)
!Block size (bits)
!Max message size (bits)
!Word size (bits)
!Rounds
!Operations
![[Hash collision|Collision]]
|- align="center"
| colspan="2" | '''SHA-0''' || 160 || 160 || 512 || 2<sup>64</sup> − 1 || 32 || 80 || +,and,or,xor,rotflrotl || YesSì
|- align="center"
| colspan="2" | '''SHA-1''' || 160 || 160 || 512 || 2<sup>64</sup> − 1 || 32 || 80 || +,and,or,xor,rotflrotl || Attacco 2<sup>63</sup> attack
|- align="center"
| rowspan="2" | '''SHA-2''' || ''SHA-256/224''' || 256/224 || 256 || 512 || 2<sup>64</sup> − 1 || 32 || 64 || +,and,or,xor,shr,rotfrrotr || None yetNessuna
|- align="center"
| '''SHA-512/384''' || 512/384 || 512 || 1024 || 2<sup>128</sup> − 1 || 64 || 80 || +,and,or,xor,shr,rotfrrotr || None yetNessuna
|}
==Applications==
{{details|Cryptographic hash function#Applications}}
SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512 are the secure hash algorithms required by law for use in certain U. S. Government applications, including use within other cryptographic algorithms and protocols, for the protection of sensitive unclassified information. FIPS PUB 180-1 also encouraged adoption and use of SHA-1 by private and commercial organizations.
A prime motivation for the publication of the Secure Hash Algorithm was the [[Digital Signature Algorithm|Digital Signature Standard]], in which it is incorporated.
The SHA hash functions have been used as the basis for the [[SHACAL]] [[block cipher]]s.
==Example hashes==
{{main|Examples of SHA digests}}
The following is an example of SHA-1 digests. [[ASCII]] encoding is assumed for all messages.
SHA1("[[The quick brown fox jumps over the lazy dog]]")
= 2fd4e1c6 7a2d28fc ed849ee1 bb76e739 1b93eb12
Even a small change in the message will, with overwhelming probability, result in a completely different hash due to the [[avalanche effect]]. For example, changing <code>dog</code> to <code>cog</code>:
SHA1("The quick brown fox jumps over the lazy '''c'''og")
= de9f2c7f d25e1b3a fad3e85a 0bd17d9b 100db4b3
Other SHA examples can be found in [[examples of SHA digests]]
==Official validation==
{{main|CMVP}}
Implementations of all FIPS-approved security functions can be officially validated through the [[CMVP|CMVP program]], jointly run by the [[National Institute of Standards and Technology]] (NIST) and the [[Communications Security Establishment]] (CSE). For informal verification, a package to generate a high number of test vectors is made available for download on the NIST site; the resulting verification however does not replace in any way the formal CMVP validation, which is required by law for certain applications.
[[as of 2006|As of October 2006]], there are more than 500 validated implementations of SHA-1, with fewer than ten of them capable of handling messages with a length in bits not a multiple of eight (see [http://csrc.nist.gov/cryptval/shs/shaval.htm SHS Validation List]). It is also important to note that some implementations available on the Internet do not digest the NIST validation vectors correctly, although they may correctly process the examples listed in the SHA-1 standard.
==SHA-1 algorithm==
[[Pseudocode]] for the SHA-1 algorithm follows:
<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
h1 = 0xEFCDAB89
h2 = 0x98BADCFE
h3 = 0x10325476
h4 = 0xC3D2E1F0
<span style="color: green;">''Pre-processing:''</span>
append the bit '1' to the message
append k bits '0', where k is the minimum number = 0 such that the resulting message
length (in ''bits'') is [[modular arithmetic|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[i] = (w[i-3] '''xor''' w[i-8] '''xor''' w[i-14] '''xor''' w[i-16]) '''[[Circular shift|leftrotate]]''' 1
<span style="color: green;">''Initialize hash value for this chunk:''</span>
a = h0
b = h1
c = h2
d = h3
e = h4
<span style="color: green;">''Main loop:''</span>
'''for''' i '''from''' 0 to 79
'''if''' 0 = i = 19 '''then'''
f = (b '''and''' c) '''or''' (('''not''' b) '''and''' d)
k = 0x5A827999
'''else if''' 20 = i = 39
f = b '''xor''' c '''xor''' d
k = 0x6ED9EBA1
'''else if''' 40 = i = 59
f = (b '''and''' c) '''or''' (b '''and''' d) '''or''' (c '''and''' d)
k = 0x8F1BBCDC
'''else if''' 60 = i = 79
f = b '''xor''' c '''xor''' d
k = 0xCA62C1D6
temp = (a '''leftrotate''' 5) + f + e + k + w[i]
e = d
d = c
c = b '''leftrotate''' 30
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
Instead of the formulation from the original FIPS PUB 180-1 shown, the following equivalent expressions may be used to compute <code>f</code> in the main loop above:
(0 = i = 19): f = d '''xor''' (b '''and''' (c '''xor''' d)) <span style="color: green;">''(alternative 1)''</span>
(0 = i = 19): f = (b '''and''' c) '''xor''' (('''not''' b) '''and''' d) <span style="color: green;">''(alternative 2)''</span>
(40 = i = 59): f = (b '''and''' c) '''or''' (d '''and''' (b '''or''' c)) <span style="color: green;">''(alternative 1)''</span>
(40 = i = 59): f = (b '''and''' c) '''or''' (d '''and''' (b '''xor''' c)) <span style="color: green;">''(alternative 2)''</span>
(40 = i = 59): f = (b '''and''' c) + (d '''and''' (b '''xor''' c)) <span style="color: green;">''(alternative 3)''</span>
(40 = i = 59): f = (b '''and''' c) '''xor''' (b '''and''' d) '''xor''' (c '''and''' d) <span style="color: green;">''(alternative 4)''</span>
==SHA-2 algorithm==
[[Pseudocode]] for the SHA-256 algorithm follows. Note the great increase in mixing between bits of the <code>w[16..63]</code> words compared to 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
h2 := 0x3c6ef372
h3 := 0xa54ff53a
h4 := 0x510e527f
h5 := 0x9b05688c
h6 := 0x1f83d9ab
h7 := 0x5be0cd19
<span style="color:green;">''Initialize table of round constants''</span>
<span style="color:green;">(first 32 bits of the <em>fractional parts</em> of the cube roots of the first 64 primes 2..311):</span>
k[0..63] :=
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
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
append k bits '0', where k is the minimum number >= 0 such that the resulting message
length (in ''bits'') is [[modular arithmetic|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
s0 := (w[i-15] '''rightrotate''' 7) '''xor''' (w[i-15] '''rightrotate''' 18) '''xor''' (w[i-15] '''rightshift''' 3)
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
b := h1
c := h2
d := h3
e := h4
f := h5
g := h6
h := h7
<span style="color:green;">''Main loop:''</span>
'''for''' i '''from''' 0 to 63
s0 := (a '''rightrotate''' 2) '''xor''' (a '''rightrotate''' 13) '''xor''' (a '''rightrotate''' 22)
maj := (a '''and''' b) '''xor''' (a '''and''' c) '''xor''' (b '''and''' c)
t2 := s0 + maj
s1 := (e '''rightrotate''' 6) '''xor''' (e '''rightrotate''' 11) '''xor''' (e '''rightrotate''' 25)
ch := (e '''and''' f) '''xor''' (('''not''' e) '''and''' g)
t1 := h + s1 + ch + k[i] + w[i]
h := g
g := f
f := e
e := d + t1
d := c
c := b
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
The <code>ch</code> and <code>maj</code> functions can be optimized the same way as described for SHA-1.
SHA-224 is identical to SHA-256, except that:
* the initial variable values <code>h0</code> through <code>h7</code> are different, and
* the output is constructed by omitting <code>h7</code>.
==Applicazioni==
SHA-512 is identical in structure, but:
L'SHA-1 è il più utilizzato algoritmo 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.
* all numbers are 64 bits long,
* there are 80 rounds instead of 64,
* the initial values and additive constants are extended to 64 bits, and
* the shift and rotate amounts used are different.
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 [[cifrari a blocchi]] [[SHACAL]].
SHA-384 is identical to SHA-512, except that:
* the initial values <code>h0</code> through <code>h7</code> are different, and
* the output is constructed by omitting <code>h6</code> and <code>h7</code>.
==Voci correlate==
* [[DigitalHash|Funzion timestampingdi hash]]
* [[Hashcash]]
* [[RIPEMD-160]]
* [[WHIRLPOOL]]
==Note==
==Collegamenti esterni==
<!-- We suffer from a lot of self promotion here. Please do not add a link to you own site. It will be removed, and you may be blocked without further warning. -->
===Siti Internet per il calcolo degli hash===
===Crittoanalisi===
* [http://news.zdnet.com/2100-1009_22-5598536.html InterviewIntervista withcon Yiqun Lisa Yin concerning the attack onsull'attacco all'SHA-1]
* [http://cm.bell-labs.com/who/akl/hash.pdf Lenstra's Summary of impact of the February 2005 cryptanalytic results]
* [http://www.heise-security.co.uk/articles/75686 Explanation of the successful attacks on SHA-1] (3 pages, 2006)
===Implementazioni===
<!-- This section should include only implementations that are commercially or algorithmically significant, such as those widely used in existing technologies and platforms -->
* [http://www.openssl.org/ The OpenSSL Project] – The widely used OpenSSL <code>crypto</code> library includes [[free software|free]], [[open source|open-source]] implementations of SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512
* [http://www.cryptopp.com/ Crypto++] Crypto++, Librarylibreria islibera a freein C++ class library ofcon cryptographicschemi schemes.crittografici
* [http://www.bouncycastle.org/ Bouncy Castle] The Bouncy Castle Library is a free Java and C# class library that contains implementations of the SHA-1, SHA-224, SHA-256, SHA-384 and SHA-512 algorithms as well as other algorithms like [[Whirlpool_%28cryptography%29|Whirlpool]], [[Tiger_%28hash%29|Tiger]], [[RIPEMD]], GOST-3411, [[MD2_%28cryptography%29|MD2]], [[MD4]] and [[MD5]].
===Tutorial e codici d' esempio===
<!-- Moved all implementations by individual programmers to this section and rearranged the entries by last name; I wish this entire section could be deleted, because, although these individuals are to be congratulated for their programming skills, including these links in the main article comes across as more of a case of people showing off their own code rather than as commercially or algorithmically significant implementations that absolutely have to be mentioned in this article -->
* [[Wikia:Code:SHA checksum|Comparison of SHA function in different languages]]
* [http://xyssl.org/code/source/sha1/ A SHA-1 implementation in C] by Christophe Devine
-->
{{Portale|matematica}}
[[Categoria:Hash crittografici]]
[[cs:Secure Hash Algorithm]]
| 