no tengo muy claro que es lo que falla con este codigo. Es un programa en asebler que lanza la calcularora, y está pensado para ser convertido en una shellcode. Está basado en el típico ejemplo que se usa para hacer una shellcode, y en general su estructura es esta:
funcion que busca dirección de getprocaddress
buscar direccion de winexec
ejecutar winexec calc.exe
buscar direccion de exitprocess
ejecutar exitprocess

Funciona correctamente hasta llegar a buscar la dirección de exitprocess. Al llegar ahí, algún fallo hay al meter la cadena en la pila y no reconoce tal cadena, y getprocaddress no encuentra su dirección.
Podría ser que se pierde la integridad de la pila, la verdad el tema de la integridad de la pila no lo he logrado entender. Así que pongo el código a ver si podeis confirmarme algo.

.386
.model flat, stdcall  ;32 bit memory model
option casemap :none  ;case sensitive
assume fs:nothing
 
.code
 
dirFuncion proc
; ******************************************
; 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
   pop esi   ;con esto quitamos el valor base del kernel32 que de lo contrario seria la proxima instruccion a ejecutar, y lo metemos en esi para no perderlo
   ;leave    ;esta instruccion es para dejar la pila como estaba, en este ejemplo se he echo manualmente enla instruccion anterior
   ret
dirFuncion endp
 
start:
 
 
 
; **********************************
; programa principal
; **********************************
 
   call dirFuncion
 
   ;mov esi, [esp]
   ;push ebp
   ;mov ebp, esp
   xor dl, dl
   sub esp, 0fh ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-0ah], 57h  ; 'W'
   mov byte ptr [ebp-09h], 69h  ; 'i'
   mov byte ptr [ebp-08h], 6eh  ; 'n'
   mov byte ptr [ebp-07h], 45h  ; 'E'
   mov byte ptr [ebp-06h], 78h  ; 'x'
   mov byte ptr [ebp-05h], 65h  ; 'e'
   mov byte ptr [ebp-04h], 63h  ; 'c'
   mov byte ptr [ebp-03h], dl   ; 0x00
   lea ecx, [ebp-0ah]	; cargamos la direccion que apunta a nuestra cadena
   push ecx
   push esi       ;dirección base de kernel32
   call eax 		; llamamos a getprocadress
 
   ;push ebp
   ;mov ebp, esp
   sub esp, 11h ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-11h], 63h  ; 'c'
   mov byte ptr [ebp-10h], 61h  ; 'a'
   mov byte ptr [ebp-0fh], 6Ch  ; 'l'
   mov byte ptr [ebp-0eh], 63h  ; 'c'
   mov byte ptr [ebp-0dh], 2Eh  ; '.'
   mov byte ptr [ebp-0ch], 65h  ; 'e'
   mov byte ptr [ebp-0bh], 78h  ; 'x'
   mov byte ptr [ebp-0ah], 65h  ; 'e'
   mov byte ptr [ebp-09h], dl   ; 0x00
    push 5   ;parametro de winexec (show)
   lea ecx, [ebp-11h]	; cargamos la direccion que apunta a nuestra cadena
   push ecx
   call eax    ;llamamos a winexec
 
   call dirFuncion   ;llamamos a la funcion para obtener el geptrocaddress
 
   ;push ebp
   ;mov ebp, esp
   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 eax 		; llamamos a getprocadress
                    ;obtenemos direccion de exitprocess
   xor ecx, ecx
   push ecx
   call eax        ;llamamos a exitprocess
 
 
end start
 
;ml -c -coff -Cp e:\masm_archivos\shellcode_getprocaddress_exitprocess2\shellcode_getprocaddress_exitprocess2.asm
;link /SUBSYSTEM:WINDOWS shellcode_getprocaddress_exitprocess2.obj

Eso es para guardar el puntero de pila en la pila. Si por ejemplo llamas a una función desde tu main, y tienes que reservar espacio para más cadenas o lo que sea, puedes perder el ebp del main, entonces lo guardas en la pila, y mueves esp (dir por encima de donde metiste ebp) a ebp, así puedes trabajar con ebp como lo hacías en el main. Luego, antes de retornar, recuperas ebp y retornas.

Ahora no puedo probar el código de arriba, mañana lo hago, pero te recomiendo mientras intentar buscar el error con un depurador como OllyDbg, ahí vas a poder ver qué es lo que hay en la pila y como avanza, y por qué se produce el error.

Saludos

Bueno, no puedo compilar hoy (mañana te lo miro), pero vi esta línea que utilizas en todo el programa:

mov byte ptr [ebp-07h], dl   ; '0'
 

Asegúrate de que edx vale 0, el valor de edx (y de muchos otros regitros) puede cambiar con cada llamada a API's. Fíjate que esté el caracter nulo en la pila, y que luego del "lea" ecx apunte a la cadena.

Saludos

No es necesario recuperar el ebp original si no lo necesitas, depende de lo que quieras hacer. Y para funciones, no sé como ensambla masm, pero fasm ya se encarga de que no haya problemas en esas cosas con las macros de funciones. Lo mejor es que pruebes a hacer cosas, funciones, meter cadenas, y juegues con ebp y esp para que lo pilles. Puedes analizar otras shellcodes también, para ver como juega con ellos, no sé.

Saludos

sí, yo tambien lo he comprobado, sí lo hace. Por cierto tambien he comprobado que no tiene sentido guardar el valor de ebp en la pila si luego no se va a recuperar.
De todas formas ya que estoy lanzado apreguntar... todavía me queda una última duda. Si os fijais el espacio que se resta al esp no es el mismo que eltamaño de la cadena. Por ejemplo "calc.exe" tiene 8 caracteres + 1 caracter nulo = 9 caracteres. Pero he comprobado de forma empírica, que si no resto 11h a la pila no funciona el programa. No funciona porque aunque la cadena parece ser que la reconoce (pues aparece "calc.exe" en la pila..., al llamar a winexec devuelve file not found. Es decir que se ha de restar un número mayor o igual a 11h, con 10h o menor ya no funciona.

Lo mismo pasa con las otras dos cadenas, con "winexec" y con "ExitProcess" en los cuales hay que reservar más espacio en la pila del en realidad necesitan. no así, es necesario colocar la cadena desde el principio, ya que puedo posicionar los caracteres, en lugar de desde la posición ebp-11h, hacerlo desde la ebp-09h.

Vuelvo a poner el código que tengo ahora ya que he modificado algunas cosas.