Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

PROCESS DUMPER


Information sur la source

Catégorie :Application Classé sous : Dump, Process, Processus, ReadProcessMemory, Mémoire Niveau : Débutant Date de création : 13/01/2008 Date de mise à jour : 20/01/2008 18:48:16 Vu : 4 253

Note :
Aucune note

Commentaire sur cette source (6)
Ajouter un commentaire et/ou une note

Description

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

  • #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;
  • }
#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;
}
    

Historique

20 janvier 2008 18:48:16 :
Correction de fuites de mémoire.

Commentaires et avis

signaler à un administrateur
Commentaire de BruNews le 13/01/2008 23:26:28 administrateur CS

La même que source précédente, fuites mémoire à combler.

char process[] = "dumpme.exe"; //Le processus que vous voulez dumper
strstr(uProcess.szExeFile, process)) //On a trouvé le processus...

NIET, on a seulement trouvé une possibilité mais aucun garantie. Faut se placer sur le dernier '\\' et faire un strcmp() pour savoir si c'est le bon exe.
Ex: D:\dossier\bndumpme.exe
ben c'est pas celui voulu.

signaler à un administrateur
Commentaire de draluorg le 15/01/2008 17:24:55

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...

++

signaler à un administrateur
Commentaire de lilxam7 le 20/01/2008 19:01:23

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

signaler à un administrateur
Commentaire de BruNews le 20/01/2008 19:26:55 administrateur CS

Bien entendu qu'un processus a un chemin complet.
GetModuleFileName[Ex]().

signaler à un administrateur
Commentaire de draluorg le 20/01/2008 19:38:42

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...

++

signaler à un administrateur
Commentaire de lilxam7 le 23/01/2008 23:10:57

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.

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

[C ou C++]écriture direct dans la mémoire d'un processus [ par supers03 ] Salut &#224; tousSuite &#224; la lecture des deux articles de Krust sur "comment cr&#233;er des cheats" (http://www.cppfrance.com/gma/tout/cheat) , j' File Mapping entre deux processus [ par vinvay ] Voilà, mon problème est que j'ai deux processus, un qui écrit dans la mémoire partagée et l'autre qui lit, et je voudrai que lorsque le processus qui PATCH DLL NT/9X [ par ouranos ] Bonjour à tous,J'ai réalisé un programme fonctionnant sous win NT/XP/2000 qui détourne des APIwindows afin de pouvoir contrôler le système (limitation ReadProcessMemory [ par ymca2003 ] Salut,J'essaye d'utiliser la fonction ReadProcessMemory pour lire le contenu de la mémoire d'un processus mais je n'y arrive pas.Lorsque j'appel cette processus [ par sebseb42 ] Bonjour,voila, j'utilise l'API Process Status (PSAPI) pour lister tout les process existant ainsi que leur modules...La seul information que j'arrive temps d'exécution trop long [ par diable007 ] bonjour, j'ai une application parallèle en c++ et MPI,  j'ai une partie qui ne nécessite pas de communication avec mpi entre les processeurs.  En séqu Processus en cours d'execution? Psapi.lib et Psapi.h? `EnumProcesses@12` & `GetModuleBaseNameA@16` ? [ par wizard512 ] Bonjour, J'essaie en vain de compiler un petit bout de code me permettant de vérifier si telle ou telle processus et bien en cour d'execution. Mais j' Gestionnaire de la mémoire [ par BabGirl ] Bonjour à tous !Pourriez-vous me guider pour créer un petit gestionnaire de la mémoire. Ce petit gestionnaire doit connaître les parties libres et occ trouver le bon process ID!!! [ par anthraxx ] Je voudrais terminer un processus (avec TerminateProcess) dont je ne connais que le nom du fichier executable (mdm.exe par exemple), et le processus n Mémoire partagée et pointeur [ par darsh99 ] Bonjour,J'essai de faire passer un tableau dynamique, un pointeur donc, d'un programme à un autre, l'adresse est bien passée et les champs non dynamiq


Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Téléchargements

Comparez les prix Nouvelle version

Photothèque Nouveau !



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 2,621 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.