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