1. Accueil
  2. Tous les snippets
  3. Snippets C / C++ / C++.NET
  4. Process dumper

Process dumper

Soyez le premier à donner votre avis sur cette source.

Snippet vu 8 611 fois - Téléchargée 22 fois

Commenter

Contenu du snippet

Bonjour/Bonsoir,
le titre de l'article parle de lui-même... Ce code montre comment faire un dump d'un processus en cours d'execution.

Je vous renvoie ici pour les explications : http://lilxam.blogspot.com/2007/12/process-dumper.html

Source / Exemple : 


#include <windows.h>
#include <iostream>
#include <tlhelp32.h>

using namespace std;

/*


          •  Structure de PROCESSENTRY32 *****


typedef struct tagPROCESSENTRY32 {
  DWORD dwSize;
  DWORD cntUsage;
  DWORD th32ProcessID;
  ULONG_PTR th32DefaultHeapID;
  DWORD th32ModuleID;
  DWORD cntThreads;
  DWORD th32ParentProcessID;
  LONG pcPriClassBase;
  DWORD dwFlags;
  TCHAR szExeFile[MAX_PATH];
} PROCESSENTRY32, 


     
  • PPROCESSENTRY32;

          •  Prototype de la fonction CreateToolhelp32Snapshot() *****


HANDLE WINAPI CreateToolhelp32Snapshot(
  __in  DWORD dwFlags,
  __in  DWORD th32ProcessID
);


          •  Prototype de la fonction OpenProcess() *****


HANDLE WINAPI OpenProcess(
  __in  DWORD dwDesiredAccess,
  __in  BOOL bInheritHandle,
  __in  DWORD dwProcessId
);


          •  Prototype de la fonction ReadProcessMemory() *****


BOOL WINAPI ReadProcessMemory(
  __in   HANDLE hProcess,
  __in   LPCVOID lpBaseAddress,
  __out  LPVOID lpBuffer,
  __in   SIZE_T nSize,
  __out  SIZE_T* lpNumberOfBytesRead
);


  • /


int main()
{
    /* Ce programme permet d'établir un dump d'un processus. 
    Il vous faut donc connaitre l'Original Entry Point du processus.
    Il vous faudra également rétablir la table des imports (IAT) sinon vous ne pourrez pas executer le dump.


        
  • /

    
    char process[] = "dumpme.exe"; //Le processus que vous voulez dumper
    char save[] = "dumped.exe"; //Le dump de votre processus
    int offset = 0x00400000; //L'offset à partir duquel on commence le dump. Mettez donc l'OEP du programme
    
    
    //Création d'un fichier vide que l'on va remplir par le code de notre processus à dumper
    FILE *pFile = NULL;
    pFile = fopen(save, "ab+");
    
    if(pFile != NULL)
    {
             //On liste tous les processus jusqu'à trouver celui qu'on cherche
             HANDLE hSnapShot;
             PROCESSENTRY32 uProcess;
             
             hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);//On établi une liste de tous les processus
             uProcess.dwSize = sizeof(PROCESSENTRY32);
             
             int p;
             DWORD PID;
             
             p = Process32First(hSnapShot, &uProcess);//On récupère le premier processus de la liste en remplissant la strcture PROCESSENTRY32
             while(p)
             {
                     if(strstr(uProcess.szExeFile, process)) //On a trouvé le processus à dumper
                     {
                                                   cout<<"\n\n[+]Process found : "<<uProcess.szExeFile;
                                                   
                                                   //On récupère l'id du processus
                                                   PID = uProcess.th32ProcessID;
                                                   
                                                   //On récupère un handle sur le processus
                                                   HANDLE hTemp = NULL;
                                                   hTemp = OpenProcess(PROCESS_ALL_ACCESS, 0, PID);
                                                   
                                                   char buffer[1]; //buffer qui recevra les octets du programme en mémoire
                                                   memset(buffer, 0, sizeof(buffer));
                                                   
                                                   int nul = 0x00; //null char
                                                   
                                                   if(hTemp != NULL)
                                                   {
                                                           while(ReadProcessMemory(hTemp,  (LPVOID)offset, &buffer, 1, NULL)) //On lit chaque octet du programme en mémoire
                                                           {
                                                                                           if(!strcmp(buffer,""))//On rétabli tout les 0->0x00
                                                                                           {
                                                                                                     fputc(nul, pFile);
                                                                                           }
                                                                                           else
                                                                                           {
                                                                                                     fprintf(pFile, "%s", buffer); //On écris les octets un à un dans le fichier
                                                                                           }
                                                                                           offset += 0x01;
                                                                                           memset(buffer, 0, sizeof(buffer));
                                                           }
                                                   }
                                                   else
                                                       cout<<"\n\n[-]Failed to get process handle\nError : "<<GetLastError();
                     }
                     
                     p = Process32Next(hSnapShot, &uProcess); //On récupère le processus suivant de la liste en remplissant la strcture PROCESSENTRY32
             }
             fclose(pFile);
             CloseHandle(hSnapShot);
    }
    else
        cout<<"\n\n[-]Failed to create file\n---Error : "<<GetLastError();
        
    cout<<"\n\n";
    system("pause");
    return 0;
}

A voir également

Ajouter un commentaire Commentaires
lilxam7 Messages postés 12 Date d'inscription dimanche 2 décembre 2007 Statut Membre Dernière intervention 3 février 2008
23 janv. 2008 à 23:10
BruNews -> D'accord mais ça reste plus pratique de rechercher un processus par son nom plutot que de devoir entrer le chemin entier du programme et le comparer au résultat obtenu par la fonction GetModuleFileName[Ex]().
Draluorg -> Tout ceci reviens à peu près au même, sauf que je garde en tête que je risque de vouloir modifier quelques parametres, récupérer plus de un octet à la fois par exemple. Ca reste donc dans un soucis pratique mais rien ne t'empeche de modifier le code comme bon te semble.
draluorg Messages postés 625 Date d'inscription vendredi 23 avril 2004 Statut Membre Dernière intervention 25 novembre 2010
20 janv. 2008 à 19:38
Eh char Buffer[1];? pourquoi pas char Buff;?
Puis memset pour 1 octet? pourquoi pas buff=0;?
Plus important, tu ne fermes toujours pas le handle des process que tu ouvre!

Aussi offset += 0x01; ne peut il pas devenir offset++; ? ca change rien niveau perf mais plus facile a ecrire et par habitudes je dirais plus facile a comprendre...

++
BruNews Messages postés 21041 Date d'inscription jeudi 23 janvier 2003 Statut Modérateur Dernière intervention 21 août 2019 20
20 janv. 2008 à 19:26
Bien entendu qu'un processus a un chemin complet.
GetModuleFileName[Ex]().
lilxam7 Messages postés 12 Date d'inscription dimanche 2 décembre 2007 Statut Membre Dernière intervention 3 février 2008
20 janv. 2008 à 19:01
Salut, j'ai comblé la fuite de mémoire.
Pour la remarque de BruNews, je ne vois pas trop ce que tu veux dire. "Ex: D:\dossier\bndumpme.exe", le nom d'un processus en mémoire n'est pas son chemin. Donc tu dois entrer quelque chose comme "exolorer.exe" par exemple.
Ensuite tu remarque que j'utilise strstr() au lieu de strcmp(), c'est dans un soucit pratique que je fais comme ça mais il est vrai que strcmp() reste mieux pour éviter toute confusion.
Draluorg, tu fais bien de remarquer mon erreur, en effet j'ai oublié de modifier le char[15] en char[1], c'est parce que je faisais des tests au debut en récupérant plusieurs octets à la fois. J'ai changé ça.
Bref escusez moi pour tous ces petits détails.
@+ et n'hesitez pas si vous avez des soucis :)
draluorg Messages postés 625 Date d'inscription vendredi 23 avril 2004 Statut Membre Dernière intervention 25 novembre 2010
15 janv. 2008 à 17:24
Salut,

Eh j'ai un peu de mal a comprendre un truc:

char buffer[15];
while(ReadProcessMemory(hTemp, (LPVOID)offset, &buffer, 1, NULL))
memset(buffer, 0, sizeof(buffer));

tu cree un buffer de 15 octets et tu n'en utilise qu'un?
Puis tu remets chaques fois tout le buffer a zero!
Dans tous les cas, il serait preferable de recuperer la taille a lire et de la lire en une fois ou au moins par bloc...

++
Afficher les 6 commentaires
S'inscrire maintenant

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.

Du même auteur (lilxam7)