SHA

Introduzione

Gli algoritmi SHA (acronimo di Secure Hash Algorithm) sono stati sviluppati dalla National Security Agency (NSA) e pubblicati dal National Institute of Standards and Technology. Gli algoritmi sono suddivisi in quattro categorie:

  • SHA-0 (obsoleto)
  • SHA-1
  • SHA-2
  • SHA-3 (annunciato)

L'algoritmo SHA-0 venne pubblicato nel documento FIPS PUB 180 nel 1993, e fu ritirato poco dopo la pubblicazione per essere sostituito dall'algoritmo SHA-1, pubblicato nel documento FIPS PUB 180-1 nel 1995 [1]. La sostituzione avvenne a causa di una falla che ne minava la sicurezza. Sia SHA-0 che SHA-1 producono un valore di hash di 160 bit. Successivamente, la nuova versione dello standard chiamata FIPS PUB 180-2 [2 ]e pubblicata nel 2002 ha introdotto la famiglia detta SHA-2, composta inizialmente dalle versioni SHA-256, SHA-384 e SHA-512. L'ultima versione dello standard, FIPS PUB 180-3 del 2008 [3], ha introdotto la versione SHA-224.
La differenza tra le versioni della famiglia SHA-2 è dovuta alla diversa lunghezza in bit del codice hash. Quando il messaggio o il file ha dimensione inferiore a 264 bit si utilizzano gli algoritmi SHA-1, SHA-224 o SHA-256, mentre se ha una dimensione superiore, ma inferiore a 2128 bit, allora si usano gli algoritmi SHA-384 e SHA-512.
La famiglia SHA-3 dovrebbe essere presentata nel 2012 [4] e conterrà le nuove versioni degli algoritmi SHA-224, SHA-256, SHA-384, SHA-512.

SHA-1

Descrizione

L'algoritmo SHA 1 calcola un valore di hash lungo 160 bit suddividendo ed elaborando il messaggio, ovvero una sequenza di bit, in blocchi da 512 bit. Ogni blocco viene convertito in una sequenza di 16 word da 32 bit ed elaborato attraverso una serie di operazioni. L'algoritmo prevede 80 cicli di operazioni da effettuare per ogni blocco.

Padding

Sia L la lunghezza in bit del messaggio, il padding viene effettuato aggiungendo un bit "1" seguito da un certo numero di bit "0", così (10000…0). In seguito viene aggiunto il valore di L espresso in numero binario da 64 bit. Viene richiesto che L non sia più grande di 264 bit. I dati di padding che vengono aggiunti sono tali da rendere la lunghezza del messaggio un multiplo di 512 bit, quindi essendo gli ultimi 64 bit utilizzati per inserire il valore di L, allora la stringa composta dal bit "1" seguito dai bit "0" dovrà essere tale da rendere il messaggio 64 bit inferiore ad un multiplo di 512 bit, quindi la lunghezza della stringa modulo 512 deve essere uguale a 448 (512 - 64 = 448).

Funzioni e operazioni

Addizione

Le addizioni vengono definite modulo 232 , ovvero il risultato viene troncato a 32 bit. In questo modo il risultato non va in overflow e può sempre essere rappresentato da un'altra word da 32 bit. Quindi se a = 0xF351284C e b = 0xD58AB106 la loro somma non sarà 0x1C8DBD952 ma invece 0xC8DBD952.

Rotazione

Le rotazioni a destra e a sinistra effettuate su una word da 32 bit vengono definite a partire dalle operazioni di spostamento, o shift, a destra e a sinistra di una word da 32 bit.

Lo spostamento (shift) a sinistra di n bit di una word a 32 bit comporta uno scorrimento a sinistra dei bit che compongono la word. I bit a destra che restano vuoti vengono sostituiti con bit di valore "0" in questo modo:
Si considera uno spostamento a sinistra di 10 bit
b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 b10 b11 b12 b13 b14 b15 b16 b17 b18 b19 b20 b21 b22 b23 b24 b25 b26 b27 b28 b29 b30 b31

b10 b11 b12 b13 b14 b15 b16 b17 b18 b19 b20 b21 b22 b23 b24 b25 b26 b27 b28 b29 b30 b31 0 0 0 0 0 0 0 0 0 0

Allo stesso modo viene definito uno spostamento a destra di n bit. Considerando sempre n = 10 allora:
b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 b10 b11 b12 b13 b14 b15 b16 b17 b18 b19 b20 b21 b22 b23 b24 b25 b26 b27 b28 b29 b30 b31

0 0 0 0 0 0 0 0 0 0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 b10 b11 b12 b13 b14 b15 b16 b17 b18 b19 b20 b21
Sia W una word e n il numero di bit da spostare. Allora l'operazione di spostamento a sinistra viene indicata con la notazione
W << n
mentre una operazione di spostamento a destra viene indicata in questo modo:
W >> n

La rotazione a destra o a sinistra è simile allo spostamento, ma a differenza di quest'ultima i bit che vengono "persi" sono inseriti al posto dei bit "0" di riempimento. Nella rotazione (detto anche spostamento ciclico - cyclic shift) a sinistra vengono inseriti i primi n bit a destra, mentre nella rotazione a destra vengono inseriti gli ultimi n bit a sinistra:
Rotazione di n=10 bit a sinistra
b10 b11 b12 b13 b14 b15 b16 b17 b18 b19 b20 b21 b22 b23 b24 b25 b26 b27 b28 b29 b30 b31 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9
Rotazione di n=10 bit a destra
b22 b23 b24 b25 b26 b27 b28 b29 b30 b31 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 b10 b11 b12 b13 b14 b15 b16 b17 b18 b19 b20 b21
L'operazione di rotazione a destra e a sinistra viene indicata con la seguente notazione:
W <<< n
W >>> n
e può essere definita convenientemente a partire dalle operazioni di spostamento. Infatti si può pensare che una rotazione di n bit a sinistra sia il risultato di una operazione di or tra la word spostata a sinistra di n bit con la stessa word spostata a destra di 32 - n bit. Allo stesso modo una rotazione di n bit a destra è risultante da una operazione di or tra la word spostata a destra di n bit con la stessa word spostata a sinistra di 32 - n bit.
Spostamento a sinistra di 10 bit
b10 b11 b12 b13 b14 b15 b16 b17 b18 b19 b20 b21 b22 b23 b24 b25 b26 b27 b28 b29 b30 b31 0000000000
Spostamento a destra di 32 - 10 = 22 bit
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9
Quindi si ha:
W @<<@@ n = (W @@<<@@ n) or (W @@>@ 32-n)
W >>> n = (W >> n) or (W << 32-n)

Funzioni

Vengono definite 3 funzioni utilizzate in vari cicli. Sia t il ciclo di elaborazione; allora la funzione utilizzata sarà:
Ch(X, Y, Z) = (X and Y) xor ((not)X and Z) per 0 <= t <= 19
Parity(X, Y, Z) = X xor Y xor Z per 20 <= t <= 39 e per 60 <= t <= 79
Maj(X, Y, Z) = (X and Y) xor (X and Z) xor (Y and Z) per 40 <= t <= 59
Tutte le funzioni ricevono come argomenti 3 word e restituiscono una word. La funzione utilizzata verrà in seguito indicata genericamente come ft (X, Y, Z).

Costanti

Vengono utilizzate 4 costanti utilizzate durante l'elaborazione. La costante dipende dal ciclo in cui viene utilizzata:
K = 0x5a827999 per 0 <= t <= 19
K = 0x6ed9eba1 per 20 <= t <= 39
K = 0x8f1bbcdc per 40 <= t <= 59
K = 0xca62c1d6 per 60 <= t <= 79

Elaborazione

Il codice hash viene memorizzato in 5 word da 32 bit H0, H1, H2, H3, H4 che vengono inizializzate prima dell'elaborazione del primo blocco di dati con i seguenti valori:

  • H0 = 0x67452301
  • H1 = 0xefcdab89
  • H2 = 0x98badcfe
  • H3 = 0x10325476
  • H4 = 0xc3d2e1f0

Viene utilizzato un insieme di 80 valori W0 , W1 , …, W79 che vengono generati in questo modo:
Wt = Mt per 0 <= t <= 15
Wt = (Wt-3 xor Wt-8 xor Wt-14 xor Wt-16) <<< 1
I valori da 0 a 15 sono uguali alle 16 word che compongono il blocco da 512 bit che viene elaborato, mentre i valori rimanenti sono costruiti a partire da quelli precedenti utilizzando le operazioni di xor e di rotazione a sinistra.
Si utilizzano 6 word temporanee denominate a, b, c, d, e, temp. Le prime 5 vengono inizializzate con il valore delle word che contengono il codice hash temporaneo in questo modo:
a = H0
b = H1
c = H2
d = H3
e = H4
Il nucleo dell'elaborazione consiste in una serie di operazioni che costituiscono un ciclo. Esistono in totale 80 cicli.
Viene calcolato il valore della variabile temp come la somma (modulo 232) della rotazione a sinistra di 5 del valore di a, della funzione (la quale varia a seconda del ciclo) a cui vengono passati coma argomenti i valori di b, c, d, del valore di e, della costante K e del valore W (anche questi ultimi due dipendono dal ciclo).
Vengono ruotati i valori delle variabili in modo da assegnare alla variabile e il valore di d, a d il valore di c, a c il valore di b ruotato a sinistra di 30, a b il valore di a e infine ad a il valore di temp.
Dopo aver effettuato tutti gli 80 cicli, i valori di a, b, c, d, e vengono sommati rispettivamente alle variabili H0, H1, H2, H3, H4, che ora conterranno il nuovo valore temporaneo di hash.
Una volta elaborato l'ultimo blocco da 512 bit, allora il codice hash sarà contenuto proprio nelle variabili H0, H1, H2, H3, H4.

sha1.png

SHA 256

Descrizione

L'algoritmo SHA 256 calcola un valore di hash lungo 256 bit suddividendo ed elaborando il messaggio, ovvero una sequenza di bit, in blocchi da 512 bit. Ogni blocco viene convertito in una sequenza di 16 word da 32 bit ed elaborato attraverso una serie di operazioni. L'algoritmo prevede 64 cicli di operazioni da effettuare per ogni blocco.

Padding

Il padding viene effettuato nello stesso modo dell'algoritmo SHA1.

Funzioni e operazioni

Le operazioni di addizione modulo 232, di spostamento e di rotazione sono identiche a quelle dell'algoritmo SHA1.

Funzioni

Vengono definite 6 funzioni di cui 2 sono le funzioni Ch e Maj utilizzate nell'algoritmo SHA1 mentre le altre 4 ricevono come argomento una word e la trasformano attraverso operazioni di xor e di rotazione/spostamento di bit

  • Ch(X, Y, Z) = (X and Y) xor ((not)X and Z)
  • Maj(X, Y, Z) = (X and Y) xor (X and Z) xor (Y and Z)
  • S0(X) = (X >>> 2) xor (X >>> 13) xor (X >>> 22)
  • S1(X) = (X >>> 6) xor (X >>> 11) xor (X >>> 25)
  • S'0(X) = (X >>> 7) xor (X >>> 18) xor (X >> 3)
  • S'1(X) = (X >>> 17) xor (X >>> 19) xor (X >> 10)

Costanti

Vengono utilizzate 64 word da 32 bit costanti K0, K1, …, K63 da utilizzare in ogni ciclo. Sono state ricavate considerando i primi 32 bit della parte frazionale della radice cubica dei primi 64 numeri primi.

ciclo K ciclo K ciclo K ciclo K ciclo K ciclo K ciclo K ciclo K
1 0x428a2f98 2 0x71374491 3 0xb5c0fbcf 4 0xe9b5dba5 5 0x3956c25b 6 0x59f111f1 7 0x923f82a4 8 0xab1c5ed5
9 0xd807aa98 10 0x12835b01 11 0x243185be 12 0x550c7dc3 13 0x72be5d74 14 0x80deb1fe 15 0x9bdc06a7 16 0xc19bf174
17 0xe49b69c1 18 0xefbe4786 19 0x0fc19dc6 20 0x240ca1cc 21 0x2de92c6f 22 0x4a7484aa 23 0x5cb0a9dc 24 0x76f988da
25 0x983e5152 26 0xa831c66d 27 0xb00327c8 28 0xbf597fc7 29 0xc6e00bf3 30 0xd5a79147 31 0x06ca6351 32 0x14292967
33 0x27b70a85 34 0x2e1b2138 35 0x4d2c6dfc 36 0x53380d13 37 0x650a7354 38 0x766a0abb 39 0x81c2c92e 40 0x92722c85
41 0xa2bfe8a1 42 0xa81a664b 43 0xc24b8b70 44 0xc76c51a3 45 0xd192e819 46 0xd6990624 47 0xf40e3585 48 0x106aa070
49 0x19a4c116 50 0x1e376c08 51 0x2748774c 52 0x34b0bcb5 53 0x391c0cb3 54 0x4ed8aa4a 55 0x5b9cca4f 56 0x682e6ff3
57 0x748f82ee 58 0x78a5636f 59 0x84c87814 60 0x8cc70208 61 0x90befffa 62 0xa4506ceb 63 0xbef9a3f7 64 0xc67178f2

Elaborazione

l codice hash viene memorizzato in 8 word da 32 bit H0, H1, H2, H3, H4, H5, H6, H7 che vengono inizializzate prima dell'elaborazione del primo blocco di dati con i seguenti valori:
H0 = 0x6a09e667
H1 = 0xbb67ae85
H2 = 0x3c6ef372
H3 = 0xa54ff53a
H4 = 0x510e527f
H5 = 0x9b05688c
H6 = 0x1f83d9ab
H7 = 0x5be0cd19
Viene utilizzato un insieme di 64 valori W0, W1, …, W63 che vengono generati in questo modo:
Wt = Mtper 0 <= t <= 15
Wt = S'1(Wt-2) + Wt-7 + S'0(Wt-15) + Wt-16 per 16 <= t <= 63
I valori da 0 a 15 sono uguali alle 16 word che compongono il blocco da 512 bit che viene elaborato, mentre i valori rimanenti sono costruiti a partire da quelli precedenti utilizzando le funzioni s1 e s0.
Si utilizzano 10 word temporanee denominate a, b, c, d, e, f, g, h, T1, T2. Le prime 8 vengono inizializzate con il valore delle word che contengono il codice hash temporaneo in questo modo:
a = H0
b = H1
c = H2
d = H3
e = H4
f = H5
g = H6
h = H7
Il nucleo dell'elaborazione consiste in una serie di operazioni che costituiscono un ciclo. Esistono in totale 64 cicli.
Viene calcolato il valore della variabile T1 come la somma (modulo 232) della funzione S1 a cui viene passato il valore di e, della funzione Ch a cui vengono passati coma argomenti i valori di e, f, g, del valore di h, della costante K e del valore W (anche questi ultimi due dipendono dal ciclo).
Il valore T2 è dato dalla somma (modulo 264) della funzione S0 del valore di a e della funzione Maj a cui viene passato il valore di a, b, c. Vengono ruotati i valori delle variabili in modo da assegnare alla variabile h il valore di g, a g il valore di f, a f il valore di e, ad e la somma di d con T1, a d il valore di c, a c il valore di b, a b il valore di a ed infine ad a il valore della somma di T1 e T2.
Dopo aver effettuato tutti i 64 cicli, i valori di a, b, c, d, e, f, g, h vengono sommati rispettivamente alle variabili H0, H1, H2, H3, H4, H5, H6, H7, che ora conterranno il nuovo valore temporaneo di hash.
Una volta elaborato l'ultimo blocco da 512 bit, allora il codice hash sarà contenuto proprio nelle variabili H0, H1, H2, H3, H4, H5, H6, H7.

for i = 1 to N (N numero di blocchi da elaborare)
a = H0
b = H1
c = H2
d = H3
e = H4
f = H5
g = H6
h = H7
for t = 0 to 64
T1 = h + S1(e) + Ch(e, f, g) + K + W
T2 = S0(a) + Maj(a, b, c)
h = g
g = f
f = e
e = d + T1
d = c
c = b
b = a
a = T1 + T2
H0 = H00 + a
H1 = H1 + b
H2 = H2 + c
H3 = H3 + d
H4 = H4 + e
H5 = H5 + f
H6 = H6 + g
H7 = H7 + h

SHA 512

Descrizione

L'algoritmo SHA 512 calcola un valore di hash lungo 512 bit suddividendo ed elaborando il messaggio, ovvero una sequenza di bit, in blocchi da 1024 bit. Ogni blocco viene convertito in una sequenza di 16 word da 64 bit ed elaborato attraverso una serie di operazioni. L'algoritmo prevede 64 cicli di operazioni da effettuare per ogni blocco.

Padding

Sia L la lunghezza in bit del messaggio, il padding viene effettuato aggiungendo un bit "1" seguito da un certo numero di bit "0", così (10000…0). In seguito viene aggiunto il valore di L espresso in numero binario da 128 bit. Viene richiesto che L non sia più grande di 2128 bit. I dati di padding che vengono aggiunti sono tali da rendere la lunghezza del messaggio un multiplo di 1024 bit, quindi essendo gli ultimi 128 bit utilizzati per inserire il valore di L, allora la stringa composta dal bit "1" seguito dai bit "0" dovrà essere tale da rendere il messaggio 128 bit inferiore ad un multiplo di 1024 bit, quindi la lunghezza della stringa modulo 1024 deve essere uguale a 896 (1024 - 128 = 896).

Funzioni e operazioni

Le operazioni di addizione, rotazione e spostamento sono analoghe a quelle definite nell'algoritmo SHA1, ma operano su word da 64 bit.

Funzioni

Vengono definite 6 funzioni di cui 2 sono le funzioni Ch e Maj utilizzate nell'algoritmo SHA1, ma operano su word da 64 bit mentre le altre 4 ricevono come argomento una word e la trasformano attraverso operazioni di xor e di rotazione/spostamento di bit. La differenza rispetto a quelle definite negli altri algoritmi consiste nel numero di bit da spostare.
Ch(X, Y, Z) = (X and Y) xor ((not)X and Z)
Maj(X, Y, Z) = (X and Y) xor (X and Z) xor (Y and Z)

S0(X) = (X >>> 28) xor (X >>> 34) xor (X >>> 39)
S1(X) = (X >>> 14) xor (X >>> 18) xor (X >>> 41)
S'0(X) = (X >>> 1) xor (X >>> 8) xor (X >> 7)
S'1(X) = (X >>> 19) xor (X >>> 61) xor (X >> 6)

Costanti

Vengono utilizzate 80 word da 64 bit costanti K0, K1, …, K79 da utilizzare in ogni ciclo. Sono state ricavate considerando i primi 64 bit della parte frazionale della radice cubica dei primi 80 numeri primi.

ciclo K ciclo K ciclo K ciclo K
1 0x428a2f98d728ae22 2 0x7137449123ef65cd 3 0xb5c0fbcfec4d3b2f 4 0xe9b5dba58189dbbc
5 0x3956c25bf348b538 6 0x59f111f1b605d019 7 0x923f82a4af194f9b 8 0xab1c5ed5da6d8118
9 0xd807aa98a3030242 10 0x12835b0145706fbe 11 0x243185be4ee4b28c 12 0x550c7dc3d5ffb4e2
13 0x72be5d74f27b896f 14 0x80deb1fe3b1696b1 15 0x9bdc06a725c71235 16 0xc19bf174cf692694
17 0xe49b69c19ef14ad2 18 0xefbe4786384f25e3 19 0x0fc19dc68b8cd5b5 20 0x240ca1cc77ac9c65
21 0x2de92c6f592b0275 22 0x4a7484aa6ea6e483 23 0x5cb0a9dcbd41fbd4 24 0x76f988da831153b5
25 0x983e5152ee66dfab 26 0xa831c66d2db43210 27 0xb00327c898fb213f 28 0xbf597fc7beef0ee4
29 0xc6e00bf33da88fc2 30 0xd5a79147930aa725 31 0x06ca6351e003826f 32 0x142929670a0e6e70
33 0x27b70a8546d22ffc 34 0x2e1b21385c26c926 35 0x4d2c6dfc5ac42aed 36 0x53380d139d95b3df
37 0x650a73548baf63de 38 0x766a0abb3c77b2a8 39 0x81c2c92e47edaee6 40 0x92722c851482353b
41 0xa2bfe8a14cf10364 42 0xa81a664bbc423001 43 0xc24b8b70d0f89791 44 0xc76c51a30654be30
45 0xd192e819d6ef5218 46 0xd69906245565a910 49 0xf40e35855771202a 48 0x106aa07032bbd1b8
49 0x19a4c116b8d2d0c8 50 0x1e376c085141ab53 51 0x2748774cdf8eeb99 52 0x34b0bcb5e19b48a8
53 0x391c0cb3c5c95a63 54 0x4ed8aa4ae3418acb 55 0x5b9cca4f7763e373 56 0x682e6ff3d6b2b8a3
57 0x748f82ee5defb2fc 58 0x78a5636f43172f60 59 0x84c87814a1f0ab72 60 0x8cc702081a6439ec
61 0x90befffa23631e28 62 0xa4506cebde82bde9 63 0xbef9a3f7b2c67915 64 0xc67178f2e372532b
65 0xca273eceea26619c 66 0xd186b8c721c0c207 67 0xeada7dd6cde0eb1e 68 0xf57d4f7fee6ed178
69 0x06f067aa72176fba 70 0x0a637dc5a2c898a6 71 0x113f9804bef90dae 72 0x1b710b35131c471b
73 0x28db77f523047d84 74 0x32caab7b40c72493 75 0x3c9ebe0a15c9bebc 76 0x431d67c49c100d4c
77 0x4cc5d4becb3e42b6 78 0x597f299cfc657e2a 79 0x5fcb6fab3ad6faec 80 0x6c44198c4a475817

Elaborazione

Il codice hash viene memorizzato in 8 wrd da 64 bit per un totale di 512 bit H0, H1, H2, H3, H4, H5, H6, H7 che vengono inizializzate prima dell'elaborazione del primo blocco di dati con i seguenti valori:
H0 = 0x6a09e667f3bcc908
H1 = 0xbb67ae8584caa73b
H2 = 0x3c6ef372fe94f82b
H3 = 0xa54ff53a5f1d36f1
H4 = 0x510e527fade682d1
H5 = 0x9b05688c2b3e6c1f
H6 = 0x1f83d9abfb41bd6b
H7 = 0x5be0cd19137e2179
Viene utilizzato un insieme di 80 valori W0, W1, …, W63 che vengono generati in questo modo:
Wt = Mt per 0 <= t <= 15
Wt = S'1(Wt-2) + Wt-7 + S'0(Wt-15) + Wt-16 per 16 <= t <= 79
I valori da 0 a 15 sono uguali alle 16 word che compongono il blocco da 1024 bit che viene elaborato, mentre i valori rimanenti sono costruiti a partire da quelli precedenti utilizzando le funzioni S'1 e S'0.
Si utilizzano 10 word temporanee denominate a, b, c, d, e, f, g, h, T1, T2. Le prime 8 vengono inizializzate con il valore delle word che contengono il codice hash temporaneo in questo modo:
a = H0
b = H1
c = H2
d = H3
e = H4
f = H5
g = H6
h = H7
Il nucleo dell'elaborazione consiste in una serie di operazioni che costituiscono un ciclo. Esistono in totale 80 cicli.
Viene calcolato il valore della variabile T1 come la somma (modulo 264) della funzione S1 a cui viene passato il valore di e, della funzione Ch a cui vengono passati coma argomenti i valori di e, f, g, del valore di h, della costante K e del valore W (anche questi ultimi due dipendono dal ciclo).
Il valore T2 è dato dalla somma (modulo 232) della funzione S0 del valore di a e della funzione Maj a cui viene passato il valore di a, b, c. Vengono ruotati i valori delle variabili in modo da assegnare alla variabile h il valore di g, a g il valore di f, a f il valore di e, ad e la somma di d con T1, a d il valore di c, a c il valore di b, a b il valore di a ed infine ad a il valore della somma di T1 e T2.
Dopo aver effettuato tutti gli 80 cicli, i valori di a, b, c, d, e, f, g, h vengono sommati rispettivamente alle variabili H0, H1, H2, H3, H4, H5, H6, H7, che ora conterranno il nuovo valore temporaneo di hash.
Una volta elaborato l'ultimo blocco da 512 bit, allora il codice hash sarà contenuto proprio nelle variabili H0, H1, H2, H3, H4, H5, H6, H7.

for i = 1 to N (N numero di blocchi da elaborare)
a = H0
b = H1
c = H2
d = H3
e = H4
f = H5
g = H6
h = H7
for t = 0 to 79
T1 = h + S1(e) + Ch(e, f, g) + K + W
T2 = S0(a) + Maj(a, b, c)
h = g
g = f
f = e
e = d + T1
d = c
c = b
b = a
a = T1 + T2
H0 = H0 + a
H1 = H1 + b
H2 = H2 + c
H3 = H3 + d
H4 = H4 + e
H5 = H5 + f
H6 = H6 + g
H7 = H7 + h

sha256.png
Bibliography
1. NIST, "Secure Hash Standard", FIPS PUB 180-1, aprile 1995, Sito web: http://www.itl.nist.gov/fipspubs/fip180-1.htm
2. NIST, "Secure Hash Standard", FIPS PUB 180-2, agosto 2002, Sito web: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
3. NIST, "Secure Hash Standard", FIPS PUB 180-3, ottobre 2008, Sito web: http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf
4. NIST, "Announcing Request for Candidate Algorithm Nominations for a New Cryptographic Hash Algorithm (SHA–3) Family", novembre 2007, Sito web: http://csrc.nist.gov/groups/ST/hash/documents/FR_Notice_Nov07.pdf
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License