@@ -1 +1,96 @@
|
||||
# La Funzione SHA-512
|
||||
# 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 = egin{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.
|
||||
Reference in New Issue
Block a user