À propos

Hale est un moniteur/espion de commande et contrôle de botnet avec une conception modulaire permettant de développer facilement de nouveaux modules qui surveillent de nouveaux protocoles utilisés par les serveurs C&C. Hale est livré avec des moniteurs IRC et HTTP développés avec Twisted pour gérer la scalabilité d'un grand nombre de connexions. Ces modules ont une grammaire de protocole et des paramètres de bot configurables, mais peuvent également être modifiés selon vos besoins. Tous les logs et fichiers capturés sont enregistrés dans une base de données, et dans le cas de l'IRC, les numéros IP suivis également.

Pour masquer l'emplacement de l'opérateur, les connexions peuvent être effectuées via des mandataires SOCKSv5, et cela est configurable via l'interface web où tous les logs sont également disponibles pour consultation, accompagnés de graphiques statistiques et de chronologies. L'interface a été développée avec Django et l'API Google Visualization. Quelques fonctionnalités supplémentaires dans l'interface web incluent le support d'une API RESTful avec support OAuth et un moteur de recherche.

L'idée principale de Hale est d'aider la chasse aux botnets et la recherche en créant un réseau de capteurs (moniteurs Hale). Pour améliorer cette idée, un bot XMPP est disponible pour se connecter à un serveur XMPP centralisé où deux salles de groupe différentes sont actuellement utilisées : une pour la coordination entre les capteurs et une pour le partage des logs et fichiers. La salle de coordination utilise des hachages de botnet constitués à partir des clés uniques dans les paramètres du botnet. De cette façon, deux botnets n'ont pas besoin d'être surveillés simultanément s'ils ont le même hachage (identité), ce qui améliore l'utilisation. Pour aider les tiers à utiliser ce réseau, un bot peut rejoindre la salle de coordination et demander à un capteur de commencer à suivre un botnet s'il n'est pas suivi, en lui envoyant les configurations nécessaires. De plus, dans la salle de partage, les bots tiers peuvent obtenir les logs et fichiers capturés par les capteurs en temps réel. Pour faciliter l'historique des logs, l'API web peut être utilisée et prend en charge les requêtes GET.

Installation

Hale a les dépendances suivantes :

Python == 2.6
Django == 1.2.1
Twisted == 10.1.0
GeoIP-Python == 1.2.4 (et lib C GeoIP)
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

De plus, le moniteur nécessite un pilote de base de données backend correspondant à la base de données utilisée par Django. Lorsque ces bibliothèques sont installées, téléchargez la source à partir d'ici et extrayez-la n'importe où.

Configuration

Commencez par créer une base de données qui sera utilisée par Hale. Le moteur de base de données peut être celui de votre choix. Si vous utilisez une base de données existante, passez cette étape.
L'étape suivante consiste à installer les pilotes Python de backend correspondant à ceux utilisés par le moteur du serveur.
Modifiez settings.py dans hale/src/webdb/ et éditez les configurations suivantes : ENGINE, NAME, USER, PASSWORD, HOST et PORT où le paramètre ENGINE est par exemple django.db.backends.mysql si votre moteur de serveur est MySQL. Le paramètre NAME est le nom de votre base de données utilisé lors de sa création.
Si vous ne souhaitez pas lancer votre propre interface web, passez cette étape et allez à l'étape 8). Dans settings.py, modifiez PATH_TO_APP pour pointer vers le chemin complet de l'application Django, par exemple : '/home/..../Hale/src/webdb'. Dans le répertoire webdb, exécutez la commande suivante : python manage.py syncdb. Si vous obtenez des erreurs, il est très probable que les paramètres de base de données dans settings.py soient incorrects. Pendant la synchronisation, définissez le superutilisateur qui sera utilisé pour l'administration des utilisateurs.
Pour activer la recherche dans l'interface web, exécutez python manage.py rebuild_index pour que le moteur de recherche crée l'index une première fois. Cela créera un répertoire nommé . Pour permettre au serveur web d'écrire ici, exécutez . Ensuite, exécutez à la place et placez-le en tâche cron pour mettre à jour les index à intervalle régulier de votre choix.

    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

et modifiez le nom d'utilisateur et le groupe sous lesquels le démon WSGI doit s'exécuter. WSGIScriptAlias doit être défini sur le chemin complet du fichier django.wsgi situé dans le répertoire webdb. L'alias spécifié ci-dessus est nécessaire pour que la page d'administration soit rendue correctement. Pour pouvoir télécharger des modules via l'interface web, exécutez chmod o+w webdb/modules.

Téléchargez les modules qui seront utilisés depuis hale/src/modules/ ou écrivez les vôtres (voir la section Développement). Téléchargez le module souhaité dans l'interface d'administration et modifiez par exemple le nom du module en irc et le nom du fichier en ircModule.py. Spécifiez les règles de configuration pour le module dans la section correspondante située dans hale/conf/modules.conf et mettez-les dans la zone de texte. Ajoutez également les sections uniqueKeys pour le module téléchargé.
Avant d'exécuter le moniteur, modifiez hale.conf dans hale/src/conf/ si vous souhaitez utiliser un serveur XMPP. Pour activer le bot XMPP, définissez le paramètre use sur True et modifiez soit les informations de connexion d'un compte et d'un serveur existant, soit démarrez votre propre serveur XMPP. Une étape importante lors du démarrage d'un serveur XMPP est d'augmenter la taille maximale des stanzas de la valeur par défaut à environ 10 Mo. Sinon, la publication de malwares ne sera pas possible. Les paramètres de canal dans hale.conf sont utilisés pour la salle de groupe de partage utilisée par le bot, et le paramètre coord est utilisé pour la salle de groupe où toute la coordination entre les capteurs a lieu.
Modifiez et configurez les paramètres client et serveur.

Utilisation

Pour démarrer le moniteur, allez dans hale/src/ et exécutez python server.py. S'il démarre avec des erreurs, cela signifie que le fichier settings.py de Django n'est pas correctement configuré ou que certaines bibliothèques manquent. Avec le client, il est possible d'envoyer des commandes au serveur, mais cela nécessite que l'utilisateur s'authentifie auprès du serveur. L'accès est accordé aux utilisateurs définis comme membres du personnel via l'interface web. Lorsque le client est en cours d'exécution, tapez help ou ? pour obtenir les commandes disponibles. Tapez help commande pour obtenir plus d'informations sur une commande spécifique. Pour démarrer un bot moniteur, commencez par éditer le fichier hale/src/conf/modules.conf, par exemple en utilisant une configuration IRC comme suit :

[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

Modifiez ou créez une nouvelle configuration en spécifiant une nouvelle section avec un nom unique (la partie [ircConf]). En haut du fichier de configuration se trouve une section appelée uniqueKeys où tous les champs uniques d'un module sont spécifiés et utilisés pour générer le hachage du botnet. Cela ne devrait généralement pas être modifié pour préserver un suivi correct des botnets. Une fois cela fait, exécutez useconf section pour charger la configuration, puis lancez le bot avec exec nommodule id où id est défini par vous pour identifier le botnet.

L'interface web donne accès à toutes les données capturées dans la base de données, accessibles depuis la page d'index. Il existe également une fonction de recherche qui permet à l'utilisateur de rechercher des hachages de botnet et de fichiers, des numéros IP associés, des identifiants de botnet, les modules de botnet utilisés et les hôtes de botnet. Si l'utilisateur a accès pour modifier des mandataires ou des modules, cela peut être fait dans la section d'administration, dont l'URL est http://.../admin. L'administrateur peut définir les modes utilisateur et également ajouter des consommateurs pour l'API web.

Développement

COMMENT AJOUTER DES MODULES

Implémentez le module, par exemple :

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. """
```
 return IRC(config, hash)
```
must inherit from Module class

class IRC(moduleInterface.Module):
```
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
```

Ajoutez un décorateur pour la fonction d'enregistrement (dans ce cas module_setup) qui sera appelée avec la configuration courante en argument et le hachage de configuration constitué des clés uniques. Cette fonction peut être nommée arbitrairement. Transmettez les configurations à l'objet module, le gestionnaire de configuration (configHandler) intercepte les KeyErrors, donc si des configurations incorrectes sont envoyées à cette fonction, configHandler vous en informera.

Suivez également la convention de nommage nomModule.py et @moduleManager.register("nom") et importez moduleManager, sinon le gestionnaire de modules vous informera des éventuelles erreurs.

Le reste du code du module est omis mais doit créer un objet factory Twisted et le démarrer avec le reactor dans la méthode run. Consultez les modules existants pour un exemple. Pour des tutoriels sur la programmation avec Twisted, veuillez consulter ici. Il existe également quelques utilitaires à utiliser lors du développement de modules, comme suit :

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)

Gestion des erreurs de connexion dans l'objet 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)

Ceci enverra les erreurs dans le seau d'erreurs accessible en exécutant showlog dans le CLI.

Journalisation :

# 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 gestion des IPs liées se fait en appliquant une expression régulière à utiliser pour le protocole que le module va supporter. Dans le cas du module IRC, le code ressemble à ceci :

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

où l'expression régulière est la suivante :

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

2) Glissez le fichier dans le répertoire des modules. Le gestionnaire de modules l'importera alors automatiquement et vérifiera les erreurs.

Dans modules.conf, modifiez la configuration.
Téléchargez le module dans l'interface web en définissant le nom du module (par exemple irc), le nom du fichier (ircModule.py) et ajoutez un exemple de configuration pour ce module.

COMMENT UTILISER LE BOT XMPP

Lors de l'envoi d'une demande de suivi d'un botnet, la demande est faite comme suit dans la salle de coordination du groupe

sensorLoadReq

où tous les capteurs répondent avec leur identifiant et la longueur de la file d'attente (nombre de botnets surveillés)

sensorLoadAck id=353f6650859547ed06597dbfa1dcfd88 queue=0

Le fournisseur (feeder) choisit alors un capteur en fonction de ces informations, par exemple la plus petite longueur de file d'attente, et si plusieurs capteurs ont la même valeur, le capteur dont l'identifiant est trié alphabétiquement avec la plus petite valeur est choisi.

Lorsque le fournisseur a choisi un capteur, il envoie un message de chat privé au capteur

startTrackReq config

où config est une représentation sous forme de chaîne de la configuration, par exemple

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

Le capteur répond alors par un accusé de réception accompagné du hachage de la configuration qui peut être utilisé pour distinguer les logs de ce botnet des autres logs dans le canal de partage. Exemple d'accusé de réception :

startTrackAck hash

si personne d'autre ne surveille ce botnet, sinon un startTrackNack est reçu si le botnet est déjà surveillé ou si le capteur n'a pas le module installé pour ce botnet. Le partage de malwares est effectué par les capteurs envoyant un message comme :

fileCaptured hash=353f6650... file content

où le contenu est codé en Base64 et vient juste après la valeur du hachage du fichier.

API Web RESTful

Pour accéder à l'API, vous avez besoin d'une clé de consommateur et d'une clé secrète, qui peuvent être créées par l'administrateur et sont utilisées avec OAuth pour l'authentification. Les URL suivantes sont disponibles pour récupérer des données au format JSON :

http://.../api/botnet répondra avec tous les botnets surveillés
http://.../api/botnet/hachage_botnet répondra avec le botnet dont le hachage est égal à hachage_botnet
http://.../api/host/nom_hôte répondra avec tous les botnets surveillés dont l'hôte est égal à nom_hôte
http://.../api/type/module répondra avec tous les botnets surveillés avec le module
http://.../api/botips/hachage répondra avec toutes les IP capturées par le botnet de valeur hachage
http://.../api/bologs/hachage répondra avec tous les logs du botnet de valeur hachage
http://.../api/bofiles/hachage répondra avec les hachages de fichiers capturés par le botnet de valeur hachage
http://.../api/file/hachage renvoie les informations du(des) botnet(s) qui ont capturé le fichier avec le hachage spécifié
http://.../api/ip/adr répondra avec les informations du(des) botnet(s) qui ont détecté une IP avec le numéro adr

Notez que seules les requêtes GET sont actuellement possibles.

Hale

Populaires