Informazioni

Hale è un monitor/spia per botnet command & control con un design modulare per sviluppare facilmente nuovi moduli che monitorano nuovi protocolli usati dai server C&C. Hale include monitor IRC e HTTP sviluppati con Twisted per gestire la scalabilità di un grande numero di connessioni. Questi moduli hanno una grammatica del protocollo e impostazioni dei bot configurabili, ma possono anche essere modificati per adattarsi alle proprie esigenze. Tutti i log e i file catturati vengono salvati in un database e, nel caso di IRC, vengono tracciati anche gli IP.

Per nascondere la posizione dell'operatore, le connessioni possono essere effettuate tramite proxy SOCKSv5 e questo è configurabile tramite l'interfaccia web, dove tutti i log sono disponibili per la navigazione insieme a grafici statistici e timeline. L'interfaccia è stata sviluppata con Django e Google Visualization API. Alcuni extra nell'interfaccia web includono il supporto per un'API RESTful con supporto OAuth e un motore di ricerca.

L'idea principale di Hale è aiutare la caccia alle botnet e la ricerca a collaborare creando una rete di sensori (monitor Hale). Per migliorare questa idea, è disponibile un bot XMPP per connettersi a un server XMPP centralizzato, dove attualmente vengono usate due diverse stanze di gruppo: una per il coordinamento tra i sensori e una per la condivisione di log e file. La stanza di coordinamento utilizza hash delle botnet generati dalle chiavi univoche nelle impostazioni della botnet; in questo modo due botnet non devono essere monitorate simultaneamente se hanno lo stesso hash (identità), migliorando l'utilizzo. Per aiutare terze parti a usare questa rete, un bot può unirsi alla stanza di coordinamento e chiedere a un sensore di iniziare a tracciare una botnet se non è tracciata, inviandone le configurazioni. Inoltre, nella stanza di condivisione, i bot di terze parti possono ottenere in tempo reale log e file catturati dai sensori. Per consultare la cronologia dei log è possibile usare l'API web, che supporta richieste GET.

Installazione

Hale ha le seguenti dipendenze:

Python == 2.6
Django == 1.2.1
Twisted == 10.1.0
GeoIP-Python == 1.2.4 (and GeoIP C lib)
Whoosh == 0.3.18
django-haystack == 1.0.1-final
django-piston == 0.2.3rc1
pefile == 1.2.10-63
sleekxmpp == 0.9Rrc1
wsgiref == 0.1.2
zope.interface == 3.6.1
oauth2 == 1.2.0
httplib2 == 0.6.0

Inoltre, il monitor richiede un driver di backend del database corrispondente al database usato da Django. Quando queste librerie sono installate, scarica i sorgenti da qui ed estraili ovunque.

Configurazione

1. Prima crea un database che verrà usato da Hale; il motore del database può essere quello che preferisci. Se stai usando un database esistente, salta questo passaggio.

2. Il passo successivo è installare i driver Python di backend corrispondenti a quelli usati dal motore del server.

3. Modifica settings.py in hale/src/webdb/ e imposta le seguenti configurazioni: ENGINE, NAME, USER, PASSWORD, HOST e PORT, dove l'impostazione engine è ad esempio django.db.backends.mysql se il motore del server è MySQL. L'impostazione name è il nome del database usato durante la sua creazione.

4. Se non vuoi avviare la tua interfaccia web, salta questo passaggio e vai al punto 8). In settings.py, imposta PATH_TO_APP in modo che punti al percorso completo dell'applicazione Django, ad esempio: '/home/..../Hale/src/webdb'. Nella directory webdb esegui il seguente comando: python manage.py syncdb. Se ricevi errori, molto probabilmente le impostazioni del database in settings.py non sono corrette. Inoltre, durante la sincronizzazione, imposta il superutente che verrà usato per amministrare gli utenti.

5. Per supportare la ricerca nell'interfaccia web, esegui python manage.py rebuild_index per far indicizzare il motore di ricerca la prima volta. Questo creerà una directory chiamata ; per consentire al server web di scrivervi, esegui . Dopodiché esegui e dovresti inserirlo come cron job per aggiornare gli indici a un intervallo regolare di tua scelta.

    Alias /media /usr/local/lib/python2.6/dist-packages/django/contrib/admin/media/
    <Location /media>
      Order allow,deny
      Allow from all
    </Location>


    WSGIDaemonProcess username processes=2 maximum-requests=500 threads=10
    WSGIProcessGroup group

    WSGIScriptAlias / /home/..../webdb/django.wsgi

e modifica lo username e il gruppo con cui il demone WSGI deve essere eseguito. WSGIScriptAlias deve essere impostato al percorso completo del file django.wsgi situato nella directory webdb. L'alias specificato sopra è necessario affinché la pagina di amministrazione venga renderizzata correttamente. Per poter caricare moduli tramite l'interfaccia web, esegui chmod o+w webdb/modules.

8. Carica i moduli che verranno usati da hale/src/modules/ oppure scrivine di tuoi (vedi la sezione Sviluppo). Carica il modulo desiderato nell'interfaccia di amministrazione e modifica, ad esempio, il nome del modulo su irc e il nome del file su ircModule.py. Specifica le regole di configurazione per il modulo nella sezione corrispondente situata in hale/conf/modules.conf e inseriscile nella casella di testo; aggiungi inoltre le sezioni uniqueKeys per il modulo caricato.

9. Prima di eseguire il monitor, modifica hale.conf in hale/src/conf/ se desideri usare un server XMPP. Per attivare il bot XMPP, imposta l'impostazione use su True e modifica le informazioni di accesso con un account e un server esistenti oppure avvia il tuo server XMPP. Un passaggio importante quando si avvia un server XMPP è aumentare la dimensione massima della stanza (max stanza size) dal valore predefinito a qualcosa come 10Mb. Altrimenti la segnalazione di malware non sarà possibile. Le impostazioni del canale in hale.conf sono usate per la stanza di condivisione usata dal bot, mentre l'impostazione coord è usata per la stanza di gruppo in cui avviene tutto il coordinamento tra i sensori.

10. Modifica hale.conf e imposta le impostazioni client e server.

Utilizzo

Per avviare il monitor, vai su hale/src/ ed esegui python server.py. Se parte con errori, il file settings.py di Django non è configurato correttamente o mancano alcune librerie. Con il client è possibile inviare comandi al server, ma richiede che l'utente si autentichi sul server; l'accesso è consentito agli utenti impostati come membri dello staff tramite l'interfaccia web. Quando il client è in esecuzione, digita help o ? per ottenere i comandi disponibili. Digita help comando per maggiori informazioni sul comando specifico. L'avvio di un bot di monitoraggio si effettua modificando prima il file hale/src/conf/modules.conf, ad esempio usando una configurazione IRC come la seguente:

[uniqueKeys]
irc = botnet, *grammar

[ircConf] 
module = irc 
botnet = irc.freenode.net 
port = 6667 
password = None 
nick = nickname
username = agent007 
realname = Spying 
channel = #channelname 
channel_pass = somepass 
pass_grammar = PASS 
nick_grammar = NICK 
user_grammar = USER 
join_grammar = JOIN 
version_grammar = VERSION 
time_grammar = TIME 
privmsg_grammar = PRIVMSG 
topic_grammar = TOPIC 
currenttopic_grammar = 332 
ping_grammar = PING 
pong_grammar = PONG

Modifica o crea una nuova configurazione specificando una nuova sezione con nome univoco (parte [ircConf]). In cima al file di configurazione c'è una sezione chiamata uniqueKeys in cui sono specificati tutti i campi univoci per un modulo e usati per generare l'hash della botnet; di solito non dovrebbe essere modificata per preservare un corretto tracciamento delle botnet. Quando hai finito, esegui useconf section per caricare la configurazione e poi avvia il bot con exec modulename id, dove id è impostato da te per identificare la botnet.

L'interfaccia web fornisce accesso a tutti i dati catturati nel database, accessibili dalla pagina principale. C'è anche una funzione di ricerca che consente all'utente di cercare hash di botnet e file, indirizzi IP correlati, ID delle botnet, moduli usati dalle botnet e host delle botnet. Se l'utente ha accesso per modificare proxy o moduli, può farlo nella sezione di amministrazione; l'URL è http://.../admin. L'amministratore può impostare i ruoli utente e aggiungere anche consumer per l'API web.

Sviluppo

Come aggiungere moduli

1. Implementa il modulo, ad esempio:

   import moduleManager from utils import moduleInterface

   @moduleManager.register("irc") def module_setup(config, hash): """ Function to register modules, simply implement this to pass along the config and hash to the module object and return the it back. """

   root@kitploit:~

    return IRC(config, hash)
   

   must inherit from Module class

   class IRC(moduleInterface.Module):

   root@kitploit:~

   def __init__(self, config, hash):
       self.config = config
       self.hash = hash
   
   # must be implemented
   def stop(self):
       # stop execution
   
   # must be implemented
   def run(self):
       # start execution
   
   # must be implemented    
   def getConfig(self):
       return self.config
   

Aggiungi il decorator per la funzione di registrazione (in questo caso module_setup), che verrà chiamata con la configurazione corrente come argomento e l'hash della configurazione generato dalle chiavi univoche. Questa funzione può essere chiamata con qualsiasi nome. Passa le configurazioni all'oggetto del modulo; configHandler intercetta i KeyError, quindi se vengono inviate configurazioni errate a questa funzione, configHandler ti avviserà.

Segui anche la convenzione di denominazione nameModule.py e @moduleManager.register("name") e importa moduleManager; in caso contrario, moduleManager ti notificherà eventuali errori.

Il resto del codice del modulo è omesso, ma dovrebbe creare un oggetto factory di Twisted e avviarlo con il reactor nel metodo run; consulta i moduli esistenti per un esempio. Per tutorial sulla programmazione con Twisted, vedi qui. Ci sono anche alcune utility (utils) da usare quando si sviluppano moduli; questo viene fatto come segue:

Socksify:

# import all utils
from utils import *

# in the constructor create a new proxy object
self.prox = proxySelector.ProxySelector()

# in the run method add the following after having created the factory method.
proxyInfo = self.prox.getRandomProxy()
    if proxyInfo == None:
        self.connector = reactor.connectTCP(host, port, factory)
    else:
        proxyHost = proxyInfo['HOST']
        proxyPort = proxyInfo['PORT']
        proxyUser = proxyInfo['USER']
        proxyPass = proxyInfo['PASS']
        socksify = socks5.ProxyClientCreator(reactor, factory)
        if len(proxyUser) == 0:
            self.connector = socksify.connectSocks5Proxy(host, port, proxyHost, proxyPort, "HALE")
        else:
            self.connector = socksify.connectSocks5Proxy(host, port, proxyHost, proxyPort, "HALE", proxyUser, proxyPass)

Gestione degli errori di connessione nell'oggetto factory:

def clientConnectionFailed(self, connector, reason):
    """
    Called on failed connection to server
    """

    moduleCoordinator.ModuleCoordinator().putError("Error connecting to " + self.config['botnet'], self.module)

def clientConnectionLost(self, connector, reason):
    """
    Called on lost connection to server
    """

    moduleCoordinator.ModuleCoordinator().putError("Connection lost to " + self.config['botnet'], self.module)

Questo invierà gli errori al bucket degli errori, accessibile eseguendo showlog nella CLI.

Registrazione log:

# in the factory create the following method to handle logs (note that the hash and config must be sent to the factory)
# and call it in the protocol class with: self.factory.putLog(data)
def putLog(self, log):
    """
    Put log to the event handler
    """
        
    moduleCoordinator.ModuleCoordinator().addEvent(moduleCoordinator.LOG_EVENT, log, self.hash, self.config)

# apply reg expression to look for URLs containing possible malware
# and call it in the protocol class with: self.factory.checkForURL(data)
def checkForURL(self, data):
    """
    Check for URL in the event handler
    """
    
    moduleCoordinator.ModuleCoordinator().addEvent(moduleCoordinator.URL_EVENT, data, self.hash)

# if you module should detect IP numbers of other bots and herders implement the following method in the factory
def addRelIP(self, data):
    """
    Put possible ip related to the botnet being monitored
    in the event handler.
    """
        
    moduleCoordinator.ModuleCoordinator().addEvent(moduleCoordinator.RELIP_EVENT, data, self.hash)

la gestione degli IP correlati viene effettuata applicando un'espressione regolare da usare per il protocollo che il modulo andrà a supportare; nel caso del modulo IRC, il codice è il seguente:

checkHost = data.split(':')[1].split(' ')[0].strip()
match = self.factory.expr.findall(checkHost)
if match:
    self.factory.addRelIP(data.split('@')[1].split(' ')[0].strip())

dove l'espressione regolare è la seguente:

self.expr = re.compile('!~.*?@')

2) Trascina il file nella directory dei moduli. moduleManager lo importerà automaticamente e controllerà gli errori.

3. In modules.conf modifica la configurazione.

4. Carica il modulo nell'interfaccia web impostando il nome del modulo, ad esempio, su irc, il nome del file su ircModule.py, quindi aggiungi un esempio di configurazione per questo modulo.

Come usare il bot XMPP

Quando si invia una richiesta per tracciare una botnet, la richiesta viene effettuata come segue alla stanza di coordinamento della groupchat:

sensorLoadReq

a cui tutti i sensori rispondono con il loro id e la lunghezza della coda (numero di botnet monitorate)

sensorLoadAck id=353f6650859547ed06597dbfa1dcfd88 queue=0

Il feeder sceglie quindi un sensore in base a queste informazioni, come la lunghezza della coda più bassa; se queste sono uguali per più sensori, viene scelto il sensore con id ordinato alfabeticamente con il valore più basso.

Quando il feeder ha scelto un sensore, invia un messaggio privato al sensore

startTrackReq config

dove config è una rappresentazione stringa della configurazione, ad esempio

module=irc botnet=irc.freenode.net etc..

Il sensore risponde quindi con un acknowledgement insieme all'hash della configurazione, che può essere usato per distinguere i log della botnet dagli altri log nel canale di condivisione. Esempio di acknowledgement:

startTrackAck hash

se nessun altro sta monitorando questa botnet; in caso contrario viene ricevuto un startTrackNack se la botnet è già monitorata o se il sensore non ha installato il modulo per questa botnet. La condivisione di malware viene effettuata dai sensori inviando un messaggio come:

fileCaptured hash=353f6650... file content

dove il contenuto è codificato Base64 e viene subito dopo il valore dell'hash del file.

API Web RESTful

Per ottenere accesso all'API servono una consumer key e una secret key; possono essere create dall'amministratore e sono usate con OAuth per l'autenticazione. I seguenti URL sono disponibili per recuperare dati in formato JSON:

http://.../api/botnet will reply with all botnets monitored
http://.../api/botnet/botnethash will reply with the botnet with hash equal to botnethash
http://.../api/host/hostname will reply with all botnets monitored with host equal to hostname
http://.../api/type/module will reply with all botnets monitored with the module
http://.../api/botips/hash will reply with all ips captured by botnet with the value hash
http://.../api/bologs/hash will reply with all logs for botnet with value hash
http://.../api/bofiles/hash will reply with file hashes captured by botnet with value hash
http://.../api/file/hash returns botnet(s) info for those that have captured file with the hash specified
http://.../api/ip/addr will reply with botnet(s) info for those that have detected an IP with number addr

Nota che attualmente sono possibili solo richieste GET.