Soyez le premier à donner votre avis sur cette source.
Vue 27 321 fois - Téléchargée 1 221 fois
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; } }
23 juil. 2007 à 19:14
This dynamically links SharpSpyHelper.dll to msvcr80.dll or mscvr80d.dll (depending on your project configuration (release or debug)) which may be what you're looking for or not.
21 juil. 2007 à 18:13
Libc.lib isn't supported by VS2005 anymore. If I replace it with Libcmt.lib, I get strange errors. Also a problem if I install libc.lib from my old computer. Maybe additional compiler settings?
9 mai 2006 à 13:07
Tu dit :
"je suis tombé il y a pas longtemps sur une fonction qui permettait d'intercepter un appel à une fonction de Windows, mais seulement dans le même processus"
Puis je savoir à quelle fonction tu fais référence ?
1 mai 2006 à 23:46
Tres interessant :)
Manque plus qu'un exemple d'utilisation en Vb.net ^^
++
3 janv. 2006 à 05:37
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.