DoS - Come effettuare un attacco DoS in poche semplici mosse
April 13, 2021
La guida
In questa piccola guida vediamo di studiare un attacco DoS, non entrando troppo nel dettaglio in maniera tale da favorire la lettura anche a chi non è molto avvezzo ancora. Mi baso sul codice pubblicato da Hacker Journal nell’edizione N. 249 che volendo potrete acquistare tramite il loro sito web ufficiale. Se non sai neanche che cosa vuol dire “Attacco DoS” allora ti consiglio di leggere la guida completa di Stefano Novelli, accessibile cliccando qui, oppure dare una veloce lettura quanto meno per capire quale è il nostro obiettivo.
L’articolo
Nell’articolo pubblicato su Hacker Journal l’obiettivo non è semplicemente effettuare un attacco DoS, bensì loro spiegano come sia possibile effettuare un attacco tramite la IoT(Internet delle Cose) quindi distribuendolo su più macchine. Non scenderò nel dettaglio volontariamente al fine di mantenere una difficoltà bassa per chiunque.
Cosa serve
Basterà avere un computer con un qualunque Sistema Operativo, io utilizzo Ubuntu, attualmente alla versione 20.10
Avere Python installato, se non sai come installarlo puoi seguire questa guida.
Un programma utile a studiare il nostro attacco, consiglio principalmente Wireshark, però se volete potete anche installare etherape tramite il comando [ICODE]apt install etherape[/ICODE] per vedere come il nostro attacco prende vita.
Programma pronto all’uso
Creazione del programma
Andiamo quindi a creare finalmente il nostro programma, se volete saltare questa parte potete scaricarlo dal mio GitHub ovviamente gratuitamente.
Per prima cosa create un file con estensione .py e salvate.
Una volta creato il programma apriamolo e importiamo 2 librerie:
Python:
import socket
import threading
che rispettivamente socket ci serve per creare effettivamente il paccheto e per gestire la connessione e threading per creare più istanze di processo.
Fondamentalmente ci serviranno 3 informazioni principalmente, iptarget ovvero l’indirizzo che vogliamo attaccare e ipfake indirizzo fake dell’host che potrebbe essere non necessaria(visto che già creaimo la connessione TCP) qualora non fosse una informazionie richiesta dalla cache dei proxy e in fine port ovvero la porta alla quale vogliamo mandare il pacchetto, per ora mettiamo 80.
Python:
iptarget = "192.168.1.11"
ipfake = "111.111.111.111"
port = 80
Adesso andiamo a creare effettivamente la funzione che, una volta lanciata, verrà eseguita fino a che non verrà bloccata volontariamente. Ovviamente fate attenzione a non lasciarla avviata perché potreste avere problemi a lungo andare, è buona usanza chiuderla subito dopo aver raccimulato abbastanza dati su cui studiare.
Python:
def attacco():
iptarget = "192.168.1.11"
ipfake = "111.111.111.111"
port = 80
while True:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((iptarget, port))
s.sendto(("GET /" + iptarget + " HTTP/1.1\ r\n").encode("ascii"), (iptarget, port))
s.sendto(("Host: " + ipfake + "\r\n\r\n").encode("ascii"), (iptarget, port))
s.close()
- def attacco() Definisce la funzione di nome attacco
- iptarget, ipfake, port Crea le variabili necessarie
- While True: Dichiara il ciclo che verrà ripetuto “teoricamente” per sempre
- s = socker… Inizio creazione del pacchetto, lo stiamo dichiarando con il protocollo TCP, se non sai di cosa sto parlando e vuoi approfondire l’argomento ti lascio questa guida che spiega di cosa si tratta, se già sai che cos’è il TCP e vuoi approfondire questa riga di codice ti lascio questa domanda fatta su Stackoverflow che lo spiega in maniera semplice.
- s.connect(…) Creo la connessione verso l’iptarget alla porta port
- s.sendto(….) Creo la richiesta HTTP
- s.sendto(…) Dichiaro come Host l’ipfake dichiarato precedentemente
- s.close() Chiudo la connessione, alla nuova iterazione(del ciclo While) verrà riaperta e così via…
In fine andiamo a creare tutti i Thread che, andandoli ad eseguire, non faranno altro che mandare richieste.
Python:
for i in range(60000):
thread = threading.Thread(target = attacco)
thread.start()
- for in range(60000): Il ciclo crea un nuovo Thread ad ogni iterazione per 60.000 volte, quindi avrò 60.000 Thread che manderanno richieste
- thread… Dichiaro il mio Thread specificandogli che cosa dovrà eseguire una volta avviato
- thread.start() Avvio il Thread
Passiamo all’attacco
E' arrivato il momento di Hackerare la NASA!!!
No dai, restando più sul reale andremo a far partire il programma -> Che a sua volta andrà a creare 60.000 Thread(Nel mio caso) -> Che a loro volta andranno a creare una connessione verso l’indirizzo vittima, gli manderà un pacchetto e poi chiuderà la connessione.
Prima di avviare la nostra macchina da guerra armatevi di Wireshark e, se volete, anche di etherape e subito dopo averli avviati sarete pronti per far partire il vostro programma.
Per lanciare un programma Python vi basta cliccare sul pulsante Play nella maggior parte degli ambienti di sviluppo, oppure scrivere [ICODE]python3
…
Una volta avviato il programma, avviate i programmi di controllo, dopo pochi secondi dovreste vedere i primi pacchetti catturati e quindi potrete chiuderli. Bastano pochi secondi visto che le nostre macchine processano milioni di piccole operazioni al secondo. Ricordate di terminare anche il programma!!!
Studiamo l’attacco
Al fine di studiare nel migliore dei modi l’attacco e capire che cosa succede una volta avviato vedremo in primis una rappresentazione grafica tramite etherape e poi parleremo un po' di ciò che ci rileva Wireshark.
In questa prima immagine possiamo vedere il nostro attacco in corso d’opera. A sinistra abbiamo Wireshark che sta catturando i nostri pacchetti, li vedremo meglio dopo, a destra vediamo etherape che come si può notare ha rilevato un incredibile quantità di pacchetti, a destra invece vediamo il nostro programma scritto e il terminale che lo mantiene in esecuzione.
Wireshark
Wireshark è una vera e propria miniera di informazioni, tanto che alcune ci vengono fornite semplicemente, altre vengono tirate fuori da alcuni algoritmi “sotto il cofano”. Senza scendere troppo nel dettaglio, potete notare che nella colonna Source e Destination ci sono 2 indirizzi IP ricorrenti.
192.168.1.16 ed 192.168.1.11
Uno lo conosciamo bene perché lo abbiamo dichiarato nel programma come indirizzo vittima, l’altro invece? L’altro è l’indirizzo della macchina dalla quale è stato mandato l’attacco, il nostro computer.
“Ma noi avevamo messo un altro IP, avevamo messo ipfake” ve lo dicevo che non sarebbe bastato, preferisco ad ogni modo non approfondire il tema per evitare di aumentare la complessità.
Se ci fate caso, andando in basso a sinistra nella foto, potete vedere una riga che comincia con Internet Protocol(IP) Version 4, e rispettivamente Src(Sorgente): … Dst(Destinazione):… Subito dopo quella riga ne possiamo vedere un altra, Transmission Control Protocol dove, tra le innumerevoli informazioni, possiamo vedere la porta sorgente Src Port:.. e la porta destinatario che, ovviamente, è esattamente quella che gli abbiamo detto nel programma, ovvero la porta 80.
Etherape
Tramite questo bel programmino possiamo vedere che cos’è successo senza troppe scritte come con Wireshark. Il dispositivo attaccato è il mio iPhone che si chiama iPhoneAlessandro-001 e, come potete vedere, a differenza delle altre connessioni(rappresentate dalle altre linee) noi abbiamo qualcosa di abnorme! Se vogliamo possiamo dire che lo spessore è direttamente proporzionale ai pacchetti in transito da quelle zone e in questo caso ce ne sono veramente tante!
Nella seconda immagine possiamo vedere che cos’è successo in quel punto enorme rosso. Come si evince dalla foto stiamo parlando della nostra vittima che risponde all’indirizzo 192.168.1.11 e che proprio nella porta 80 (non a caso quella indicata nel nostro programma) ha ricevuto la bellezza di 7.905 pacchetti. Sono tanti? Sono pochi? Io dico che se uno vuole approcciarsi a questo mondo sono abbastanza per studiare, i server reali riescono a gestire giusto un paio di pacchetti in più ! :D Se vogliamo approfondire lo studio possiamo certamente prendere nota dei dati forniti come velocità, spazio accumulato, dimensione media ecc…
E invece l’attaccante?
Anche per lui c’è qualcosa da studiare, certamente molto di più con Wireshark ma vediamo cosa ci offre il nostro bel programmino. Intanto ci comunica il nome del nostro computer, o meglio, come viene visualizzato -> dell.homenet.telecomitalia.it che corrisponde al nostro IP reale 192.168.1.16 Anche in questo caso vediamo una grande quantità di pacchetti HTTP relativi alla porta 80
Conclusioni
Detto ciò, io spero veramente con tutto il cuore che questa guida possa servire a qualcuno per approfondire il tema degli attacchi DoS. Molto spesso vedo sul forum utenti che fanno qualche domanda a riguardo e spesso e volentieri si ha la voglia di studiare l’argomento. Ecco a voi un semplicissimo punto di partenza per studiare gli attacchi DoS. Effettuare un attacco del genere ad un server di un certo livello richiede una grande potenza e per tanto è veramente difficile strutturare un attacco serio ad un server buono. Con un server ad una velodità di accesso di R bps, l’attaccante avrà bisogno di mandare traffico a una velocità approssimativamente uguale a R bps per causare danni. Se _R è molto grande, una singola sorgente di attacco non potrà mai essere in grado di danneggiare il server stesso. Ecco da dove nasce l’esigenza di distribuire l’attacco (DDoS) su più macchine.
Nota bene
Questa guida non è un manuale per come fare danni ma tende a diffondere materiale di studio utile per approfondire certi temi sulla sicurezza informatica. Qualora prendessi ciò di cui ho parlato per divulgarlo/usarlo con intendi malevoli io mi dissocio e sono totalmente esente dalle tue scelte. Anche un tentato attaco mal riuscito è pursempre un reato e per tanto punibile secondo codice penale anche con la reclusione! Se vuoi testare il programma allora attacca un altro tuo dispositivo come ho fatto io stesso in questa guida attaccando il mio telefono. Se non sai come scrivilo nei commenti e o io o qualcuno della community ti aiuterà a trovare ciò che cerchi.