Archive

Posts Tagged ‘pentesting python’

Junio, mes de cursos de Python en Securizame.

mayo 19, 2016 Deja un comentario

logo_securizame

Llega junio con una propuesta formativa muy interesante por parte de Securizame, en donde tendré el placer y el honor de colaborar con la serie de cursos enfocados completamente a Python. Como podréis apreciar en la web de Securizame, se trata de una oferta formativa bastante completa en la que tendréis la posibilidad de conocer en profundidad las características más interesantes del lenguaje con el acompañamiento de profesionales de primer nivel, entre los que se encuentran Dani Garcia (Cr0hn), Maria José Montes, Julio Semper y un servidor. Podéis adquirir los módulos en formato individual o el curso completo, algo que recomiendo si de verdad queréis aprender a crear herramientas de todo tipo con Python. Algunos de los módulos son online, pero como podréis comprobar, algunos son presenciales incluyendo el que voy a impartir, aunque se está barajando la posibilidad de hacerlos también online para las personas que por cualquier motivo no podéis acercaros a las oficinas de Securizame en Madrid. Evidentemente, los cursos presenciales tienen la ventaja de que podéis hacer todas las preguntas que queráis y resolverlas “in-situ” y por si fuera poco, son cursos que se van a impartir los viernes en la tarde y los sábados, lo que facilita enormemente las cosas para aquellas personas que por trabajo u otras obligaciones no tienen la posibilidad de asistir entre semana. Las instalaciones se encuentran muy bien equipadas y con todo lo necesario para desarrollar cada uno de las clases que haremos los profesores, cuyos contenidos hemos diseñado con mucho cariño e ilusión, esperando que de verdad os sean útiles para vuestras vidas profesionales y/o académicas.
Creo que es una buena oportunidad para dominar el lenguaje y automatizar muchas de las labores que seguramente hacéis manualmente y que pueden suponer varias horas del día haciéndolas.
Finalmente, para animaros un poco y dependiendo del número de asistentes que decidáis apuntaros al curso completo, llevaré algunas copias de los dos libros de Python que he escrito para rifarlas entre vosotros, algo que os vendrá como anillo al dedo para apoyar vuestra formación en dicho lenguaje.

Espero veros por allí y si necesitáis más información al respecto, podéis rellenar el formulario que se encuentra disponible aquí o llamar directamente al teléfono que aparece en la página.

Un saludo y Happy Hack!
Adastra.

Nueva convocatoria del curso de Python para Pentesters el próximo 29 de Junio.

junio 18, 2015 Deja un comentario

Ya os podéis inscribir a la próxima convocatoria del curso de Python para Pentesters que comienza el próximo 29 de Junio. Se trata de un curso que ha tenido muy buena aceptación en su primera convocatoria y que debido a la demanda que ha tenido, hemos decidido abrir una nueva convocatoria para que se apunten las personas que no han podido hacerlo en la primera. Como ya os comentaba en la entrada en la que hablaba del curso comienza con los conceptos básicos de programación y en la medida que avanza, el enfoque se especializa en temas relacionados con el pentesting y el hacking. Es recomendado para personas que tienen escasos conocimientos en programación y que quieren aprender a desarrollar sus propias herramientas con Python enfocadas a la seguridad informática. Los estudiantes también podrán entrar en un espacio privado en el que se encuentran todos los contenidos del curso y en el que además, se puede hablar por chat conmigo y con otros estudiantes. Por mi parte, os guiaré en vuestro proceso de aprendizaje y me encuentro disponible para responder a vuestras dudas y apoyaros en el desarrollo de las practicas. Intento que sea lo más personalizado posible, por ese motivo el número de alumnos en cada convocatoria es reducido. Tienes más información sobre los contenidos del curso en el siguiente enlace: http://www.thesecuritysentinel.es/1/curso_de_python_para_pentester_676511.html
Por otro lado, también hay una nueva convocatoria de Certificación Profesional de Hacking Ético (CPHE), impartida por Francisco Sanz y que comienza el día 22 de Junio. Las plazas de ambos cursos son limitadas, por lo que os recomiendo que reservéis plaza cuanto antes enviando un correo electrónico a info@thesecuritysentinel.es

Un saludo y Happy Hack!

Adastra.

Curso de desarrollo de software enfocado a la seguridad informática con Python

mayo 21, 2015 2 comentarios

En esta ocasión quiero hablaros de un curso que me encuentro preparando y que seguramente será de interés para muchos de vosotros, se trata de un curso de desarrollo de software con Python enfocado a la seguridad informática, al pentesting y al hacking. El curso responde a la necesidad de aquellas personas que quieren aprender a programar desde cero y para los que los libros de “Python para pentesters” y “Hacking con Python” que he escrito hace algunos meses, aun les resultan muy complejos debido a su falta de conocimientos en programación.
Dicho esto, será un curso que partirá desde los conceptos básicos de programación estructurada y orientada a objetos, así como las bases del lenguaje, los principales módulos disponibles, etc. En la medida que el curso va avanzando se explican conceptos básicos de recolección de información, técnicas OSINT y pentesting utilizando Python. En los últimos dos módulos de los seis que se compone el curso, hablaré sobre integración de Python con herramientas de uso común en auditorías de seguridad, tales como Metasploit Framework o Nessus y conceptos básicos sobre patrones de diseño y arquitectura de software.

Como mencionaba antes, el curso se compone de 6 módulos, los cuales se encuentran distribuidos en 10 semanas. Cada semana podréis descargar un fichero comprimido con todos los recursos correspondientes, en el que se incluirán vídeos, documentos y código.

Junto con el curso, se os entregará una copia del libro de “Python para Pentesters”, el cual os servirá como recurso de estudio durante las semanas del curso.
Se encuentra planificado para comenzar el día 1 de Junio y podéis registraros o solicitar información desde ya en el sitio web de “The Security Sentinel” (http://www.thesecuritysentinel.es/1/curso_de_python_para_pentester_676511.html)

Todos los alumnos que os apuntéis, además de los recursos que he mencionado anteriormente (vídeos, documentos, código y el libro de “Python para Pentesters”), también podréis entrar en un espacio privado para poder realizar las practicas, interactuar con otros alumnos que se encuentran apuntados al curso (si os apetece) y contactar conmigo directamente vía chat. En dicho espacio también tendréis disponible una consola Linux en la que podréis practicar con lo aprendido en curso.

Espero veros apuntados y como siempre, ante cualquier duda, comentario o sugerencia podéis contactar conmigo directamente (adastra@thehackerway.com).

Un saludo y Happy Hack!

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” https://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.

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 4 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 malware 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.

Tornado para rutinas de red asincronas y no bloqueantes

noviembre 27, 2014 1 comentario

“Tornado” es una librería para programas escritos en Python que permite crear sistemas asíncronos y no bloqueantes para operaciones de red, en donde cada petición ejecutada por los clientes puede ser asíncrona. La forma en la que se encuentra implementada la librería, permite escalar a varios miles de conexiones abiertas, algo que resulta ideal para aplicaciones que requieren conexiones con un tiempo de vida largo. Tornado no es una librería simple, de hecho es todo un framework para diferentes tipos de elementos de red, muy similar a Twisted, pero con la diferencia de que Tornado se centra en el desarrollo de componentes de red asíncronos y no bloqueantes y Twisted es un framework reactivo, centrado en el desarrollo de componentes de red que se activan ante diferentes eventos.
El modelo tradicional para crear aplicaciones tales como servidores web que soportan varios clientes de forma concurrente, se basa en un sistema “multi-hilo”, en el que se crea un nuevo hilo por cada cliente que se conecta al servicio. Esto da como resultado un consumo bastante alto de recursos del sistema y problemas de rendimiento que pueden ser bastante serios.
Un sistema “no-bloqueante” se basa en la ejecución de un único hilo de forma continua y que responde a las peticiones de cada cliente de forma asíncrona, de esta forma, el efecto de “bloqueo” de cada función se ve muy disminuido, ya que una función asíncrona retorna antes de finalizar. Por otro lado, últimamente se ha vuelto bastante popular el uso de librerías como Tornado o AsyncIO (de la que se hablará en una próxima entrada) no solamente en Python, sino en muchos otros lenguajes como Java, PHP o Javascript para implementar rutinas asíncronas y sistemas no bloqueantes. Es un modelo que ha ido cobrando fuerza por los beneficios que aporta un sistema que consume pocos recursos comparado con los sistemas clásicos, los cuales para manejar la concurrencia crean un nuevo hilo de ejecución por cada cliente.

Para instalar Tornado, basta con ejecutar el comando “pip install tornado” o descargar la última versión disponible en el repositorio GitHub (https://github.com/tornadoweb/tornado) e instalar manualmente con el script “setup.py”.
Uno de los ejemplos más básicos a la hora de usar Tornado, consiste en crear una aplicación web, para lo cual es necesario utilizar como mínimo tres elementos: una o varias clases del tipo “RequestHandler” para el procesamiento de las peticiones, uno o varios objetos del tipo “Application” para gestionar y enrutar adecuadamente las peticiones entrantes y finalmente, una función “main” que se encargará de iniciar el servidor. El siguiente es un ejemplo muy simple para crear un servidor web que procesa las peticiones “POST” de forma síncrona y las peticiones “GET” de forma asíncrona.

BasicTornadoWebServer.py

from tornado.ioloop import IOLoop
from tornado.web import RequestHandler, Application, url, asynchronous

class HelloHandler(RequestHandler):
    @asynchronous
    def get(self):
        self.write("Hello, world")

    def post(self):
        self.write("Hello, world")    

app = Application([ url(r"/", HelloHandler), ])
app.listen(9090)
IOLoop.current().start()

Como se puede apreciar, la clase “IOLoop” es la encargada de crear el hilo de ejecución que se encargará de procesar cada petición entrante por el puerto “9090”. Por otro lado, por defecto las funciones de una instancia de “RequestHandler” son síncronas, esto quiere decir que el hilo de ejecución principal será bloqueado hasta que la función retorne y en este caso, para implementar una función asíncrona, se debe utilizar el decorador “asynchronous”.
Se trata de un ejemplo muy simple y Tornado implementa muchas clases y funciones que permiten crear aplicaciones web asíncronas y con elementos tan interesantes como autenticación de usuarios, protección a CSRF o cookies seguras. Estos elementos serán analizados con mayor detalle en una próxima entrada, en esta nos centraremos en el uso de las utilidades incluidas en Tornado para networking.
Elementos y utilidades en Tornado para operaciones de red asíncronas
Tal como se ha visto antes la utilidad “tornado.ioloop” es el elemento principal para iniciar el hilo de ejecución en Tornado, no obstante no solamente se puede utilizar para crear un servidor HTTP que permita el procesamiento de peticiones, también es posible crear sockets TCP o UDP y responder a cada cliente de forma asíncrona. El siguiente es un ejemplo de cómo crear un servidor TCP básico con Tornado.


import errno
import functools
import socket
from tornado import ioloop, iostream
def connection(sock, filedes, event):
    while True:
        try:
            connection, address = sock.accept()
        except socket.error, e:
            if e[0] not in (errno.EWOULDBLOCK, errno.EAGAIN):
                raise
            return
        connection.setblocking(0)
        stream = iostream.IOStream(connection)
        stream.write("HTTP/1.1 200 OK\r\nHello!\r\n", stream.close)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setblocking(0)
sock.bind(("", 8080))
sock.listen(1000)
io_loop = ioloop.IOLoop.instance()
callback = functools.partial(connection, sock)
io_loop.add_handler(sock.fileno(), callback, io_loop.READ)
try:
    io_loop.start()
except KeyboardInterrupt:
    io_loop.stop()
    print "exited cleanly"

Las primeras instrucciones que ejecuta el script anterior resultan bastante comunes para cualquier programador de Python que conoce el uso de los sockets, en este caso se está vinculando el puerto “8080” y posteriormente se utiliza una función de callback que será invocada automáticamente por la utilidad “IOLoop” cuando un cliente realice una petición al puerto 8080. La función de callback encargada de procesar cada conexión es “connection” y como se puede apreciar, recibe como argumento el socket servidor, el “file descriptor” y un listado de eventos producidos durante la conexión. Las primeras instrucciones de la función “connection” resultaran bastante comunes también, ya que lo primero que se hace es aceptar la conexión iniciada por el cliente. Posteriormente, se crea una instancia de la clase “iostream.IOStream” recibiendo como argumento la conexión del cliente. Este elemento de Tornado es lo que hace que este sencillo servidor TCP sea una rutina no bloqueante, ya que se encarga de gestionar de forma asíncrona las respuestas a todos los clientes que se conectan al servidor.

tornado1

La clase “tornado.iostream.IOStream” es una de las clases que extiende de “tornado.iostream.BaseIOStream”, la cual incluye las funciones básicas para leer y escribir datos en sockets no bloqueantes. Existen otras implementaciones tales como “iostream.SSLIOStream” o “iostream.PipeIOStream” que implementan características extendidas.

Por otro lado, el modulo “tornado.netutil” incluye varias funciones que son bastante útiles tanto para clientes como servidores. El uso de algunas de dichas funciones se enseña a continuación.

>>> from tornado import netutil
>>> sockets = netutil.bind_sockets(8000)
sockets [<socket._socketobject object at 0x7f067a1bf670>, <socket._socketobject object at 0x7f067a1bf6e0>]
>>> netutil.is_valid_ip('') False
>>> netutil.is_valid_ip('192.168.1.2') True
>>> netutil.is_valid_ip('192.168.1.999') False
>>> netutil.is_valid_ip('fe80::fe15:b4ff:fefc:f808') True
>>> netutil.is_valid_ip('aas10::fe15:b4ff:fefc:f808') False
>>> resDNS = netutil.Resolver()
>>> resDNS.configure('tornado.netutil.BlockingResolver')
>>> resDNS.resolve('www.google.com',80) <tornado.concurrent.Future object at 0x7f0679b01bd0> >>> dir(_)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_callbacks', '_check_done', '_done', '_exc_info', '_exception', '_result', '_set_done', 'add_done_callback', 'cancel', 'cancelled', 'done', 'exc_info', 'exception', 'result', 'running', 'set_exc_info', 'set_exception', 'set_result']

La función “bind_sockets” se encarga de crear los sockets en todas las interfaces de red disponibles y devuelve un listado con cada una de las referencias creadas.
La función “is_valid_ip” se encarga de validar si una dirección IPv4 o IPv6 es válida y finalmente, la clase “Resolver” permite configurar varios de tipos de “resolvers” para peticiones DNS bloqueantes y no bloqueantes.
Para mayor información sobre más utilidades disponibles en Tornado, se recomienda revisar la documentación: http://tornado.readthedocs.org/en/latest/netutil.html

Finalmente, Tornado incluye un servidor TCP que puede ser utilizado como un envoltorio de la utilidad “IOLoop” descrita anteriormente. Dicho servidor incluido en Tornado tiene la ventaja de que se encarga de gestionar automáticamente el estado del bucle iniciado por “IOLoop”.
Existen 3 mecanismos que se pueden implementar con la utilidad TCPServer.
1. Un único proceso en ejecución.

>>> from tornado import tcpserver >>> server = tcpserver.TCPServer() >>> server.listen(8080) >>> from tornado import ioloop
>>> ioloop.IOLoop.instance().start()

2. Multi-proceso simple con las funciones estandar “bind” y “start”

>>> from tornado import tcpserver
>>> server = tcpserver.TCPServer()
>>> server.bind(8080)
>>> server.start(8080)
>>> from tornado import ioloop
>>> ioloop.IOLoop.instance().start()

3. Multi-proceso avanzado utilizando la funcion “add_sockets”

>>> from tornado import tcpserver
>>> from tornado import ioloop
>>> from tornado import netutil
>>> from tornado import process
>>> sockets = netutil.bind_sockets(8000)
>>> process.fork_processes(0)
>>>server = tcpserver.TCPServer()
>>>server.add_sockets(sockets)
>>>IOLoop.instance().start()

Este ha sido el uso básico de Tornado, sin embargo hay que aclarar que existen otras librerías que son bastante robustas y que permiten conseguir los mismos objetivos, como es el caso de AsyncIO o incluso algunos módulos de Twisted. En el caso de AsyncIO, se encuentra incluida por defecto en las últimas versiones de Python 3, concretamente a partir de la versión 3.4. De dicha librería se hablará más adelante en otro artículo.
Saludos y Happy Hack!

A %d blogueros les gusta esto: