28 respuestas en este tema

[escafandra]

Voy a completar el tutorial con el código en C que está expuesto en delphi:

APIHook.h

cpp

//---------------------------------------------------------------------------
#ifndef APIHookH
#define APIHookH
//---------------------------------------------------------------------------
//#include "APIdef.h"
 
#include <Windows.h>
#ifdef __cplusplus
extern "C" {
#endif
 
void  InstallHook(void* HookAPI, void** ToAPI, char* dllName, char* ApiName, BOOL Resume);
void  InstallHookFromAddr(void* HookAPI, void** ToAPI,  void* API, BOOL Resume);
void  SuspendHook(void* ToAPI, char* dllName, char* ApiName);
void  SuspendHookFromAddr(void* ToAPI, void* API);
void  ResumeHook(void* HookFunc, char* dllName, char* ApiName);
void  ResumeHookFromAddr(void* HookFunc, void* API);
void  UnInstallHook(void** pToAPI, char* dllName, char* ApiName);
void  UnInstallHookFromAddr(void** pToAPI, void* API);
DWORD Transfer(BYTE* Source, BYTE* Dest);
 
#ifdef __cplusplus
}
#endif
 
/---------------------------------------------------------------------------
#endif

APIHook.c

cpp

#pragma hdrstop
 
#include "APIHook.h"
//---------------------------------------------------------------------------
#pragma hdrstop
 
#include "APIHook.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
 
#pragma link "ldasm.obj"
 
#ifdef __cplusplus
extern "C" {
#endif
  unsigned long SizeOfCode(unsigned char *code);
  unsigned long x_code_flags(unsigned char *code);
#ifdef __cplusplus
}
#endif
 
#define  OP_REL32  0x40
#define  OP_REL8   0x80
 
int GetOverloadBytes(BYTE* pB);
int ASMmemcpy(BYTE* Dest, BYTE* Source, DWORD NBytes);
 
 
////////////////////////////////////////////////////////////////////////////////
// Instalación general de API_Hooks
// HookAPI: API Hookeada
// ToAPI:   Salta a la API original
// ddlName: Nombre de la DLL donde se encuentra la API
// ApiName: Nombre de la API que vamos a Hookear
////////////////////////////////////////////////////////////////////////////////
void InstallHook(void* HookAPI, void** pToAPI, char* dllName, char* ApiName, BOOL Resume)
{
   HMODULE hLib = GetModuleHandle(dllName);
   if(!hLib) hLib = LoadLibrary(dllName);
   if(hLib){
     BYTE* API = (BYTE*)GetProcAddress(hLib, ApiName);
     InstallHookFromAddr(HookAPI, pToAPI, API, Resume);
   }
}
 
void InstallHookFromAddr(void* HookAPI, void** pToAPI,  void* API, BOOL Resume)
{
  int NBytes;
  PBYTE HookFunc, ToAPI;
  DWORD OldProtect;
 
  NBytes   = GetOverloadBytes((BYTE*)API); // Bytes a sobreescribir de la API
  *pToAPI        = VirtualAlloc(0, NBytes+5, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
  HookFunc = (BYTE*)HookAPI;
  ToAPI    = (BYTE*)*pToAPI;
 
  // Preparar la función ToAPI
  // Autorizo escribir en ToAPI
 
  VirtualProtectEx((void*)-1, ToAPI, NBytes+5, PAGE_EXECUTE_READWRITE, &OldProtect);
  ASMmemcpy((BYTE*)ToAPI, (BYTE*)API, NBytes); // Copio los primeros bytes de la api
  ToAPI[NBytes] = 0xE9 ; //jmp
  *(DWORD*)(ToAPI + NBytes+1) = ((BYTE*)API + NBytes) - (ToAPI + NBytes+5);
  VirtualProtectEx((void*)-1, ToAPI, NBytes+5, OldProtect, 0);
 
  // Preparar la API a Hookear
  if(Resume) ResumeHookFromAddr(HookFunc, API);
 
  FlushInstructionCache(GetCurrentProcess(), NULL, 0);
}
 
void UnInstallHook(void** pToAPI, char* dllName, char* ApiName)
{
   HMODULE hLib = GetModuleHandle(dllName);
   if(!hLib) hLib = LoadLibrary(dllName);
   if(hLib){
     void* API = GetProcAddress(hLib, ApiName);
     if(API) UnInstallHookFromAddr(pToAPI, API);
   }  
}
 
void UnInstallHookFromAddr(void** pToAPI, void* API)
{
  if(*pToAPI==0 || API==0) return;
  SuspendHookFromAddr(*pToAPI, API);
  VirtualFree(*pToAPI, 0, MEM_RELEASE);
  *pToAPI = 0;
}
 
////////////////////////////////////////////////////////////////////////////////
// Calcula los Bytes que se pueden modificar en la API Original
////////////////////////////////////////////////////////////////////////////////
int GetOverloadBytes(BYTE* pB)
{
  int Result = 0;
  for(; Result < 5;)
    Result += SizeOfCode(pB+Result);
 
  return Result;
}
 
 
// Transfiere una instrucción asm completa desde fuente a destino
// Si es un salto relativo lo recalcula.
// Devuelve el nº de Bytes transferidos en destino.
DWORD Transfer(BYTE* Source, BYTE* Dest)
{
  int   Offset;
  DWORD Size = SizeOfCode(Source);
  DWORD Flag = x_code_flags(Source);
  CopyMemory(Dest, Source, Size);
 
  // Si es un salto relativo
  if(Flag & (OP_REL8 | OP_REL32)){
    // Salto relativo lejano:
    if(Flag & OP_REL32){
      Offset = *(int*)&Source[Size-4];
      *(int*)&Dest[Size-4] = Offset - (Dest - Source);
    }
    // Salto relativo cercano
    else if(Flag & OP_REL8){
      Offset = *(signed char*)&Source[1];
      Dest[0] = 0xE9;
      *(int*)&Dest[1] = Offset - (Dest - Source);
      Size = 5;
    }
  }
  return Size;
}
 
////////////////////////////////////////////////////////////////////////////////
// Escribe los Bytes a modificar ajustando saltos condicionales
////////////////////////////////////////////////////////////////////////////////
int ASMmemcpy(BYTE* Dest, BYTE* Source, DWORD NBytes)
{
  DWORD Result = 0;
  for(; Result < NBytes;){
    Transfer(Source + Result, Dest + Result);
    Result += SizeOfCode(Source + Result);
  }
  return Result;
}
 
////////////////////////////////////////////////////////////////////////////////
// Suspende momentaneamente el Hook sin desinatalar ToHook
////////////////////////////////////////////////////////////////////////////////
void SuspendHookFromAddr(void* ToAPI, void* API)
{
  int n;
  DWORD OldProtect;
 
  if(ToAPI==0 || API ==0) return;
  // Autorizo escribir en la API Hookeada
  VirtualProtectEx((void*)-1, API, 5, PAGE_EXECUTE_READWRITE, &OldProtect);
  for(n=0; n<5; n++) ((BYTE*)API)[n] = ((BYTE*)ToAPI)[n];
  //memcpy(API, ToAPI, 5);
  VirtualProtectEx((void*)-1, API, 5, OldProtect, 0);
}
 
void SuspendHook(void* ToAPI, char* dllName, char* ApiName)
{
  void* API = 0;
  HMODULE hLib = 0;
 
  if(ToAPI==0 || dllName==0 || ApiName==0) return;
 
  hLib = GetModuleHandle(dllName);
  if(!hLib) hLib = LoadLibrary(dllName);
  if(!hLib) return;
 
  API = GetProcAddress(hLib, ApiName);
  if(API)
    SuspendHookFromAddr(ToAPI, API);
}
 
////////////////////////////////////////////////////////////////////////////////
// Resume o reinicia el Hook
////////////////////////////////////////////////////////////////////////////////
void ResumeHookFromAddr(void* HookFunc, void* API)
{
  DWORD OldProtect;
  BYTE* Api;
 
  if(HookFunc==0 || API==0) return;
 
  // Autorizo escribir en la API a Hookear
  VirtualProtectEx((void*)-1, API, 5, PAGE_EXECUTE_READWRITE, &OldProtect);
  Api = (BYTE*)API;
  *Api = 0xE9 ; //jmp
  *(DWORD*)(Api+1) = (BYTE*)HookFunc - (Api+5);
  VirtualProtectEx((void*)-1, API, 5, OldProtect, 0);
}
 
void ResumeHook(void* HookFunc, char* dllName, char* ApiName)
{
  void* API;
 
  if(HookFunc==0) return;
  API = GetProcAddress(GetModuleHandle(dllName), ApiName);
  if(API)
    ResumeHookFromAddr(HookFunc, API);
}

Dado que las explicaciones a dicho código están expuestas más arriba, no creo que merezca la  pena repetir.


Saludos.

[escafandra]

Para seguir ilustrando el tema, os dejo una dll que realiza un Hook a la API MessageBox en el que el mensaje será cambiado por "HOOKED" seguido del mensaje original y expondrá el icono MB_ICONWARNING

cpp

#include <windows.h>
#include "APIHook.h"
 
#pragma argsused
 
typedef int (__stdcall *PMESSAGEBOX)(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType);
PMESSAGEBOX OMessageBox = 0;
 
//----------------------------------------------------------------------------
int WINAPI NewMessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType)
{
  char Buffer[256];
  lstrcat(lstrcpy(Buffer, "HOOKED\n"), lpText);
  return OMessageBox(hWnd, Buffer, "HOOK", MB_ICONWARNING);
}
 
//----------------------------------------------------------------------------
// Aquí instalaremos todos los Hooks a las API que deseemos
void InstallHook()
{
  InstallHook(NewMessageBox, (void**)&OMessageBox, "User32.dll", "MessageBoxA", true);
}
 
//----------------------------------------------------------------------------
// Aquí desinstalaremos todos los Hooks
void UnInstallHook()
{
  UnInstallHook((void**)&OMessageBox, "User32.dll", "MessageBoxA");
}
 
//----------------------------------------------------------------------------
// El punto de entrada a nuestra dll
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fwdreason, LPVOID lpvReserved)
{
  switch (fwdreason) {
    case DLL_PROCESS_ATTACH:
      InstallHook();
      break;
    case DLL_PROCESS_DETACH:
      UnInstallHook();
      break;
  }
  return 1;
}
//---------------------------------------------------------------------------

Al cargar o inyectar la dll instala los Hooks en el proceso y los desninstala al descargarla
La inyección sólo se puede hacer efectiva en procesos 32bits, ya que el sistema de Hooks está diseñado para ellos.


Saludos

[escafandra]

Y como no podía dejar a delphi huerfano, vamos a escribir la dll en ese lenguaje:

delphi

library Hookdll;
 
uses
  SysUtils,
  Windows, APIHook;
 
type PMESSAGEBOX = function(hWnd: THandle; lpText, lpCaption: PCHAR; uType: integer): Integer; stdcall;
 
var
  OMessageBox: PMESSAGEBOX = nil;
 
 
//----------------------------------------------------------------------------
// La API MessageBox Hookeada
function NewMessageBox(hWnd: THandle; lpText, lpCaption: PCHAR; uType: integer): Integer; stdcall;
begin
  Result:= OMessageBox(hWnd, 'MessageBox HOOKED    ', lpCaption, uType or MB_ICONEXCLAMATION);
end;
 
//----------------------------------------------------------------------------
// Aquí instalaremos todos los Hooks a las API que deseemos
procedure InstallHooks;
begin
  InstallHook(@NewMessageBox, @OMessageBox, 'User32.dll', 'MessageBoxA', true)
end;
 
//----------------------------------------------------------------------------
// Aquí desinstalaremos todos los Hooks
procedure UnInstallHooks;
begin
  UnInstallHook(@OMessageBox, 'User32.dll', 'MessageBoxA');
end;
 
procedure DllMain(reason: integer) ;
begin
   case reason of
     DLL_PROCESS_ATTACH:
       InstallHooks;
     DLL_PROCESS_DETACH:
       UnInstallHooks;
   end;
end; (*DllMain*)
 
begin
 DllProc := @DllMain;
 DllProc(DLL_PROCESS_ATTACH) ;
end.

Saludos.

[aguml]

en mi caso me hará falta ya que la funcion NtSetInformationThread es asi:

delphi

7C91DCAE > B8 E5000000      MOV EAX,0E5
7C91DCB3   BA 0003FE7F      MOV EDX,7FFE0300
7C91DCB8   FF12             CALL DWORD PTR DS:[EDX]
7C91DCBA   C2 1000          RETN 10

Y la funcion NtQueryInformationProcess es así:

delphi

7C91D7FE > B8 9A000000      MOV EAX,9A
7C91D803   BA 0003FE7F      MOV EDX,7FFE0300
7C91D808   FF12             CALL DWORD PTR DS:[EDX]
7C91D80A   C2 1400          RETN 14

El parcheo no me sirve ya que esas apis son llamadas con mucha asiduidad por el sistema y si parcheo a fuego no funcionan como deben ya que dependen de los parametros para que hagan una cosa u otra. Toca hacer un hook con filtro pero antes de nada tengo que ver porque la dll no corre si la inyecto en otro proceso, es lo mas urgente y luego ya se van viendo otras cosas.

[escafandra]

en mi caso me hará falta ya que la funcion NtSetInformationThread es asi:

delphi

7C91DCAE > B8 E5000000      MOV EAX,0E5
7C91DCB3   BA 0003FE7F      MOV EDX,7FFE0300
7C91DCB8   FF12             CALL DWORD PTR DS:[EDX]
7C91DCBA   C2 1000          RETN 10

Y la funcion NtQueryInformationProcess es así:

delphi

7C91D7FE > B8 9A000000      MOV EAX,9A
7C91D803   BA 0003FE7F      MOV EDX,7FFE0300
7C91D808   FF12             CALL DWORD PTR DS:[EDX]
7C91D80A   C2 1400          RETN 14

El parcheo no me sirve ya que esas apis son llamadas con mucha asiduidad por el sistema y si parcheo a fuego no funcionan como deben ya que dependen de los parametros para que hagan una cosa u otra. Toca hacer un hook con filtro pero antes de nada tengo que ver porque la dll no corre si la inyecto en otro proceso, es lo mas urgente y luego ya se van viendo otras cosas.

Si ves, los 5 primeros bytes son una instrucción completa con lo que no debes tener problemas. El código que dejo usa automáticamente el desnsamblador de longitud, de forma que en principio no debes preocuparte del tema. Revisa la dll que dejé mas arriba, es completamente funcional.

Ten en cuenta que desde win32 no puedes inyectar un proceso win64, CreateRemoteTread no funciona en estos casos y los hooks te darán problema al ser tratados como enteros de 32bits en parte del código, eso habría que revisarlo.


Saludos.

[aguml]

El ejemplo de la dll que has puesto no compila. Haces algo extraño, tienes declarada por ejemplo la funcion para hookear como: void InstallHook() y la llamas al crear la dll en el entrypoint de la dll pero dentro de la funcion haces: InstallHook(NewMessageBox, (void**)&OMessageBox, "User32.dll", "MessageBoxA", true);
Eso es como si hicieras una sobrecarga de la funcion pero no la tienes declarada con esos parametros y ademas ¿seria recursiva la funcion? lo digo porque se llama a si misma aunque con diferentes parametros.

[escafandra]

Si compila. No publico código sin probarlo antes. 

La función está sobrecargada, pero puedes cambiar el nombre a InstallHooks si te gusta mas. La declaración está en APIHook.h

Te subo el proyecto y el binario.


Saludos.

Archivos adjuntos

•  Hookdll.rar   27,34KB   24 descargas

[escafandra]

Los tiempos han cambiado en el entorno de delphi y Builder. Se impone el Unicode y con ello quedan obsoletas algunas implementaciones. En este caso vuelvo sobre este tema para actualizar el código tras una pregunta en el vecino CD: localizada aquí.

 

La revisión no hace más cambios que adaptarse al unicode forzando a no usarlo, la razón es porque GetProcAddress no tiene equivalente en GetProcAddressW y resulta más cómodo usar las versiones no unicode del resto de las API (LoadLibraryA y GetModuleHandleA)

 

He preparado un proyecto para compilar una dll que porta el Hook, otro para usarla y un tercero que no hace uso de la dll y sirve para experimentar todo en una sola app.

La utilidad del los hooks es mediante la inyección de dll, esa es la razón de los dos primeros proyectos, el tercero es para simplificar el aprendizaje y la experimentación. La inyección dll no es asunto de este turorial.

 

Dejo la revisión para Builder Berlín.

 

 

Saludos.

Archivos adjuntos

•  API Hook CPP Berlin.rar   333,96KB   9 descargas

[escafandra]

Para delphi también tenemos que actualizar con ajustes en el Unicode para forzar su no uso debido a la API GetProcAddress. No se usa Unicode en las funciones que usan el hook pero el resto del programa es normal. Hay que tener presente que las APIs suelen tener una versión Unicode y otra clásica. Para el ejemplo que se usa MessageBox, tenemos MessageBoxA para la versión clásica y MessageBoxW para la versión unicode. No tratéis de hacer un hook con el nombre MessageBox sin especificar la versión, pues no existe ese nombre. El compilador lo ajusta y es por eso que estamos acostumbrados a no especificar. Para realizar el hook hay que especificar con exactitud que versión queremos.

 

Como he hecho para Builder, presento tres ejemplos, un proyecto para una dll que realiza un hook al cargarla o inyectarla, un proyecto que funciona con esa dll y otro proyecto para experimentar que se "hookea" a si mismo.

 

Subo los ejemplos para Berlin con código y binarios.

Archivos adjuntos

•  API Hook delphi Berlin.rar   1,47MB   15 descargas