Discussion :

[Legarsdelouest]

Bonjour à tous

Je cherche depuis plusieurs jours à récupérer l'adresse mémoire d'un processus. En utilisant la propriété "BaseAddress" du module principal de l'instance Process souhaitée, je n'obtient généralement que des valeurs égalent à &H400000. Après plusieurs recherches, j'ai appris que c'était une valeur "standard" que l'OS retourne pour tous les processus ; c'est une adresse virtuelle il me semble.
Cependant, je cherche l'adresse PHYSIQUE du processus dans la mémoire. Je ne peux pas donc pas utiliser les fonctions CLR pour arrivé à mes fins (du moins, je n'en connais pas).

Je me suis alors penché sur les fonctions systèmes, notamment le OpenProces() et le GetModuleInformation() qui semble être la fonction adhoc pour récupérer l'adresse. Cependant, quant je tente d'utiliser cette fonction (GetModuleInformation), j'obtiens un déséquilibre de la pile, le problème étant certainement que la déclaration du prototype est inexacte.

Voici la déclaration de la fonction externe que j'utilise :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
Imports System.Runtime.InteropServices
Imports System.Reflection
 
Public Structure MODULEINFO
        Public lpBaseOfDll As IntPtr
        Public SizeOfImage As UInt32
        Public EntryPoint As IntPtr
    End Structure
 
 <DllImport("psapi.dll")> _
    Private Function GetModuleInformation(<[In]> hProcess As IntPtr, <[In]> hModule As IntPtr, <Out> moduleInfo As MODULEINFO, <[In]> tailleModuleInfo As UInt32) As [Boolean]

Avec son utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
'Objet processus standard
Dim  _targetProcess As Process 
 
'Pointeur obtenu par la fonction OpenProcess appelé dans la fonction TryAttachToProcess
Dim _targetProcessHandle As IntPtr
Dim result As Boolean = false
Dim info As New MODULEINFO
 
'Ouverture du process => pas de soucis ici
'Initialisation correcte de _targetProcess et _targetProcessHandle
TryAttachToProcess("foo.exe", _targetProcess, _targetProcessHandle)
 
'Récupération des données du module => Echec
result = GetModuleInformation(_targetProcessHandle,  _targetProcess.MainWindowHandle, info, Marshal.SizeOf(info.GetType))

Les questions que je me posent alors sont :
- Y a t-il une façon bien plus simple de récupérer l'adresse physique d'un processus (via le CLR) ?
- Est-ce que mon proto de GetModuleInformation est correcte, et si non, lequel est-ce ?
- Est-ce que j'utilise correctement la fonction (bons types de paramètre et de valeur, notamment sur le second paramètre) ?


Si quelqu'un pouvait éclairer ma lanterne et éventuellement me donner un exemple, je le remercie par avance

Bien cordialement

[Matthieu76]

bonjour, j'ai à peu près le même problème que toi même sauf que je travaille en C++, mais tu peux tester un truc du genre :

HANDLE handle = OpenProcess(PROCESS_VM_READ, false, process_id);

l'adresse de ton handle devrait être l'adresse de début de ton process car HANDLE est un "pointer" sur ton process.

Préviens-moi si tu avances, ça m'intéresse beaucoup.

Sur ce bonne chance !!!

[Legarsdelouest]

Bonjour

Il se trouve que j'ai réussi il y a une dizaine de mois à résoudre ce problème. Je passe en effet via la fonction OpenProcess. Voici une partie du code source que j'utilise en vb.net :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
    Private Declare Function OpenProcess Lib "kernel32.dll" (ByVal dwDesiredAcess As UInt32, ByVal bInheritHandle As Boolean, ByVal dwProcessId As Int32) As IntPtr
    Private Declare Function CloseHandle Lib "kernel32.dll" (ByVal hObject As IntPtr) As Boolean
    Private Declare Function GetProcessImageFileName Lib "psapi.dll" (<[In]> ByVal hProcess As IntPtr, <[Out]> strbbuilder As StringBuilder, <[In]> <MarshalAs(UnmanagedType.U4)> ByRef nSize As Integer) As UInteger
    Private Declare Function ReadProcessMemory Lib "kernel32.dll" (ByVal hProcess As IntPtr, ByVal lpBaseAddress As IntPtr, ByVal lpBuffer() As Byte, ByVal iSize As Integer, ByRef lpNumberOfBytesRead As Integer) As Boolean
    Private Declare Function EnumProcessModules Lib "psapi.dll" (ByVal handle As IntPtr, ByVal modules As IntPtr, ByVal size As Integer, ByRef needed As Integer) As Boolean
    Private Declare Function GetModuleInformation Lib "psapi.dll" (<[In]> hProcess As IntPtr, <[In]> hModule As IntPtr, <[Out]> ByRef moduleInfo As MODULEINFO, <[In]> tailleModuleInfo As UInt32) As [Boolean]
 
    Private _targetProcess As Process = Nothing
    Private _targetProcessHandle As IntPtr = IntPtr.Zero
    Private _hMod As IntPtr
    Private Const PROCESS_ALL_ACCESS As UInt32 = &H1F0FFF
    Private Const PROCESS_VM_READ As UInt32 = &H10
 
 Private Function AttachToProcess(ByVal windowCaption As String) As Boolean
        'Déclaration des variables locales
        Dim _allProcesses() As Process = Process.GetProcesses
 
        'Pour chaque processus
        For Each pp As Process In _allProcesses
            If pp.MainWindowTitle.ToLower.Contains(windowCaption.ToLower) Then
                'Pocessus trouvé, on procède à la tentative 
                Return TryAttachToProcess(pp)
            End If
        Next
 
        Return False
    End Function
 
    Private Function TryAttachToProcess(ByVal proc As Process) As Boolean
        'Déclaration des variables locales
        Dim sb As New StringBuilder(2000)
        Dim nb As Integer = -1
        Dim hMods As IntPtr() = New IntPtr(1023) {}
        Dim gch As GCHandle
        Dim pModules As IntPtr
        Dim uiSize As UInteger
        Dim cbNeeded As UInteger = 0
 
 
        'Vérification d'un attachement existant
        If Not _targetProcessHandle = IntPtr.Zero Then
            Return False
        End If
 
        'Enregistrement du processus cible
        _targetProcess = proc
 
        'Tentative d'accès au processus
        _targetProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, False, _targetProcess.Id)
        If _targetProcessHandle = 0 Then
            'Echec lors de la connexion
            'Vérifier les droits d'admin
            Return False
        End If
 
 
 
        gch = GCHandle.Alloc(hMods, GCHandleType.Pinned)
        pModules = gch.AddrOfPinnedObject()
 
        ' Setting up the rest of the parameters for EnumProcessModules
        uiSize = CUInt(Marshal.SizeOf(GetType(IntPtr)) * (hMods.Length))
 
        If Not EnumProcessModules(_targetProcess.Handle, pModules, uiSize, cbNeeded) Then
            Return False
        End If
 
        ' Must free the GCHandle object
        gch.Free()
 
        Dim info As New MODULEINFO
        GetModuleInformation(_targetProcessHandle, hMods(0), info, Marshal.SizeOf(info.GetType))
 
        'Sauvegarde du pointeur de base
        Me._hMod = hMods(0)
 
        Return True
    End Function
 
    Private Sub DetachFromProcess()
        'Vérification d'un attachement existant
        If Not (_targetProcessHandle = IntPtr.Zero) Then
            _targetProcess = Nothing
 
            'Tentative de fermeture
            Try
                CloseHandle(_targetProcessHandle)
                _targetProcessHandle = IntPtr.Zero
            Catch ex As Exception
            End Try
        End If
    End Sub