Acerca de

Hale es un monitor/espía de command & control para botnets con un diseño modular que facilita el desarrollo de nuevos módulos para monitorizar nuevos protocolos usados por servidores C&C. Hale incluye monitores IRC y HTTP desarrollados con Twisted para manejar la escalabilidad de un gran número de conexiones. Estos módulos tienen gramática de protocolo y configuraciones de bot ajustables, pero también pueden modificarse para satisfacer tus necesidades. Todos los registros y archivos capturados se guardan en una base de datos y, en el caso de IRC, también se rastrean las direcciones IP.

Para ocultar la ubicación del operador, las conexiones pueden hacerse a través de proxies SOCKSv5, y esto es configurable mediante la interfaz web, donde también se pueden explorar todos los registros junto con gráficos estadísticos y líneas de tiempo. La interfaz se desarrolló con Django y Google Visualization API. Algunos extras en la interfaz web incluyen soporte para una API RESTful con soporte OAuth y un motor de búsqueda.

La idea principal de Hale es ayudar en la caza de botnets y la investigación colaborativa mediante la creación de una red de sensores (monitores Hale). Para mejorar esta idea, hay disponible un bot XMPP que se conecta a un servidor XMPP centralizado donde actualmente se utilizan dos salas de grupo diferentes: una para coordinar entre sensores y otra para compartir registros y archivos. La sala de coordinación utiliza hashes de botnet generados a partir de las claves únicas en las configuraciones de la botnet; de esta manera, dos botnets con el mismo hash (identidad) no se monitorizan simultáneamente, mejorando la utilización. Para ayudar a terceros a hacer uso de esta red, un bot puede unirse a la sala de coordinación y pedirle a un sensor que comience a rastrear una botnet si no está siendo rastreada, enviando las configuraciones correspondientes. Además, en la sala de compartición, bots de terceros pueden obtener registros y archivos capturados por los sensores en tiempo real. Para facilitar el historial de registros se puede usar la API web que soporta solicitudes GET.

Instalación

Hale tiene las siguientes dependencias:

Python == 2.6
Django == 1.2.1
Twisted == 10.1.0
GeoIP-Python == 1.2.4 (y librería C de 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

Adicionalmente, el monitor requiere un controlador de base de datos back-end correspondiente a la base de datos utilizada por Django. Cuando estas librerías estén instaladas, descarga el código fuente desde aquí y extráelo en cualquier lugar.

Configuración

Primero, crea una base de datos que será usada por Hale; el motor de base de datos puede ser cualquiera de tu elección. Si estás usando una base de datos existente, omite este paso.
El siguiente paso es instalar los controladores back-end de Python correspondientes al motor del servidor.
Edita settings.py en hale/src/webdb/ y modifica las siguientes configuraciones: ENGINE, NAME, USER, PASSWORD, HOST y PORT, donde el ajuste de engine es, por ejemplo, django.db.backends.mysql si tu motor de servidor es MySQL. El ajuste name es el nombre de tu base de datos que usaste al crearla.
Si no quieres iniciar tu propia interfaz web, omite este paso y ve al 8). En settings.py, cambia PATH_TO_APP para que apunte a la ruta completa de la aplicación Django, por ejemplo: '/home/..../Hale/src/webdb'. En el directorio webdb ejecuta el siguiente comando: python manage.py syncdb. Si obtienes algún error aquí, lo más probable es que los ajustes de la base de datos en settings.py sean incorrectos. Además, durante la sincronización, establece el superusuario que se usará al administrar los usuarios.
Para admitir la búsqueda en la interfaz web, ejecuta python manage.py rebuild_index para que el motor de búsqueda indexe por primera vez. Esto creará un directorio llamado ; para permitir que el servidor web escriba aquí, ejecuta . Después de esto, ejecuta en su lugar y deberías poner esto como una tarea cron para actualizar los índices en un intervalo regular de tu elección.

    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

y edita el username y group bajo los que debe ejecutarse el demonio WSGI. WSGIScriptAlias debe establecerse a la ruta completa del archivo django.wsgi ubicado en el directorio webdb. El Alias especificado arriba es necesario para que la página de administración se renderice correctamente. Para poder subir módulos a través de la interfaz web, ejecuta chmod o+w webdb/modules.

Sube los módulos que se usarán desde hale/src/modules/ o escribe los tuyos propios (consulta la sección Desarrollo). Sube el módulo deseado en la interfaz de administración y edita, por ejemplo, el nombre del módulo a irc y el nombre del archivo a ircModule.py. Especifica las reglas de configuración para el módulo en la sección correspondiente ubicada en hale/conf/modules.conf y ponlas en el cuadro de texto; también añade la sección uniqueKeys para el módulo que se está subiendo.
Antes de ejecutar el monitor, edita hale.conf en hale/src/conf/ si deseas usar un servidor XMPP. Para activar el bot XMPP, establece la opción use en True y edita la información de inicio de sesión a una cuenta y servidor existentes, o inicia tu propio servidor XMPP. Un paso importante al iniciar un servidor XMPP es aumentar el tamaño máximo de estrofa (max stanza size) del valor predeterminado a algo como 10Mb. De lo contrario, no será posible la difusión de malware. Los ajustes de canal en hale.conf se usan para la sala de grupo de compartición utilizada por el bot, y el ajuste coord se usa para la sala de grupo donde tiene lugar toda la coordinación entre sensores.
Edita hale.conf y configura los ajustes de cliente y servidor.

Uso

Para iniciar el monitor, ve a hale/src/ y ejecuta python server.py. Si arranca con errores, entonces el archivo settings.py de Django no está configurado correctamente o faltan algunas librerías. Con el cliente es posible enviar comandos al servidor, pero requiere que el usuario se autentique contra el servidor; el acceso se concede a los usuarios que están configurados como miembros del personal (staff) a través de la interfaz web. Cuando el cliente está en ejecución, escribe help o ? para obtener los comandos disponibles. Escribe help comando para obtener más información sobre el comando específico. Iniciar un bot monitor se hace editando primero el archivo hale/src/conf/modules.conf, por ejemplo usando una configuración IRC como la siguiente:

[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

Edita o crea una nueva configuración especificando una nueva sección con un nombre único (la parte [ircConf]). Al comienzo del archivo de configuración hay una sección llamada uniqueKeys donde se especifican todos los campos únicos para un módulo y se usan para generar el hash de la botnet; esto generalmente no debe cambiarse para preservar un seguimiento correcto de la botnet. Cuando esto esté hecho, ejecuta useconf section para cargar la configuración y luego inicia el bot con exec modulename id, donde id es establecido por ti para identificar la botnet.

La interfaz web proporciona acceso a todos los datos capturados en la base de datos, accesible desde la página de índice. También hay una función de búsqueda que permite al usuario buscar hashes de botnet y archivos, números IP relacionados, IDs de botnet, módulos de botnet utilizados y hosts de botnet. Si el usuario tiene acceso para editar proxies o módulos, esto se puede hacer en la sección de administración, cuya url es http://.../admin. El administrador puede establecer modos de usuario y también agregar consumidores para la API web.

Desarrollo

CÓMO agregar módulos

Implementa el módulo, por ejemplo:

import moduleManager from utils import moduleInterface

@moduleManager.register("irc") def module_setup(config, hash): """ Función para registrar módulos, simplemente implementa esto para pasar la configuración y el hash al objeto del módulo y devolverlo. """
```
 return IRC(config, hash)
```
debe heredar de la clase Module

class IRC(moduleInterface.Module):
```
def __init__(self, config, hash):
    self.config = config
    self.hash = hash

# debe implementarse
def stop(self):
    # detener ejecución

# debe implementarse
def run(self):
    # iniciar ejecución

# debe implementarse    
def getConfig(self):
    return self.config
```

Agrega el decorador para la función de registro (en este caso module_setup) que será llamada con la configuración actual como argumento y el hash de configuración formado por las claves únicas. Esta función puede llamarse de cualquier manera. Pasa las configuraciones al objeto del módulo; el configHandler captura KeyErrors, por lo que si se envían configuraciones incorrectas a esta función, configHandler te notificará al respecto.

También sigue la convención de nomenclatura nameModule.py y @moduleManager.register("name") e importa moduleManager; de lo contrario, el moduleManager te notificará sobre cualquier error.

El resto del código del módulo se omite, pero debe crear un objeto factory de Twisted e iniciarlo con el reactor en el método run; consulta los módulos existentes para ver un ejemplo. Para tutoriales sobre programación con Twisted, consulta aquí. También hay algunas utilidades que se pueden usar al desarrollar módulos, esto se hace de la siguiente manera:

Socksify:

# importar todas las utilidades
from utils import *

# en el constructor crear un nuevo objeto proxy
self.prox = proxySelector.ProxySelector()

# en el método run agregar lo siguiente después de haber creado el método factory.
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)

Manejo de errores de conexión en el objeto factory:

def clientConnectionFailed(self, connector, reason):
    """
    Llamado cuando falla la conexión al servidor
    """

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

def clientConnectionLost(self, connector, reason):
    """
    Llamado cuando se pierde la conexión al servidor
    """

    moduleCoordinator.ModuleCoordinator().putError("Conexión perdida con " + self.config['botnet'], self.module)

Esto enviará los errores al bucket de errores, al cual se puede acceder ejecutando showlog en la CLI.

Logging:

# en el factory crear el siguiente método para manejar logs (nota que el hash y la configuración deben enviarse al factory)
# y llamarlo en la clase protocol con: self.factory.putLog(data)
def putLog(self, log):
    """
    Colocar log en el manejador de eventos
    """
        
    moduleCoordinator.ModuleCoordinator().addEvent(moduleCoordinator.LOG_EVENT, log, self.hash, self.config)

# aplicar expresión regular para buscar URLs que contengan posible malware
# y llamarlo en la clase protocol con: self.factory.checkForURL(data)
def checkForURL(self, data):
    """
    Verificar URL en el manejador de eventos
    """
    
    moduleCoordinator.ModuleCoordinator().addEvent(moduleCoordinator.URL_EVENT, data, self.hash)

# si tu módulo debe detectar números IP de otros bots y herders, implementa el siguiente método en el factory
def addRelIP(self, data):
    """
    Colocar posible IP relacionada con la botnet que se está monitoreando
    en el manejador de eventos.
    """
        
    moduleCoordinator.ModuleCoordinator().addEvent(moduleCoordinator.RELIP_EVENT, data, self.hash)

El manejo de IPs relacionadas se hace aplicando una expresión regular para el protocolo que el módulo va a soportar; en el caso del módulo IRC, el código se ve así:

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

donde la expresión regular es la siguiente:

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

2) Arrastra el archivo al directorio de módulos. El moduleManager lo importará automáticamente y verificará si hay errores.

En modules.conf edita la configuración.
Sube el módulo a la interfaz web estableciendo el nombre del módulo, por ejemplo irc, nombre de archivo ircModule.py, y luego agrega un ejemplo de configuración para este módulo.

CÓMO usar el bot XMPP

Al enviar una solicitud para rastrear una botnet, la solicitud se hace de la siguiente manera a la sala de chat grupal de coordinación:

sensorLoadReq

donde todos los sensores responden con su id y longitud de cola (número de botnets monitoreadas):

sensorLoadAck id=353f6650859547ed06597dbfa1dcfd88 queue=0

El alimentador (feeder) elige un sensor basándose en esta información, como la longitud de cola más baja; si varias tienen la misma longitud, se elige el sensor con el id ordenado alfabéticamente con el valor más bajo.

Cuando el alimentador ha elegido un sensor, envía un mensaje privado al sensor:

startTrackReq config

donde config es una representación en cadena de la configuración, por ejemplo:

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

El sensor responde con un acuse de recibo junto con el hash de configuración, que puede usarse para distinguir los logs de esa botnet de otros logs en el canal de compartición. Ejemplo de acuse:

startTrackAck hash

si nadie más está monitoreando esta botnet; de lo contrario, se recibe un startTrackNack si la botnet ya está siendo monitoreada o el sensor no tiene el módulo instalado para esta botnet. La compartición de malware se realiza mediante sensores que envían un mensaje como:

fileCaptured hash=353f6650... file content

donde el contenido está codificado en Base64 y viene inmediatamente después del valor del hash del archivo.

API Web RESTful

Para obtener acceso a la API necesitas una clave de consumidor y una clave secreta; estas pueden ser creadas por el administrador y se usan con OAuth para autenticarse. Las siguientes URLs están disponibles para obtener datos en formato JSON:

http://.../api/botnet responderá con todas las botnets monitoreadas
http://.../api/botnet/botnethash responderá con la botnet cuyo hash sea igual a botnethash
http://.../api/host/hostname responderá con todas las botnets monitoreadas cuyo host sea igual a hostname
http://.../api/type/module responderá con todas las botnets monitoreadas que usen el módulo
http://.../api/botips/hash responderá con todas las IPs capturadas por la botnet con valor hash
http://.../api/bologs/hash responderá con todos los logs de la botnet con valor hash
http://.../api/bofiles/hash responderá con los hashes de archivos capturados por la botnet con valor hash
http://.../api/file/hash devuelve información de la(s) botnet(s) que han capturado el archivo con el hash especificado
http://.../api/ip/addr responderá con información de la(s) botnet(s) que han detectado una IP con número addr

Ten en cuenta que actualmente solo son posibles solicitudes GET.

Hale

Más Populares