From cff0b9ff4836e8a785c92b7043528fd7955f2b8f Mon Sep 17 00:00:00 2001 From: elisabetta Date: Thu, 28 May 2026 11:15:56 +0200 Subject: [PATCH] last commit?? --- .../main/resources/get/documentazione/SHA3.md | 83 +++++++++---------- .../resources/get/documentazione/SHA512.md | 4 +- backend/src/main/resources/get/index.html | 2 +- 3 files changed, 42 insertions(+), 47 deletions(-) diff --git a/backend/src/main/resources/get/documentazione/SHA3.md b/backend/src/main/resources/get/documentazione/SHA3.md index e98a739..34c6762 100644 --- a/backend/src/main/resources/get/documentazione/SHA3.md +++ b/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: -* $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$). +Questo documento offre una spiegazione semplice, discorsiva e visiva di come funziona questa spugna crittografica. --- -## 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, -ho, \pi, \chi, \iota$**. +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). -### 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. +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). -$$A'[x,y,z] = A[x,y,z] \oplus C[x-1, z] \oplus C[x+1, z-1]$$ - -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. +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). --- +## 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: diff --git a/backend/src/main/resources/get/documentazione/SHA512.md b/backend/src/main/resources/get/documentazione/SHA512.md index c4be7d6..e24d722 100644 --- a/backend/src/main/resources/get/documentazione/SHA512.md +++ b/backend/src/main/resources/get/documentazione/SHA512.md @@ -39,9 +39,9 @@ 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 +\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. diff --git a/backend/src/main/resources/get/index.html b/backend/src/main/resources/get/index.html index 48e3f25..3c782d6 100644 --- a/backend/src/main/resources/get/index.html +++ b/backend/src/main/resources/get/index.html @@ -42,7 +42,7 @@

- +