Usando Sulley para fuzzear aplicaciones locales

Como comenté en el anterior post, Sulley es una herramienta impresionante para fuzzear aplicaciones, pero viene más preparada para atacar servidores y no para aplicaciones locales. Como la generación de mutaciones funciona muy bien, he creado un script que usa esta funcionalidad, para atacar aplicaciones locales que cargan ficheros por línea de parámetros, es decir, ficheros de tipo DOC, XLS, PDF, TXT, SWF, etc. Esto unido a pydbg de PaiMei para controlar las excepciones.

La verdad es que el script no tiene ningún misterio. Lo que hace básicamente es:

  1. Genera una mutación con Sulley
  2. Crea un fichero con el resultado
  3. Abre el programa a fuzzear pasando como parámetro el fichero generado
  4. Pausa de 5 segundos para dejar que abra correctamente y, para que el manejador de excepciones haga su trabajo en caso de haber un crasheo
  5. Si todo ha funcionado bien, cierra y lanza la siguiente mutación
  6. En caso de crasheo, muestra los datos por pantalla y termina

El fichero de sesiones variará poco de una aplicación a otra, teniendo que indicar únicamente la ruta del EXE y la extensión que se desea usar para el fichero. La librería se la tendrá que crear cada uno, en función a lo que se desee fuzzear (PDF, SFW, etc).

He creado un ejemplo sencillo para fuzzear BACnet OPC Client 1.0.24. Podeis ver la vulnerabilidad y descargar el programa aquí: http://www.exploit-db.com/exploits/15026/. Hace tiempo escribí un tutotrial sobre como explotar esta aplicación (para iniciados en el fantástico mundo de los Buffer Overflows en Windows) en el que lo hacíamos de forma manual todo. Lo podeis leer aquí: http://pepelux.org/download.php?f=papers/BACnet.pdf

Repito que con ese programa no tiene mucho sentido usar un fuzzer ya que se explota con una cadena demasiado larga. Pero sí que tendría sentido para usarlo en un navegador o en un lector de PDFs, ya que es donde Sulley nos permite usar su potencial y, con unas buenas librerías, se pueden hacer maravillas.

Aquí va el código de la sesión:

# script to fuzz SCADA BACnet
#
# by:
# Pepelux <pepeluxx@gmail.com> - http://www.pepelux.org/ && http://www.enye-sec.org/

from sulley import *
from requests import bacnet_generic    # library to fuzz
from time import sleep
from pydbg import *
from pydbg.defines import *
import os
import threading
import sys

req=s_get("bn")        # session
stop=0

tmpfolder="c:\\sulley\\tmp\\"
name=tmpfolder+"test.csv"
proc_path="C:\\Program Files\\SCADA Engine\\BACnet OPC Client\\";
proc_name="BACnOPCClient.exe";

################################
### ACCESS VIOLATION HANDLE ####
################################

def av_handler(dbg):
 print "Access Violation Handler"

 print dbg.dump_context()

 try:
 mod = dbg.addr_to_dll(dbg.context.Eip)
 print 'Eip module path : ', mod.path
 print 'Eip module base : 0x%08x'%mod.base
 print 'Eip offset : 0x%08x '%(dbg.context.Eip - mod.base)
 except:
 print 'Unable resolve Eip module'

 global stop
 stop=1

 dbg.stack_unwind()

 for i in dbg.disasm_around(dbg.context.Eip, 12):
 print "%x %s"%i

 dbg.terminate_process()

 return DBG_CONTINUE

##################################
### START PROCESS USING PYDBG ####
##################################

class start_proc (threading.Thread):
 def __init__(self, t_proc_name, t_name):
 threading.Thread.__init__(self)
 self.t_proc_name = t_proc_name
 self.t_name = t_name

 def run(self):
 dbg = pydbg()
 dbg.load(self.t_proc_name, self.t_name)
 dbg.set_callback(EXCEPTION_ACCESS_VIOLATION, av_handler)
 dbg.run()

#####################
### STOP PROCESS ####
#####################

class stop_proc (threading.Thread):
 def __init__(self, t_proc_name):
 threading.Thread.__init__(self)
 self.t_proc_name = t_proc_name

 def run(self):
 os.system("taskkill /T /F /IM "+self.t_proc_name+">"+tmpfolder+"/null")

#############
### INIT ####
#############

if not os.path.isdir(tmpfolder):
 os.mkdir(tmpfolder)

for i in range(req.names["ini"].num_mutations()):
 file = open(name,"w")
 file.writelines(s_render())
 file.close()

 print "starting target process (session "+str(i)+")"
 t = start_proc(proc_path+proc_name, name)
 t.start()

 sleep(5)
 print "stopping target process"

 t = stop_proc(proc_name)
 t.start()
 t.join()

 if (stop == 0):
 s_mutate()
 else:
 sleep(2)
 sys.exit()

Y la mini-librería usada en este caso:

# script to fuzz SCADA BACnet
#
# by:
# Pepelux <pepeluxx@gmail.com> - http://www.pepelux.org/ && http://www.enye-sec.org/

from sulley import *

########################################################################################################################

s_initialize("bn")
if s_block_start("ini"):
 s_static("OPC_TAG_NAME,OBJECT_TYPE,INSTANCE,OBJECT_NAME\n\\")
 s_string("A", size=400, padding="A")
 s_static("\\<OPC Server Name>\\<OPC Tag Name>,0,0,\n")
s_block_end()

Si a alguien se le ocurre alguna forma de mejorar esto que me mande un mail :)

Un saludo a Roi y a Boken, que me han ayudado con muchas dudas

Tags: , ,

17 Responses to “Usando Sulley para fuzzear aplicaciones locales”

  1. chr1x dice:

    Excelente aporte. ;)

    Saludos!

  2. Boken dice:

    Muy buen trabajo!!

    Enhorabuena!! Ahora tirale al Firefox ;D

    Saludos.

  3. Pepelux dice:

    jaja no pides tú nada! si me pasas la librería curradita con los tags, yo lanzo el fuzzer xDDD

  4. NCR dice:

    Hola!,

    me encontre con este blog y me gustaron estos post sobre fuzzing con sulley. Solo un consejo, para manejar los cashes te recomiendo que uses winappdbg (http://winappdbg.sourceforge.net/). Esta mejor programado que pydbg, es escalable, un proyecto activo, muy bien documentado y facil de aprender a utilizar.

    Saludos

  5. Pepelux dice:

    Hola NCR. Gracias, lo miraré! nos vemos en CracksLatinos :)

  6. [...] alot Pepelux. So here’s the PDF, read and enjoy. And here’s the original article from his [...]

  7. brugalin dice:

    Gracias Pepelux por la explicacion, pero sulley me da un error cuando ejecuto process_monitor.py me dice algo de _ctypes.Structure, sabes como puedo arreglarlo?

  8. Pepelux dice:

    tienes instaladas las ctypes? qué versión de python usas? yo todas las pruebas las hice con la 2.5

  9. brugalin dice:

    perdon por la tardanza pero es que como el mensaje no salio publicado en el acto pense que quizas estaria cerrado el post, uso python 2.7, mirare lo de instalar ctypes pero mi sistema es de 64 bits no se si funcionara correctamente, repito perdona por la tardanza, como no le encontre solución opte por buscar otros fuzzers, aunque me gustaría aprender a usar sulley por lo que te he leido a ti y en algun que otro foro es muy versátil, un saludo y gracias x contestar!

  10. Pepelux dice:

    Da igual que sea de 64 bits. Paimei está optimizado para python 2.4 y cuesta un poco instalarlo en python 2.5, aunque si buscas en Google hay muchos manuales.

    Para usarlo con versiones superiores a la 2.5 no lo he probado pero imagino que será cosa de modificar algunas cosas para que funcione. Al fin y al cabo, de Paimei, sólo necesitas el pydbg.

    Saludos

  11. brugalin dice:

    igual me estoy complicando mucho la vida con sulley, lo que pretendo de momento es encontrar vulnerabilidades en aplicaciones para entender como funcionan y aprender a explotarlas, no se programar en python, se un poco de html, y por lo que leo es necesario para utilizar sulley, me recomendarías algun fuzzer mas sencillo de utilizar que aunque sea menos efectivo a la hora de encontrar vulnerabilidades pudiera servirme para ir probando en aplicaciones obsoletas, gracias de nuevo!

  12. Pepelux dice:

    Yo te recomendaría que bajaras manuales (en http://ricardonarvaja.info/WEB/) tienes muchos tutoriales de cracking y de exploiting. Para aprender es mejor no usar fuzzers.

    Un fuzzer se usa para ahorrar tiempo y lo que hace es lanzar miles de pruebas para intentar encontrar un fallo. Esto lo que hace es que luego vas un poco ‘a tiro hecho’ pero debes tener los conocimientos previos.

    Cada fuzzer sirve para una cosa diferente (te recomiendo que te leas algún libro de fuzzers) y además, ninguno es infalible, es decir, que un fuzzer no te encuentre un fallo no quiere decir que no exista. Por eso mucha gente es reacia al uso de estos programas.

  13. brugalin dice:

    de acuerdo, seguire tu consejo de buscarlos manualmente, supongo que si lo consigo entenderé mucho mejor como va esto, lo que yo quería era ahorrarme este paso con un fuzzer pero como tu dices si encuentras una vulnerabilidad sin utilizar ningun fuzzer supongo que tambien tendrá la ventaja de ser menos conocida y quizás ningún fuzzer sea capaz de encontrarla pero bueno esto todo son suposiciones mias, muchas gracias por tu tiempo y por el enlace que tambien me interesa el manual de cracking con olly asi que tb le echare un vistazo, Un saludo!

  14. newlog dice:

    Llego 4 años tarde, pero cuando hay calidad, hay calidad!

    En todo el interné no he encontrado nada como esto. La verdad es que parece que sulley está un poco abandonado y es una pena, porqué es una bestia! Hace un/dos año(s) que no lo actualizan y casi que sigue siendo lo mejor que hay.

    En fin, que me has alegrado el día. Si hago algo un poco decente, ya te daré un toque.

    Gracias!

  15. Pepelux dice:

    Muchas gracias fiera. Es un honor que pueda servirte de utilidad algo que he escrito sobre una temática que dominas. Hace tantos años de esto que ni recuerdo ya como va :)

  16. newlog dice:

    Jajaja, eso significa que cuando yo voy, tu ya has vuelto! Imagínate, hace 4 años ya… Eso significa que en este mundillo, nunca nos aburrimos eh

    Gracias por el comentario :)

  17. Pepelux dice:

    jaja .. bueno, también te saco unos años (pocos, eh!!) :)

Leave a Reply

%d personas les gusta esto: