Mensajes

Muy bueno, te pongo chincheta Espero verlo acabado pronto

Como dice Hacker_Zero ves con cuidado de no pillar instrucciones a medias...sino habrá un error muy feo

Muchas gracias karccrack , en la noche lo continuo

[YST & Hacker_Zero]

Taller de Api hooking

Este texto se puede publicar libremente siempre que se mantenga el autor.

Autores:YST & Hacker_Zero

Conocimientos previos:

• ASM        
  
• Manejo minimo de las apis de windows
  
• Formato PE [Metodo IAT patch]
  

Contenido

• 1.-Introducción
  
  
• 2.-Inyección de codigo
  
• 2.1-Teoría
  
• 2.2-Relización
  
  
• 3.-Metodo de trampolín
  
• 3.1-Teoría
  
• 3.2-Relización
  
  
• 4.-Metodo de IAT patch
  
• 4.1-Teoría
  
• 4.2-Relización
  
  
• Despedida
  
  
  
  
  1.Introducción
  
  En este taller se explicara el api hooking, mediante 2 metodos distintos conocidos como el metodo trampolín y el metodo IAT patch .
  
  El api hooking para quien no lo conosca es basicamente en modificar el comportamiento de una api por lo que queramos nosotros.
  
  Todo el taller sera hecho usando el lenguaje ensamblador, a si que si no dominas el lenguaje aunque sea en un nivel basico no comprenderas todo el taller por eso recomiendo leer un poco sobre este lenguaje antes de leer el taller .
  
  
  
  2.Inyección de codigo
  
  
  
  2.1Teoría
  
  La inyección de codigo consiste en hacer que un codigo que nosotros programemos sea ejecutado por un proceso externo.
  
  Para esto se crea un hilo con CreateRemoteThread en el proceso externo teniendo su PID ( Process ID ) y se escriber el codigo inyectado en el proceso creando un espacio con VirtualAllocEx y luego escribimos en el espacio generado con WriteProcessMemory .
  
  
  
  
  2.1Relización
  
  
  Para darnos una idea de la inyección de codigo inyectaremos un codigo que muestre un mensaje mediante la api MessageBoxA .
  
  Entonces inyectaremos la siguiente función
  
  Código (asm) [Seleccionar] Expandir
  ;pGetProcAddress = Puntero a la api GetProcAddress
proc FuncionInyectada,pGetProcAddress
locals ; Definimos las variables locales
BaseKernel32 dd ?    ;MZ de la kernel32.dll
endl
;Leemos el PEB  para obtener la base del kernel
    xor  eax, eax
    add  eax,[fs:eax+30h]
    mov  eax, [eax + 0ch]
    mov  esi, [eax + 1ch]
    lodsd
    mov  eax, [eax + 08h]
    mov [BaseKernel32],eax ;Guardamos en BaseKernel32 el MZ de la kernel32.dll

 stdcall [pGetProcAddress],[BaseKernel32],"LoadLibraryA" ; Sacamos la posición de LoadLibraryA en la kernel32.dll
 stdcall eax,"user32.dll" ;Cargamos la user32.dll
  stdcall [pGetProcAddress],eax,"MessageBoxA";Sacamos la posición de la api MessageBoxA
  stdcall eax,0,0,0,0     ;Mostramos el mensaje
  leave ;Terminamos
    ret ;
    endp
    FinFuncion:
  
  Para evitar lios los procesos donde trabajaremos seran creados por nosotros mismo mediante la api CreateProcessA y en nuestro code usaremos la siguiente función que mediante esta api crea un proceso.
  
  Código (ASM) [Seleccionar] Expandir
  
;pExe = Nombre del exe
;PI = Puntero a una estructura de PROCESS_INFORMATION
proc LanzarHilo,pExe,PI   ;Función que cre un proceso
   invoke GlobalAlloc,GPTR,sizeof.STARTUPINFO
   mov edi,eax
invoke CreateProcessA,0,[pExe],0,0,0,CREATE_SUSPENDED,0,0,eax,[PI]  ;creamos el proceso
   invoke GlobalFree,edi
   ret
endp  
  
  El siguiente paso es crear un espacio en el proceso donde escribiremos nuestra función , para eso usaremos la api  VirtualAllocEx y igual que en la creación del proceso para comodidad nos aremosa una comoda función que use esta api y nos retorne la posición donde se puede escribir
  
  Código (asm) [Seleccionar] Expandir
  
;pTamaño = Tamaño necesitado
;pPid = Id del proceso.
proc ReservarEspacio,pTamaño,pPid        ;Función que crea un espacio en el proceso
   invoke VirtualAllocEx,[pPid],0,[pTamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
   ret
endp    
  
  Luego de generar el espacio en el proceso , escribimos nuestra funcion con WriteProcessMemory y creamos el hilo remoto con CreateRemoteThread pasandole por el parametro la direccion del GetProcAddress que usamos en nuestra función inyectada, el codigo nos queda mas o menos a si.
  
  
  Código (asm) [Seleccionar] Expandir
  
; FinFuncion-FuncionInyectada = tamaño de la funcion
include 'win32ax.inc' ;Incluimos la libreria
.code ; Declaramos la sección de codigo
proc start ; Entry Point
   locals
       PI                      PROCESS_INFORMATION   ;Información del Proceso
       DirFun                  dd ? ;Espacio donde escribiremos    nuestro codigo
   endl
stdcall LanzarHilo,"notepad.exe",addr PI ; Creamos el proceso donde inyectaremos , el proceso es de un notepad.
stdcall ReservarEspacio,FinFuncion-FuncionInyectada,[PI.hProcess]     ;Creamos un espacio donde podremos esacribir
 mov [DirFun],eax                    ;Guardamos la direccion donde podemos escribir en DirFun
     invoke WriteProcessMemory,[PI.hProcess],[DirFun],FuncionInyectada,FinFuncion-FuncionInyectada,0  ;Escribimos nuestra funcion en el proceso.
     invoke CreateRemoteThread,[PI.hProcess],0,0,[DirFun],[GetProcAddress],0,0  ;Creamos un hilo en el proceso pasandole por parametro ola direccion de GetProcAddress
ret
endp
proc LanzarHilo,pExe,PI   ;Función que cre un proceso
   invoke GlobalAlloc,GPTR,sizeof.STARTUPINFO
   mov edi,eax
invoke CreateProcessA,0,[pExe],0,0,0,CREATE_SUSPENDED,0,0,eax,[PI]  ;creamos el proceso
   invoke GlobalFree,edi
   ret
endp
;pTamaño = Tamaño necesitado
;pPid = Id del proceso.
proc ReservarEspacio,pTamaño,pPid        ;Función que crea un espacio en el proceso
   invoke VirtualAllocEx,[pPid],0,[pTamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
   ret
endp
;pGetProcAddress = Puntero a la api GetProcAddress
proc FuncionInyectada,pGetProcAddress
locals ; Definimos las variables locales
BaseKernel32 dd ?    ;MZ de la kernel32.dll
endl
;Leemos el PEB  para obtener la base del kernel
    xor  eax, eax
    add  eax,[fs:eax+30h]
    mov  eax, [eax + 0ch]
    mov  esi, [eax + 1ch]
    lodsd
    mov  eax, [eax + 08h]
    mov [BaseKernel32],eax ;Guardamos en BaseKernel32 el MZ de la kernel32.dll

 stdcall [pGetProcAddress],[BaseKernel32],"LoadLibraryA" ; Sacamos la posición de LoadLibraryA en la kernel32.dll
 stdcall eax,"user32.dll" ;Cargamos la user32.dll
  stdcall [pGetProcAddress],eax,"MessageBoxA";Sacamos la posición de la api MessageBoxA
  stdcall eax,0,0,0,0     ;Mostramos el mensaje
  leave ;Terminamos
    ret ;
    endp
    FinFuncion:
.end start ; Declaramos el Import data y el Entry Point    

  
  
  
  2.Metodo de trampolín
  
  
  
  2.1-Teoría
  
  El metodo trampolín consiste en hacer que la api salte a nuestra función , esto se consigue cambiando los primeros bytes de la api por un codigo que salte a nuestra función ( por eso lo de trampolín) .
  
  Para lograrlo se inyecta un codigo que saca el MZ de la dll mediante la api GetModuleHandle , se saca la dirección de la api con GetProcAddress y luego se le da permisos de escritura a los 6 primeros bytes con VirtualProtectEx .
  
  Muchos se preguntaran por que a los 6 primeros bytes , esto es por que escribiremos un
  
  Código (asm) [Seleccionar] Expandir
  push DireccionDeNuestraFuncion
ret
  que esto ocupa un total de 6 bytes ( 0x68 = PUSH[1byte] , 1 Dword la posicion y 0xC3 = Ret[1 byte] ) , para los que no sepan el ret hace algo que se podria describir como un "pop EIP" haciendo un salto a lo ultimo pusheado en la pila.
  
  Para lograr hookear se necesita estar en su mismo espacio en memoria , para esto se inyectara de la manera anteriormente explicada el codigo que hace el hook.
  
  
  
  2.2-Realización
  
  Para explicar un poco mas la idea nos "autohookearemos" , la api que hookearmos en nosotros mismos es la api lstrlenA de la libreria kernel32.dll y haremos que devuelva siempre 0.
  
  Ya explicado lo que vamos a hacer nos ponemos en marcha   .
  
  
  Lo primero que haremos sera sacar la posición de la libreria kernel32.dll usando la api GetModuleHandle
  , de la siguiente manera:
  
  
  Código (asm) [Seleccionar] Expandir
  include 'win32ax.inc'     ;Incluimos la libreria
.code                 ;Declaramos la sección de codigo .
start:  ;Entry point
invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
ret ; salimos
.end start ;Establecemos el EntryPoint y el

                                                                 
  
  Luego obtendremos la dirección de la api lstrlenA( la que hoockearemos ) mediante la api GetProcAddress de la siguiente manera
  
  
  Código (asm) [Seleccionar] Expandir
  
include 'win32ax.inc'     ;Incluimos la libreria
.code                 ;Declaramos la sección de codigo .
start:  ;Entry point
invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx
ret ; salimos
.end start ;Establecemos el EntryPoint y el

                                                     

  
  Luego le tenemos que dar permisos de escritura a los primeros 6 bytes de la api lstrlenA que tenemos guardada su posición previamente en ebx , entonces para esto usaremos la api VirtualProtectEx de la siguiente manera
  
  
  Código (asm) [Seleccionar] Expandir
  
include 'win32ax.inc'     ;Incluimos la libreria
.code                 ;Declaramos la sección de codigo .
start:  ;Entry point
invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx

lea edx,dword[ebp-4]
invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA

ret ; salimos
.end start ;Establecemos el EntryPoint y el

                                             
  La fuunción con que remplazaremos la lstrlenA sera la siguiente
  
  Código (asm) [Seleccionar] Expandir
  
;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
proc MylstrlenA,p1
mov eax,0
ret
endp  

  
  Ya teniendo la función y permisos de escritura , escribiremos nuestro codigo que saltara hacia nuestra función quedando de la siguiente manera nuestro code
  
  Código (asm) [Seleccionar] Expandir
  
include 'win32ax.inc'     ;Incluimos la libreria
.code                 ;Declaramos la sección de codigo .
start:  ;Entry point
invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx

lea edx,dword[ebp-4]
invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA

   mov byte[ebx],0x68   ;Escribimos un PUSH en el primer byte de lstrlenA
   inc ebx   ;Nos vamos al segundo byte de lstrlenA
   mov dword[ebx],MylstrlenA  ;escribimos la direccion de nuestra funcion ( Estaria quedan un PUSH MylstrlenA )
   add ebx,4         ;Nos saltamos 4 bytes(1 dword)
   mov byte[ebx],0xC3;Escribimos el ret
ret ; salimos
;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
proc MylstrlenA,p1
mov eax,0
ret
endp
.end start ;Establecemos el EntryPoint y el import data                                                

  
  En este codigo la api ya estaria hookeada , para comprobarlo mostraremos un MessageBox con lo que devuelve ( Si no devuelve 0 daria error el MessageBoxA ).
  
  
  Código (asm) [Seleccionar] Expandir
  include 'win32ax.inc'     ;Incluimos la libreria
.code                 ;Declaramos la sección de codigo .
start:  ;Entry point
invoke GetModuleHandle,"kernel32.dll"   ;Sacamos la posicion de la kernel32.dll
invoke GetProcAddress,eax,"lstrlenA"    ;Sacamos la dirección de lstrlenA de la libreria kernel32.dll
mov ebx,eax                             ;Guardamos la direccion de lstrlenA en ebx

lea edx,dword[ebp-4]
invoke VirtualProtectEx,-1,ebx,6,PAGE_EXECUTE_READWRITE,edx ;Le damos permisos de escritura a los 6 primeros bytes de lstrlenA

   mov byte[ebx],0x68   ;Escribimos un PUSH en el primer byte de lstrlenA
   inc ebx   ;Nos vamos al segundo byte de lstrlenA
   mov dword[ebx],MylstrlenA  ;escribimos la direccion de nuestra funcion ( Estaria quedan un PUSH MylstrlenA )
   add ebx,4         ;Nos saltamos 4 bytes(1 dword)
   mov byte[ebx],0xC3;Escribimos el ret
   invoke lstrlen,"Hola" ; Esto deberia devolver 4
   invoke MessageBox,0,eax,0,0 ; Mostramos lop que devuelve , si se muestra el MessageBox LO LOGRAMOS!!
ret ; salimos
;Nuestra función que remplazara a la apì lstrlenA , esta funcion siempre devuelve 0.
proc MylstrlenA,p1
mov eax,0
ret
endp
.end start ;Establecemos el EntryPoint y el import data

                                 
  
  En la idea la unica diferencia entre el Autohook que hicimos y un Hook a otro proceso es que tenemos que inyectar nuestro codigo que hace hook en el proceso  .
  
  
  Ya sabiendo inyectar y teniendo la idea de como se hace el API Hook, vamos a hacer algo más divertido, inyectaremos nuestro código en otro proceso para modificar su comportamiento, en éste caso Hookearemos MessageBoxA. Para ésto será necesario crear un buffer con los 5 bytes (en éste caso) que pisamos en la API, para así, cuando queramos llamar a la API original poder hacerlo sin que la llamada caiga tambien en nuestra función  . Con una imagen queda más claro  :
  
  
  
  Por qué 5 bytes? Porque a la hora de modificar los bytes del comienzo de la Api, no podemos cortar instrucciones, y en el caso de Messagebox, la Api comienza por:
  
  
  Código (asm) [Seleccionar] Expandir
  
       mov edi,edi
        push ebp
        mov ebp,esp

  
  Eso ocupa exactamente 5 bytes, si lo reemplazamos por un jmp dirección, no cortaríamos ninguna instrucción. Pero ésto no es una constante, no todas las apis empiezan por lo mismo, por lo que en cada Api que vayamos a hookear, necesitaremos echar mano del debuger para fijarnos de no cortar ningúna instrucción  .
  
  MANOS A LA OBRA!
  
  Lo primero será inyectar nuestra función en el proceso que queremos Hookear:
  
  
  Código (asm) [Seleccionar] Expandir
  
proc start
   locals
       ProcessName             db                              "MessageBoxA.exe",0
   endl

   stdcall Inyectar,addr ProcessName,FINFuncion-FuncionInyectada,FuncionInyectada,[GetProcAddress]
   cmp eax,-1
   jne salir

   invoke MessageBoxA,0,"No se encontró el proceso!",0,0

   salir:
   invoke ExitProcess,0
endp

proc Inyectar,ProcessName,Tamaño,Funcion,Datos
   locals
       struct PROCESSENTRY32
           dwSize                  dd ?
           cntUsage                dd ?
           th32ProcessID           dd ?
           th32DefaultHeapID       dd ?
           th32ModuleID            dd ?
           cntThreads              dd ?
           th32ParentProcessID     dd ?
           pcPriClassBase          dd ?
           dwFlags                 dd ?
           szExeFile               rb MAX_PATH
       ends

       pInfo                   PROCESSENTRY32                  ?
       Handle                  dd                              ?
       PID                     dd                              ?
       DirFuncion              dd                              ?
       hProcess                dd                              ?
   endl

   ;Obtenemos el PID del proceso
   invoke CreateToolhelp32Snapshot,0x00000002,0
   mov [Handle],eax

    mov eax,sizeof.PROCESSENTRY32
    mov [pInfo.dwSize], eax

   BuclePid:
       invoke Process32Next,[Handle],addr pInfo
       cmp eax,0
       je FinProcBuclePID ;No hay más procesos
       invoke lstrcmp,addr pInfo.szExeFile,[ProcessName]
       cmp eax,0
       jne BuclePid
       jmp FinBuclePid

   FinProcBuclePID:
   invoke CloseHandle,[Handle]
   mov eax,-1
   ret

   FinBuclePid:
   invoke CloseHandle,[Handle]
   push [pInfo.th32ProcessID]
   pop [PID]

   ;Lazamos el proceso
   invoke OpenProcess,PROCESS_CREATE_THREAD+PROCESS_VM_OPERATION+PROCESS_VM_WRITE,FALSE,[PID]
   mov [hProcess],eax

   ;Reservamos espacio en el proceso
   invoke VirtualAllocEx,[hProcess],0,[Tamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
   mov [DirFuncion],eax

   ;Escribimos los datos en memoria
   invoke WriteProcessMemory,[hProcess],[DirFuncion],[Funcion],[Tamaño],0

   ;Creamos el hilo
   invoke CreateRemoteThread,[hProcess],0,0,[DirFuncion],[GetProcAddress],0,0

   ret
endp                    

  
  No explicaré el código de inyección, con los comentarios es más que suficiente, ya lo explicó mi compañero YST y se supone que dominamos la inyección y queremos hacer un Rootkit  .
  
  Ahora lo interesante, la función que inyectaremos:
  
  
  Código (asm) [Seleccionar] Expandir
  
proc FuncionInyectada,pGetProcAddress

    locals
        BaseKernel32                   dd               ?
        OriginalProtection             dd               ?
    endl

    ;Leemos el PEB  para obtener la base de KERNEL32.DLL
    xor  eax, eax
    add  eax,[fs:eax+30h]
    mov  eax, [eax + 0ch]
    mov  esi, [eax + 1ch]
    lodsd
    mov  eax, [eax + 08h]
    mov [BaseKernel32],eax

    ;Obtenemos la dirección de MessageBoxA
    stdcall [pGetProcAddress],[BaseKernel32],"GetModuleHandleA"
    mov edi,eax
    stdcall edi,"USER32.DLL"
    stdcall [pGetProcAddress],eax,'MessageBoxA'

    ;ebx contendrá la dirección de la Api MessageBoxA
    mov ebx,eax

    ;Obtenemos la dirección de VirtualProtect y damos permisos
    ;de lectura, escritura y ejecución a los 5 primeros bytes de la Api
    stdcall [pGetProcAddress],[BaseKernel32],"VirtualProtect"
    stdcall eax,ebx,5,PAGE_EXECUTE_READWRITE,addr OriginalProtection

    ;Calculamos el delta offset para saber en que
    ;dirección nos estamos ejecutando
    call delta
    delta:
    pop edx
    sub edx,delta  ;edx=delta

    ;Lo guardamos en la pila para no perderlo
    push edx

    ;Mostramos un Messagebox para indicar que nos inyectamos correctamete en el proceso
    ;(Obtenemos la dirección de las variables a partir del delta offset)
    mov eax,edx
    add edx,RMensaje             ;Obtenemos la direccion de las variables RMensaje y msgTitulo
    add eax,msgTitulo             ;a partir del delta offset
    stdcall ebx,0,edx,eax,0    ;ebx=puntero MessageBoxA

    ;Recuperamos el valor de delta de la pila y lo volvemos a guardar
    pop edx
    push edx

    ;Guardamos la dirección de MessageBoxA en la variable dirMessageBoxA
    add edx,dirMessageBoxA
    mov dword[edx],ebx

    pop edx  ;Recuparamos el valor de delta offset de la pila

    ;Modificamos los 5 primeros bytes de la API por un jmp a FuncionHook
    mov byte[ebx],0xE9   ;0xE9=jmp
    inc ebx
    mov ecx,FuncionHook
    add ecx,edx
    sub ecx,ebx
    sub ecx,4
    mov dword[ebx],ecx   ;la dirección a la que saltará

    ret          ;Terminamos, ya hemos modificado el principio de la api,
                  ;cuando el programa llame a MessageBoxA, saltará a FuncionHook

;--------------------------------------------------------------------------------------------------------------------------------------------

    ;Contiene los 5 primeros bytes de la Api MessageBoxA y una rutina para saltar a MessageBox+5
    ApiOriginal:
        ;edx=delta
        mov edi,edi         ; Primeros bytes de la api MessageBoxA
        push ebp            ; que pisamos poniendo nuestro salto,
        mov ebp,esp       ;

        add edx,dirMessageBoxA  ;Obtenemos la dirección de MessageBoxA leyendo
        mov eax,dword[edx]       ;la variable dirMessageBoxA y la guardamos en eax
        add eax,5           ;Nos desplazamos 5 bytes
        jmp eax             ;Saltamos a MessageBoxA+5

;--------------------------------------------------------------------------------------------------------------------------------------------

    ;Función a la que salta el programa cuando se llama a la API hookeada
    FuncionHook:
        ;Calculamos el delta offset
        call delta2
        delta2:
        pop edx
        sub edx,delta2  ;edx=delta

        ;Limpiamos la pila de los parametros originales
        pop eax
        mov ebx,eax ;Guardamos la dirección de retorno en ebx
        pop eax    
        pop eax
        pop eax
        pop eax

        push edx edx   ;Copiamos el delta a eax y ecx
        pop ecx eax

        ;pusheamos nuestros parámetros obteniendo la dirección de las variables
        ;a partir del delta offset
        push 0
        add ecx,msgTitulo
        push ecx
        add eax,ApiHookedMensaje
        push eax
        push 0

        ;Pusheamos la dirección de retorno
        push ebx

        ;Obtenemos la dirección de ApiOriginal
        mov ecx,edx
        add ecx,ApiOriginal

        ;Saltamos a ApiOriginal
        jmp ecx

;-------------------------------------------------------------------------------------------------------------------------------------------

        RMensaje                       db               "Soy el RootKit, me inyecté! :D!",0
        ApiHookedMensaje               db               "Soy un MessageBoxA Hookeado! :D!",0
        msgTitulo                      db               "xD",0
        dirMessageBoxA                 dd               ?
endp                

  
  Con eso tendríamos nuestro Rootkit terminado usando el método trampolín:
  
  Éste es el ejecutable Llamando a MessageboxA:
  
  
  
  Ejecutamos el Rootkit:
  
  
  
  Y cuando el programa hace MessageBoxa(0,"No estoy Hookeado !","",0) sucede ésto:
  
  
  
  Subo el código fuente completo: Descargar
  
  
  
  En construcción
  
  
  

Muy bueno el libro es el que yo uso pero creo que te gane 
http://foro.elhacker.net/asm/entry_point-t256455.0.html;msg1244831#msg1244831 

saludos

oh   Me ganaste.

Un exelente libro de ASM

http://rapidshare.com/files/161065925/Assembly_Language_For_Intel_based_computers.zip

Muy bueno   , por fin lo sacaste 

En la barra de botones


PD: Mi post 500 wijiiiiii 

Alguien me podria explicar para que sirve el boton mas  Que si lo apreto solo me oscurece la pantalla 

SAludos

Se mejoro la funcion  GetAddressFunction .

Si no me equivoco esta desactivado para usuarios normales ya que se podria prestar para bombardear a los moderadores.

Aunque siempre puedes enviar un MP al moderador del foro .

Saludos

si no usas apis tus resultados solo los vas a ver con un debugger

Ah! Digamos que ASM no tiene un "modo consola"? Unicamente veré un mensaje utilizando API's?

ASM se puede utilizar en modo consola , pero para imprimir datos y todo eso es neceesaario o usar interrupciones o api's