Denial of service: L’attacco SYN Flood e mitigazione.

Attacco SYN flood.

TCP SYN flood è un tipo di attacco DDoS (Distributed Denial of Service) che sfrutta parte del three-way handshake TCP per consumare risorse sul server target e renderlo non reattivo.

Essenzialmente, con i DDoS SYN flood, l’autore dell’attacco invia le richieste di connessione TCP più velocemente di quanto il computer target le possa elaborare (possa farle decadere), causando la saturazione della rete.

  • Il client richiede la connessione inviando un messaggio SYN al server.
  • Il server conferma inviando un messaggio SYN-ACK  al client.
  • Il client risponde con un messaggio ACK  e la connessione viene stabilita.
  • In un attacco SYN flood, l’aggressore invia pacchetti SYN ripetuti a ogni porta del server mirato, spesso utilizzando un indirizzo IP falso. Il server, inconsapevole dell’attacco, riceve richieste multiple, apparentemente legittime, di stabilire una comunicazione. Risponde ad ogni tentativo con un pacchetto SYN-ACK da ogni porta aperta.
  • Il client dannoso non invia l’ACK previsto oppure, se l’indirizzo IP è stato spoofed, non riceve mai il SYN-ACK. In entrambi i casi, il server sotto attacco aspetterà per qualche tempo la conferma del suo pacchetto SYN-ACK.

 

Ricapitoliamo su  SYN flood.

Un attacco SYN-flood DDoS sfrutta il processo di handshake a tre vie TCP (Transmission Control Protocol) inondando più porte TCP sul sistema di destinazione con messaggi SYN per avviare una connessione tra il sistema di origine e il sistema di destinazione.

Questo fa sì che la macchina di destinazione tenti di aprire una connessione per ogni richiesta malevola e successivamente attenda un pacchetto ACK che non arriva mai. Un server sotto un attacco di SYN flood continuerà ad attendere un pacchetto SYN-ACK per ogni richiesta di connessione, poiché il ritardo potrebbe essere normale e legato alla congestione della rete.

Tuttavia, poiché un pacchetto SYN-ACK non arriva mai per nessuna delle richieste di connessione; il numero massiccio di connessioni semiaperte riempie rapidamente la tabella TCB del server prima che possa effettuare qualsiasi connessione. Questo processo continua per tutto il tempo in cui continua l’attacco di flood.

 

 SYN flood
attacco SYN flood

Il sistema target risponde con un messaggio SYN-ACK  per ogni messaggi o SYN ricevuto e apre temporaneamente una porta di comunicazione per ogni tentativo di connessione in attesa di un ultimo messaggio ACK (conferma) dalla sorgente in risposta a ciascun messaggio SYN-ACK. La sorgente che attacca non invia mai i messaggi ACK finali e quindi la connessione non è mai completata. La connessione temporanea alla fine si esaurirà e verrà chiusa, ma non prima che il sistema di destinazione sia sovraccaricato di connessioni incomplete.



Three-way handshake

Un handshake a tre vie (Three-way handshake) è un metodo utilizzato in una rete TCP/IP per creare una connessione tra un host/client locale e un server. Si tratta di un metodo in tre fasi che richiede sia al client che al server di scambiare i pacchetti SYN e ACK (riconoscimento-acknowledgment) prima dell’inizio della comunicazione dei dati.

Funziona così:

  • Un  client invia un pacchetto dati SYN su una rete IP a un server sulla stessa rete o a una rete esterna. L’obiettivo di questo pacchetto è di chiedere se il server è disponibile per nuove connessioni.
  • Il server di destinazione deve disporre di porte aperte in grado di accettare e avviare nuove connessioni. Quando il server riceve il pacchetto SYN dal nodo client, risponde e restituisce una ricevuta di conferma, il pacchetto ACK o SYN/ACK.
  • Ilclient riceve il SYN/ACK dal server e risponde con un pacchetto ACK.
  • Al termine di questo processo, viene creata la connessione e l’host e il server sono in grado di comunicare.

 

Vediamo

Tcp-handshake
Tcp-handshake : Client = A : Server = B

 

  1. A invia un segmento SYN a B – il flag SYN è impostato a 1 e il campo Sequence number contiene il valore x che specifica l’Initial Sequence Number di A;
  2. B invia un segmento SYN/ACK ad A – i flag SYN e ACK sono impostati a 1, il campo Sequence number contiene il valore y che specifica l’Initial Sequence Number di B e il campo Acknowledgment numbercontiene il valore x+1 confermando la ricezione del ISN di A;
  3. A invia un segmento ACK a B – il flag ACK è impostato a 1 e il campo Acknowledgment number contiene il valore y+1 confermando la ricezione del ISN di B.



Il terzo segmento non sarebbe, idealmente, necessario per l’apertura della connessione in quanto già dopo la ricezione da parte di A del secondo segmento.  Entrambi gli host hanno espresso la loro disponibilità all’apertura della connessione. Tuttavia esso risulta necessario al fine di permettere anche all’host B una stima del timeout iniziale, come tempo intercorso tra l’invio di un segmento e la ricezione del corrispondente ACK.

Modalità di attacco SYN flood.

I principali modi in cui avvengono gli attacchi di tipo SYN flood sono vari, e vengono descritti di seguito:

  • Attacco diretto

In questo tipo di attacco, l’attaccante invia richieste SYN multiple e in rapida successione, senza neanche nascondere il suo indirizzo IP. Per risultare più efficace l’attaccante può modificare il suo sistema in modo da non rispondere al SYN-ACK.

  • Attacco distribuito

L’attacco distribuito (Distribuited direct attacks) è un tipo di attacco che permette all’attaccante di utilizzare non più una singola macchina, ma fare affidamento a N macchine. Questo permette ad ogni singola macchina di sferrare un attacco diretto ricorrendo anche alla tecnica dello spoofing, con conseguente difficoltà da parte della vittima di difendersi da vari attacchi SYN flood. Al giorno d’oggi questi attacchi sono possibili poiché esistono reti di molte macchine, le cosiddette Botnet, che permettono ai vari cyber criminali di sferrare attacchi senza esser riconosciuti.

  • Spoofing attack

In questo tipo di attacco, l’attaccante ricorrendo all’utilizzo dello spoofing, riesce a creare una connessione (SYN request) con il server vittima, il quale risponde con un SYN-ACK. Il server tuttavia non riceverà mai una risposta da parte dell’attaccante, lasciando di conseguenza la connessione aperta e provocando la congestione del traffico sul server.

 

syn_flood_spoofed
SYN flood con  spoofing IP



Lo spoofing IP

Lo spoofing IP è la creazione di pacchetti IP utilizzando indirizzi sorgente IP precostruiti o random. Viene utilizzato per nascondere l’identità del mittente. Lo spoofing IP è utilizzato più frequentemente negli attacchi di  tipo denial of service. In tali attacchi, l’obiettivo degli aggressori è solo quello di generare pacchetti con una quantità enorme di traffico, e l’aggressore non si preoccupa di ricevere alcuna risposta al pacchetto IP.
Lo spoofing IP utilizza indirizzi IP randomizzati che diventa l’indirizzo di origine degli attacchi. Tali indirizzi  sono difficili da filtrare in quanto ogni pacchetto spoofed appare provenire sempre da un ip diverso, e in questo modo sono più difficili le contromisure.

Mitigazione di un attacco SYN flood.

SYNPROXY

SYNPROXY è un target di iptables che è stato aggiunto nella versione 3.12 del kernel Linux e iptables 1.4.21. CentOS 7 ha eseguito il backport della funzionalità ed è disponibile nel suo kernel 3.10 di default.

Lo scopo di SYNPROXY è di verificare se l’host che ha inviato il pacchetto SYN stabilisce effettivamente una connessione TCP completa o semplicemente non fa nulla dopo aver inviato il pacchetto SYN.

Se non fa nulla, scarta il pacchetto con un impatto minimo sulle prestazioni.

Ecco le regole di SYNPROXY iptables che aiutano a mitigare le “inondazioni” di SYN:

  1. iptables -t raw -A PREROUTING -p tcp -m tcp –syn -j CT –notrack
  2. iptables -A INPUT -p tcp -m tcp -m conntrack –ctstate INVALID,UNTRACKED -j SYNPROXY –sack-perm –timestamp –wscale 7 –mss 1460
  3. iptables -A INPUT -m conntrack –ctstate INVALID -j DROP

Vogliamo proteggere un unico indirizzo ip ?

  1. iptables -t raw -I PREROUTING -p tcp -m tcp -d 192.168.0.50 –syn -j CT –notrack
  2. iptables -I INPUT -p tcp -m tcp -d 192.168.0.50 -m state –state INVALID,UNTRACKED -j SYNPROXY –sack-perm –timestamp –wscale 7 –mss 1460
  3. iptables -A INPUT -m state –state INVALID -j DROP



Continuiamo?

Bene, perché non mettiamo un pochetto in sicurezza il nostro server ?

Il seguente esempio farà cadere le connessioni in entrata se l’IP effettua più di 30 connessioni alla porta 80 entro 200 secondi.

#!/bin/bash
PA=/sbin/iptables
# Numero di secondi
SECONDI=200
# Nr massimo di connessioni per IP
RAGGIUNTOLIMITE=30
# posiamo far scaturire un DROP o  un REJECT
AZIONE=”DROP”
$PA -A INPUT -p tcp –dport 80 -i eth0 -m state –state NEW -m recent –set
$PA -A INPUT -p tcp –dport 80 -i eth0 -m state –state NEW -m recent –update –seconds ${SECONDI} –hitcount ${RAGGIUNTOLIMITE} -j ${AZIONE}

oppure ancora più brutale: massimo 20 connessioni !

/sbin/iptables -A INPUT -p tcp –syn –dport 80 -m connlimit –connlimit-above 20 -j REJECT –reject-with tcp-reset

brutale al massimo: setto il numero di connessioni totali sulla porta a 3000 e droppo

iptables -t filter -I INPUT -p tcp –syn –dport 80 -m connlimit –connlimit-above 3000 -j DROP

E’ semplice limitare numero connessioni !

Esempio porta 22 con massimo di connessioni per ip

iptables -A INPUT -p tcp –syn –dport 22 -m connlimit –connlimit-above 3 -j REJECT

Quindi, bastano poche linee e possiamo stare un pochettino più tranquilli. Implementatele sempre !

Blocchiamo lo spoofed packets.

  1. iptables -t mangle -A PREROUTING -s 0.0.0.0/8 -j DROP
  2. iptables -t mangle -A PREROUTING -s 127.0.0.0/8 ! -i lo -j DROP

la Vs rete

iptables -t mangle -A PREROUTING -s 192.168.0.0/23 -j DROP

e quindi potete aggiungere tutte le i segmenti che volete
iptables -t mangle -A PREROUTING -s xxx.xxx.xxx.x/y -j DROP

dopo, potreste anche implementare….

Droppiamo pacchetti TCP che sono “new” ma non sono SYN.

iptables -t mangle -A PREROUTING -p tcp ! –syn -m conntrack –ctstate NEW -j DROP

e dopo questo potreste …

Blocchiamo i Bogus packets.

Oltre allo spoofing dei pacchetti, ci sono altri tipi di pacchetti “fasulli” che un aggressore potrebbe generare per cercare di esporre i processi nello stack di rete. Prendiamo ad esempio i flag SYN e FIN. TCP SYN è usato per richiedere l’apertura di una connessione TCP su un server; TCP FIN è usato per terminare una connessione esistente. Quindi, ha senso inviare un pacchetto che ha sia SYN che FIN impostati insieme?

Assolutamente no. Questo tipo di pacchetti sono “fasulli”, in quanto utilizzano combinazioni di flag che non hanno senso. Tuttavia, alcune implementazioni di rete possono essere ingannate in qualche strano comportamento quando vengono ricevuti pacchetti così inaspettati. La miglior difesa, quindi, è proprio quella di rifiutarli tutti. Ecco come limitare i pacchetti fasulli usando iptables:

Droppiamo i pacchetti non validi immediatamente

iptables -A INPUT -m state –state INVALID -j DROP
iptables -A FORWARD -m state –state INVALID -j DROP
iptables -A OUTPUT -m state –state INVALID -j DROP

e quindi Droppiamo quelli fasulli

iptables -A INPUT -p tcp -m tcp –tcp-flags SYN,FIN SYN,FIN -j DROP
iptables -A INPUT -p tcp -m tcp –tcp-flags SYN,RST SYN,RST -j DROP

 

Giovanni Popolizio