injection de dll

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;
 
 SetDebugPrivilege();
 hmKernel = GetModuleHandle("kernel32.dll");
 
 LPTHREAD_START_ROUTINE lpthThreadFunction; /* Pointeur de fonction. */
    lpthThreadFunction = (LPTHREAD_START_ROUTINE)GetProcAddress(hmKernel, "LoadLibraryA"); /* GetProcAdress renvoie l'adresse de la fonction LoadLibrary. */
    if(lpthThreadFunction == NULL){CloseHandle(hmKernel); return FALSE;}
    CloseHandle(hmKernel);

 HANDLE hProcess;
    hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE,dwPid);
    if(hProcess == INVALID_HANDLE_VALUE)return FALSE;
   
    char * szDllVariable;
    szDllVariable = (char*) VirtualAllocEx(hProcess, 0, strlen(szDLLPath)+1, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    if(szDllVariable == NULL){ CloseHandle(hProcess); return FALSE; }
   
    DWORD dwBytes;
    if(!WriteProcessMemory(hProcess, szDllVariable, szDLLPath, strlen(szDLLPath)+1, &dwBytes)){ CloseHandle(hProcess); return FALSE; }
   
    DWORD dwThreadID = 0;
    HANDLE hThread;
    hThread = CreateRemoteThread(hProcess, NULL, 0, lpthThreadFunction, szDllVariable, 0, &dwThreadID);
    if(hThread == INVALID_HANDLE_VALUE)return FALSE;
   
    VirtualFreeEx(hProcess,szDllVariable,strlen(szDLLPath)+1,MEM_RELEASE);
    CloseHandle(hProcess);
    CloseHandle(hThread);
   
    return TRUE;
}


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

Merci d'avance.
 
++
deck_bsd
___________________________________
[ [ Lien ]]

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.

ciao...
BruNews, MVP VC++

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.

++
deck_bsd
___________________________________
[ [ Lien ]]

Qu'est ce que je raconte, LoadLibrary serai pour faire charger au processus cible la dll à injecter.

Bon je vai lire richter mdr ce bon vieu Richter :D

++
deck_bsd
___________________________________
[ [ Lien ]]

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);

  bResult = TRUE;

CloseThreadHandle:
  CloseHandle(hThread);
FreeRemoteMemory:
  VirtualFreeEx(hProcess, szDllVariable, 0, MEM_RELEASE);
CloseProcessHandle:
  CloseHandle(hProcess);
  return bResult;
}

//
// 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;
}