@@ -22,60 +22,43 @@ Per una data dimensione del digest di output $n$, la capacità viene solitamente
---
## 2. Lo Stato Interno di Keccak
## Lo Stato Interno: Il "Cubo" di Bit
Lo stato interno di 1600 bit viene geometricamente rappresentato come una matrice tridimensionale di dimensioni **$5 imes 5 imes 64$ bit**.
Invece di pensare a una stringa lineare di dati, immagina lo stato interno di Keccak (che è lungo 1600 bit) come un **cubo perfetto di blocchetti di memoria** (una griglia 3D).
Ogni elemento della matrice è una "parola" (word) di 64 bit. Le coordinate sono espresse come:
* $x \in \{0, 1, 2, 3, 4\}$ (colonne)
* $y \in \{0, 1, 2, 3, 4\}$ (righe)
* $z \in \{0, 1, \dots, 63\}$ (bit all'interno della parola)
Questo cubo ha una struttura fissa:
* La base è una griglia di **5 righe per 5 colonne**, formando 25 caselle in totale.
* Ogni casella si sviluppa in altezza per **64 bit** (pensa a una torre di 64 cubetti).
Un singolo bit dello stato è indicato come $A[x, y, z]$. Le operazioni aritmetiche sugli indici delle coordinate $x$ e $y$ sono eseguite in modulo 5 ($\pmod 5$).
In gergo, ognuna di queste 25 torri da 64 bit viene chiamata **"parola" (word)** o **"filo" (lane)**. L'intero algoritmo non fa altro che rimescolare, ruotare e modificare i cubetti di questo grande blocco 3D per 24 volte (i 24 round).
---
## 3. La Funzione di Permutazione $f$
## I Round
La sicurezza di SHA-3 risiede nella funzione di permutazione iterativa $Keccak-f[1600]$, che consta di **24 round**. Ogni round applica sullo stato cinque trasformazioni matematiche e logiche consecutive: **$ heta,
ho, \pi, \chi, \iota$**.
Ogni singolo round prende questo cubo, applica 5 modifiche in sequenza (chiamate con le lettere greche $\theta, \rho, \pi, \chi, \iota$) e sputa fuori il cubo modificato per il round successivo.
### 1. Passo $ heta$ (Theta) - Diffusione
Calcola la parità di ciascuna colonna e la combina con le colonne adiacenti. Serve a garantire un'ampia diffusione dei bit.
Immagina questo passaggio come un controllo di vicinato. Per decidere se un singolo bit deve cambiare o rimanere uguale, l'algoritmo guarda l'intera colonna in cui si trova, calcola una sorta di "riassunto" (la parità) e fa la stessa cosa con le due colonne vicine (quella a sinistra e quella a destra).
***A cosa serve:** Se modifichi anche un solo bit all'estrema sinistra del cubo, l'effetto si propaga immediatamente a destra e a sinistra nel round successivo. Garantisce che i dati si mescolino alla velocità della luce.
Prendi le 25 torri verticali del cubo. Ognuna di queste torri viene fatta "scorrere" verso l'alto o verso il basso di un certo numero di posizioni. I bit che escono dall'alto rientrano dal basso (una rotazione ciclica). Ogni torre si muove di una quantità diversa e prestabilita.
***A cosa serve:** Cambia la posizione verticale dei bit all'interno della stessa torre, assicurandosi che i bit non rimangano mai intrappolati allo stesso "piano".
### 2. Passo $
ho$ (Rho) - Rotazione Intrapola
Ruota i bit di ciascuna delle 25 parole di un offset fisso triangolare $t_{x,y}$, specifico per ogni posizione $(x,y)$:
### 3. $\pi$ (Pi) – Permutazione orizzontale
Qui le torri non si muovono più in verticale, ma cambiano di posto sulla griglia di base 5x5. Immagina che le 25 torri giochino a un gioco in cui ognuna deve spostarsi in una nuova casella della scacchiera seguendo una regola geometrica precisa.
***A cosa serve:** Rompe totalmente la struttura delle righe e delle colonne originarie. Quello che prima era una colonna ora diventa una riga o una diagonale.
$$A'[x,y,z] = A[x,y, (z - t_{x,y}) \pmod{64}]$$
### 4. $\chi$ (Chi) – Aggiunta di una riga
Questo è il passaggio più importante dal punto di vista della sicurezza. L'algoritmo prende una riga orizzontale di 5 bit. Il valore del primo bit cambia in base a quello che fanno i suoi due vicini di destra. Questo cambiamento avviene usando una logica non lineare (una porta AND).
***A cosa serve:** In crittografia la "non-linearità" è fondamentale. Senza questo passaggio, l'intero SHA-3 sarebbe solo una serie di spostamenti geometrici lineari risolvibili con una banale equazione matematica di scuola superiore. $\chi$ rende l'algoritmo impossibile da decifrare a ritroso.
### 3. Passo $\pi$ (Pi) - Permutazione Interpola
Permuta la posizione delle parole all'interno della matrice $5 imes 5$, rimescolando la geometria dello stato:
$$A'[X, Y, z] = A[x, y, z] \quad ext{dove } egin{pmatrix} X \ Y \end{pmatrix} = egin{pmatrix} 0 & 1 \ 2 & 3 \end{pmatrix} egin{pmatrix} x \ y \end{pmatrix} \pmod 5$$
O in modo più esplicito: $A'[y, (2x + 3y) \pmod 5, z] = A[x, y, z]$.
### 4. Passo $\chi$ (Chi) - Elemento Non Lineare
È l'unico passaggio non lineare dell'algoritmo (equivalente a una porta logica AND combinata con XOR). Modifica il valore di un bit in base ai bit adiacenti della stessa riga:
$$A'[x,y,z] = A[x,y,z] \oplus \left( ig(
eg A[x+1, y, z] ig) \wedge A[x+2, y, z]
ight)$$
### 5. Passo $\iota$ (Iota) - Rottura delle Simmetrie
Aggiunge una costante di round $RC[i_r]$ tramite XOR esclusivamente alla parola in posizione $(0,0)$ dello stato. Questo impedisce la nascita di simmetrie periodiche tra i round:
$$A'[0,0,z] = A[0,0,z] \oplus RC[i_r][z]$$
Dove $i_r$ è l'indice del round corrente ($0 \le i_r \le 23$). Le restanti parole dello stato rimangono invariate in questo passaggio.
---
### 5. $\iota$ (Iota) – Rottura delle simmetrie
I quattro passaggi precedenti sono identici per ogni round. Se inserissimo dei dati con pattern ripetitivi o simmetrici, l'algoritmo potrebbe portarsi dietro queste simmetrie fino alla fine, creando un punto debole. Per evitare questo, in ogni round viene preso un numero "magico" sempre diverso (la costante di round) e viene combinato (tramite XOR) **solo ed esclusivamente sul primissimo bit** in un angolo del cubo (la posizione 0,0).
***A cosa serve:** Rende ogni round leggermente diverso dall'altro e distrugge qualsiasi simmetria matematica che un attaccante potrebbe sfruttare.
@@ -39,7 +39,7 @@ Vengono inizializzate 8 variabili di registro a 64 bit ciascuna (da $A$ ad $H$).
### 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:
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
elisabetta