miao

last commit??
2026-05-28 13:01:08 +02:00 · 2026-05-28 11:34:01 +02:00 · 2026-05-28 11:15:56 +02:00 · 2026-05-27 20:06:49 +02:00 · 2026-05-27 19:45:21 +02:00 · 2026-05-26 12:58:19 +02:00
34 changed files with 1975 additions and 30 deletions
@@ -6,21 +6,35 @@ public class Caesar {
        char encoded[] = plaintext.toCharArray();

        for(int i = 0; i < plaintext.length(); i++){
-            encoded[i] = alphabet.charAt(alphabet.indexOf(encoded[i]) + key % 26);
+            if (alphabet.indexOf(encoded[i]) == -1) continue;
+            encoded[i] = alphabet.charAt((alphabet.indexOf(encoded[i]) + key) % 26);
        }
        return String.valueOf(encoded);
    }

    public static String[] decode(String ciphertext){
        String alphabet = "abcdefghijklmnopqrstuvwxyz";
-        char encoded[] = ciphertext.toCharArray();
+        char encoded[] = ciphertext.strip().toCharArray();
+
        char decoded[] = new char[ciphertext.length()];
        String bruteforce[] = new String[26];
+
        for(int key = 0; key < alphabet.length(); key++){
+
            for(int i = 0; i < ciphertext.length(); i++){
-                decoded[i] = alphabet.charAt(alphabet.indexOf((encoded[i] + key) % 26));
+                if (alphabet.indexOf(encoded[i]) == -1) {
+                    decoded[i] = encoded[i];
+                    continue;
+                }
+                char current = encoded[i];
+                int pos = alphabet.indexOf(current);
+                if(pos != -1) {
+                    int newpos = (pos + key) % 26;
+                    decoded[i] = alphabet.charAt(newpos);
+                } else
+                    decoded[i] = current;
            }
-            bruteforce[key] = String.valueOf(encoded);
+            bruteforce[key] = String.valueOf(decoded);
        }
        return bruteforce;

@@ -20,8 +20,9 @@
            <i class="fa-solid fa-bars"></i>
        </div>
        <ul class="nav-links" id="nav-links">
-            <li><a href="rsa.html"><i class="fa-solid fa-key"></i> RSA</a></li>
-            <li><a href="cesare.html"><i class="fa-solid fa-arrow-right-arrow-left"></i> Cesare</a></li>
+            <li><a href="rsa.html"><i class="fa-solid fa-key"></i>RSA</a></li>
+            <li><a href="cesare.html"><i class="fa-solid fa-landmark"></i>Cesare</a></li>
+            <li><a href="materiale.html"><i class="fa-regular fa-clipboard"></i></i>Materiale</a></li>
            <li><a href="team.html"><i class="fa-solid fa-users"></i> Il Team</a></li>
        </ul>
    </nav>
@@ -42,10 +43,10 @@

            <label style="display:block; margin-top: 25px;">Testo Cifrato:</label>
            <textarea id="ciphertext" placeholder="Il risultato cifrato apparirà qui..."></textarea>
-            <button class="btn-green" onclick="decrypt()">🔓 Decifra in chiaro</button>
+            <button class="btn-green" onclick="decrypt()">🔓 Attacca</button>

-            <label style="display:block; margin-top: 25px;">Risultato decifrato:</label>
-            <textarea id="decodedtext" readonly placeholder="Il messaggio originale tornerà qui..."></textarea>
+            <label style="display:block; margin-top: 25px;">Simulazione attacco Bruteforce:</label>
+            <textarea id="decodedtext" readonly placeholder="Qui compariranno tutte le combinazioni possibili, riconoscerai subito quella corretta !!"></textarea>
        </div>
    </div>
    <footer>
@@ -0,0 +1,62 @@
+# L'Algoritmo AES - Advanced Encryption Standard
+
+L'**AES** (Advanced Encryption Standard), noto originariamente come **Rijndael**, è un cifrario a blocchi simmetrico standardizzato dal NIST nel 2001 (FIPS 197). A differenza di altri algoritmi, AES opera su blocchi di dati di dimensione fissa a **128 bit** e supporta tre diverse lunghezze di chiave: 128, 192 e 256 bit.
+
+Per cifrare testi di lunghezza superiore ai 128 bit, l'input viene suddiviso in più blocchi. Il modo in cui questi blocchi vengono concatenati ed elaborati dipende dalla **modalità di funzionamento (Mode of Operation)** utilizzata. Di seguito vengono analizzate le due modalità fondamentali: **ECB** e **CBC**.
+
+---
+
+## Il Funzionamento di AES
+
+A differenza dei cifrari storici, l'AES processa il blocco di dati ripetutamente attraverso diversi cicli, chiamati **Round** (10, 12 o 14 round a seconda della chiave). In ogni singolo round avvengono 4 trasformazioni geometrico-matematiche:
+
+1.  **SubBytes:** Sostituisce i byte seguendo una tabella fissa (*S-Box*).
+2.  **ShiftRows:** Sposta le righe dei dati facendole scivolare di lato.
+3.  **MixColumns:** Mescola le colonne tra loro tramite formule algebriche.
+4.  **AddRoundKey:** Fonde i dati temporanei con una porzione della chiave segreta tramite un'operazione logica XOR.
+
+> **Sicurezza dell'AES:** Ad oggi **non esistono attacchi noti** capaci di violare l'AES se la chiave è robusta. Per indovinare una chiave AES a 256 bit tramite attacco a forza bruta (*brute-force*), tutti i supercomputer del pianeta dovrebbero lavorare per miliardi di anni (un tempo superiore all'età dell'universo stesso).
+
+---
+
+## Modalità ECB (Electronic Codebook)
+
+La modalità **ECB** è la più semplice e intuitiva. Ogni blocco di testo in chiaro ($P_i$) viene cifrato in modo completamente indipendente dagli altri, utilizzando la stessa chiave crittografica ($K$).
+
+### Formule Matematiche
+* **Cifratura**: 
+  $$C_i = E_K(P_i)$$
+* **Decifratura**: 
+  $$P_i = D_K(C_i)$$
+
+Dove $P_i$ è il $i$-esimo blocco di testo in chiaro, $C_i$ è il $i$-esimo blocco di testo cifrato, $E_K$ è la funzione di cifratura AES e $D_K$ è la funzione di decifratura.
+
+### La Criticità dell'Algoritmo
+Come si può facilmente intuire, con questa modalità a blocchi di testo in chiaro identici producono blocchi di testo cifrato identici. Questo significa che la modalità ECB **non nasconde i pattern del testo in chiaro**. Se applicata a un'immagine, ad esempio, i contorni delle figure rimangono chiaramente visibili anche dopo la cifratura (ex. pinguino linux) e quindi non è **semantically secure**
+Per questa ragione, ECB non è considerata sicura per la maggior parte delle applicazioni pratiche, in quanto dà info all'utente.
+
+<img src="" alt="">
+
+---
+
+## Modalità CBC (Cipher Block Chaining)
+
+Per superare i limiti di sicurezza di ECB, la modalità **CBC** introduce un meccanismo di dipendenza: ciascun blocco di testo in chiaro viene combinato con il blocco cifrato precedente prima di essere sottoposto a cifratura.
+
+Per il primo blocco, non essendoci un blocco cifrato precedente, si utilizza un vettore di inizializzazione chiamato **IV (Initialization Vector)**, che deve essere unico e idealmente casuale per ogni sessione di cifratura.
+
+### Formule Matematiche
+* **Cifratura**: 
+  $$C_1 = E_K(P_1 \oplus IV)$$
+  $$C_i = E_K(P_i \oplus C_{i-1}) \quad \text{per } i > 1$$
+* **Decifratura**: 
+  $$P_1 = D_K(C_1) \oplus IV$$
+  $$P_i = D_K(C_i) \oplus C_{i-1} \quad \text{per } i > 1$$
+
+Dove $\oplus$ rappresenta l'operazione logica XOR (OR esclusivo).
+
+### Vantaggi e Svantaggi
+* **Vantaggi**: Garantisce la sicurezza semantica. Blocchi di testo in chiaro identici produrranno blocchi cifrati completamente diversi a causa della dipendenza dal blocco precedente e dall'IV. I pattern dei dati vengono interamente nascosti.
+* **Svantaggi**: 
+  * **Propagazione degli errori**: Un errore di un bit nel blocco cifrato $C_i$ corromperà completamente la decifratura del blocco $P_i$ e altererà lo stesso bit nel blocco $P_{i+1}$.
+
@@ -0,0 +1,24 @@
+# Gli Attacchi APT (Advanced Persistent Threats)
+
+Con il passare degli anni e l'avvento delle nuove tecnologie il modo per sferrare gli attacchi è mutato ed è diventato pìiù sofisticato, e così sono nate le gli **attacchi APT**.
+Gli attacchi APT vengono definiti come tecniche di hacking mirate e sofisticate, usate per **sabotaggio o spionaggio a lungo termine** e sono solitamente basati sul **Social Engineering**. 
+Prevedono 7 fasi precise: 
+
+### Ricognizione
+Vengono raccolte una serie di informazioni aggiornate e pubbliche riguardanti il target tramite **social engineering** per capire al meglio la struttura e il funzionamento del sistema che si vuole attaccare e le sue debolezze (spesso è proprio il lato umano la maggiore debolezza).
+### Armamento 
+L'attaccante pianifica l'attacco creando le cosiddette "armi" e identificando nello specifico i fronti di attacco
+### Distribuizione 
+L'attaccante invia il malware al target tramite tecniche note di iniezione, quali sql injection, xss, allegati malevoli inviati via mail, phishing etc...
+### Sfruttamento 
+Il payload dannoso apre un varco nel sistema sfruttando una specifica vulnerabilità
+### Installazione
+Vengono istanziate delle backdoor sulla macchina target infetta e ciò permette agli attaccanti di prendere le info sensibili necessarie al proseguimento dell'attacco quali credenziali, registri di sistema etc...
+### Comando e Controllo
+Tramite le credenziali rubate gli attaccanti accedono ai **dati riservati** del sistema e li esfiltrano, tutti i dati interessanti vengono inviati a server intermedi e crittografati prima di venire inviati al team esterno che usa questi dati per operazioni illecite
+### Azioni sull'obiettivo
+Tutti i precedenti processi vengono "occultati" ai membri del sistema perchè lo scopo è rimanere dentro il più possibile in modo da poter captare una grande mole di dati, **è l'esatto motivo per cui questi attacchi sono così complicati da gestire !!**
+
+Questa catena viene anche detta **Cyber Kill Chain** e viene utilizzata per descrivere il ciclo di vita di un attacco informatico.
+
+---
@@ -0,0 +1,77 @@
+# L'Algoritmo Diffie And Hellman
+
+La crittografia simmetrica come sappiamo aveva un enorme problema: lo scambio sicuro della chiave simmetrica 
+
+Questo problema, apparentemente impossibile, è stato risolto nel 1976 da Whitfield Diffie e Martin Hellman grazie al loro rivoluzionario **Protocollo di scambio delle chiavi Diffie-Hellman**.
+
+---
+
+## La Base del Funzionamento: il Logaritmo Discreto
+
+Nel caso di Diffie-Hellman come funzione si usa l'**elevamento a potenza in aritmetica modulare**.
+
+L'operazione matematica unidirezionale alla base di Diffie-Hellman è la seguente: dati un numero base $g$, un esponente $x$ e un modulo primo $p$, è molto facile calcolare:
+
+$$Y = g^x \pmod p$$
+
+Tuttavia, se conosciamo solo $Y$, $g$ e $p$, trovare l'esponente $x$ è un problema computazionalmente complesso quando i numeri sono molto elevati. Questo problema prende il nome di **Problema del Logaritmo Discreto**.
+
+---
+
+## Il Funzionamento dell'Algoritmo
+Vediamo come si svolge lo scambio numerico tra Alice e Bob.
+
+### 1 - Scelta di p e r
+Vengono scelti due numeri noti a entrambi gli utenti:
+* $p$: Un numero primo elevato e crittograficamente sicuro.
+* $g$: Un intero chiamato *generatore* (o base), che è una radice primitiva di $p$.
+
+### 2 - Calcolo della chiavi dell'utente 1 (Alice)
+* L'utente **Alice** sceglie un numero intero segreto $a$ (la sua chiave privata) e poi calcola la sua chiave pubblica $kpbA$ e la invia a Bob:
+    $$kpb = g^a \pmod p$$
+
+* L'utente **Bob** riceve i dati e sceglie un numero intero segreto $b$ (la sua chiave privata). Poi calcola la sua chiave pubblica $kpbB$ e la invia ad Alice:
+    $$kpb = g^b \pmod p$$
+
+### Calcolo della chiave condivisa
+Ciascuno dei due unisce la chiave pubblica ricevuta con la propria chiave privata.
+
+* Alice riceve $kpbB$ e calcola la chiave segreta $K$:
+    $$K = B^a \pmod p$$
+
+* Bob riceve $kpbA$ e calcola la chiave segreta $K$:
+    $$K = A^b \pmod p$$
+
+### Dimostrazione dell'uguaglianza delle chiavi
+
+Sostituiamo le definizioni di $A$ e $B$ nelle formule del segreto condiviso:
+* Per Alice: $K = B^a \pmod p = (g^b)^a \pmod p = g^{ba} \pmod p$
+* Per Bob: $K = A^b \pmod p = (g^a)^b \pmod p = g^{ab} \pmod p$
+
+Poiché nell'esponente la proprietà commutativa della moltiplicazione è valida ($ab = ba$), ne consegue che:
+$$g^{ab} \pmod p = g^{ba} \pmod p$$
+
+Alice e Bob hanno calcolato lo stesso identico numero $K$. Questo numero verrà ora utilizzato come chiave simmetrica per cifrare il resto della loro sessione di comunicazione.
+
+---
+
+## Esempio Didattico con Valori Ristretti
+
+Proviamo il protocollo con cifre contenute:
+
+1. **Parametri Pubblici:** Scegliamo il numero primo $p = 23$ e il generatore $g = 5$.
+2. **Alice:**
+   * Sceglie il segreto privato $a = 6$.
+   * Calcola la chiave pubblica: $A = 5^6 \pmod{23} = 15625 \pmod{23} = 8$.
+   * Invia $A = 8$ a Bob.
+3. **Bob:**
+   * Sceglie il segreto privato $b = 15$.
+   * Calcola la chiave pubblica: $B = 5^{15} \pmod{23} = 19$.
+   * Invia $B = 19$ ad Alice.
+4. **Calcolo della chiave comune $K$:**
+   * **Alice** calcola: $K = B^a \pmod{23} = 19^6 \pmod{23} = 2$.
+   * **Bob** calcola: $K = A^b \pmod{23} = 8^{15} \pmod{23} = 2$.
+
+Entrambi hanno ottenuto autonomamente il numero **2**. Un malintenzionato che ha ascoltato la conversazione conosce solo $p=23, g=5, A=8, B=19$, ma senza risolvere il logaritmo discreto non può risalire al valore 2.
+
+---
@@ -0,0 +1,69 @@
+# L'Architettura IPsec (Internet Protocol Security)
+
+**IPsec** è una suite di protocolli standard definiti dall'IETF (RFC 4301) operante al **livello di rete (Layer 3)** dello stack OSI. Il suo scopo principale è proteggere e autenticare i pacchetti IP che transitano su reti non sicure (come Internet), consentendo la creazione di reti private virtuali (VPN) sicure.
+
+A differenza di TLS, che opera a livelli superiori ed è legato alle singole applicazioni, IPsec è completamente trasparente per le applicazioni sottostanti, proteggendo tutto il traffico che transita tra due nodi di rete.
+
+---
+
+## 1. I Componenti Principali di IPsec
+
+L'architettura si basa su due protocolli fondamentali:
+
+### Authentication Header (AH - RFC 4302)
+Garantisce l'**integrità dei dati** e l'**autenticazione dell'origine** del pacchetto, offrendo anche protezione contro gli attacchi di tipo *replay*. **Non fornisce riservatezza** (i dati non sono cifrati). AH protegge anche l'header IP esterno (tranne i campi mutabili come il TTL).
+
+### Encapsulating Security Payload (ESP - RFC 4303)
+Fornisce **riservatezza** (cifratura), autenticazione dell'origine dei dati, integrità dei dati e protezione anti-replay. ESP può essere configurato solo per la cifratura, solo per l'autenticazione o, nella configurazione standard attuale, per entrambe (utilizzando algoritmi AEAD).
+
+---
+
+## 2. Modalità di Funzionamento
+
+IPsec può essere implementato in due diverse modalità a seconda della topologia di rete:
+
+### 1. Modalità Trasporto (Transport Mode)
+* Viene protetto esclusivamente il **payload** del pacchetto IP (i dati di livello superiore come TCP/UDP).
+* L'header IP originale non viene modificato né cifrato.
+* Utilizzato principalmente per comunicazioni *End-to-End* (es. da Host a Host).
+
+$$\text{Pacchetto IP Standard: } [\text{Header IP}][\text{Payload IP}]$$
+$$\text{Pacchetto ESP Transport: } [\text{Header IP}][\text{Header ESP}][\text{Payload IP Cifrato}][\text{Trailer/Auth ESP}]$$
+
+### 2. Modalità Tunnel (Tunnel Mode)
+* Viene protetto **l'intero pacchetto IP originale** (Header + Payload).
+* Il pacchetto originale viene cifrato e incapsulato all'interno di un nuovo pacchetto IP con un nuovo header (Header IP Esterno).
+* Utilizzato principalmente per connessioni *Gateway-to-Gateway* (es. VPN Site-to-Site) o *Gateway-to-Host*.
+
+$$\text{Pacchetto ESP Tunnel: } [\text{Nuovo Header IP}][\text{Header ESP}][\text{Header IP Orig Cifrato}][\text{Payload Cifrato}][\text{Trailer/Auth ESP}]$$
+
+---
+
+## 3. Aspetti Matematici e Crittografici
+
+### Lo Scambio Chiavi in IKEv2 (Diffie-Hellman)
+Durante la fase iniziale di IKEv2, i nodi concordano una chiave simmetrica comune su un canale non sicuro usando l'algoritmo **Diffie-Hellman (DH)** o la sua variante su curve ellittiche (ECDH).
+
+Dati un numero primo grande $p$ e un generatore $g$ del gruppo ciclico $\mathbb{Z}_p^*$:
+1. Il nodo $A$ sceglie un segreto privato $a$ e calcola la chiave pubblica:
+   $$X = g^a \pmod p$$
+2. Il nodo $B$ sceglie un segreto privato $b$ e calcola la chiave pubblica:
+   $$Y = g^b \pmod p$$
+3. Si scambiano $X$ e $Y$. Il segreto condiviso $K$ viene calcolato indipendentemente:
+   $$K = Y^a \pmod p = (g^b)^a \pmod p = g^{ab} \pmod p$$
+   $$K = X^b \pmod p = (g^a)^b \pmod p = g^{ab} \pmod p$$
+
+### Derivazione delle Chiavi (SKEYID)
+In IKEv2, partendo dal segreto condiviso $K$ (indicato come $g^{ab}$) e dai nonce generati dai due peer ($N_i, N_r$), viene calcolata una stringa master chiamata `SKEYID` tramite una funzione pseudo-casuale (PRF), come HMAC-SHA256:
+
+$$\text{SKEYID} = \text{PRF}(N_i \parallel N_r, g^{ab})$$
+
+Da questo valore base vengono derivate tutte le sottochiavi per il controllo del tunnel e per la cifratura/autenticazione dei dati (chiavi ESP):
+
+$$\text{SK}_d \parallel \text{SK}_a \parallel \text{SK}_e = \text{PRF}^+(\text{SKEYID}, N_i \parallel N_r \parallel \text{SPI}_i \parallel \text{SPI}_r)$$
+
+Dove:
+* $\text{SK}_d$: Chiave per la derivazione di successive SA.
+* $\text{SK}_a$: Chiave per l'autenticazione del canale di controllo.
+* $\text{SK}_e$: Chiave per la cifratura del canale di controllo.
+* $\text{SPI}$: *Security Parameter Index*, un identificatore univoco locale per la SA.
@@ -0,0 +1,101 @@
+# L'Algoritmo RSA
+
+L'algoritmo RSA è Il primo algoritmo che soddisfa i requisiti della chiave pubblica è stato messo a punto solo nel 1977 da Ron Rivest, Adli Shamir e Leonard Adlemann, ed è noto, dalle iniziali degli autori, come algoritmo RSA. 
+Ancora oggi è uno dei più utilizzati in tutto il mondo
+
+## La Base dell'Algoritmo: La Fattorizzazione di Interi
+
+La sicurezza di RSA poggia su un concetto matematico noto come **funzione unidirezionale a botola (trapdoor function)**. 
+Si tratta di un'operazione estremamente facile da eseguire in un senso, ma quasi impossibile da invertire, a meno che non si possieda un'informazione aggiuntiva (la "botola").
+
+* La funzione di complessità “polinomiale” è la **moltiplicazione di due numeri primi p e q molto grandi**; 
+Poichè noti p e q, il prodotto n = pq si calcola immediatamente. 
+
+
+* La funzione inversa, di complessità "esponenziale", è la **fattorizzazione**;
+Se un numero n è il prodotto di due numeri primi “grandi”, la sua fattorizzazione richiede di norma tempi superiori all’età dell’universo. Infatti non si conoscono a tutt’oggi (e c’è ragione di ritenere che non si conosceranno mai), algoritmi efficienti di fattorizzazione.
+
+### Esempio pratico
+Dati due numeri primi:
+$$p = 61 \quad \text{e} \quad q = 53$$
+Calcolare il loro prodotto $n$ è un gioco da ragazzi:
+$$n = p \times q = 61 \times 53 = 3233$$
+
+Ma se ti dessi direttamente $n = 3233$ e ti chiedessi di trovare i due fattori primi originali $p$ e $q$, ci vorrebbe molto più tempo. 
+Nella realtà, RSA utilizza numeri primi lunghi migliaia di cifre: un supercomputer impiegherebbe miliardi di anni per trovare i fattori primi partendo da $n$.
+
+---
+
+## Generazione delle Chiavi
+
+Vediamo come un utente (per convenzione Alice) genera la sua coppia di chiavi.
+
+### 1 - Scelta dei numeri primi p e q
+Vengono scelti due numeri primi casuali, crittograficamente sicuri e particolarmente grandi, $p$ e $q$.
+
+### 2 - Calcolo del modulo n
+Viene calcolato il loro prodotto:
+$$n = p \times q$$
+Il numero $n$ sarà la lunghezza del nostro "orologio" nell'aritmetica modulare e farà parte della chiave pubblica.
+
+### 3 - Calcolo della funzione Toziente di Eulero phi
+Si calcola la funzione $\phi(n)$ (phi di Eulero), che indica quanti numeri interi minori di $n$ sono coprimi con $n$:
+$$\phi(n) = (p - 1) \times (q - 1)$$
+
+### 4 - Scelta dell'esponente pubblico e
+Viene scelto un intero $e$ (esponente di cifratura) tale che:
+* $1 < e < \phi(n)$
+* $e$ e $\phi(n)$ siano coprimi (cioè il loro Massimo Comune Divisore sia 1).
+
+*Nota: Nella pratica comune si usa spesso il numero $e = 65537$ perché rende i calcoli veloci.*
+
+### 5 - Calcolo dell'esponente privato d
+Alice calcola l'esponente di decifratura $d$ (la chiave privata). Questo numero è l'inverso moltiplicativo di $e$ modulo $\phi(n)$. Significa che deve soddisfare la seguente formula:
+$$d \times e \equiv 1 \pmod{\phi(n)}$$
+
+### 6 - Il Mazzo di Chiavi
+A questo punto è stato generato un mazzo di chiavi composto da due coppie di numeri:
+
+* **Chiave Pubblica:** Coppia $(e, n)$
+* **Chiave Privata:** Coppia $(d, n)$ (mentre $p$, $q$ e $\phi(n)$ devono essere distrutti o nascosti!).
+
+---
+
+## Cifratura e Decifratura
+
+Supponiamo che Bob voglia inviare un messaggio segreto ad Alice.
+
+### Cifratura (Bob)
+1. Bob prende la chiave pubblica di Alice: $(e, n)$.
+3. Calcola il messaggio cifrato $C$ usando la formula di cifratura:
+   $$C \equiv M^e \pmod n$$
+4. Bob invia il messaggio cifrato $C$ ad Alice.
+
+### Decifratura (Alice)
+1. Alice riceve $C$.
+2. Usa la sua chiave privata $(d, n)$ per ripristinare il messaggio originale $M$ tramite la formula di decifratura:
+   $$M \equiv C^d \pmod n$$
+
+Grazie ai teoremi di Eulero e Fermat, l'aritmetica modulare garantisce che l'operazione $(M^e)^d \pmod n$ restituisca esattamente $M$. Un eventuale spia che intercettasse $C$, $e$ ed $n$ non potrebbe calcolare $M$ perché non conosce $d$, e calcolare $d$ richiederebbe la fattorizzazione di $n$ in $p$ e $q$.
+
+---
+
+## Esempio Pratico con Valori Ridotti
+
+1. **Scelta:** Scegliamo $p = 3$ e $q = 11$.
+2. **Modulo:** $n = 3 \times 11 = 33$.
+3. **Toziente:** $\phi(n) = (3 - 1) \times (11 - 1) = 2 \times 10 = 20$.
+4. **Esponente Pubblico:** Scegliamo $e = 3$ (notiamo che $3$ e $20$ non hanno fattori in comune, quindi sono coprimi).
+   * *Chiave Pubblica: $(e=3, n=33)$*
+5. **Esponente Privato:** Cerchiamo un numero $d$ tale che $d \times 3 \equiv 1 \pmod{20}$. Il numero è $d = 7$, infatti $7 \times 3 = 21$, e $21 \div 20$ dà resto $1$.
+   * *Chiave Privata: $(d=7, n=33)$*
+
+### Il messaggio da cifrare è  $M = 9$:
+$$C \equiv 9^3 \pmod{33} = 729 \pmod{33}$$
+Se dividiamo $729$ per $33$, otteniamo $22$ con il resto di **3**. Quindi $C = 3$.
+
+### Il messaggio da decifrare è $C = 3$:
+$$M \equiv 3^7 \pmod{33} = 2187 \pmod{33}$$
+Se dividiamo $2187$ per $33$, otteniamo $66$ con il resto di **9**. Abbiamo recuperato il messaggio originale $M = 9$!
+
+---
@@ -0,0 +1,70 @@
+# L'Algoritmo di Hashing SHA-3 (Keccak)
+
+Lo **SHA-3** (Secure Hash Algorithm 3) è l'ultimo standard di hashing rilasciato dal *NIST* nel 2015 (FIPS 202). A differenza dei suoi predecessori (SHA-1 e SHA-2), che si basano sulla struttura di Merkle-Damgård, SHA-3 adotta una filosofia completamente nuova chiamata **costruzione a spugna (Sponge Construction)**, basata sulla famiglia di primitive crittografiche **Keccak**.
+
+---
+
+## 1. La Costruzione a Spugna
+
+La costruzione a spugna permette di ricevere un input di lunghezza arbitraria e produrre un output di lunghezza desiderata. Il processo si divide in due fasi principali:
+
+1. **Fase di Assorbimento (Absorbing)**: I blocchi del messaggio di input vengono inseriti gradualmente nello stato interno tramite operazioni XOR ($\oplus$).
+2. **Fase di Spremitura (Squeezing)**: L'output viene estratto in modo incrementale dallo stato interno fino a raggiungere la lunghezza desiderata.
+
+### Parametri Fondamentali
+Lo stato interno di Keccak ha una dimensione totale di **$b = 1600$ bit**. Questo stato è diviso in due parti:
+* **Bitrate ($r$)**: La porzione di stato che interagisce direttamente con i blocchi del messaggio in input e viene estratta in output.
+* **Capacità ($c$)**: La porzione di stato tenuta nascosta all'esterno, che garantisce la sicurezza dell'algoritmo. Vale la relazione $b = r + c$.
+
+Per una data dimensione del digest di output $n$, la capacità viene solitamente impostata a $c = 2n$. Di conseguenza:
+* **SHA3-256**: $c = 512$ bit, $r = 1088$ bit.
+* **SHA3-512**: $c = 1024$ bit, $r = 576$ bit.
+
+---
+
+## Lo Stato Interno: Il "Cubo" di 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).
+
+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). 
+
+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).
+
+---
+
+## I 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.
+
+## 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:
+
+* **Resistenza alle estensioni di lunghezza (Length Extension Attacks)**: Non richiede costrutti come l'HMAC per essere sicuro come MAC, poiché la parte segreta dello stato (la capacità $c$) non viene mai esposta nel digest finale.
+* **Flessibilità**: Modificando i parametri $r$ e $c$, l'algoritmo può essere facilmente adattato per fungere da cifrario a flusso, generatore di numeri pseudocasuali (PRNG) o funzioni ad output estendibile (SHAKE128, SHAKE256).
+
+Ciononostante, la vasta maggioranza delle applicazioni oggi usa funzioni di hash del tipo precedente, non ci sono ragioni di sicurezza, ma cambiare le cose è difficile e richiede molto tempo
@@ -0,0 +1,96 @@
+# 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.
@@ -0,0 +1,42 @@
+# Minacce TCP/IP
+
+Il protocollo **TCP/IP** è la base della comunicazione su Internet. Proprio per la sua natura aperta e universale, è soggetto a numerosi attacchi che sfruttano debolezze nel design dei protocolli di rete.
+
+## Principali attacchi sul protocollo TCP/IP
+
+### IP Spoofing
+L'attaccante **falsifica l'indirizzo IP sorgente** dei pacchetti per impersonare un host fidato o nascondere la propria identità.
+
+### SYN Flood (DoS/DDoS)
+Sfrutta il meccanismo di **handshake a tre vie** di TCP:
+1. Il client invia SYN
+2. Il server risponde con SYN-ACK e alloca risorse
+3. L'attaccante **non risponde mai** con l'ACK finale
+
+Il server accumula connessioni "semiaperte" fino all'esaurimento delle risorse.
+
+### Man-in-the-Middle (MitM)
+L'attaccante si **interpone nella comunicazione** tra due host, potendo intercettare, modificare o iniettare pacchetti in tempo reale.
+
+### Teardrop
+Invio di frammenti di pacchetti IP **corrotti** che il sistema non riesce a riassemblare, mandandolo in tilt.
+
+### Botnet e DDoS
+Una rete di **dispositivi infetti** (botnet) controllati all'insaputa dei proprietari, usati per lanciare attacchi **DDoS (Distributed Denial of Service)**, mirati a disattivare un servizio sovraccaricandolo di richieste.
+
+### Session Hijacking
+Furto del **token di sessione TCP** per impersonare un utente autenticato senza conoscerne le credenziali.
+
+### DNS Poisoning / Spoofing
+Corruzione della cache DNS per **reindirizzare l'utente** verso siti malevoli pur digitando un indirizzo legittimo.
+
+### Packet Sniffing
+Intercettazione passiva del traffico di rete. Particolarmente pericolosa su reti non cifrate (HTTP, FTP, Telnet).
+
+## Contromisure
+- Utilizzo di **TLS/SSL** per cifrare le comunicazioni
+- **Firewall** e sistemi IDS/IPS
+- **IPSec** per autenticazione e cifratura a livello di rete
+- **DNSSEC** per l'integrità delle risposte DNS
+
+---
@@ -0,0 +1,69 @@
+# Il Protocollo TLS 1.3 (Transport Layer Security)
+
+Il **TLS** (Transport Layer Security), standardizzato dall'IETF (RFC 8446 per la versione 1.3), è un protocollo crittografico operante al di sopra del **livello di trasporto (Layer 4)**. Progettato come evoluzione del vecchio protocollo SSL, garantisce la sicurezza delle comunicazioni end-to-end su canali TCP, proteggendo protocolli applicativi diffusissimi come HTTP (dando vita ad HTTPS), SMTP, IMAP e FTP.
+
+TLS fornisce tre obiettivi fondamentali:
+1. **Riservatezza**: Mediante cifratura simmetrica dei dati.
+2. **Autenticazione**: Mediante certificati digitali a chiave pubblica (generalmente sul lato server).
+3. **Integrità**: Verificando che i messaggi non subiscano alterazioni tramite codici MAC.
+
+---
+
+## 1. Architettura a Due Livelli
+
+TLS 1.3 si compone di un'architettura strutturata principalmente su due macro-livelli:
+
+1. **TLS Record Protocol (Livello Inferiore)**: Riceve i dati dall'applicazione, li frammenta, applica la protezione crittografica concordata e li incapsula in record pronti per essere passati al livello TCP.
+2. **TLS Handshake Protocol (Livello Superiore)**: Gestisce la fase iniziale di negoziazione. Permette al client e al server di autenticarsi a vicenda, concordare la suite crittografica e generare in modo sicuro le chiavi simmetriche di sessione.
+
+---
+
+## Il Flusso di Handshake TLS (Transport Layer Security)
+
+Il protocollo **TLS (Transport Layer Security)**, l'evoluzione di SSL, è il pilastro fondamentale della sicurezza su Internet. Permette a due parti (tipicamente un client come un browser web e un server) di comunicare in modo sicuro tramite cifratura, autenticazione e integrità dei dati.
+
+### 1. ClientHello
+Il client avvia la connessione inviando un pacchetto di saluto (ClientHello). Questo messaggio contiene:
+
+Versioni TLS: L'elenco delle versioni del protocollo supportate (prediligendo TLS 1.3).
+
+Cipher Suites: L'elenco degli algoritmi di cifratura supportati dal client.
+
+Client Random: Una stringa di byte casuali utilizzata successivamente per prevenire attacchi di tipo replay.
+
+Key Share (Estensione): A differenza di TLS 1.2, il client assume l'algoritmo di scambio chiavi che verrà scelto (es. X25519 o P-256) e invia immediatamente la sua parte della chiave pubblica Diffie-Hellman. Questo permette di risparmiare un intero viaggio di rete (RTT).
+
+### 2. ServerHello
+Il server riceve il ClientHello, elabora le informazioni e risponde con il ServerHello:
+
+Seleziona la versione TLS 1.3 e la Cipher Suite migliore tra quelle comuni.
+
+Genera il proprio Server Random.
+
+Invia il proprio Server Key Share, completando lo scambio di chiavi Diffie-Hellman. Da questo preciso momento in poi, sia il client che il server possiedono i dati necessari per calcolare la Master Secret (chiave simmetrica) e tutta la comunicazione successiva viene cifrata.
+
+### 3. Messaggi Cifrati del Server (Server Encrypted Handshake)
+Sotto la protezione della chiave appena generata, il server invia:
+
+EncryptedExtensions: Estensioni del server che non devono essere lette in chiaro.
+
+Certificate: Il certificato digitale SSL/TLS del server (rilasciato da una CA fidata), che contiene la chiave pubblica del server.
+
+CertificateVerify: Una firma crittografica creata dal server utilizzando la sua chiave privata. Dimostra che il server possiede effettivamente la chiave privata corrispondente al certificato inviato.
+
+Finished: Un hash di tutti i messaggi dell'handshake scambiati finora, che conferma che nessuno ha manomesso i dati.
+
+### 4. Verifica del Client e Finished
+Il client esegue i seguenti controlli:
+
+Verifica la validità del Certificato (scadenza, catena di fiducia della CA, dominio corrispondente).
+
+Verifica la firma in CertificateVerify usando la chiave pubblica del certificato.
+
+Se tutto è corretto, genera le chiavi simmetriche finali di sessione.
+
+Invia il proprio messaggio di Finished al server, anch'esso protetto e contenente l'hash dei messaggi scambiati.
+
+### Passaggio alla Fase di Record
+Entrambe le parti passano all'invio dei dati applicativi (es. richieste HTTP nel protocollo HTTPS) cifrati con algoritmi simmetrici veloci e sicuri come AES-GCM o ChaCha20-Poly1305.
+
@@ -0,0 +1,57 @@
+# Gli Attacchi Informatici
+
+Gli **attacchi informatici**, nell’ultimo decennio, hanno registrato, a livello globale, un incremento significativo, sia sotto il profilo della frequenza che dell’impatto e delle dimensioni. Al punto che risulta **estremamente complesso** riuscire a identificare chi c’è dietro tali azioni e distinguere immediatamente le sorgenti di un attacco informatico.
+
+L’attacco informatico viene definito dal **National Initiative For Cybersecurity Careers And Studies (NICCS)** come “il tentativo di ottenere un accesso non autorizzato a servizi, risorse o informazioni di sistema e/o di comprometterne l’integrità e, in generale, consiste nell’atto intenzionale di tentare di eludere uno o più servizi di sicurezza o i controlli di un sistema informativo digitale per alterare la riservatezza, l’integrità e la disponibilità dei dati”.
+
+## I Diversi Tipi di Hackers
+
+Questi attacchi vengono condotti da figure dette hackers che sfruttano le loro conoscenze per divincolarsi nei sistemi informatici. 
+Vengono classificati in base alle loro intenzioni in 
+* **White Hat Hackers** : Sono hacker "etici" che mettono le loro competenze al servizio del miglioramento della sicurezza, il loro scopo è quindi scovare le vulnerabilità nei sistemi in modo da estirparle
+* **Grey Hat Hackers**: Sono figure ambigue che oscillano tra legalità e illegalità
+* **Black Hat Hackers**: sono figure che sfruttano le loro competenze informatiche per compiere azioni illecite e trarne un vantaggio personale
+
+Caso a parte sono poi gli **Hacktivists** che promuovono cause sociali e politiche attraverso attacchi informatici e gli **Hacker sponsorizzati** che agiscono per via di supporto di organizzazioni o del governo.
+
+La classificazione degli attacchi informatici dipende da quelle che sono le motivazioni che vi sono alla base. Motivazioni che, a loro volta, determinano le modalità stesse dell’azione malevola e le sue caratteristiche.
+
+### I White Hat Hackers, come si dividono?
+La sicurezza si avvale di team specializzati di white hat hackers che simulano attacchi per migliorare le difese:
+* **Red Team:** Simula i criminali informatici effettuando attacchi mirati (Penetration Test) per scovare le vulnerabilità.
+* **Blue Team:** È il team di difesa interno. Monitora l'infrastruttura, rileva le intrusioni e risponde agli attacchi.
+* **Purple Team:** Coordina Red e Blue team per massimizzare l'apprendimento e migliorare l'efficacia complessiva della sicurezza.
+
+## Classificazione degli Attacchi Informatici
+
+Come già specificato prima gli attacchi informatici sfruttano delle minacce tramite exploits per causare un impatto su un sistema.
+Distinguiamo tre macro-tipologie di attacchi, derivanti da specifiche minacce: 
+
+### I Malware
+
+Il termine deriva da *malicious software*. È un codice malevolo progettato per penetrare illecitamente in un sistema per rubare, alterare dati, spiare o assumere il controllo del dispositivo. Spesso l'infezione richiede l'inconsapevole complicità dell'utente (social engineering).
+
+### I Keylogger
+
+Un **keylogger** è uno strumento — hardware o software — che **registra ogni tasto premuto** dall'utente a sua insaputa, con l'obiettivo di sottrarre credenziali, dati sensibili e informazioni riservate.
+
+### Attacchi a Livello TCP/IP
+ 
+Il protocollo **TCP/IP** è la base della comunicazione su Internet. Proprio per la sua natura aperta e universale, è soggetto a numerosi attacchi che sfruttano debolezze nel design dei protocolli di rete.
+
+### Errori Umani
+
+Gli errori umani rappresentano storicamente la **causa principale** delle violazioni di sicurezza. Non si tratta di attacchi tecnici, ma di comportamenti che aprono vulnerabilità sfruttabili da attori malevoli — o che causano danni diretti senza alcun intervento esterno ai quali purtroppo non c'è una soluzione immediata.
+
+
+### Gli Attacchi APT (Advanced Persistent Threats)
+
+Gli attacchi APT vengono definiti come tecniche di hacking mirate e sofisticate, usate per **sabotaggio o spionaggio a lungo termine** e sono solitamente basati sul **Social Engineering**. 
+
+### Classificazione standard: CWE e CVE
+La MITRE Corporation gestisce database fondamentali per catalogare tutti questi problemi:
+* **CWE (Common Weakness Enumeration):** Un dizionario delle *debolezze* software/hardware (es. Buffer Overflow). Serve agli sviluppatori per non ripetere errori noti.
+* **CVE (Common Vulnerabilities and Exposures):** Un catalogo delle *vulnerabilità* specifiche già identificate, a cui viene assegnato un ID unico. Ad ogni CVE è associato un punteggio di gravità da 0 a 10 chiamato **CVSS (Common Vulnerability Scoring System)**.
+
+
+
@@ -0,0 +1,135 @@
+# La Progettazione della Sicurezza e il ciclo PDCA
+
+Per rendere sicuri i sistemi informatici c'è bisogno di un piano adeguato composto da politiche di sicurezza che coprano anche l'ambito organizzativo (includendo nel piano la formazione dei dipendenti dato che la maggior parte degli incidenti informatici parte da una falla umana e non tecnica) tramite modello PCDAA.
+
+Il modello **PDCA** (noto anche come **Ciclo di Deming**) è un approccio iterativo alla gestione e al miglioramento continuo dei processi. Applicato alla sicurezza informatica e all'educazione alle TIC, consente di progettare interventi strutturati, misurabili e migliorabili nel tempo.
+
+> 💡 Il ciclo PDCA non è lineare ma **circolare**: al termine di ogni ciclo, i risultati alimentano un nuovo ciclo di miglioramento.
+
+---
+
+## Il Ciclo PDCA applicato all'Educazione alla Sicurezza Informatica
+
+## PLAN — Pianifica
+
+La fase di **pianificazione** è il punto di partenza del ciclo. Si definiscono obiettivi, contesto, risorse e strategie prima di agire.
+
+### Attività principali
+
+- **Analisi del contesto**: identificare il target (studenti, dipendenti, cittadini), il livello di competenze digitali esistenti e i rischi specifici
+- **Definizione degli obiettivi**: stabilire cosa si vuole ottenere (es. ridurre gli incidenti di phishing, aumentare l'uso del 2FA, promuovere un uso consapevole dei social)
+- **Mappatura dei rischi**: individuare le minacce più rilevanti per il contesto (malware, errori umani, violazioni privacy)
+- **Progettazione del percorso formativo**: definire contenuti, metodologie didattiche, strumenti e tempistiche
+- **Allocazione delle risorse**: personale, budget, strumenti tecnologici, materiali didattici
+- **Definizione degli indicatori (KPI)**: stabilire metriche misurabili per valutare il successo
+
+### Output della fase PLAN
+
+| Output | Descrizione |
+|---|---|
+| Piano formativo | Struttura del percorso educativo |
+| Analisi dei rischi | Mappa delle minacce per il contesto |
+| KPI definiti | Indicatori misurabili di successo |
+| Calendario attività | Tempistica delle azioni previste |
+| Risorse assegnate | Budget, personale e strumenti |
+
+---
+
+## DO — Esegui
+
+La fase **operativa**: si mettono in atto le azioni pianificate, si erogano i contenuti formativi e si implementano le misure di sicurezza.
+
+### Attività principali
+
+- **Erogazione della formazione**: lezioni frontali, e-learning, workshop, simulazioni (es. simulazioni di phishing)
+- **Implementazione delle misure tecniche**: installazione antivirus, configurazione firewall, attivazione 2FA
+- **Distribuzione di materiali**: guide, vademecum, infografiche, policy di sicurezza
+- **Sensibilizzazione continua**: campagne di awareness, newsletter, poster informativi
+- **Raccolta dati**: documentare le attività svolte per la fase di verifica
+
+### Esempi di attività formative
+
+| Tipologia | Esempio |
+|---|---|
+| **Simulazione** | Invio di email di phishing simulato per testare la reazione |
+| **Workshop pratico** | Configurazione sicura di account e dispositivi |
+| **Lezione teorica** | Normativa GDPR, reati informatici, triade CIA |
+| **Esercitazione** | Riconoscimento di fake news e contenuti manipolati |
+| **Role-playing** | Gestione di un incidente informatico simulato |
+
+---
+
+## CHECK — Verifica
+
+La fase di **monitoraggio e valutazione**: si misurano i risultati ottenuti rispetto agli obiettivi pianificati, utilizzando i KPI definiti nella fase PLAN.
+
+### Attività principali
+
+- **Raccolta e analisi dei dati**: quanti utenti hanno completato la formazione? Quanti hanno superato i test?
+- **Valutazione dell'apprendimento**: test di verifica, quiz, prove pratiche
+- **Analisi degli incidenti**: si sono verificati incidenti di sicurezza durante il periodo? Di che tipo?
+- **Confronto con i KPI**: i risultati raggiunti sono in linea con gli obiettivi?
+- **Raccolta feedback**: questionari di gradimento, interviste, osservazioni
+
+### Strumenti di verifica
+
+| Strumento | Finalità |
+|---|---|
+| **Test e quiz** | Misurare l'apprendimento teorico |
+| **Simulazioni di attacco** | Valutare il comportamento pratico |
+| **Audit di sicurezza** | Verificare la corretta implementazione delle misure |
+| **Report sugli incidenti** | Monitorare l'andamento degli eventi critici |
+| **Questionari feedback** | Misurare efficacia percepita e soddisfazione |
+| **Analisi dei log** | Controllare comportamenti anomali sui sistemi |
+
+### Domande chiave della fase CHECK
+
+- Gli obiettivi sono stati raggiunti?
+- I KPI mostrano miglioramenti rispetto alla baseline?
+- Ci sono aree in cui i risultati sono sotto le aspettative?
+- Quali attività hanno funzionato meglio?
+- Cosa non ha funzionato e perché?
+
+---
+
+## ACT — Agisci (Migliora)
+
+La fase di **miglioramento continuo**: sulla base dei risultati della verifica, si apportano correzioni, si standardizzano le pratiche efficaci e si pianifica il ciclo successivo.
+
+### Attività principali
+
+- **Standardizzazione delle best practice**: ciò che ha funzionato bene diventa procedura standard
+- **Correzione delle criticità**: modificare o eliminare le attività che non hanno prodotto i risultati attesi
+- **Aggiornamento del piano formativo**: integrare nuove minacce emergenti, nuove normative, nuovi strumenti
+- **Comunicazione dei risultati**: condividere i miglioramenti ottenuti con stakeholder e partecipanti
+- **Avvio del nuovo ciclo PDCA**: i risultati di ACT diventano l'input della nuova fase PLAN
+
+### Tipi di azioni nella fase ACT
+
+| Tipo | Descrizione |
+|---|---|
+| **Azione correttiva** | Risolve una non conformità già verificatasi |
+| **Azione preventiva** | Evita il ripetersi di problemi già identificati |
+| **Azione di miglioramento** | Ottimizza processi già funzionanti |
+| **Standardizzazione** | Formalizza le pratiche efficaci in procedure stabili |
+
+---
+
+## Il Piano Completo: Schema Integrato
+
+| Fase | Domanda guida | Output |
+|---|---|---|
+| **PLAN** | Cosa vogliamo ottenere e come? | Piano formativo, KPI, analisi rischi |
+| **DO** | Come mettiamo in pratica il piano? | Formazione erogata, misure implementate |
+| **CHECK** | Abbiamo raggiunto gli obiettivi? | Report di valutazione, analisi scostamenti |
+| **ACT** | Come miglioriamo per il prossimo ciclo? | Azioni correttive, nuovo piano aggiornato |
+
+---
+
+## La Ciclicità del Modello
+
+Il punto di forza del PDCA è la sua natura **iterativa e adattiva**:
+
+> Ogni ciclo completato genera conoscenza, che alimenta il ciclo successivo rendendolo più efficace, più mirato e più rispondente ai cambiamenti del contesto digitale.
+
+In un settore in continua evoluzione come la sicurezza informatica — dove nuove minacce emergono quotidianamente — il PDCA garantisce che il piano educativo non sia mai statico, ma sempre **aggiornato, verificato e migliorato**.
@@ -0,0 +1,48 @@
+# La Crittografia Asimmetrica 
+
+La crittografia **asimmetrica** nasce per risolvere il problema dello scambio delle chiavi, una delle criticità legata alla crittografia simmetrica, tramite i principi aritmetica modulare e le proprietà dei numeri primi. 
+
+La differenza fondamentale tra quest'ultima e la crittografia simmetrica è proprio la chiave: questa volta ogni utente ne possiederà due:
+
+* La **chiave pubblica**: una chiave che è utilizzabile a tutti e utilizzata per comunicare con l'utente, nella cifratura dei dati
+
+* La **chiave privata**: una chiave che è accessibile solamente all'utente che la possiede e viene usata nella decifratura
+
+Queste due chiavi sono legate da relazioni matematiche dette **"unidirezionali con trappola"** (*trapdoor one-way functions*): 
+operazioni facili da eseguire in un senso, ma computazionalmente impossibili da invertire, a meno che non si conosca un'informazione specifica chiamata "trappola" (la chiave privata).
+
+* Ricavare la **chiave pubblica** partendo dalla privata risulti di **complessità polinomiale**
+
+* Ricavare la **chiave privata** partendo dalla pubblica risulti di **complessità esponenziale**
+
+### Cifratura
+Chiunque può cifrare un messaggio per il destinatario usando la chiave pubblica di quest'ultimo:
+$$C = E(K_{pub}, M)$$
+
+### Decifratura
+Solo il legittimo proprietario può decifrare il testo usando la propria chiave privata:
+$$M = D(K_{priv}, C)$$
+
+### Proprietà di Correttezza
+Il sistema garantisce che solo la chiave privata corrispondente possa invertire il processo:
+$$D(K_{priv}, E(K_{pub}, M)) = M$$
+
+---
+
+## Comunicazione Standard con Crittografia Asimmetrica
+
+1.  Entrambi gli utenti calcolano il loro mazzo di chiavi adoperando un determinato algoritmo
+2.  Il mittente M cifra il messaggio che vuole inviare con la chiave pubblica del destinatario T e lo invia
+3.  Il destinatario D riceve il messaggio e lo decifra con la sua chiave privata, è l'unico a poterlo fare
+
+
+> La riservatezza del messaggio è garantita ma la sua identità no, per quella serve una CA - Certification Authority, il procedimento adeguato per arrivare a garantire il triangolo della sicurezza informatica verrà descritto in un articolo a parte
+
+## Comunicazione Standard con Crittografia Asimmetrica
+
+Gli algoritmi di crittografia asimmetrica più rinomati sono:
+
+* **RSA - Rivest,Shamir,Adleman**
+* **Diffie and Hellman**
+
+Essi verrano analizzati in maniera approfondita negli articoli seguenti
@@ -0,0 +1,79 @@
+# La Crittografia Simmetrica
+
+La crittografia **simmetrica** affonda le sue radici nell'antichità, a testimonianza del fatto che l'uomo ha sempre cercato un modo per **rendere incomprensibili** le proprie informazioni riservate agli occhi degli estranei.
+
+Il suo funzionamento è molto intuitivo e prevede due funzioni (dette complessivamente **cifrario**): una di *encrypt* (cifratura) e una di *decrypt* (decifratura). Entrambe adoperano la **medesima chiave** all'interno dell'algoritmo; ciò significa che l'intera sicurezza dei dati si fonda esclusivamente sulla segretezza della chiave stessa.
+
+### Cifratura
+Per ottenere il testo cifrato si applica la funzione $E$ al messaggio usando la chiave $K$:
+$$C = E(K, M)$$
+
+### Decifratura
+Per riottenere il messaggio originale si applica la funzione $D$ al testo cifrato usando la medesima chiave $K$:
+$$M = D(K, C)$$
+
+### Proprietà di Correttezza
+L'algoritmo è valido se e solo se la decifratura annulla esattamente la cifratura:
+$$D(K, E(K, M)) = M$$
+
+---
+
+## Classificazione dei Cifrari Classici
+
+Prima di addentrarci nella storia, è fondamentale distinguere due macro-categorie di cifrari:
+
+* **Cifrari a Sostituzione:** Consistono nel sostituire ogni carattere del testo in chiaro (*plaintext*) con un altro carattere di un determinato alfabeto, basandosi su un criterio stabilito dall'algoritmo.
+* **Cifrari a Trasposizione:** Consistono nel creare un **anagramma** del testo in chiaro seguendo uno schema geometrico, senza modificare i caratteri originali o la loro frequenza, ma cambiandone solo la posizione.
+
+---
+
+## L'Evoluzione Storica
+
+### 1. La Scitale Spartana (V secolo a.C.)
+La prima nota storica di crittografia (in questo caso per trasposizione) risale alla **Scitale Spartana**. 
+
+Il suo funzionamento era molto semplice: prima di scrivere il messaggio, gli efori avvolgevano a spirale una striscia di pergamena lunga e stretta attorno a una bacchetta (*scitale*). Questa bacchetta era identica, per lunghezza e diametro, a quella fornita in precedenza al destinatario. 
+
+Dopo aver fatto aderire la pergamena alla bacchetta senza lasciare spazi vuoti o sovrapposizioni, vi scrivevano il messaggio in senso longitudinale. Una volta srotolata, la striscia mostrava solo lettere sparse e scollegate, risultando incomprensibile a eventuali intercettatori. Solo il destinatario, riavvolgendo la pergamena sulla bacchetta gemella, poteva ricostruire l'ordine originario delle lettere.
+
+### 2. Il Cifrario di Cesare (Antica Roma)
+Il **Cifrario di Cesare** è uno dei più antichi algoritmi di tipo sostitutivo (*sostituzione monoalfabetica*). Ogni lettera del testo in chiaro viene sostituita dalla lettera che si trova un certo numero di posizioni dopo nell'alfabeto (cifrario a scorrimento). In particolare, Giulio Cesare utilizzava uno spostamento fisso di **3 posizioni**.
+
+#### La vulnerabilità dei sistemi monoalfabetici
+Dall'XI secolo, con la scoperta dell'**analisi delle frequenze** da parte del matematico arabo *Al-Kindi*, tutti i cifrari a sostituzione monoalfabetica sono diventati facili da violare. Le loro vulnerabilità principali sono:
+1.  **Numero di chiavi limitato:** Facilmente attaccabile tramite *brute-force* (tentando tutte le combinazioni).
+2.  **Invarianza delle frequenze:** Le lettere cifrate mantengono la stessa frequenza statistica delle lettere della lingua originale (es. in italiano la 'E' e la 'A' compaiono più spesso), permettendo di indovinare la chiave.
+
+### 3. Il Cifrario di Alberti (1467)
+Per superare i limiti dell'analisi delle frequenze si è giunti al **cifrario polialfabetico** di Leon Battista Alberti. A differenza dei metodi precedenti, non usava lo stesso alfabeto segreto per tutto il messaggio, ma lo cambiava continuamente.
+
+Lo strumento si basava su **due dischi concentrici** ruotabili:
+* **Disco Esterno (Fisso):** Conteneva l'alfabeto in chiaro e alcuni numeri.
+* **Disco Interno (Mobile):** Conteneva un alfabeto disordinato per il testo segreto.
+
+Il funzionamento prevedeva tre passi:
+1.  **Allineamento iniziale:** Si decideva una chiave di partenza (es. allineare la `A` esterna con la `k` interna).
+2.  **Scrittura:** Si cercava la lettera in chiaro sul disco esterno e si scriveva la corrispondente sul disco mobile.
+3.  **Il colpo di genio:** Ogni tanto il mittente inseriva una lettera maiuscola nel testo. Questa indicava al ricevente di **ruotare il disco interno** su una nuova combinazione, cambiando completamente l'alfabeto da quel punto in poi.
+
+### 4. Il Cifrario di Vigenère
+Formulato successivamente, nacque come una variante semplificata del concetto di Alberti. Può essere considerato una generalizzazione del cifrario di Cesare: invece di spostare le lettere di un numero fisso di posti, lo spostamento varia carattere per carattere in base a una **parola chiave** (detta anche *verme*). La chiave viene scritta ripetutamente sotto il messaggio per determinare lo scorrimento di ogni singola lettera.
+
+### 5. Il Cifrario di Vernam - One Time Pad
+Il cifrario di Vernam è un sistema crittografico basato sul cifrario di Vigenère, al quale aggiunge il requisito che la chiave di cifratura sia lunga quanto il testo e non riutilizzabile (per questo viene spesso chiamato OTP, acronimo per l'inglese One Time Pad (OTP), letteralmente "taccuino monouso").
+Quest'ultimo è l'unico sistema crittografico la cui sicurezza sia comprovata da una dimostrazione matematica pubblicata nel 1949 da Claude Shannon per la quale si è guadagnato il titolo di "cifrario perfetto".
+Il suo funzionamento è banale, scelta una chiave lecita si effettua lo XOR tra messaggio e chiave: tuttavia nonostante la sua definizione il cifrario risulta comunque vulnerabile in caso di **riutilizzo della chiave** e **attacchi statistici specifici** in più il vincolo della chiave risulta molto complesso quando si ha a che fare con grandi quantità di dati.
+ 
+> Da questo deduciamo che nella pratica è **impossibile** ottenere segretezza perfetta
+---
+
+## La Crittografia Simmetrica Moderna: DES e AES
+
+Oggi i cifrari storici sono obsoleti. La crittografia moderna si affida ad algoritmi matematici complessi tali: 
+
+* **DES**
+* **Triple DES**
+* **AES**
+
+
+
@@ -0,0 +1,83 @@
+# La Firma Digitale e le Certification Authority
+
+La **firma digitale** è un meccanismo matematico e crittografico utilizzato per attestare l'autenticità, l'integrità e il non ripudio di un documento informatico o di un messaggio trasmesso per via telematica. Rappresenta l'equivalente informatico della firma autografa su carta, offrendo tuttavia garanzie di sicurezza nettamente superiori.
+
+---
+
+## Proprietà Fondamentali
+
+La firma digitale garantisce tre proprietà cruciali per la sicurezza informatica:
+
+1. **Autenticità**: Garantisce l'identità del firmatario. Solo il possessore della chiave privata può aver generato quella specifica firma.
+2. **Integrità**: Assicura che il documento non sia stato modificato o manomesso dopo l'apposizione della firma.
+3. **Non Ripudio**: Il firmatario non può negare di aver firmato il documento, poiché la chiave privata è sotto il suo esclusivo controllo.
+
+---
+
+## L'Applicazione Pratica delle Firme Digitali
+
+Il funzionamento si basa sulla **crittografia asimmetrica** (o a coppia di chiavi) e sull'uso di funzioni di **hashing**.
+
+* Le funzioni di hash sono algoritmi matematici che prendono in input un file e restituiscono una stringa di lunghezza fissa chiamata **digest** (l'impronta digitale del file). È un processo unidirezionale (non si può tornare al file originale) e serve a garantire l'integrità dei dati.
+
+Ogni utente possiede una coppia di chiavi:
+* **Chiave Privata ($K_{priv}$)**: Tenuta segreta dal proprietario, utilizzata per *firmare*.
+* **Chiave Pubblica ($K_{pub}$)**: Distribuita liberamente, utilizzata da chiunque per *verificare* la firma.
+
+### Fasi del Processo di Firma
+
+#### Generazione della Firma (Mittente)
+1. Viene calcolato l'impronta (hash) del messaggio $M$ tramite una funzione di hash sicura $h$:
+   $$H = h(M)$$
+2. L'impronta $H$ viene cifrata utilizzando la chiave privata del mittente $K_{priv}$. Il risultato ottenuto è la firma digitale $S$:
+   $$S = 	ext{Cifra}(K_{priv}, H)$$
+3. Il messaggio $M$ e la firma $S$ vengono inviati insieme al destinatario.
+
+#### Verifica della Firma (Destinatario)
+1. Il destinatario riceve il messaggio $M$ e la firma $S$.
+2. Calcola l'impronta del messaggio ricevuto utilizzando la stessa funzione di hash:
+   $$H_{calcolato} = h(M)$$
+3. Decifra la firma $S$ utilizzando la chiave pubblica del mittente $K_{pub}$, ottenendo l'impronta originale:
+   $$H_{estratto} = 	ext{Decifra}(K_{pub}, S)$$
+4. Il destinatario confronta i due valori:
+   $$	ext{Se } H_{calcolato} = H_{estratto} \implies 	ext{Firma Valida (Documento Autentico e Integro)}$$
+   $$	ext{Se } H_{calcolato} 
+eq H_{estratto} \implies 	ext{Firma Non Valida (Messaggio corrotto o chiave errata)}$$
+
+---
+
+## Rappresentazione Matematica del Flusso
+
+Possiamo sintetizzare l'intero schema attraverso le seguenti relazioni matematiche:
+
+$$	ext{Sintesi della Firma: } S = E_{K_{priv}}(h(M))$$
+$$	ext{Sintesi della Verifica: } D_{K_{pub}}(S) = h(M)$$
+
+Dove:
+* $M$: Il messaggio/documento originario.
+* $h$: La funzione di hash (es. SHA-256 o SHA-512).
+* $E$: L'algoritmo di cifratura asimmetrica (es. RSA o ECDSA).
+* $D$: L'algoritmo di decifratura associato.
+
+---
+
+## I Certificati Digitali 
+
+Per garantire che una determinata chiave pubblica appartenga effettivamente a un soggetto specifico, interviene un terzo attore fidato, chiamato **Autorità di Certificazione (Certification Authority - CA)**. 
+
+La CA rilascia un **Certificato Digitale** (conforme allo standard X.509) che lega l'identità del titolare alla sua chiave pubblica. La validità di questo legame è a sua volta protetta dalla firma digitale della CA stessa.
+
+
+## Le Funzioni di Hash Note
+Attualmente, le funzioni di hash più utilizzate sono, in base all'impiego:
+#### Hashing di Dati per l'Integrità
+* SHA-2 - possiede più varianti tra cui SHA-256 E SHA-512
+* SHA-3 - basato su Keccak, è l'ultimo rilasciato come standard, più sicuro di SHA-2
+#### Hashing delle Password - 
+Per l'hashing delle password si utilizzano funzioni apposite e **MAI** funzioni come SHA2 O SHA3 che sono troppo rapide e vulnerabili ad attacchi bruteforce e hardware.
+Le funzioni adoperayte vengono dette *memory-hard* e sono state progettate per essere particolarmente lente in modo da rendere complesso il **bruteforce**.
+* Argon2 - lo standard attuale
+* bcrypt - basato su Blowfish
+* scrypt
+* PBKDF2
+
@@ -0,0 +1,39 @@
+# Errori Umani
+
+Gli errori umani rappresentano storicamente la **causa principale** delle violazioni di sicurezza. Non si tratta di attacchi tecnici, ma di comportamenti che aprono vulnerabilità sfruttabili da attori malevoli — o che causano danni diretti senza alcun intervento esterno ai quali purtroppo non c'è una soluzione immediata.
+
+## Categorie di errori umani
+
+### Vittime di Phishing e Social Engineering
+L'utente viene **manipolato psicologicamente** per rivelare credenziali, cliccare su link malevoli o eseguire azioni dannose. Include:
+- Phishing via email
+- Vishing (voice phishing)
+- Smishing (SMS phishing)
+- Pretexting e impersonificazione
+
+### Gestione inadeguata delle credenziali
+- Password deboli o riutilizzate su più servizi
+- Condivisione di credenziali tra colleghi
+- Mancato aggiornamento delle password dopo una violazione
+- Post-it con password attaccati al monitor
+
+### Configurazioni errate (Misconfiguration)
+- Permessi troppo permissivi su file, cartelle o database
+- Servizi esposti su internet senza necessità
+- Bucket cloud (S3, Azure Blob) lasciati pubblici per errore
+- Default credentials non modificate
+
+### Installazione di software non autorizzato
+- Download di applicazioni da fonti non ufficiali
+- Uso di software craccato contenente malware
+- Estensioni browser malevole installate inconsapevolmente
+
+### Smaltimento non sicuro dei dati
+- Hard disk eliminati senza formattazione sicura
+- Documenti sensibili cestinati senza distruzione
+- Dispositivi aziendali venduti o donati senza sanificazione
+
+### Shadow IT
+Utilizzo di strumenti, app o servizi cloud **non approvati dall'IT aziendale**, che sfuggono a qualsiasi controllo di sicurezza.
+
+> 💡 **Il fattore umano** non si elimina con la tecnologia, ma con **formazione continua, cultura della sicurezza e processi chiari**. Il 95% delle violazioni di sicurezza ha una componente umana (fonte: IBM Cyber Security Intelligence Index).
@@ -0,0 +1,31 @@
+# Introduzione alla Cybersecurity
+
+La **sicurezza informatica (cybersecurity)** è l'insieme di pratiche, tecnologie e processi utilizzati per proteggere reti, sistemi e programmi dagli attacchi digitali.
+Questa disciplina nasce dalla necessità di rendere **sicuro** il massiccio flusso di dati che trafficava sulla rete dopo un primo esperimento di virus informatico, il Creeper, nato nel 1971.
+
+Nel modello **DIKW** (Data, Information, Knowledge, Wisdom), la sicurezza informatica si colloca al di sopra della semplice informatica (livello 3): non si limita a elaborare dati, ma utilizza la conoscenza per comprendere le informazioni, identificare i rischi, mitigare i danni e garantire la continuità operativa.
+
+> **Nota sui personaggi convenzionali:** In crittografia e sicurezza si usano nomi standard per gli esempi: **Alice e Bob** (comunicanti legittimi), **Cindy/Trudy** (intrusi attivi che alterano i messaggi), ed **Eve** (eavesdropper, spia che si limita ad ascoltare).
+
+---
+
+### Il modello CIA - Il triangolo della Cybersecurity
+
+La sicurezza delle informazioni si basa su tre obiettivi principali, noti come **Triangolo CIA (o RID in italiano)**, che ci permettono di focalizzare l'attenzione sugli aspetti da considerare per rendere una rete sicura.
+Essi sono:
+
+* **C - Confidentiality (Riservatezza):** Garantisce che le informazioni non siano **accessibili** e manipolabili da persone **non autorizzate**. Viene realizzata tramite meccanismi come la cifratura dei dati, il controllo degli accessi (autenticazione e autorizzazione) e la gestione delle identità.
+
+* **I - Integrity (Integrità):** Garantisce che le informazioni non vengano **alterate** durante il loro ciclo di vita (tramite crittografia, controlli, backup). Questo aspetto è strettamente legato anche al concetto di **Non Ripudio**, che invece garantisce che tutte le azioni in rete siano tracciate e che da esse si possa risalire al nodo che le ha effettuate. Strumenti tipici sono le funzioni di hash crittografico (es. SHA-256) e le firme digitali.
+
+* **A - Availability (Disponibilità):** Garantisce che i dati e i servizi siano sempre disponibili quando richiesti dimostrando di essere resilienti ai guasti (es. tramite ridondanza, load balancing e piani di disaster recovery). Le minacce principali a questo pilastro sono gli attacchi **DoS/DDoS** (Denial of Service), che mirano a saturare le risorse di un sistema fino a renderlo irraggiungibile.
+
+---
+
+### Il principio del minimo privilegio e la difesa in profondità
+
+Due principi cardine nella progettazione di sistemi sicuri sono:
+
+* **Principio del minimo privilegio (Least Privilege):** ogni utente, processo o componente deve disporre **solo** dei permessi strettamente necessari per svolgere la propria funzione. Ridurre la superficie di attacco limita il danno potenziale in caso di compromissione.
+
+* **Difesa in profondità (Defense in Depth):** la sicurezza non deve affidarsi a un unico meccanismo di protezione, ma a **più livelli sovrapposti** (firewall perimetrali, sistemi IDS/IPS, antivirus, segmentazione della rete, cifratura, monitoraggio SIEM). In questo modo, se un livello viene compromesso, gli altri continuano a proteggere il sistema.
@@ -0,0 +1,28 @@
+# Introduzione alla Crittografia
+
+La **crittologia** è la scienza che studia le scritture segrete e si divide in:
+* 1.  **Crittografia:** Studio degli algoritmi per offuscare (cifrare) le informazioni.
+* 2.  **Crittoanalisi:** Tecniche usate per violare i sistemi crittografici.
+
+## Il Funzionamento alla Base
+Il **Testo in chiaro** (leggibile) viene trasformato in **Testo cifrato** tramite un **Algoritmo di cifratura** e una **Chiave** (una stringa di bit).
+
+> **Principio di Kerckhoffs:** La sicurezza di un sistema crittografico non deve dipendere dalla segretezza dell'algoritmo (che deve poter essere pubblico), ma esclusivamente dalla segretezza della chiave.
+
+---
+
+## Crittografia Simmetrica vs Asimmetrica
+
+I sistemi crittografici si dividono principalmente in due grandi categorie:
+
+### 1. Crittografia Simmetrica (a chiave privata)
+Utilizza la **stessa identica chiave** sia per cifrare che per decifrare il messaggio. Un esempio moderno è l'AES.
+
+* **Pro:** È estremamente veloce ed efficiente, ideale per cifrare grandi quantità di dati.
+* **Contro:** Il problema dello scambio delle chiavi. Mittente e destinatario devono condividere la chiave in modo sicuro prima di comunicare; se un estraneo la intercetta, il sistema fallisce.
+
+### 2. Crittografia Asimmetrica (a chiave pubblica)
+Utilizza una **coppia di chiavi matematicamente collegate**: una *Chiave Pubblica* (che chiunque può conoscere e serve per cifrare) e una *Chiave Privata* (segreta, posseduta solo dal destinatario e serve per decifrare).
+
+* **Pro:** Risolve il problema dello scambio delle chiavi. Non serve condividere segreti in anticipo: chiunque può usare la chiave pubblica per inviarti un messaggio che solo tu potrai aprire.
+* **Contro:** È molto più lenta e complessa dal punto di vista matematico rispetto alla crittografia simmetrica. Per questo motivo viene spesso usata solo per scambiare in modo sicuro la chiave simmetrica all'inizio di una sessione.
@@ -0,0 +1,68 @@
+# I Keylogger
+
+Un **keylogger** è uno strumento di monitoraggio diagnostico o spionistico espressamente progettato per intercettare, registrare e memorizzare sequenzialmente gli input generati da una tastiera.
+
+## Tipologie di keyloggers
+
+I keylogger possono fare parte di due categorie:
+
+### Software 
+- Si installa come processo di sistema nascosto
+- Può catturare screenshot, appunti, form web
+- Spesso distribuito come componente di trojan o spyware
+
+### Hardware
+- Dispositivo fisico inserito tra tastiera e PC (USB/PS2)
+- Invisibile a qualsiasi antivirus
+- Richiede accesso fisico alla macchina
+
+## Keylogger Software
+I keylogger software intercettano i tasti premuti inserendosi a vari livelli dell'architettura del sistema operativo:
+
+### 1. Windows Hooks (`SetWindowsHookEx`)
+Utilizza le API native del sistema operativo Windows per installare una procedura di filtro all'interno della catena di gestione dei messaggi. Registrando l'hook di tipo `WH_KEYBOARD` o `WH_KEYBOARD_LL` (Low-Level), il keylogger riceve una copia esatta di ogni messaggio di input (`WM_KEYDOWN`, `WM_KEYUP`) prima ancora che questo venga consegnato alla finestra dell'applicazione attiva.
+
+### 2. Polling dello Stato dei Tasti (`GetAsyncKeyState`)
+Il malware esegue un ciclo continuo (*loop*) ad alta frequenza interrogando lo stato fisico di ciascun tasto tramite la funzione `GetAsyncKeyState`. Se il bit più significativo restituito dall'API è impostato a 1, significa che il tasto è attualmente premuto. Questo metodo non richiede l'iniezione di DLL ma è esoso in termini di cicli CPU se non ottimizzato.
+
+### 3. Kernel-Mode Filter Drivers
+È il metodo più avanzato e difficile da rilevare. Il keylogger si installa come un driver di filtro di alto livello sopra il driver di classe della tastiera (es. `kbdclass.sys` in Windows). Intercetta direttamente i pacchetti di richiesta di I/O (IRP - *I/O Request Packets*) generati dall'hardware prima che transitino nel sottosistema user-mode.
+
+### Funzionalità accessorie avanzate
+I moderni keylogger non limitano l'azione ai tasti, ma implementano:
+* **Form Grabbing:** Intercettazione dei dati inseriti nei form dei browser prima che vengano cifrati dal protocollo HTTPS.
+* **Clipboard Hijacking:** Monitoraggio costante degli appunti di sistema (`Ctrl+C` / `Ctrl+V`) per catturare password o sostituire al volo indirizzi di wallet di criptovalute.
+* **Screen Scraping:** Cattura di screenshot mirati ad ogni clic del mouse per eludere l'uso di tastiere virtuali a schermo.
+
+---
+
+## Keylogger Hardware
+I dispositivi hardware operano a livello fisico e sono totalmente indipendenti dal sistema operativo e dal file system della macchina bersaglio.
+* **Architettura Interna:** Sono costituiti da un microcontrollore miniaturizzato (es. architettura ARM o AVR) e da una memoria flash non volatile (da pochi megabyte fino a diversi gigabyte). Il dispositivo si interpone fisicamente tra il cavo della tastiera e la porta USB/PS2 del computer.
+* **Meccanismo di Funzionamento:** Agisce come un analizzatore di bus trasparente. Intercetta i pacchetti di report HID (*Human Interface Device*) inviati dalla tastiera, decodifica gli *Scan Codes* dei tasti premuti e li memorizza nella memoria flash interna in formato testuale. Al contempo, inoltra i pacchetti originari immutati verso il PC, garantendo che l'utente non sperimenti alcun ritardo nell'input.
+* **Esfiltrazione:** I modelli base richiedono che l'attaccante scolleghi fisicamente il dispositivo per leggere la flash (digitando una sequenza segreta di tasti per far apparire il keylogger come una comune unità disco USB). I modelli avanzati integrano moduli **Wi-Fi** ed esfiltrano i log inviandoli via email, FTP o verso un server web dedicato non appena rilevano una rete wireless disponibile.
+
+---
+
+### Matrice dei Target Informativi
+I dati esfiltrati subiscono una classificazione interna da parte del malware (tramite espressioni regolari o *regex*) per identificare stringhe ad alto valore:
+* **Credenziali d'accesso:** Analisi contestuale dei tasti digitati subito dopo l'apertura di finestre con titoli come "Login", "Sign In" o URL bancari.
+* **Dati Finanziari:** Stringhe numeriche di 16 cifre che soddisfano l'algoritmo di Luhn (numeri di carte di credito) associate a date di scadenza e codici CVV/CVC.
+* **Informazioni Sensibili:** Stringhe testuali scambiate su client di messaggistica aziendale, email o elaboratori di testi (spionaggio industriale).
+
+---
+
+## Contromisure Sperimentali
+
+### A. Autenticazione a Più Fattori (MFA / 2FA)
+Rende inutile la sottrazione della sola password. Anche se un keylogger intercetta le credenziali statiche, l'attaccante non potrà accedere al sistema senza il token dinamico OTP (One-Time Password) generato da un'app crittografica (Google Authenticator) o tramite chiavi hardware (YubiKey basate su standard FIDO2/WebAuthn).
+
+### B. Tastiere Virtuali Dinamiche (A Schermo)
+L'inserimento dei dati avviene tramite clic del mouse su una tastiera grafica. Per contrastare lo *screen scraping* associato, i sistemi bancari evoluti randomizzano la posizione dei tasti sulla matrice grafica ad ogni clic, rendendo inutile il tracciamento delle coordinate spaziali del mouse.
+
+### C. Antimalware con Moduli Euristici e Keystroke Encryption
+* **Analisi Euristica e Comportamentale:** Monitoraggio delle chiamate API. Se un processo non firmato tenta di eseguire `SetWindowsHookEx` o di aprire l'handle del driver di tastiera, l'EDR/Antivirus blocca preventivamente l'applicazione.
+* **Keystroke Encryption:** Software di sicurezza specializzati iniettano un driver a livello kernel che cifra i tasti premuti non appena vengono generati dall'hardware. I dati viaggiano cifrati lungo tutto il sistema operativo e vengono decifrati solo all'interno del processo del browser legittimo protetto, lasciando a un eventuale keylogger software solo un flusso di caratteri casuali privi di significato.
+
+### D. Ispezione Fisica e Controllo degli Accessi
+Ispezione visiva sistematica del retro dei computer aziendali per rilevare la presenza di dongle intermedi estranei inseriti nelle porte USB. Implementazione di policy di sicurezza fisiche (blocco delle porte USB inutilizzate, case dei PC chiusi a chiave) per impedire ad attori malintenzionati l'innesto di hardware ostile.
@@ -0,0 +1,51 @@
+# L'Autenticazione e l'Integrità nella Crittografia Simmetrica
+
+Nella crittografia simmetrica, algoritmi come AES (in modalità ECB o CBC) garantiscono esclusivamente la **riservatezza**: un attaccante non può leggere il messaggio, ma potrebbe comunque alterare i bit del testo cifrato causando la decifratura di dati corrotti o malevoli. 
+
+Per proteggersi da questo tipo di attacchi, la crittografia simmetrica introduce meccanismi per garantire l'**integrità** e l'**autenticazione della sorgente**.
+
+---
+
+## MAC (Message Authentication Code)
+
+Un **MAC** (noto anche come *tag di autenticazione*) è una firma simmetrica. Viene generato prendendo in input il messaggio e la chiave segreta simmetrica condivisa tra le parti.
+
+### Il Meccanismo
+Il mittente calcola il tag e lo appende al messaggio:
+$$\text{Tag} = \text{MAC}(K, M)$$
+
+Il destinatario riceve la coppia $(M, \text{Tag})$, ricalcola il MAC sul messaggio $M$ usando la stessa chiave $K$ e verifica che coincida con il tag ricevuto. 
+* Se un attaccante modifica anche un solo bit di $M$ o del $\text{Tag}$, il controllo fallisce.
+
+---
+
+## HMAC (Hash-based MAC)
+
+L'**HMAC** (RFC 2104) è un'implementazione specifica del MAC che utilizza come motore interno una funzione di hash crittografica (come SHA-256). 
+
+Non è sicuro calcolare un MAC semplicemente concatenando la chiave e il messaggio all'interno di un hash (es. $H(K \parallel M)$), perché molte funzioni di hash sono vulnerabili ai cosiddetti *Length Extension Attacks* (attacchi di estensione della lunghezza). HMAC risolve questo problema applicando la funzione di hash **due volte** e introducendo due costanti di riempimento (*padding*).
+
+
+## AEAD (Authenticated Encryption with Associated Data)
+
+Storicamente, per ottenere sia riservatezza che autenticazione, gli sviluppatori combinavano un cifrario (es. AES-CBC) e un MAC (es. HMAC) in passaggi separati. Questo approccio empirico ha causato gravissimi bug di sicurezza (come i famosi attacchi *Padding Oracle*).
+
+La moderna crittografia simmetrica ha risolto il problema introducendo i cifrari **AEAD** (standardizzati nell'RFC 5116). Un algoritmo AEAD esegue **cifratura e autenticazione simultaneamente** in un unico passaggio atomico e sicuro. Inoltre, permette di autenticare dei dati associati in chiaro ($A$), come gli header di un pacchetto di rete, che non devono essere cifrati ma non devono subire alterazioni.
+
+### La Formula Matematica
+
+$$(C, T) = \text{AEAD-Encrypt}(K, N, P, A)$$
+
+Dove:
+* $K$: La chiave simmetrica.
+* $N$: Il *Nonce* (Number Used Once), un valore numerico che deve essere tassativamente unico per ogni operazione di cifratura con la stessa chiave.
+* $P$: Il testo in chiaro (*Plaintext*).
+* $A$: I dati associati in chiaro (*Associated Data*).
+* $C$: Il testo cifrato risultante (*Ciphertext*).
+* $T$: Il tag di autenticazione integrato (*Tag*).
+
+In fase di decifratura, l'algoritmo elabora l'input ed estrae il testo in chiaro originale **solo se** il tag $T$ risulta valido. Se il tag è alterato, l'intero blocco viene scartato prima ancora di mostrare i dati corrotti.
+
+## Gli Standard più Utilizzati oggi
+* **AES-GCM** (Galois/Counter Mode): Lo standard industriale utilizzato ovunque (HTTPS, TLS 1.3, IPsec). Sfrutta la parallelizzazione ed è velocissimo sui processori moderni grazie all'accelerazione hardware.
+* **ChaCha20-Poly1305**: Un'alternativa software estremamente performante e sicura, utilizzata nativamente in protocolli come WireGuard e come suite di riserva in TLS.
@@ -0,0 +1,55 @@
+# I Malware (Malicious Software)
+
+Un **malware** è un costrutto software ingegnerizzato con finalità ostili, progettato per infiltrarsi, alterare, esfiltrare dati o compromettere la disponibilità, l'integrità e la riservatezza di un sistema informatico senza il consenso legittimo dell'amministratore.
+
+## Struttura di un malware
+In generale, un malware è composto da due parti funzionali (assimilabili a un missile):
+1.  **Vettore (Carrier):** Il mezzo attraverso cui il malware si diffonde (un file allegato, un link, una chiavetta USB) e che serve a superare le difese del sistema sfruttando una vulnerabilità.
+2.  **Carico utile (Payload):** Le istruzioni specifiche (la "testata esplosiva") che il malware esegue una volta dentro il sistema bersaglio (es. cifrare i file, rubare password, attivare la fotocamera).
+
+## Tipologie di Malware
+
+L'ecosistema delle minacce si articola in categorie distinte in base al meccanismo di replicazione, occultamento ed esecuzione:
+
+### Virus
+Un virus è un frammento di codice parassita non autonomo. Richiega l'inserimento all'interno di un file eseguibile ospite (*host*) legittimo.
+* **Meccanismo:** Quando l'utente esegue il file infetto, il controllo della CPU passa temporaneamente alla routine del virus, che infetta altri eseguibili sovrascrivendone le sezioni (es. `.text`) o inserendosi in coda (*Appending*), per poi restituire il controllo al programma originale.
+* **Esempio storico:** *ILOVEYOU* (sfruttava script VBScript allegati).
+
+### Worm
+A differenza dei virus, i worm sono programmi completamente autonomi che non necessitano di un file ospite né dell'interazione umana per replicarsi.
+* **Meccanismo:** Scansionano attivamente la rete alla ricerca di porte aperte e servizi vulnerabili. Una volta individuata una falla (es. un buffer overflow in un servizio di rete), inviano un exploit, eseguono una shellcode e scaricano una copia di se stessi sul target, propagandosi in modo esponenziale.
+* **Esempio storico:** *WannaCry* (sfruttava l'exploit EternalBlue sul protocollo SMBv1).
+
+### Trojan Horse (Cavallo di Troia)
+Software provvisto di funzionalità apparentemente lecite, utili o attraenti, che nasconde codice malevolo non visibile all'utente.
+* **Meccanismo:** Sfrutta tecniche di ingegneria sociale per indurre l'utente all'installazione (es. finti crack software o utility di sistema). Non si autoconcatena ad altri file e non si replica in rete da solo, ma funge da "apripista" per l'installazione di moduli ben più pericolosi, come i RAT (*Remote Access Trojan*).
+
+### Ransomware
+Malware focalizzato sulla distruzione della disponibilità dei dati a scopo di estorsione finanziaria.
+* **Meccanismo:** I moderni ransomware utilizzano una **cifratura ibrida**. Generano localmente una chiave simmetrica ultra-veloce (es. ChaCha20 o AES-256) per cifrare i file della vittima sul disco. Successivamente, cifrano la chiave simmetrica stessa con una chiave pubblica asimmetrica (es. RSA-4096 o ECC) il cui rispettivo segreto privato si trova esclusivamente sul server C2 dell'attaccante. Senza quella chiave privata, la decifratura è matematicamente impossibile. Inoltre, applicano la *Double Extortion*: esfiltrano i dati prima di cifrarli, minacciando di pubblicarli.
+* **Esempi attuali:** *LockBit*, *Ryuk*, *BlackCat*.
+
+### Spyware & Adware
+* **Spyware:** Progettato per violare la riservatezza monitorando silenziosamente i canali di input, la navigazione web, le credenziali memorizzate nei browser e i file locali, per poi inviarli all'attaccante. Opera in background cercando di mantenere il consumo di CPU minimo per non destare sospetti.
+* **Adware:** Meno distruttivo ma altamente invasivo, dirotta i vettori di rendering del browser o del sistema operativo per iniettare banner pubblicitari non richiesti, modificando spesso i motori di ricerca predefiniti e tracciando le abitudini di navigazione commerciale dell'utente.
+
+### Rootkit
+Insieme di strumenti software progettati per nascondere la presenza di processi, file o chiavi di registro malevole modificando i flussi di esecuzione del sistema operativo.
+* **Rootkit a livello User (Kernel-land vs User-land):** Intercettano e alterano le API di sistema (es. eseguendo l'hooking delle funzioni `NtQuerySystemInformation` in Windows) in modo che i Task Manager non mostrino il processo malware.
+* **Rootkit a livello Kernel:** Operano nel Ring 0 del processore. Modificano direttamente le strutture dati del kernel (es. la *System Service Descriptor Table* - SSDT) o caricano driver malevoli capaci di disattivare i software antivirus alla radice.
+
+### Backdoor & Botnet
+* **Backdoor:** Un punto di acesso logico che bypassa i normali controlli di autenticazione del sistema (come i login SSH o RDP). Può essere intenzionalmente inserita da sviluppatori corrotti o creata da un malware per consentire il rientro futuro dell'attaccante.
+* **Botnet:** Una rete geodistribuita di migliaia o milioni di dispositivi compromessi (definiti *Zombie* o *Bot*). Rispondono in modo sincrono ai comandi impartiti da un singolo attaccante tramite un server C2. Vengono utilizzate per sferrare attacchi DDoS (*Distributed Denial of Service*) massivi, campagne di spam o brute-forcing su larga scala.
+* **Esempio:** La botnet *Mirai*, che infettava dispositivi IoT sfruttando credenziali di fabbrica predefinite.
+
+---
+
+## Vettori di Infezione Tecnici
+* **Phishing e Malicious Attachments:** Sfruttamento di macro VBA in documenti Office, file d'archivio protetti da password (per eludere i gateway email) o file ISO/VHD contenenti scorciatoie malevole LNK.
+* **Drive-by Downloads:** Infezione trasparente che avviene semplicemente visitando un sito web compromesso o malevolo, all'interno del quale è inserito un *Exploit Kit* che sfrutta vulnerabilità note del browser o delle sue estensioni.
+* **Supply Chain Attacks:** Compromissione dei server di aggiornamento di un software legittimo. Gli utenti scaricano un aggiornamento ufficiale che però contiene al suo interno il payload malevolo (es. il caso *SolarWinds* o la vulnerabilità *XZ Utils*).
+* **Vulnerabilità Unpatched (1-Day / 0-Day):** Sfruttamento di falle nel codice di servizi esposti su Internet (es. server VPN, firewall, web server) prima che l'amministratore applichi le patch di sicurezza.
+
+---
@@ -0,0 +1,52 @@
+# PGP (Pretty Good Privacy) e la Crittografia Ibrida
+
+**PGP** (Pretty Good Privacy), originariamente creato da Phil Zimmermann nel 1991 e oggi standardizzato dall'IETF come **OpenPGP** (RFC 4880 e successivi), è un sistema crittografico utilizzato principalmente per l'autenticazione, la firma e la cifratura di email, file e directory.
+
+La vera forza di PGP sta nel fatto che non è un singolo algoritmo, ma un **sistema ibrido** che combina i vantaggi di velocità della crittografia simmetrica con la flessibilità della crittografia asimmetrica, risolvendo al contempo il problema della distribuzione delle chiavi.
+
+---
+
+## Il Funzionamento del Sistema Ibrido
+
+La crittografia asimmetrica (come RSA) è matematicamente complessa e troppo lenta per cifrare file di grandi dimensioni. La crittografia simmetrica (come AES) è velocissima, ma richiede che le parti condividano una chiave segreta in modo sicuro prima di comunicare. 
+
+PGP unisce i due mondi:
+1. Usa un algoritmo **simmetrico** veloce per cifrare il documento vero e proprio usando una chiave temporanea monouso (chiamata *Chiave di Sessione*).
+2. Usa un algoritmo **asimmetrico** per cifrare esclusivamente la chiave di sessione, che essendo molto piccola (es. 256 bit) viene elaborata istantaneamente.
+
+---
+
+## Il Flusso di Dati
+
+Immaginiamo che il mittente (Alice) voglia firmare e cifrare un messaggio $M$ per il destinatario (Bob).
+
+### Lato Mittente (Alice)
+
+1. **Generazione della Firma**: Alice calcola l'hash del messaggio e lo cifra con la propria chiave privata ($K_{privA}$), generando la firma digitale $S$:
+   $$S = E_{K_{privA}}(h(M))$$
+2. **Compressione**: Il messaggio originale e la firma vengono concatenati e compressi (es. tramite ZIP o ZIP2) per ridurre la dimensione e distruggere eventuali pattern ripetitivi del testo, ostacolando la crittoanalisi.
+3. **Generazione della Chiave di Sessione**: PGP genera una chiave simmetrica casuale e temporanea $K_{sess}$ (ad esempio per AES-256).
+4. **Cifratura del Messaggio**: Il blocco compresso viene cifrato simmetricamente con la chiave di sessione:
+   $$C_{data} = E_{K_{sess}}(M \parallel S)$$
+5. **Cifratura della Chiave**: La chiave di sessione $K_{sess}$ viene cifrata asimmetricamente utilizzando la chiave pubblica di Bob ($K_{pubB}$):
+   $$C_{key} = E_{K_{pubB}}(K_{sess})$$
+
+Il pacchetto finale inviato a Bob è la concatenazione dei due blocchi cifrati: $C_{final} = C_{key} \parallel C_{data}$.
+
+### Lato Destinatario (Bob)
+
+1. **Decifratura della Chiave**: Bob riceve il pacchetto e usa la propria chiave privata ($K_{privB}$) per estrarre la chiave di sessione:
+   $$K_{sess} = D_{K_{privB}}(C_{key})$$
+2. **Decifratura dei Dati**: Usando la $K_{sess}$ appena ottenuta, Bob decifra il blocco dati, ricavando il messaggio originale e la firma:
+   $$M \parallel S = D_{K_{sess}}(C_{data})$$
+3. **Verifica della Firma**: Bob decomprime il blocco, separa il messaggio $M$ dalla firma $S$, e usa la chiave pubblica di Alice ($K_{pubA}$) per verificare l'autenticità e l'integrità del messaggio.
+
+---
+
+## Gestione delle Chiavi: Il Web of Trust (WoT)
+
+Una delle differenze più radicali tra PGP e altri sistemi (come TLS o IPsec) risiede nella gestione dei certificati delle chiavi pubbliche. PGP non si affida a un'Infrastruttura a Chiave Pubblica (PKI) gerarchica governata da Autorità di Certificazione (CA) centrali. Utilizza invece il **Web of Trust** (Rete di Fiducia).
+
+* **Firma della Chiave**: Ogni utente può agire come una "mini-CA". Se Alice conosce Bob di persona e sa che la sua chiave pubblica è autentica, può apporre la propria firma digitale sul certificato di Bob.
+* **Fiducia Decentralizzata**: Quando Carlo riceve la chiave di Bob e vede che è firmata da Alice (di cui Carlo si fida ciecamente), accetta la chiave di Bob come valida per associazione.
+* **Livelli di Fiducia**: Gli utenti possono assegnare gradi di fiducia alle firme altrui (*Fiducia Marginale*, *Fiducia Totale*), creando un grafo di relazioni decentralizzato e distribuito che mappa la sicurezza dell'intero ecosistema senza bisogno di server centrali.
@@ -0,0 +1,38 @@
+# La Sicurezza nelle Reti: Protocolli e Strumenti di Difesa
+
+Per garantire la sicurezza nelle reti nel corso degli anni sono stati sviluppati una serie di strumenti sia a livello applicativo, nel contesto dei protocolli, sia a livello fisico nel contesto delle apparecchiature.
+
+---
+
+## Sicurezza dei Protocolli di Rete
+
+Per garantire la sicurezza delle comunicazioni su Internet, sono stati sviluppati protocolli crittografici specifici per i diversi livelli della pila di rete (ISO/OSI o TCP/IP).
+
+### Sicurezza a Livello di Rete: IPsec
+**IPsec (Internet Protocol Security)** è una suite di protocolli che protegge il traffico IP a livello di rete, garantendo autenticazione, integrità e riservatezza. È ampiamente utilizzato per creare connessioni VPN.
+
+---
+
+### Sicurezza a Livello di Trasporto: SSL/TLS
+**SSL (Secure Sockets Layer)** e il suo standard evolutivo **TLS (Transport Layer Security)** forniscono comunicazioni sicure posizionandosi tra il livello di trasporto (TCP) e quello applicativo.
+
+> **Nota:** L'applicazione più nota di TLS è l'**HTTPS**, che protegge la navigazione web cifrando il normale traffico HTTP.
+
+---
+
+## Sicurezza a Livello Applicativo
+
+Alcuni protocolli garantiscono la sicurezza e la riservatezza direttamente per specifiche applicazioni:
+* **PGP (Pretty Good Privacy) e S/MIME:** Standard crittografici utilizzati per firmare digitalmente e cifrare i messaggi di posta elettronica (e-mail). Garantiscono l'identità del mittente e impediscono l'intercettazione del testo da parte di server o soggetti terzi.
+* **SSH (Secure Shell):** Protocollo di rete crittografico utilizzato per accedere a distanza e amministrare sistemi informatici (es. riga di comando di un server Linux) in totale sicurezza. Ha sostituito i vecchi protocolli non cifrati come Telnet.
+
+---
+
+## Strumenti di Difesa delle Reti 
+
+Per rendere possibile la difesa delle reti dalle minacce, sono stati sviluppati una serie di strumenti:
+
+* **Firewall:** Dispositivo hardware o software che filtra il traffico di rete in entrata e in uscita, agendo come un "muro tagliafuoco" tra una rete interna sicura e una rete esterna (Internet) in base a regole predefinite.
+* **DMZ (Demilitarized Zone):** Sottorete isolata posta tra Internet e la rete locale (LAN). Contiene i server pubblici dell'azienda (es. server web) in modo che, se compromessi, gli attaccanti non abbiano accesso diretto alla rete aziendale interna.
+* **VPN (Virtual Private Network):** Crea un "tunnel" cifrato e sicuro attraverso una rete pubblica (come Internet), permettendo di comunicare o accedere alla rete aziendale in totale sicurezza.
+* **Honeypot:** Sistema informatico configurato intenzionalmente con vulnerabilità per attirare gli hacker, allo scopo di studiarne i comportamenti e le tecniche.
@@ -0,0 +1,176 @@
+# Standard di Riferimento per la Sicurezza Informatica
+
+## Introduzione
+
+Gli **standard di sicurezza informatica** sono insiemi di linee guida, best practice e requisiti tecnici definiti da organismi internazionali, nazionali o settoriali. Il loro scopo è fornire un **linguaggio comune** e un **framework condiviso** per progettare, implementare, gestire e migliorare la sicurezza delle informazioni e dei sistemi digitali.
+
+Adottare uno standard significa:
+- Ridurre i rischi in modo strutturato e misurabile
+- Dimostrare conformità normativa a clienti, partner e autorità
+- Migliorare la fiducia degli stakeholder
+- Facilitare l'interoperabilità tra organizzazioni
+
+---
+
+## Principali Organismi di Standardizzazione
+
+| Organismo | Nome completo | Ambito |
+|---|---|---|
+| **ISO** | International Organization for Standardization | Standard internazionali trasversali |
+| **IEC** | International Electrotechnical Commission | Standard per sistemi elettronici |
+| **NIST** | National Institute of Standards and Technology (USA) | Framework e linee guida tecniche |
+| **ENISA** | European Union Agency for Cybersecurity | Standard e raccomandazioni UE |
+| **CIS** | Center for Internet Security | Best practice pratiche e controlli |
+| **ISACA** | Information Systems Audit and Control Association | Governance IT e audit |
+| **ISF** | Information Security Forum | Standard of Good Practice |
+| **PCI SSC** | Payment Card Industry Security Standards Council | Sicurezza dei pagamenti digitali |
+
+---
+
+## ISO/IEC 27000 
+
+La famiglia **ISO/IEC 27000** è il riferimento internazionale per i **Sistemi di Gestione della Sicurezza delle Informazioni (ISMS — Information Security Management System)**.
+I principali Standard appartenenti alla famiglia sono:
+
+| Standard | Contenuto |
+|---|---|
+| **ISO/IEC 27000** | Vocabolario e panoramica della famiglia |
+| **ISO/IEC 27001** | Requisiti per l'implementazione di un ISMS,requisiti sicurezza organizzazione |
+| **ISO/IEC 27002** | Linee guida pratiche per i controlli di sicurezza |
+| **ISO/IEC 27003** | Guida all'implementazione dell'ISMS |
+| **ISO/IEC 27004** | Misurazione e metriche dell'ISMS |
+| **ISO/IEC 27005** | Gestione del rischio per la sicurezza delle informazioni |
+| **ISO/IEC 27006** | Requisiti per gli enti di certificazione |
+| **ISO/IEC 27017** | Controlli di sicurezza per i servizi cloud |
+| **ISO/IEC 27018** | Protezione dei dati personali nel cloud |
+| **ISO/IEC 27032** | Linee guida per la cybersecurity |
+| **ISO/IEC 27035** | Gestione degli incidenti di sicurezza |
+| **ISO/IEC 27701** | Estensione per la privacy (PIMS) — collegato al GDPR |
+
+---
+
+## 🇺🇸 NIST — Framework e Pubblicazioni Speciali
+
+Il **National Institute of Standards and Technology** statunitense produce standard e linee guida di riferimento globale, liberamente accessibili per individuare e ridurre i rischi relativi alla sicurezza informatica.
+
+### NIST Cybersecurity Framework (CSF)
+
+Pubblicato nel 2014, aggiornato alla versione **2.0 nel 2024**, è organizzato attorno a **6 funzioni core** cicliche dette Incident Response LifeCycle:
+
+| Funzione | Descrizione |
+|---|---|
+Fase di Preparazione all'Incidente
+| **GOVERN** (nuovo in v2.0) | Definire la strategia, le policy e i ruoli di cybersecurity |
+| **IDENTIFY** | Comprendere il contesto, gli asset e i rischi |
+| **PROTECT** | Implementare misure di protezione |
+Fase di Gestione degli Incidenti
+| **DETECT** | Identificare eventi di sicurezza |
+| **RESPOND** | Agire in risposta a un incidente rilevato |
+| **RECOVER** | Ripristinare le capacità operative dopo un incidente |
+
+### NIST Special Publications (SP) più rilevanti
+
+| Pubblicazione | Argomento |
+|---|---|
+| **NIST SP 800-53** | Controlli di sicurezza per sistemi federali USA |
+| **NIST SP 800-61** | Guida alla gestione degli incidenti informatici |
+| **NIST SP 800-63** | Linee guida per l'identità digitale e l'autenticazione |
+| **NIST SP 800-115** | Guida ai test di sicurezza tecnica |
+| **NIST SP 800-171** | Protezione delle informazioni controllate non classificate |
+| **NIST SP 800-207** | Architettura Zero Trust |
+
+---
+
+## CIS Controls
+
+I **CIS Critical Security Controls** (sviluppati dal Center for Internet Security) sono un insieme di **18 controlli prioritizzati** per la difesa informatica, progettati per essere immediatamente applicabili.
+
+### I 18 CIS Controls (v8)
+
+| # | Controllo |
+|---|---|
+| 1 | Inventario e controllo degli asset hardware |
+| 2 | Inventario e controllo degli asset software |
+| 3 | Protezione dei dati |
+| 4 | Configurazione sicura degli asset aziendali |
+| 5 | Gestione degli account |
+| 6 | Gestione del controllo degli accessi |
+| 7 | Gestione continua delle vulnerabilità |
+| 8 | Gestione dei log di audit |
+| 9 | Protezione della posta elettronica e del browser |
+| 10 | Difese contro i malware |
+| 11 | Recupero dati |
+| 12 | Gestione dell'infrastruttura di rete |
+| 13 | Monitoraggio e difesa della rete |
+| 14 | Formazione e sensibilizzazione sulla sicurezza |
+| 15 | Gestione dei fornitori di servizi |
+| 16 | Sicurezza del software applicativo |
+| 17 | Gestione della risposta agli incidenti |
+| 18 | Test di penetrazione |
+
+### Gruppi di implementazione (IG)
+
+I controlli CIS sono organizzati in tre livelli di maturità:
+- **IG1**: protezione essenziale, adatta a piccole organizzazioni
+- **IG2**: protezione intermedia, per organizzazioni con risorse IT dedicate
+- **IG3**: protezione avanzata, per organizzazioni con alta esposizione al rischio
+
+## SIEM, SOC e CERT
+
+Nel panorama della sicurezza informatica moderna, la capacità di **rilevare, analizzare e rispondere** alle minacce in tempo reale è fondamentale. Tre elementi chiave costituiscono l'ossatura operativa della difesa cyber:
+
+- **SIEM** — il sistema tecnologico di raccolta e correlazione degli eventi
+- **SOC** — il centro operativo che monitora e gestisce la sicurezza H24
+- **CERT** — il team specializzato nella risposta agli incidenti informatici
+
+Questi tre componenti non sono indipendenti: si integrano in un **ecosistema coordinato** dove la tecnologia, i processi e le persone lavorano insieme.
+
+---
+
+### SIEM — Security Information and Event Management
+
+Il **SIEM** è una piattaforma tecnologica che raccoglie, normalizza, correla e analizza in tempo reale i **log e gli eventi di sicurezza** provenienti da tutta l'infrastruttura IT di un'organizzazione, con l'obiettivo di rilevare anomalie, minacce e incidenti.
+
+> Il SIEM è gli permette al SOC di operare: senza di esso, analizzare milioni di eventi al giorno sarebbe impossibile.
+
+
+### SOC — Security Operations Center
+
+Il **SOC** è il centro operativo — fisico o virtuale — in cui un team dedicato di professionisti della sicurezza **monitora, analizza, rileva e risponde** agli eventi e agli incidenti di sicurezza informatica, tipicamente in modalità **24/7/365**.
+
+> Il SOC è la mente della sicurezza: interpreta i dati del SIEM, prende decisioni e coordina le risposte.
+
+
+### CERT — Computer Emergency Response Team
+
+Il **CERT** (anche detto **CSIRT** — Computer Security Incident Response Team) è un'unità specializzata nella **risposta coordinata agli incidenti informatici**. A differenza del SOC — che opera in modo continuo e reattivo — il CERT si attiva in modo più strutturato su incidenti specifici, spesso di maggiore complessità o impatto.
+
+> Il CERT è progettato per gestire le crisi: interviene quando l'incidente supera la capacità di gestione ordinaria del SOC.
+
+---
+## 🇪🇺 Standard e Normative Europee
+
+### NIS2 — Direttiva sulla Sicurezza delle Reti e dei Sistemi Informativi
+
+La **Direttiva NIS2 (UE 2022/2555)**, recepita in Italia nel 2024, aggiorna la precedente NIS e si applica a **operatori di servizi essenziali e importanti**.
+
+**Obblighi principali:**
+- Implementare misure di gestione del rischio cyber
+- Notificare gli incidenti significativi entro **24 ore** (notifica preliminare) e **72 ore** (notifica completa)
+- Garantire la sicurezza della supply chain
+- Formare il personale e il management sulla cybersecurity
+- Adottare politiche di crittografia e controllo degli accessi
+
+### GDPR e Sicurezza dei Dati
+
+Il **Regolamento Generale sulla Protezione dei Dati (GDPR — Reg. UE 679/2016)** impone requisiti di sicurezza specifici:
+
+| Articolo | Contenuto |
+|---|---|
+| **Art. 25** | Privacy by design e privacy by default |
+| **Art. 32** | Misure tecniche e organizzative adeguate |
+| **Art. 33** | Notifica violazione al Garante entro 72 ore |
+| **Art. 34** | Comunicazione della violazione agli interessati |
+| **Art. 35** | Valutazione d'impatto (DPIA) |
+
+---
@@ -0,0 +1,61 @@
+# Pratiche per l'Utilizzo Consapevole e Lecito delle TIC
+
+## Introduzione
+
+Le Tecnologie dell'Informazione e della Comunicazione (TIC) hanno trasformato profondamente il modo in cui lavoriamo, comunichiamo e apprendiamo. Questa trasformazione porta con sé enormi opportunità, ma anche responsabilità concrete: ogni volta che utilizziamo un dispositivo connesso, lasciamo tracce, interagiamo con altri e partecipiamo a un ecosistema digitale condiviso. Usare le TIC in modo consapevole e lecito non significa rinunciare alla libertà, ma esercitarla con intelligenza e rispetto.
+
+---
+
+## Privacy e Protezione dei Dati Personali
+
+Uno degli errori più comuni nell'uso quotidiano delle TIC è la sottovalutazione del valore dei dati personali. Spesso condividiamo informazioni sensibili — fotografie, posizione geografica, abitudini di consumo — senza renderci conto di quanto possano essere utilizzate da terzi.
+
+La soluzione non è isolarsi dalla rete, ma adottare un approccio più critico e selettivo. Prima di registrarsi a un servizio online, vale la pena chiedersi quali dati vengono richiesti e perché. Usare password robuste e diverse per ogni account, attivare l'autenticazione a due fattori e rivedere periodicamente le impostazioni di privacy sui propri profili sono abitudini semplici ma efficaci. Quando possibile, è preferibile scegliere servizi che rispettano la privacy per impostazione predefinita, limitando al minimo la raccolta dei dati.
+
+---
+
+## Rispetto della Proprietà Intellettuale
+
+Il digitale ha reso straordinariamente facile copiare, condividere e riprodurre contenuti. Questa facilità, però, non rende automaticamente lecito qualsiasi utilizzo. Musica, testi, immagini e software sono opere protette, frutto del lavoro creativo e intellettuale di qualcuno.
+
+Un approccio responsabile significa cercare attivamente alternative legali: esistono piattaforme che offrono contenuti gratuiti con licenze aperte, archivi di immagini libere, software open source di alta qualità. Citare le fonti quando si utilizza il lavoro altrui — anche in ambito scolastico o personale — è una pratica di rispetto fondamentale, oltre che un buon esercizio intellettuale. Presentare come propri contenuti scritti o creati da altri, inclusi quelli generati da intelligenze artificiali senza rielaborazione critica, è una forma di disonestà che impoverisce chi la pratica prima ancora che chi ne è vittima.
+
+---
+
+## Comportamento Etico Online
+
+La distanza fisica che il digitale interpone tra le persone può dare una falsa sensazione di impunità, spingendo alcuni a comportarsi online in modi che non si permetterebbero mai di persona. Insulti, diffamazioni, esclusioni sistematiche e cyberbullismo sono fenomeni reali che causano danni reali, spesso sottostimati.
+
+La risposta più efficace è costruire una cultura della responsabilità digitale, a partire da sé stessi. Significa verificare le informazioni prima di condividerle, per non diventare involontariamente veicoli di disinformazione. Significa anche non restare spettatori passivi quando si assiste a comportamenti scorretti online: segnalare contenuti inappropriati, supportare chi è bersaglio di attacchi e non alimentare dinamiche tossiche sono azioni concrete che ognuno può compiere.
+
+---
+
+## Sicurezza Informatica
+
+Le minacce informatiche — virus, phishing, ransomware — non riguardano solo grandi aziende o istituzioni. Chiunque utilizzi un dispositivo connesso è un potenziale bersaglio, e spesso gli attacchi sfruttano proprio la disattenzione o la mancanza di informazione degli utenti.
+
+Difendersi è più semplice di quanto si pensi, a patto di adottare alcune pratiche di base con costanza. Mantenere aggiornati sistemi operativi e applicazioni risolve molte vulnerabilità note. Non aprire allegati o cliccare su link provenienti da mittenti sconosciuti è una regola d'oro che vale ancora oggi, nonostante le tecniche di inganno si siano raffinate. Fare backup regolari dei propri dati — su un disco esterno o su un servizio cloud affidabile — è la misura più efficace contro la perdita irreversibile di informazioni importanti.
+
+---
+
+## Uso Responsabile dei Social Media
+
+I social media amplificano la nostra voce e ci connettono con persone in tutto il mondo, ma amplificano anche gli errori. Ciò che pubblichiamo online può rimanere accessibile per anni, essere condiviso fuori contesto e raggiungere persone che non avevamo immaginato. La gestione consapevole della propria identità digitale è quindi una competenza sempre più essenziale.
+
+Un buon punto di partenza è rivedere periodicamente le impostazioni di privacy dei propri profili, limitando la visibilità dei contenuti alle persone di fiducia. Prima di pubblicare foto o video che ritraggono altre persone, è importante chiedere il loro consenso esplicito. Più in generale, vale la pena sviluppare l'abitudine di chiedersi, prima di ogni pubblicazione: *"Sarei a mio agio se questo contenuto fosse visto da chiunque, tra dieci anni?"*
+
+---
+
+## Benessere Digitale
+
+Un aspetto spesso trascurato nell'uso delle TIC è il loro impatto sul benessere personale. L'iperconnessione, la difficoltà a staccarsi dai dispositivi e l'esposizione continua a flussi di notizie e notifiche possono generare stress, ansia e difficoltà di concentrazione.
+
+Prendersi cura del proprio benessere digitale significa innanzitutto riconoscere questi rischi. Stabilire momenti della giornata senza dispositivi, limitare le notifiche alle sole comunicazioni davvero urgenti e imparare a distinguere l'informazione affidabile dai contenuti progettati per catturare l'attenzione sono strategie concrete e alla portata di tutti. L'obiettivo non è demonizzare la tecnologia, ma integrarla nella propria vita in modo che sia uno strumento al servizio delle proprie esigenze, e non il contrario.
+
+---
+
+## Conclusione
+
+Usare le TIC in modo consapevole e lecito è, in definitiva, una questione di cultura prima ancora che di regole. Le norme esistono e vanno rispettate, ma la vera differenza la fanno le scelte quotidiane di ogni singolo utente: la cura con cui gestiamo i nostri dati, il rispetto che dimostriamo verso il lavoro altrui, l'attenzione che poniamo nelle nostre interazioni online. In un ambiente digitale sempre più pervasivo, ognuno di noi è co-responsabile della qualità di quello spazio condiviso.
+
+> *"La libertà digitale si esercita davvero solo quando include il rispetto per gli altri."*
@@ -0,0 +1,43 @@
+# Vulnerabilità, Minacce ed Exploit
+
+Per comprendere a fondo la cybersecurity è essenziale distinguere tre concetti spesso confusi tra loro: **vulnerabilità**, **minaccia** ed **exploit**.
+
+## Le Vulnerabilità
+
+Una **vulnerabilità** è una debolezza o un difetto presente in un sistema, un'applicazione o un processo che può essere sfruttata per comprometterne la sicurezza. Le vulnerabilità possono essere di natura:
+
+* **Software:** bug nel codice, configurazioni errate, librerie obsolete o mancanza di validazione degli input (es. *buffer overflow*, *SQL injection*, *Cross-Site Scripting – XSS*).
+* **Hardware:** difetti fisici nei componenti o nelle architetture dei processori (es. le vulnerabilità *Spectre* e *Meltdown* del 2018, legate all'esecuzione speculativa della CPU).
+* **Umana (Human Factor):** comportamenti scorretti degli utenti, come l'uso di password deboli, la caduta in truffe di *phishing* o la condivisione involontaria di credenziali. Questo è spesso il vettore di attacco più sottovalutato e più efficace.
+* **Procedurale:** assenza o inadeguatezza di policy di sicurezza, mancata applicazione di patch, assenza di piani di risposta agli incidenti.
+
+Le vulnerabilità vengono catalogate a livello internazionale attraverso il sistema **CVE (Common Vulnerabilities and Exposures)**, un registro pubblico mantenuto dal MITRE che assegna a ogni vulnerabilità nota un identificatore univoco (es. `CVE-2021-44228` per *Log4Shell*). La gravità di ciascuna viene misurata tramite il punteggio **CVSS (Common Vulnerability Scoring System)**, su una scala da 0 a 10.
+
+## Le Minacce e gli Exploit
+
+Una **minaccia** è qualsiasi evento o agente – interno o esterno – potenzialmente in grado di sfruttare una vulnerabilità e causare un danno. Le minacce possono essere **intenzionali** (attacchi mirati, malware, insider threat) o **accidentali** (errori umani, guasti hardware, calamità naturali).
+
+Le minacce vengono classificate principalmente in:
+
+* **Malware**
+* **Keylogger** 
+* **TCP/IP**
+* **Errori Umani**
+
+Un **exploit** è invece il meccanismo tecnico concreto – spesso un frammento di codice – che sfrutta una specifica vulnerabilità per eseguire azioni non autorizzate. Esistono exploit di tipo **zero-day** quando vengono utilizzati prima che il produttore abbia rilasciato una patch correttiva, rendendoli particolarmente pericolosi.
+
+La relazione tra questi tre elementi può essere sintetizzata così:
+
+> *Una **minaccia** sfrutta una **vulnerabilità** tramite un **exploit** per causare un impatto sul sistema.*
+
+
+### Il  Processo di Gestione delle Vulnerabilità
+
+La gestione proattiva delle vulnerabilità (Vulnerability Management) prevede un ciclo continuo articolato in quattro fasi:
+
+1. **Identificazione:** tramite strumenti di *vulnerability scanning* (es. Nessus, OpenVAS) e *penetration testing*.
+2. **Valutazione:** prioritizzazione in base al punteggio CVSS, al contesto aziendale e all'esposizione reale.
+3. **Remediation:** applicazione di patch, aggiornamenti, modifiche di configurazione o introduzione di *compensating controls*.
+4. **Verifica:** ri-scansione del sistema per confermare che la vulnerabilità sia stata effettivamente risolta.
+
+---
@@ -4,7 +4,7 @@
 <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>CryptoSeals - Home</title>
+    <title>CryptoSeals</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="style.css">
    <script src="index.js" defer></script>
@@ -26,8 +26,9 @@
            <i class="fa-solid fa-bars"></i>
        </div>
        <ul class="nav-links" id="nav-links">
-            <li><a href="rsa.html"><i class="fa-solid fa-key"></i> RSA</a></li>
-            <li><a href="cesare.html"><i class="fa-solid fa-arrow-right-arrow-left"></i> Cesare</a></li>
+            <li><a href="rsa.html"><i class="fa-solid fa-key"></i>RSA</a></li>
+            <li><a href="cesare.html"><i class="fa-solid fa-landmark"></i>Cesare</a></li>
+            <li><a href="materiale.html"><i class="fa-regular fa-clipboard"></i></i>Materiale</a></li>
            <li><a href="team.html"><i class="fa-solid fa-users"></i> Il Team</a></li>
        </ul>
    </nav>
@@ -37,11 +38,11 @@
        <h1>Welcome to CryptoSeals</h1>
        <p class="descrizione">
            Dive deep, Seal your data. <i class="fa-solid fa-water"></i><br><br>
-            Scegli uno strumento dal menu per iniziare a proteggere i tuoi messaggi!
+            Esplora gli strumenti nella barra in alto per conoscere il mondo della sicurezza informatica
        </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>
@@ -0,0 +1,106 @@
+<!DOCTYPE html>
+<html lang="it">
+
+<head>
+    <meta charset="UTF-8">
+    <title>CryptoSeals - Sezione Divulgativa</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <link rel="stylesheet" href="style.css">
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <script>
+        window.MathJax = {
+            tex: {
+                inlineMath: [['$', '$'], ['\\(', '\\)']]
+            },
+            options: {
+                skipHtmlTags: ['script', 'noscript', 'style', 'textarea', 'pre']
+            }
+        };
+    </script>
+    <script src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
+</head>
+
+<body>
+    <nav class="navbar">
+        <a href="index.html" class="nav-brand">
+            <img src="seal1.png" height="80" alt="🦭">
+            CryptoSeals
+        </a>
+        <div class="menu-toggle" onclick="toggleMenu()">
+            <i class="fa-solid fa-bars"></i>
+        </div>
+        <ul class="nav-links" id="nav-links">
+            <li><a href="rsa.html"><i class="fa-solid fa-key"></i>RSA</a></li>
+            <li><a href="cesare.html"><i class="fa-solid fa-landmark"></i>Cesare</a></li>
+            <li><a href="materiale.html"><i class="fa-regular fa-clipboard"></i></i>Materiale</a></li>
+            <li><a href="team.html"><i class="fa-solid fa-users"></i> Il Team</a></li>
+        </ul>
+    </nav>
+
+    <body>
+        <div class="main-wrapper">
+            <aside class="sidebar">
+                <h3>Indice Appunti</h3>
+                <nav>
+                    <button class="btn-appunto" onclick="showfile('documentazione/intro.md', this)">Introduzione alla
+                        Cybersecurity</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/vuln.md', this)">Le
+                        Vulnerabilità</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/attacchi.md', this)"> Gli Attacchi
+                        Informatici</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/malware.md', this)">I Malware</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/keylogger.md', this)">I
+                        KeyLogger</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/TCPattacks.md', this)">Gli Attacchi a
+                        TCP/IP</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/humans.md', this)">Il Fattore
+                        Umano</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/APT.md', this)">Gli Attacchi
+                        APT</button>
+                    <button class="btn-appunto"
+                        onclick="showfile('documentazione/intro_crittografia.md', this)">Introduzione
+                        Crittografia</button>
+                    <button class="btn-appunto"
+                        onclick="showfile('documentazione/crittografia_simmetrica.md', this)">Crittografia
+                        Simmetrica</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/AES.md', this)">AES</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/mac.md', this)">MAC,HMAC E
+                        AEAD</button>
+                    <button class="btn-appunto"
+                        onclick="showfile('documentazione/crittografia_asimmetrica.md', this)">Crittografia
+                        Asimmetrica</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/RSA.md', this)">RSA</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/DF.md', this)">Diffie and
+                        Hellman</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/fingerprint.md', this)">Le Firme
+                        Digitali</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/SHA512.md', this)">SHA 2 -
+                        SHA-512</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/SHA3.md', this)">SHA 3</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/ciclo_pdca.md', this)">La
+                        Progettazione della Sicurezza</button>
+                    <button class="btn-appunto"
+                        onclick="showfile('documentazione/standard_sicurezza.md', this)">Standard Sicurezza</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/sicurezza_reti.md', this)">Sicurezza
+                        nelle Reti</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/IPSEC.md', this)">Protocollo
+                        IPSec</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/TLS.md', this)">Protocollo
+                        TLS</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/pgp.md', this)">Protocollo
+                        PGP</button>
+                    <button class="btn-appunto" onclick="showfile('documentazione/tic.md', this)">Pratiche per
+                        l'Utilizzo Consapevole delle TIC</button>
+                </nav>
+            </aside>
+
+            <main class="content-area">
+                <div id="markdown-content" class="appunti-style">
+                    <h1>Seleziona un argomento</h1>
+                    <p>Clicca a sinistra per caricare gli appunti.</p>
+                </div>
+            </main>
+        </div>
+        <script src="materiale.js"></script>
+    </body>
@@ -0,0 +1,30 @@
+// Utilizzata la libreria marked per trasformare markdown in html
+async function showfile(filename, target) {
+    const bottoni = document.querySelectorAll('.btn-appunto');
+    bottoni.forEach(b => b.classList.remove('active'));
+    if (target) target.classList.add('active');
+
+    const container = document.getElementById('markdown-content');
+    container.innerHTML = "<p>Caricamento in corso...</p>";
+
+    try {
+        const response = await fetch(filename);
+        if (!response.ok) throw new Error("File non trovato");
+
+        const markdownRaw = await response.text();
+
+        container.innerHTML = marked.parse(markdownRaw);
+
+        if (window.MathJax && typeof MathJax.typesetPromise === 'function') {
+            MathJax.typesetPromise([container]).catch(function (err) {
+                console.error("Errore nel rendering di MathJax: ", err);
+            });
+        } else if (window.MathJax && window.MathJax.typeset) {
+            MathJax.typeset([container]);
+        }
+
+    } catch (error) {
+        console.log(error)
+        container.innerHTML = "<p style='color:red'>Errore nel caricamento dell'appunto.</p>";
+    }
+}
@@ -18,44 +18,45 @@
            <i class="fa-solid fa-bars"></i>
        </div>
        <ul class="nav-links" id="nav-links">
-            <li><a href="rsa.html"><i class="fa-solid fa-key"></i> RSA</a></li>
-            <li><a href="cesare.html"><i class="fa-solid fa-arrow-right-arrow-left"></i> Cesare</a></li>
+            <li><a href="rsa.html"><i class="fa-solid fa-key"></i>RSA</a></li>
+            <li><a href="cesare.html"><i class="fa-solid fa-landmark"></i>Cesare</a></li>
+            <li><a href="materiale.html"><i class="fa-regular fa-clipboard"></i></i>Materiale</a></li>
            <li><a href="team.html"><i class="fa-solid fa-users"></i> Il Team</a></li>
        </ul>
    </nav>

    <div class="container">
-        <h1>Motore RSA</h1>
-        <p class="descrizione">Cifra e decifra i tuoi messaggi con lo standard di sicurezza a chiave pubblica. Scegli la dimensione delle chiavi, scrivi e lascia fare alle foche.</p>
+        <h1>Algoritmo RSA (Rivest-Shamir-Adleman)</h1>
+        <p class="descrizione">Scegli la dimensione delle chiavi, scrivi e lascia fare alle foche.</p>
        
        <div class="crypto-box">
            
            <label>Dimensione Chiave RSA</label>
            <select id="keysize">
-                <option value="512">512 bit (Solo didattico - Veloce)</option>
-                <option value="1024" selected>1024 bit (Test - Bilanciato)</option>
-                <option value="2048">2048 bit (Standard - Lenta da generare)</option>
-                <option value="3072">3072 bit (Ottima - Mediamente Lenta)</option>
-                <option value="4096">4096 bit (Alta sicurezza - Molto lenta)</option>
+                <option value="512">512 bit</option>
+                <option value="1024" selected>1024 bit</option>
+                <option value="2048">2048 bit</option>
+                <option value="3072">3072 bit</option>
+                <option value="4096">4096 bit</option>
            </select>
            
            <div class="crypto-columns">
                
                <div class="crypto-col">
-                    <label>Testo in chiaro</label>
-                    <textarea id="plaintext" class="pulse-textarea" placeholder="Scrivi il messaggio segreto che vuoi proteggere..."></textarea>
+                    <label>Plaintext</label>
+                    <textarea id="plaintext" class="pulse-textarea" placeholder="Digita qui il messaggio da cifrare"></textarea>
                    <button onclick="encrypt()">🔒 Cifra il messaggio</button>
                </div>

                <div class="crypto-col">
-                    <label>Testo Cifrato (Base64)</label>
-                    <textarea id="ciphertext" placeholder="Il testo protetto apparirà qui..."></textarea>
+                    <label>Ciphertext</label>
+                    <textarea id="ciphertext" placeholder="Il testo cifrato comparirà qui"></textarea>
                    <button class="btn-green" onclick="decrypt()">🔓 Decifra il messaggio</button>
                </div>

            </div>
            <div style="margin-top: 35px;">
-                <label>Risultato finale decifrato</label>
+                <label>Decoded - Ciphertext</label>
                <textarea id="decodedtext" readonly placeholder="Il messaggio originale apparirà qui dopo la decifratura..." style="height: 100px; background-color: #0b0f19; border-color: rgba(16, 185, 129, 0.3); color: #10b981;"></textarea>
            </div>
        </div>
@@ -21,6 +21,9 @@
 body {
    font-family: 'Poppins', sans-serif;
    background: radial-gradient(circle at top right, #1f2937, var(--bg-dark));
+    background-attachment: fixed;
+    background-position: center;
+    background-size: cover;
    color: var(--text-main);
    min-height: 100vh;
    display: flex;
@@ -283,6 +286,140 @@ footer a {
        display: block;
    }
 }
+/* --- Sezione Divulgativa --- */
+.appunti-style ul,
+.appunti-style ol {
+    padding-left: 1.5em;
+    margin-top: 1.5em;
+    margin-bottom: 1.5em;
+}
+
+.appunti-style li,
+.appunti-style p {
+    padding-bottom: 1.5em;
+}
+.appunti-style {
+    background: rgba(255, 255, 255, 0.05); /* Un leggero sfondo chiaro per staccare */
+    padding: 30px;
+    border-radius: 15px;
+    margin-top: 0px;
+    line-height: 1.8;
+    text-align: left; /* Fondamentale per la lettura */
+    color: #f0f0f0;
+}
+
+.appunti-style h1:not(:first-child), 
+.appunti-style h2:not(:first-child), 
+.appunti-style h3:not(:first-child) {
+    color: var(--accent-green); 
+    margin-top: 1.5em;
+}
+
+/* Stile per i blocchi di codice */
+.appunti-style pre {
+    background: #000;
+    padding: 15px;
+    border-radius: 8px;
+    overflow-x: auto;
+    border: 1px solid #333;
+}
+
+.appunti-style code {
+    font-family: 'Courier New', monospace;
+    color: #ffca28; /* Giallo per far risaltare le variabili/formule */
+}
+.main-wrapper {
+    display: flex;
+    max-width: 100%;
+    margin: 100px 5% 50px; /* Spazio per la navbar */
+    gap: 30px;
+    padding: 0;
+}
+
+/* Sidebar Style */
+.sidebar {
+    flex: 0 0 300px; /* Larghezza fissa 250px */
+    background: rgba(255, 255, 255, 0.05);
+    backdrop-filter: blur(10px); /* Effetto vetro sfocato */
+    border-radius: 15px;
+    padding: 20px;
+    height: fit-content;
+    position: sticky;
+    top: 100px; /* Si blocca quando scendi */
+    border: 1px solid rgba(77, 184, 255, 0.2);
+}
+
+.sidebar h3 {
+    color: var(--accent-green);
+    font-size: 1.2rem;
+    margin-bottom: 20px;
+    border-bottom: 1px solid rgba(77, 184, 255, 0.3);
+    padding-bottom: 10px;
+}
+
+.sidebar nav {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 10px;
+}
+
+/* Bottoni nella sidebar */
+.btn-appunto {
+    background: transparent;
+    color: white;
+    border: none;
+    text-align: left;
+    padding: 12px 15px;
+    border-radius: 8px;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 1rem;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    text-align: left;
+    justify-content: flex-start;
+    width: 100%;
+}
+
+.btn-appunto i {
+    width: 20px; /* Allinea le icone */
+    color: var(--accent-green);
+}
+
+.btn-appunto:hover {
+    background: rgba(77, 184, 255, 0.1);
+    padding-left: 20px; /* Effetto movimento al passaggio */
+}
+
+.btn-appunto.active {
+    background: var(--accent-green);
+    color: #0b0f19;
+}
+
+.btn-appunto.active i {
+    color: #0b0f19;
+}
+
+/* Area contenuto */
+.content-area {
+    flex: 1; /* Prende tutto lo spazio rimanente */
+    min-width: 0; /* Evita bug di overflow con flex */
+}
+
+/* Responsive per cellulari */
+@media (max-width: 768px) {
+    .main-wrapper {
+        flex-direction: column;
+        margin-top: 80px;
+    }
+    .sidebar {
+        position: static;
+        flex: none;
+        width: 100%;
+    }
+}
 /* --- SFONDO SPAZIALE ANIMATO --- */
 .sfondo-spazio {
    position: fixed; /* Lo fissa allo schermo */
@@ -20,8 +20,9 @@
            <i class="fa-solid fa-bars"></i>
        </div>
        <ul class="nav-links" id="nav-links">
-            <li><a href="rsa.html"><i class="fa-solid fa-key"></i> RSA</a></li>
-            <li><a href="cesare.html"><i class="fa-solid fa-arrow-right-arrow-left"></i> Cesare</a></li>
+            <li><a href="rsa.html"><i class="fa-solid fa-key"></i>RSA</a></li>
+            <li><a href="cesare.html"><i class="fa-solid fa-landmark"></i>Cesare</a></li>
+            <li><a href="materiale.html"><i class="fa-regular fa-clipboard"></i></i>Materiale</a></li>
            <li><a href="team.html"><i class="fa-solid fa-users"></i> Il Team</a></li>
        </ul>
    </nav>
Author	SHA1	Message	Date
elisabetta	2c2c2b4987	miao Deploy / trigger (push) Successful in 27s Details	2026-05-28 13:01:08 +02:00
elisabetta	5c1b206053	miao Deploy / trigger (push) Successful in 31s Details	2026-05-28 11:34:01 +02:00
elisabetta	cff0b9ff48	last commit??	2026-05-28 11:15:56 +02:00
elisabetta	d0cd326c8a	primo ultimo commmit Deploy / trigger (push) Successful in 23s Details	2026-05-27 20:06:49 +02:00
elisabetta	d126b27015	is this the end?? Deploy / trigger (push) Successful in 25s Details	2026-05-27 19:45:21 +02:00
elisabetta	089d5c1af1	commit Deploy / trigger (push) Successful in 20s Details	2026-05-26 12:58:19 +02:00
elisabetta	9568774e35	touch repository Deploy / trigger (push) Successful in 21s Details	2026-05-26 12:51:29 +02:00
elisabetta	5c837d81cf	mao zedong Deploy / trigger (push) Successful in 22s Details	2026-05-26 12:48:07 +02:00
elisabetta	8838e5d846	chat is this legal Deploy / trigger (push) Successful in 22s Details	2026-05-26 12:46:43 +02:00
elisabetta	bb0e460073	still cooking like a pro (francesco) Deploy / trigger (push) Successful in 22s Details	2026-05-26 12:43:51 +02:00
elisabetta	0361eba45c	still cooking Deploy / trigger (push) Successful in 24s Details	2026-05-26 12:40:16 +02:00
elisabetta	655123c717	still cooking Deploy / trigger (push) Successful in 20s Details	2026-05-26 12:38:31 +02:00
elisabetta	62049bdbb6	francesco is cooking Deploy / trigger (push) Successful in 21s Details	2026-05-26 12:35:51 +02:00
elisabetta	256042b255	francesco fa danni Deploy / trigger (push) Successful in 21s Details	2026-05-26 12:27:29 +02:00
elisabetta	264a1d777c	new things Deploy / trigger (push) Successful in 23s Details	2026-05-26 12:25:35 +02:00
elisabetta	716a081f7a	Modifiche articoli e css Deploy / trigger (push) Successful in 39s Details	2026-05-26 11:28:26 +02:00
elisabetta	2552d25980	new article + polish Deploy / trigger (push) Successful in 44s Details	2026-04-30 18:07:04 +02:00
elisabetta	6e4a4839d3	fix	2026-04-29 18:43:44 +02:00
elisabetta	5171a1e925	i forgot the filename Deploy / trigger (push) Successful in 24s Details	2026-04-29 18:38:49 +02:00
elisabetta	40e18daf2b	miao Deploy / trigger (push) Successful in 35s Details	2026-04-29 18:36:28 +02:00
elisabetta	9506765838	Now you can learn !!	2026-04-29 18:17:40 +02:00
elisabetta	3680f36105	style Deploy / trigger (push) Successful in 21s Details	2026-04-29 11:04:59 +02:00
elisabetta	d101b22ac1	sidebar test Deploy / trigger (push) Successful in 21s Details	2026-04-29 11:02:25 +02:00
elisabetta	fe6d5901a2	css Deploy / trigger (push) Successful in 22s Details	2026-04-29 10:48:22 +02:00
elisabetta	860e5e70e3	non so leggere Deploy / trigger (push) Successful in 21s Details	2026-04-29 10:13:00 +02:00
elisabetta	6779697607	Merge branch 'main' of https://git.vps.francescomancuso.it/elisabetta/cryptoseals Deploy / trigger (push) Successful in 30s Details	2026-04-29 10:11:02 +02:00
elisabetta	6068319033	testing...............................	2026-04-29 10:10:57 +02:00
francesco	6477512940	iDropped my alph in hot oil Deploy / trigger (push) Successful in 24s Details Signed-off-by: Francesco Mancuso <hello@francescomancuso.it>	2026-04-21 13:55:31 +02:00
francesco	8c23a08e2a	Very well fried Deploy / trigger (push) Successful in 25s Details Signed-off-by: Francesco Mancuso <hello@francescomancuso.it>	2026-04-21 13:49:44 +02:00
francesco	5086cdf6b8	iForgot Panzerotti Deploy / trigger (push) Successful in 25s Details parentesi fritte sono gustose Signed-off-by: Francesco Mancuso <hello@francescomancuso.it>	2026-04-21 13:45:38 +02:00
francesco	d7cca0099b	panzerotti Deploy / trigger (push) Successful in 36s Details vogliamo i panzerotti Signed-off-by: Francesco Mancuso <hello@francescomancuso.it>	2026-04-21 13:38:46 +02:00
elisabetta	93ade8c460	will it work?? Deploy / trigger (push) Successful in 22s Details	2026-04-20 22:59:29 +02:00
elisabetta	532ecd47b6	idk how to read actually Deploy / trigger (push) Successful in 24s Details	2026-04-20 22:55:18 +02:00
elisabetta	080c067f27	will it work??	2026-04-20 22:53:49 +02:00