last commit??

backend/src/main/resources/get/documentazione/SHA3.md

@@ -22,61 +22,56 @@ Per una data dimensione del digest di output $n$, la capacità viene solitamente
 
 ---
 
-## 2. Lo Stato Interno di Keccak
+# Lo Stato Interno di Keccak (SHA-3) spiegato in modo semplice
 
-Lo stato interno di 1600 bit viene geometricamente rappresentato come una matrice tridimensionale di dimensioni **$5 	imes 5 	imes 64$ bit**. 
+Il funzionamento di **SHA-3 (Keccak)** può sembrare un labirinto di formule matematiche, ma se visualizziamo lo stato interno como un oggetto geometrico concreto, diventa tutto molto più intuitivo. 
 
-Ogni elemento della matrice è una "parola" (word) di 64 bit. Le coordinate sono espresse come:
+Questo documento offre una spiegazione semplice, discorsiva e visiva di come funziona questa spugna crittografica.
-* $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)
-
-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$).
 
 ---
 
-## 3. La Funzione di Permutazione $f$
+## 1. Lo Stato Interno: Il "Cubo" di Bit
 
-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, 
+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).
-ho, \pi, \chi, \iota$**.
 
-### 1. Passo $	heta$ (Theta) - Diffusione
+Questo cubo ha una struttura fissa:
-Calcola la parità di ciascuna colonna e la combina con le colonne adiacenti. Serve a garantire un'ampia diffusione dei bit.
+* 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). 
 
-$$A'[x,y,z] = A[x,y,z] \oplus C[x-1, z] \oplus C[x+1, z-1]$$
+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).
-
-Dove $C[x,z]$ è la parità di una colonna:
-$$C[x,z] = A[x,0,z] \oplus A[x,1,z] \oplus A[x,2,z] \oplus A[x,3,z] \oplus A[x,4,z]$$
-
-### 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)$:
-
-$$A'[x,y,z] = A[x,y, (z - t_{x,y}) \pmod{64}]$$
-
-### 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.
 
 ---
 
+## 2. I 5 Passaggi di ogni Round
+
+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. 
+
+Ecco cosa fanno davvero queste cinque funzioni:
+
+### 1. $\theta$ (Theta) – Diffusione
+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.
+
+### 2. $\rho$ (Rho) – Rotazione verticale
+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".
+
+### 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.
+
+### 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.
+
+### 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.
+
+---
+
+## In sintesi
+SHA-3 è come un cubo di Rubik ultra-complesso: **mescola di lato ($\theta$), fa scorrere in alto ($\rho$), sposta le colonne ($\pi$), perturba matematicamente i vicini ($\chi$) e aggiunge un pizzico di casualità ($\iota$)**. Ripeti questo processo per 24 volte, e il risultato sarà un caos crittografico perfetto e sicuro.
 ## Proprietà di Sicurezza
 
 Grazie alla costruzione a spugna e alla natura algebrica dei 5 passi di Keccak, SHA-3 offre una resistenza strutturale nativa contro diversi attacchi noti per SHA-2:

backend/src/main/resources/get/documentazione/SHA512.md

@@ -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:
 
-$$W_t =  egin{cases} 
+$$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}$$

backend/src/main/resources/get/index.html

@@ -42,7 +42,7 @@
         </p>
     </div>
 
-    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1440 320" style="margin-bottom: -5px;">
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1440 320" style="margin-bottom: -10px;">
         <path fill="#0b0f19" fill-opacity="1"
             d="M0,160L48,170.7C96,181,192,203,288,208C384,213,480,203,576,176C672,149,768,107,864,117.3C960,128,1056,192,1152,213.3C1248,235,1344,213,1392,202.7L1440,192L1440,320L1392,320C1344,320,1248,320,1152,320C1056,320,960,320,864,320C768,320,672,320,576,320C480,320,384,320,288,320C192,320,96,320,48,320L0,320Z">
         </path>