L'Algoritmo di Hashing SHA-512

Lo SHA-512 (Secure Hash Algorithm 512) è una funzione crittografica di hashing appartenente alla famiglia SHA-2, progettata dalla National Security Agency (NSA) e pubblicata dal NIST nel 2002.

L'algoritmo prende in input un messaggio di lunghezza arbitraria (fino a 2^{128} bit) e produce in output un'impronta digitale fissa a 512 bit (64 byte), comunemente rappresentata come una stringa esadecimale di 128 caratteri.

1. Caratteristiche Principali

Dimensione del Blocco di Input: 1024 bit.
Dimensione della Parola (Word): 64 bit (ottimizzato per architetture a 64-bit).
Numero di Round: 80 passaggi di compressione.
Dimensione del Digest: 512 bit.
Proprietà fondamentali:
- Resistenza alla pre-immagine: Dato un hash H, è computazionalmente impossibile trovare il messaggio M tale che SHA512(M) = H.
- Resistenza alla seconda pre-immagine: Dato un messaggio M_1, è impossibile trovare un $M_2 eq M_1$ tale che SHA512(M_1) = SHA512(M_2).
- Resistenza alle collisioni: È computazionalmente impossibile trovare due messaggi diversi che producano lo stesso hash.

2. Fasi del Funzionamento

L'algoritmo elabora il messaggio strutturandolo in blocchi successivi attraverso i seguenti passaggi:

1. Riempimento (Padding)

Il messaggio originale viene esteso in modo che la sua lunghezza in bit sia congrua a 896 \pmod{1024}.

Si aggiunge un singolo bit 1 seguito da una sequenza di bit 0.
Negli ultimi 128 bit dello spazio rimanente del blocco viene inserita la lunghezza del messaggio originale espressa in bit.

2. Inizializzazione del Buffer (IV)

Vengono inizializzate 8 variabili di registro a 64 bit ciascuna (da A ad H). I valori iniziali derivano dalle parti frazionarie delle radici quadrate dei primi 8 numeri primi:

A = ext{0x6a09e667f3bcc908} (\sqrt{2})
B = ext{0xbb67ae8584caa73b} (\sqrt{3})
C = ext{0x3c6ef372fe94f82b} (\sqrt{5})
... fino ad H (\sqrt{19}).

3. Ciclo Principale e Message Schedule

Per ogni blocco di 1024 bit, l'input viene suddiviso in 16 parole da 64 bit e poi espanso in un array W di 80 parole (W_0, W_1, \dots, W_{79}) secondo la formula:

$$W_t = \begin{cases} M_t^{(i)} & 0 \le t \le 15
\sigma_1(W_{t-2}) + W_{t-7} + \sigma_0(W_{t-15}) + W_{t-16} & 16 \le t \le 79 \end{cases}$$

Dove le funzioni \sigma_0 e \sigma_1 sono definite sotto.

3. Funzioni Logiche e Operazioni Matematiche

Ogni round degli 80 previsti utilizza costanti additive predefinite K_t (derivate dalle radici cubiche dei primi 80 numeri primi) e applica funzioni logiche bit-a-bit sulle parole a 64 bit.

Le funzioni logiche fondamentali utilizzate sono:

Funzione Ch ("Choice")

Seleziona i bit di Y o Z a seconda del valore di X: $$Ch(X, Y, Z) = (X \wedge Y) \oplus ( eg X \wedge Z)$$

Funzione Maj ("Majority")

Restituisce la maggioranza dei bit dei tre input:

Maj(X, Y, Z) = (X \wedge Y) \oplus (X \wedge Z) \oplus (Y \wedge Z)

Funzioni di Somma e Rotazione (`\Sigma` e `\sigma`)

Le funzioni utilizzano le operazioni di rotazione ciclica a destra (ROTR^n) e shift logico a destra (SHR^n):

\Sigma_0(X) = ROTR^{28}(X) \oplus ROTR^{34}(X) \oplus ROTR^{39}(X) \Sigma_1(X) = ROTR^{14}(X) \oplus ROTR^{18}(X) \oplus ROTR^{41}(X) \sigma_0(X) = ROTR^{1}(X) \oplus ROTR^{8}(X) \oplus SHR^{7}(X) \sigma_1(X) = ROTR^{19}(X) \oplus ROTR^{61}(X) \oplus SHR^{6}(X)

Aggiornamento delle Variabili nei Round

In ciascuno degli 80 round, i valori dei registri (A, B, C, D, E, F, G, H) vengono aggiornati calcolando due variabili temporanee T_1 e T_2:

T_1 = H + \Sigma_1(E) + Ch(E, F, G) + K_t + W_t T_2 = \Sigma_0(A) + Maj(A, B, C)

I registri mutano poi nel seguente modo:

H = G
G = F
F = E
E = D + T_1 \pmod{2^{64}}
D = C
C = B
B = A
A = T_1 + T_2 \pmod{2^{64}}

Al termine degli 80 round, i valori ottenuti vengono sommati ai valori iniziali del blocco corrente e si procede con il blocco successivo. Il digest finale è la concatenazione di A, B, C, D, E, F, G, H.

La Vulnerabilità principale di queste funzioni

Tutte le funzioni della famiglia SHA 2 sebbene siano tra le più diffuse presentano comunque un problema intrinseco al loro funzionamento: sono vulnerabili ai Length Extension Attacks.

Se a partire da un digest si riesce ad invertire lo step di finalization, si è in grado di ricostruire lo stato interno della funzione, il che consente di aggiungere ulteriori blocchi alla "catena" permettendo di forgiare messaggi / validare messaggi invalidi.

4.6 KiB Raw Blame History