[WINNT] INTERCEPTER LES APPELS AUX API WIN32

Pour utiliser SharpSpyHelper.dll et/ou SharpSpy.dll:

[C#]
//Ajouter la référence 'SharpSpy.dll'
//Définir un délégué pour la fonction à appeller:
delegate IntPtr LoadIconWHandler( IntPtr hInstance, IntPtr lpIconName );
//Et écrire la fonction qui doit être appellée à la place de l'API
IntPtr MyLoadIconW( IntPtr hInstance, IntPtr lpIconName )
{
   <...>
}

//puis ajouter ce code quelque part:

//INITIALISATION
//processus dans lequel intercepter des API
Process processus = Process.GetProcessesByName( "notepad" )[0];
SystemProcess proc = new SystemProcess( processus );
//tas de mémoire du processus
MiniHeap heap = proc.Heap;
SharpSpyHelper helper;
HookTable hook;
uint error = 0;
//on injecte SharpSpyHelper.dll dans le processus
uint helperAddress = proc.InjectLibraryEx( @"<Chemin de la DLL SharpSpyHelper.dll>", out error );

if( (helperAddress != 0) && (error == 0) )
{
    helper = new SharpSpyHelper( proc, @"<Chemin de la DLL SharpSpyHelper.dll>", (IntPtr)address );
    //on récupère la table des hooks
    table = helper.Table;
    helper.InitMsgWindow();	//helper.InitMsgWindow( this.Handle ); si le code s'exécute dans une Form    
}


//CREATION DU HOOK
//on récupère un handle du processus
uint hProcess = helper.GetProcessHandle(); 
//on crée un hook: <DLL>, <Fonction à hooker>
//ici HICON LoadIconW( HINSTANCE hInstance, LPCTSTR lpIconName );
HookParams hParams = new HookParams( "User32.dll", "LoadIconW", heap );
hParams.HookName = "NativeCallSinkProxy";
hParams.Module = hProcess;
hParams.HookedAddress = helper.GetFunctionAddress( "CallSinkProxy" );
//Taille des arguments en octets
 hParams.ArgumentsSize = 8;
//Taille de la valeur de retour en octets
hParams.ReturnValueSize = 4;
//on définit la fonction a appeller à la place de l'originale
hParams.Callback = new LoadIconWHandler( MyLoadIconW ); 
//on ajoute le hook à la table des hooks
table.Add( hParams );
//on initialise la table
table.Init();

//on effectue le hook
if( helper.HookByID( hParams.HookID ) )
{
    //Le hook a réussi!
    //tous les appels à LoadIconW dans notepad seront remplacés par un appel à MyLoadIconW
    //rafraîchit les infos de la table des hooks, comme l'adresse originale de la fonction
    table.Resfresh();
}

[C++ Managé]
Pas de différence avec la version C# si ce n'est dans la syntaxe... (pointeurs __gc, etc)

[C/C++]
//inclure les headers de Windows
#include <windows.h>
#include <winnt.h>
//etc
#include "SharpSpyHelper.h"
//récupérer un handle du processus d'abord
HANDLE hProcess; 

LPWSTR lpModule = L"<Chemin de la DLL SharpSpyHelper.dll>";
DWORD cbModule = (wcslen( lpModule ) + 1) * 2;
//on alloue de la mémoire dans le processus
LPVOID hMem = VirtualAllocEx( hProcess,  NULL,  cbModule,  MEM_COMMIT,  PAGE_READWRITE );
DWORD dwWritten;
//puis on écrit dans la mémoire du processus le chemin de SharpSpyHelper.dll
WriteProcessMemory( hProcess, hMem, lpModule, cbModule, &dwWritten );

//on récupère l'addresse de LoadLibraryW dans Kernel32.dll, commune à tous les procesus
DWORD hKernel = GetModuleHandle( _T("Kernel32.dll") );
DWORD hLL = GetProcAddress( _T("LoadLibraryW") );
		
//on va injecter SharpSpyHelper.dll dans le processus
//c'est à dire y créer un thread qui va exécuter LoadLibraryW( "SharpSpyHelper.dll" )
//qui contient tous les fonctions de hook.

HANDLE hThread = NULL;
DWORD dwThreadId;
DWORD hModuleAddress;
hThread = CreateRemoteThread( hProcess, NULL, hLL, hMem, 0, &dwThreadId );

if( hThread != NULL )
{
    //On attend que le thread se termine
    WaitForSingleObjectEx( hThread, TIMEOUT_INFINITE, TRUE );
    //on récupère la valeur de retour du thread: soit l'addresse de la DLL chargée,
    //soit un code d'erreur si elle n'a pas été trouvée
    GetExitCodeThread( hThread, &hModuleAddress );
}
//on libère la mémoire allouée pour le chemin de la DLL
VirtualFreeEx( hProcess, hMem, cbModule, MEM_RELEASE );

//à partir de la SharpSpyHelper.dll est chargé dans le processus (notepad par exemple)
//il reste plus qu'à obtenir l'addresse de la fonction GetMyProcAddress dans SharpSpyHelper.dll
//avec CreateRemoteThread mais en passant l'addresse de GetProcAddress (toujours Kernel32.dll)
//et comme paramètre la chaîne _T("GetMyProcAddress")
//une fois qu'on a l'addresse de GetMyProcAddress, il suffit de l'appeller (toujours avec CreateRemoteThread)
//en passant un des paramètre suivant: (pour la liste complete voir SharpSpyHelper.h)

#define PROCADDRESS_DLLMAIN			1
#define PROCADDRESS_GETPROCESSHANDLE	                2
#define PROCADDRESS_INDIRECTCALLEX		3
#define PROCADDRESS_HOOK			4

//pour avoir l'addresse d'une fonction
//par exemple en appelant GetMyProcAddress( PROCADDRESS_INDIRECTCALLEX )
//on obtient l'addresse de la fonction IndirectCallEx dans SharpSpyHelper.dll
hThread = CreateRemoteThread( hProcess, NULL, <addresse de GetMyProcAddress>, PROCADDRESS_INDIRECTCALLEX, 0, &dwThreadId );
//etc...

//On récupère l'addresse de la fonction IndirectCallEx que voila:
void __stdcall IndirectCallEx( NCallParams* lpCallParams );

struct NCallParams
{
	DWORD address;				
	DWORD* lpStack;				
	DWORD cbStack;				
	void* lpReturn;				
	DWORD cbReturn;				
	BOOL cdeclCall;				
};
//Cette fonction permet d'appeller avec CreateRemoteThread une fonction
//qui a plus d'un argument. Par exemple, pour appeller

void InitHookList( void* lpList, DWORD cbList );

void* lpList;
DWORD cbList;
//un pointeur 32 bits et un DWORD = 8 octets
BYTE* lpStack = (BYTE*)malloc( 8 );
//on copie lpList et cbList dans lpStack
memcpy( lpStack, &lpList, 4 );
memcpy( lpStack + 4, &cbList, 4 );

//il faut d'abord créer une structure NCallParams
NCallParams nc;
//à récupérer avec GetMyprocAddress (addresse de InitHookList)
nc.address = lpInitHookList;
//pile de 8 octets
nc.lpStack = (DWORD*)lpStack;
nc.cbStack = 8;
//pas de valeur de retour
nc.lpReturn = NULL; 		
nc.cbReturn = 0;
//convention d'appel __stdcall
nc.cdeclCall = FALSE; 		

//on appelle enfin la fonction avec CreateRemoteThread
DWORD dwWritten;
LPVOID hParams = VirtualAllocEx( hProcess, NULL, sizeof(NCallParams), MEM_COMMIT, PAGE_READWRITE );
WriteProcessMemory( hProcess, hParams, &nc, sizeof(NCallParams), &dwWritten );
hThread = CreateRemoteThread( hProcess, NULL, <addresse de IndirectCallEx>, hParams, 0, &dwThreadId );
//idem qu'avant avec WaitForSingleObjectEx, GetExitCodeThread et VirtualFreeEx
//on libère aussi la mémoire de la pile
free( lpStack );

//Pour faire le hook:
//Créer une structure HookParams, comme dans l'exemple C#
struct HookParams
{
	DWORD dwHookID;				
	HMODULE hModule;			
	LPSTR library;				
	LPSTR function;				
	DWORD originalAddress;		
	DWORD hookedAddress;		
	DWORD thunkAddress;			
	DWORD argsSize;				
	DWORD returnSize;			
	DWORD jumpAddress;			
	BOOL  hooked;				
};

HookParams hook;
hook.dwHookID = 0;
//à récupérer avec GetProcessHandle( 0 ) dans SharpSPyHelper.dll
hook.hModule = <hModule du processus>;
hook.library = "User32.dll";
hook.function = "LoadIconW";
//à récupérer avec GetMyProcAddress( PROCADDRESS_CALLSINKPROXY )
hook.originalAddress = NULL;
hook.hookedAddress = <Adresse de NativeCallSinkProxy>;
hook.thunkAddress = NULL;
hook.argsSize = 8;
hook.returnSize = 4;
hook.jumpAddress = NULL;
hook.hooked = FALSE;

//on copie le contenu de la structure HookParams dans la mémoire du processus,
//avec VirtualAllocEx et WriteProcessMemory
LPVOID lpHook = <VirtualAllocEx( ... ) >

//On exécute InitHookList avec GetMyProcAddres, CreateRemoteThread et IndirectCallEx
InitHookList( lpHook, sizeof(HookParams) );
//Puis on active le hook (ici, 0 est l'ID du hook - voir plus haut) ici pas besoin d'IndirectCallEx (un seul argument)
if( HookByID( 0 ) ) 
{
     // le hook est réussi!
}


//après ca il reste juste à gérer dans la boucle des messages de la fenêtre de l'application
//gérer les messages WM_COPYDATA:
//un message WM_COPYDATA est envoyé à chaque fois qu'une fonction hookée est appellée
//avec les paramètres de l'appel (ID du hook, arguments...)
InitMsgWindow( <hWnd de la fênetre> );

//Dans WndProc
LRESULT WndProc( HWND, UINT, WPARAM, LPARAM );
//dans le switch des messages de la fenêtre
switch( uMsg )
{
     case WM_COPYDATA:
     {
          	LPCOPYDATA lpcd = (LPCOPYDATA)LPARAM;
          	void* pData = malloc( lpcd.cbData ); 
          
          	memcpy( pData, lpcd.lpData, lpcd.cbData );
          	//traiter les données reçues: (voir GetSendCallBuffer dans SharpSpyHelper.cpp)
          	//struct
	//{
	//    BYTE bType = COMM_CALL;
	//    DWORD dwSize;		//taille du message
	//    DWORD dwCallID;		//ID d'appel - ignorer
	//    DWORD dwHookID;		//ID du hook appellé
	//    DWORD cbStack;		//taille de la pile
	//    //si cbStack > 0
	//    BYTE stack[cbStack];	//données de la pile (paramètres de la fonction)
	//};
	//Comme HICON LoadIconW( HINSTANCE hInstance, LPCTSTR lpIconName );
	HINSTANCE hInstance;
	LPCTSTR lpIconName;
	//on extrait les paramètres de la pile (stack)
	memcpy( &hInstance, &stack, 4 );
	memcpy( &lpIconName, &stack + 4, 4 );

	//appeller la fonction qui remplace la fonction hookée
	//elle doit retourner un HICON
	HICON hIcon;
	
	//renvoyer un pointeur vers une structure, 
	//pour la valeur de retour
	//struct
	//{
	//    BYTE bType = COMM_ANSWER;
	//    DWORD dwSize;		//taille du message
	//    DWORD dwCallID;		//ID d'appel - mettre le même
	//    DWORD dwHookID;		//ID du hook - idem
	//    DWORD cbReturn;		//taille de la valeur de retour
	//    //si cbReturn > 0
	//    BYTE returnVal[cbReturn];	//valeur de retour
	//};
	cbReturn = 4; 		//sizeof(HICON)
	bType = COMM_ANSWER;
	//on alloue une BYTE, 4 DWORDs plus de la place pour returnVal
	dwSize = 17 + cbReturn;
	BYTE* pAns = (BYTE*)malloc( dwSize );
	//on remplit la 'structure'
	memcpy( pAns, &bType, 1 );
	memcpy( pAns + 1, &dwSize, 4 );	
	memcpy( pAns + 5, &dwCallID, 4 );
	memcpy( pAns + 9, &dwHookID, 4 );
	memcpy( pAns + 13, &cbReturn, 4 );
	memcpy( pAns + 17, &hIcon, 4 );	//valeur de retour
	//on libère la mémoire allouée pour les données reçues
	free( pData );
	//on retourne la 'structure' de retour
	return pAns;
     }
}

Télécharger le zip