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.
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