Os dejo algunas funciones en FASM que e ido haciendo desde que empece con asm.

Función que compara dos cadenas:

    proc Comparar,cadena1,cadena2
            ;Si son iguales  EAX = 1
            ;Si son diferentes EAX = 0
            mov esi,[cadena1]
            mov ecx,[cadena2]
            dec ecx
            bucle:
                inc ecx
                lodsb
                cmp byte[ecx],al
                jne diferentes
                cmp al,0
                je comprovar
                jmp bucle
            comprovar:
                cmp byte[ecx],0
                je iguales
                jne diferentes
            diferentes:
                mov eax,0
                ret
            iguales:
                mov eax,1
                ret
         endp 

Ejemplo de su uso:

    include 'win32ax.inc'
 
    .data
        palabra db 'Drinky94',0
        palabra2 db 'Drinky94',0
 
    .code
    start:
        stdcall Comparar,palabra,palabra2
        .if eax = 0
            invoke MessageBoxA,0,'Son Diferentes',0,0
        .else
            invoke MessageBoxA,0,'Son Iguales',0,0
        .endif
        ret
 
        proc Comparar,cadena1,cadena2
            ;Si son iguales  EAX = 1
            ;Si son diferentes EAX = 0
            mov esi,[cadena1]
            mov ecx,[cadena2]
            dec ecx
            bucle:
                inc ecx
                lodsb
                cmp byte[ecx],al
                jne diferentes
                cmp al,0
                je comprovar
                jmp bucle
            comprovar:
                cmp byte[ecx],0
                je iguales
                jne diferentes
            diferentes:
                mov eax,0
                ret
            iguales:
                mov eax,1
                ret
         endp
    .end start 

---

Función que mide la longitud de una cadena:

    proc Len,Cadena
            ;ECX = Longitud de la cadena.
            mov eax,[Cadena]
            mov ecx,-1
            bucle:
                inc ecx
                cmp byte[eax+ecx],0
                jne bucle
            ret
    endp

Ejemplo de su uso:

    include 'win32ax.inc'
 
    .data
        palabra db 'Drinky94',0
        longitud dd ?
    .code
    start:
        stdcall Len,palabra
        mov [longitud],ecx
        invoke GlobalAlloc,GPTR,1024
        push eax
        invoke wsprintfA,eax,"%d",[longitud]
        pop eax
        invoke MessageBox,0,eax,0,MB_OK
        leave
        ret
 
        proc Len,Cadena
            ;ECX = Longitud de la cadena
            mov eax,[Cadena]
            mov ecx,-1
            bucle:
                inc ecx
                cmp byte[eax+ecx],0
                jne bucle
            ret
        endp
    .end start

---

Función que puede servir de remplazo a GlobalAlloc:

    proc DGlobalAlloc,cantidad
            sub esp,[cantidad]
            mov eax,esp
            ret
    endp

Ejemplo de su uso:

    include 'win32ax.inc'
 
    .data
        palabra db 'Drinky94',0
        longitud dd ?
    .code
    start:
 
        stdcall Len,palabra
        mov [longitud],ecx
        stdcall DGlobalAlloc,1024
        push eax
        invoke wsprintfA,eax,"%d",[longitud]
        pop eax
        invoke MessageBox,0,eax,0,MB_OK
        leave
        ret
 
        proc Len,Cadena
            mov eax,[Cadena]
            mov ecx,-1
            bucle:
                inc ecx
                cmp byte[eax+ecx],0
                jne bucle
            ret
        endp
 
        proc DGlobalAlloc,cantidad
            sub esp,[cantidad]
            mov eax,esp
            ret
        endp
    .end start 

---

Código para saber si nos están debuggeando (usa el PEB):

    format PE GUI 4.0
    entry start
 
    include 'win32ax.inc'
 
        SiDbg db 'Hay Debugger',0
        NoDbg db 'No hay Debugger',0
 
    start:
            mov eax,dword[fs:18h]
            mov eax,dword[eax+30h]
            mov bl,byte[eax+2]  ; si bl = 1 Nos estan debujeando.
 
            .if bl = 1
                invoke MessageBoxA,0,SiDbg,0,0
            .else
                invoke MessageBoxA,0,NoDbg,0,0
            .endif
            ret
 
    data import
            library user32,'user32.dll'
 
            import user32,MessageBoxA,'MessageBoxA'
 
    end data            

---

Simple cifrado Xor:

    proc Cifrar,Cadena
                xor ecx,ecx
                mov eax,[Cadena]
                .bucle:
                    .if byte[eax+ecx] = 0
                        jmp .salir
                    .endif
                    xor byte[eax+ecx],7
                    inc ecx
                    jmp .bucle
                .salir:
                ret
             endp 

Ejemplo de su uso:

    include 'win32ax.inc'
 
    .data
            hola db 'hola',0
 
    .code
    start:
             stdcall Cifrar,hola
             invoke MessageBoxA,0,eax,0,0
             ret
 
             proc Cifrar,Cadena
                xor ecx,ecx
                mov eax,[Cadena]
                .bucle:
                    .if byte[eax+ecx] = 0
                        jmp .salir
                    .endif
                    xor byte[eax+ecx],7
                    inc ecx
                    jmp .bucle
                .salir:
                ret
             endp
    .end start    

---

Función que pasa un número entero a cadena:

 proc NumToString,Numero
                ;Función creada por Drinky94. Agradecimientos a Jep.
                locals
                        divisor dw ?
                        ; buffer rb 20  Agregar esta variable en la sección data
                        ; El numero 20 es la longitud que tendra la cadena
                        ;si nuestro numero tiene 4 cifras tendremos que poner 4
                        ; CadenaFinal rb 20  ; lo mismo que con la variable buffer.
                endl
 
                mov [divisor],10
                xor eax,eax
                xor ebx,ebx
                mov eax,[Numero]
                bucle:
                        xor edx,edx
                        div [divisor]
                        add dl,0x30
                        mov byte[buffer+ebx],dl
                        inc ebx
                        cmp eax,0
                            jne bucle
                inc ebx
                mov byte[buffer+ebx],0x0
                mov eax,buffer
                mov ecx,-1
                buclelen:
                        inc ecx
                        cmp byte[eax+ecx],0
                            jne buclelen
                xor ebx,ebx
                dec ecx
                reverse:
                        xor edx,edx
                        mov dl,byte[eax+ecx]
                        mov byte[CadenaFinal+ebx],dl
                        inc ebx
                        sub ecx,1
                        cmp ecx,-1
                            jne reverse
                mov eax,CadenaFinal
                ret
        endp  

Ejemplo de su uso:

include 'win32ax.inc'
 
.data
        buffer rb 4
        CadenaFinal rb 4
.code
start:
        stdcall NumToString,1994
        invoke MessageBoxA,0,eax,0,0
        ret
 
        proc NumToString,Numero
                ;Función creada por Drinky94. Agradecimientos a Jep.
                locals
                        divisor dw ?
                        ; buffer rb 20  Agregar esta variable en la sección data
                        ; El numero 20 es la longitud que tendra la cadena
                        ;si nuestro numero tiene 4 cifras tendremos que poner 4
                        ; CadenaFinal rb 20  ; lo mismo que con la variable buffer.
                endl
 
                mov [divisor],10
                xor eax,eax
                xor ebx,ebx
                mov eax,[Numero]
                bucle:
                        xor edx,edx
                        div [divisor]
                        add dl,0x30
                        mov byte[buffer+ebx],dl
                        inc ebx
                        cmp eax,0
                            jne bucle
                inc ebx
                mov byte[buffer+ebx],0x0
                mov eax,buffer
                mov ecx,-1
                buclelen:
                        inc ecx
                        cmp byte[eax+ecx],0
                            jne buclelen
                xor ebx,ebx
                dec ecx
                reverse:
                        xor edx,edx
                        mov dl,byte[eax+ecx]
                        mov byte[CadenaFinal+ebx],dl
                        inc ebx
                        sub ecx,1
                        cmp ecx,-1
                            jne reverse
                mov eax,CadenaFinal
                ret
        endp
.end start      

Cuando valla haciendo mas las voi posteando

saludos.

http://virtuscann.com/

Servicio gratuito y no distribuye.

Tienes que pasarle el identificador del proceso.

salu2!

Ctrl + W?

Aqui te dejo un link donde viene info de lo que buscas:

http://www.codeproject.com/KB/dialog/w32inputbox_1.aspx

salu2!

Esta es la sección de asm, no de vb.

salu2!

si 

salu2!

A mi me funciona perfectamente Zero, sigue perfectamente la ejecucion del programa...

Muchas gracias una vez más     jajaja


Este es el código funcional, lo comente para que mas gente lo comprenda tambien 

;##########################################################
;##  Ejemplo API Hoking by Drinky94                      ##
;##  Agradecimientos a:                                  ##
;##      [Zero] por todo en lo que me ayuda              ##
;##       YST por su funcion ASCIITOUNICODE              ##
;##########################################################
 
format PE GUI 4.0 DLL
entry DllEntryPoint
 
include 'win32ax.inc'
 
section '.code' code readable executable
 
proc DllEntryPoint hinstDLL,fdwReason,lpvReserved
        locals
            proteccion dd ?
        endl
 
        stdcall ASCIITOUNICODE,mensajito,buffer;pasamos la cadena que se mostrara en MessageBoxW a Unicode
 
        invoke LoadLibrary,'user32.dll' ;Cargamos User32
        invoke GetProcAddress,eax,"MessageBoxA" ;obtenemos la direccion de la api
        mov ebx,eax; ebx  = direccion MessageBoxA
 
        mov eax,hook  ;Calculamos la distancia entre el jmp y la funcion donde saltaremos
        sub eax,ebx
        sub eax,4
 
        mov ecx,eax
 
        push ebx
        push ecx
 
        invoke VirtualProtect,ebx,5,PAGE_EXECUTE_READWRITE,addr proteccion     ;le damos a 5 bytes permiso de escritura
 
        pop ecx
        pop ebx
 
        mov byte[ebx],0xE9  ;escribimos un jmp
        inc ebx
        mov dword[ebx],ecx ;escriimos la longitud del salto
        add ebx,4
        ret
endp
 
proc hook,uno,dos,tres,cuatro  ;funcion que remplaza a MesasgeBoxA
    invoke MessageBox,0,buffer,0,0 ;Si se llama a MessageBoxA, mostramos nuestro mensagito :PP
    mov eax,0  ;devolvemos cero
    jmp ebx  ;saltamos donde nos quedamos para continuar la ejecucion.
endp
 
proc ASCIITOUNICODE,Cadena,Buffer
;Funcion By YST
 
push ecx ebx
mov  eax,[Cadena]
mov ebx,[Buffer]
dec eax
sub ebx,2
.bucle:
inc eax
cmp byte[eax],0
je .salir
add ebx,2
mov cl,byte[eax]
mov byte[ebx],cl
mov byte[ebx+1],0
jmp .bucle
.salir:
pop ebx ecx
ret
endp
 
proc ShowErrorMessage hWnd,dwError
  local lpBuffer:DWORD
        lea     eax,[lpBuffer]
        invoke  FormatMessage,FORMAT_MESSAGE_ALLOCATE_BUFFER+FORMAT_MESSAGE_FROM_SYSTEM,0,[dwError],LANG_NEUTRAL,eax,0,0
        invoke  MessageBox,[hWnd],[lpBuffer],NULL,MB_ICONERROR+MB_OK
        invoke  LocalFree,[lpBuffer]
        ret
endp
 
; VOID ShowLastError(HWND hWnd);
 
proc ShowLastError hWnd
        invoke  GetLastError
        stdcall ShowErrorMessage,[hWnd],eax
        ret
endp
section '.data' data readable writeable
        mensajito db 'Msgbox Hookeado',0
        buffer db ?
 
 
section '.idata' import data readable writeable
 
  library kernel,'KERNEL32.DLL',\
          user,'USER32.DLL'
 
  import kernel,\
         GetLastError,'GetLastError',\
         SetLastError,'SetLastError',\
         FormatMessage,'FormatMessageA',\
         LocalFree,'LocalFree',\
         LoadLibrary,'LoadLibraryA',\
         GetProcAddress,'GetProcAddress',\
         VirtualProtect,'VirtualProtect'
 
  import user,\
         MessageBox,'MessageBoxW'
 
section '.edata' export data readable
 
  export 'ERRORMSG.DLL',\
         ShowErrorMessage,'ShowErrorMessage',\
         ShowLastError,'ShowLastError'
 
section '.reloc' fixups data discardable  
 
 
 
 
 

salu2!

format PE Console

Lo unico que para entrada y salida de datos tendras que usar API, no puedes usar interrupciones.

salu2!