recuperer la memoire virtuelle

*lBaseAdress[*SizeBA - 1] = (unsignedlong) mbi.BaseAddress;

#include <stdio.h>
#include <windows.h>
#include <Tlhelp32.h>
 
void GetAllPrivileges()
{
	HANDLE lhTokenHandle;
	LUID tLuid;
	TOKEN_PRIVILEGES tTokenPriv;
	TOKEN_PRIVILEGES tTokenPrivNew;
unsignedlong lBufferNeeded;
	HANDLE hProc;
 
//obtient le handle de ce process
    hProc = GetCurrentProcess();
 
//change les droits de cette application
    OpenProcessToken( hProc, TOKEN_ALL_ACCESS, &lhTokenHandle );
    LookupPrivilegeValue("", SE_DEBUG_NAME, &tLuid );

//détermine le nombre de privileges à changer
    tTokenPriv.PrivilegeCount = 1;
    tTokenPriv.Privileges[0].Luid = tLuid;
    tTokenPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

//autorise le privilege SE_DEBUG_NAME
    AdjustTokenPrivileges( lhTokenHandle, false, &tTokenPriv, sizeof( tTokenPrivNew ), &tTokenPrivNew, &lBufferNeeded );

//ferme les handles
    CloseHandle( lhTokenHandle );
}
bool GetProcessId(char *Name, unsignedlong *Pid )
{
	HANDLE Hp;
	PROCESSENTRY32 pe32;
 
// handle qui contient tout les handle processus
	Hp = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0);
if( Hp == INVALID_HANDLE_VALUE )
{
		printf("CreateToolhelp32Snapshot\n");
returnfalse;
}
 
// rentre la taille de la structure
	pe32.dwSize = sizeof( PROCESSENTRY32 );
 
// retrouve les informations du premier processus
// et quitte si echoue
if( !Process32First( Hp, &pe32 ))
{
		printf("Process32First\n");  
		CloseHandle( Hp );
returnfalse;
}
 
// recherche les informations des processus suivant
// et quitte des qu'il n'y a plus de processus
while( Process32Next( Hp, &pe32 ))
{
if( strcmp( pe32.szExeFile, Name ) == 0)
{
			*Pid = pe32.th32ProcessID;
break;
}
}
 
	CloseHandle( Hp );
 
if( strcmp( pe32.szExeFile, Name ) != 0)
{
		printf("Processus non trouver\n");
returnfalse;
}
 
returntrue;
}
void RetrieveMemRegions(unsignedlong PID, unsignedlong **lBaseAdress, unsignedlong **lRegionSize, unsignedlong *SizeBA, unsignedlong *SizeRS)
{
	HANDLE lHandle;
unsignedlong lPosMem;
unsignedlong lRet;
unsignedlong lLenMBI;
	MEMORY_BASIC_INFORMATION mbi;
	SYSTEM_INFO si;
 
//initialise les tableaux
    *lBaseAdress = (unsignedlong*) malloc(sizeof(unsignedlong));
    *lRegionSize = (unsignedlong*) malloc(sizeof(unsignedlong));
 
//obtient le handle du processus
    lHandle = OpenProcess( PROCESS_ALL_ACCESS, false, PID );
 
    lLenMBI = sizeof(mbi);  //taille de la structure
    GetSystemInfo( &si );   //obtient les infos sur les adresses de début et de fin de la plage mémoire maximum

    lPosMem = (unsignedlong) si.lpMinimumApplicationAddress;  //adresse la plus petite ==> part de là

 
while( lPosMem < (unsignedlong) si.lpMaximumApplicationAddress)//tant que l'adresse est inférieure à l'adresse maximale
{
        mbi.RegionSize = 0;

//obtient les infos sur les régions mémoire du processus définit par son handle hProcess
        lRet = VirtualQueryEx( lHandle, &lPosMem, &mbi, lLenMBI );
 
if( lRet == lLenMBI)
{
if( mbi.Type == MEM_PRIVATE && mbi.State == MEM_COMMIT )
{
//alors utilisé par le processus

if( mbi.RegionSize > 0)
{
//région non nulle, alors on la stocke dans les tableaux résultats
//les redimensionne
					*SizeBA = *SizeBA + 1;
					*SizeRS = *SizeRS + 1;
                    *lBaseAdress = (unsignedlong*) realloc( *lBaseAdress, sizeof(unsignedlong) * (*SizeBA));
                    *lRegionSize = (unsignedlong*) realloc( *lRegionSize, sizeof(unsignedlong) * (*SizeRS));
//stocke à la fin
                    *lRegionSize[*SizeRS - 1] = mbi.RegionSize;
		    printf("taille region %d : %d\n", *SizeRS, mbi.RegionSize);
                    *lBaseAdress[*SizeBA - 1] = (unsignedlong) mbi.BaseAddress;
		    printf("adresse page  %d : %d\n", *SizeBA, (unsignedlong) mbi.BaseAddress);
}

}
//continue la recherche des régions (ajoute la taille de la région à l'adresse de départ ==> donne la prochaine adresse de départ)

//On Error GoTo ErrCapacityGestion 'dépassement de capacité pour la dernière adresse+regiosize

            lPosMem = (unsignedlong) mbi.BaseAddress + mbi.RegionSize;    //fait l'ajout
}
else
{
//recherche terminée
break;
}
}
//ErrCapacityGestion:
	CloseHandle( lHandle ); //ferme le handle du processus
}
int main(void)
{
unsignedlong Pid, *BaseAdress, *RegionSize, SizeBA = 0, SizeRS = 0;
 
	GetAllPrivileges();
if( GetProcessId("explorer.exe", &Pid ))
		printf("PID             : %d\n", Pid);
	RetrieveMemRegions( Pid, &BaseAdress, &RegionSize, &SizeBA, &SizeRS );
 
returntrue;
}