deck_bsd
Messages postés1243Date d'inscriptionjeudi 31 mars 2005StatutMembreDernière intervention 3 août 2016
-
7 févr. 2008 à 20:08
cs_rt15
Messages postés3874Date d'inscriptionmardi 8 mars 2005StatutModérateurDernière intervention 7 novembre 2014
-
13 févr. 2008 à 08:54
Yop,
Voila , je tente de faire une injection de dll dans un processus . Seulement voila , tout devrait bien se dérouler et d'ailleur aparement tout roule car aucune fonction ne renvoie une erreur , mais voila le processus cible n'éxécute pas la fonction MessageBox contenue dans la dll. Je join mes codes . Voyez-vous quelque chose de bizzar ?
Ma fonction d'injection :
BOOL __stdcall DLLInjecteur(DWORD dwPid,char * szDLLPath)
{
HMODULE hmKernel;
Main de ma dll :
BOOL WINAPI DllMain(HINSTANCE hdll, DWORD dwReason, LPVOID Reserved)
{
switch(dwReason) {
case DLL_PROCESS_ATTACH:
/*thismod = hdll;
DisableThreadLibraryCalls(hdll);*/
MessageBox(NULL,"La DLL a bien été injectée.","DCK DLL injected !",MB_OK);
break;
case DLL_PROCESS_DETACH:
break;
}
return 1;
}
PS : la dll à été créer a partir du template cdll pour vs 2005 de BruNews , donc p-e une option à lui bloque quelque chose :s Mais j'en doute
BruNews
Messages postés21040Date d'inscriptionjeudi 23 janvier 2003StatutModérateurDernière intervention21 août 2019 7 févr. 2008 à 21:03
Il ne faut pas de CloseHandle pour GetModuleHandle car pas d'increm du compteur de références.
Pour être franc, il n'y a pas une ligne cohérente avec celle qui la suit, pas le temps de reprendre le tout.
Quel rapport entre le hprocess et l'adresse de LoadLibrary ?
Qu'y aurait-il d'exécutable dans une chaine (que soit un chemin ou autre) ?
etc, etc.
Mets toi devant l'exemple de Richter et analyse son déroulement.
deck_bsd
Messages postés1243Date d'inscriptionjeudi 31 mars 2005StatutMembreDernière intervention 3 août 20162 7 févr. 2008 à 21:29
Heuu je comprend ce que tu dis mais j'avoue que la je voi pas bien, hprocess est le handle du processus cible et n' rien avoir avec loadlibrary qui charge seulement la dll kernel32 . Je ne voi pas ou ce situe l'incohérence.
cs_rt15
Messages postés3874Date d'inscriptionmardi 8 mars 2005StatutModérateurDernière intervention 7 novembre 201413 13 févr. 2008 à 08:54
Salut,
Comment ça des incohérences partout ?
Pour la peine, je te vole ta technique de traitement d'erreur à la goto. Bien pratique d'ailleurs.
Arg, le compilo n'aime pas les déclarations au milieu de code.
Remarque, moi non plus.
Dans le VirtualFreeEx, si on utilise MEM_RELEASE, il faut passer un dwSize de 0.
Pas la peine d'initialiser dwThreadID à 0, mais bon c'est pas horrible.
Mais à part ça, ou était l'erreur ???
Il semblerait qu'elle était dûe à une fermeture trop hative du handle du thread...
Faut attendre qu'il se termine.
Comme quoi, mal libérer est aussi mauvais que mal créer !
Vala ce que ça me donne :
#include "windows.h"
#include "tlhelp32.h"
BOOL __stdcall DLLInjecteur(DWORD dwPid, char * szDLLPath)
{
HMODULE hmKernel; // Handle sur kernel32
LPTHREAD_START_ROUTINE lpthThreadFunction; // Pointeur de fonction.
HANDLE hProcess; // Handle du processus distant
char * szDllVariable; // Adresse où on va mettre le chemin, dans le processus distant
DWORD dwBytes; // Nombre d'octets écrits par WriteProcessMemory
HANDLE hThread; // Handle du thread distant
DWORD dwThreadID; // Récupération de l'ID du thread
BOOL bResult = FALSE; // Ce qu'on va renvoyer
// Récupération de l'adresse de LoadLibraryA dans le processus courant.
// On suppose que c'est la même dans le processus distant (Pas forcément vrai en théorie, mais souvent vrai en pratique)
hmKernel = GetModuleHandle("kernel32.dll");
lpthThreadFunction = (LPTHREAD_START_ROUTINE)GetProcAddress(hmKernel, "LoadLibraryA");
if (! lpthThreadFunction) return FALSE;
// Récupération d'un handle sur le processus distant
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPid);
if (hProcess == INVALID_HANDLE_VALUE) return FALSE;
// Allocation d'une zone où on va mettre le chemin de la dll
szDllVariable = (char*)VirtualAllocEx(hProcess, 0, lstrlen(szDLLPath) + 1, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (! szDllVariable) goto CloseProcessHandle;
// Recopie du chemin depuis le processus courant vers le processus distant
if (! WriteProcessMemory(hProcess, szDllVariable, szDLLPath, strlen(szDLLPath) + 1, &dwBytes))
goto FreeRemoteMemory;
// Création d'un thread distant, démarrant LoadLibrary avec le chemin de la dll passé en paramètre
hThread = CreateRemoteThread(hProcess, NULL, 0, lpthThreadFunction, szDllVariable, 0, &dwThreadID);
if (hThread == INVALID_HANDLE_VALUE) goto CloseThreadHandle;
// Attente de la fin du thread. Obligatoire.
WaitForSingleObject(hThread, INFINITE);
//
// Renvoie un Id de processus à partir de son nom.
// Renvoie 0 si aucun processus ne porte ce nom.
// Attention : il peut y avoir plusieurs processus avec ce nom.
//
DWORD __stdcall GetProcessIdFromName(LPSTR lpProcessName)
{
HANDLE hSnapShot; // Handle du snapshot des processus
PROCESSENTRY32 processEntry; // Récupération des infos sur un processus
// Création du snapshot
hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapShot == INVALID_HANDLE_VALUE) return 0;
// On parcourt tous les processus
processEntry.dwSize = sizeof(processEntry);
if (Process32First(hSnapShot, &processEntry))
{
do
{
// Si les noms sont les mêmes, on sort de la boucle
if (! lstrcmp(lpProcessName, processEntry.szExeFile))
{
CloseHandle(hSnapShot);
return processEntry.th32ProcessID;
}
} while (Process32Next(hSnapShot, &processEntry));
}
// Libération du handle du snapshot
CloseHandle(hSnapShot);
return 0;
}
#pragma comment(linker, "/entry:main")
INT32 _cdecl main()
{
DWORD nProcessId; // Id du processus où l'on va injecter la dll
// Attention : Cela ne marche qu'une fois par calculatrice !
// En effet, si la dll est déjà chargée, Windows n'a aucune raisons de rappeler le point d'entrée...
nProcessId = GetProcessIdFromName("calc.exe");
if (nProcessId) DLLInjecteur(nProcessId, "Injection.dll");
return 0;
}