Erkennung der CPU-Architektur eines bestimmten Prozesses in C#

Question

Ich schreibe Code in C#. Mein Code läuft in Any CPU Modus und erhöht.

Mein Ziel ist Aufzählen alle Prozesse in der Maschine mit Process.GetProcesses(), und für jeden Prozess erkennt seine CPU-Architektur: x86, x64 oder IA64.

Ich implementiere Code-Injection in C# und muss die Architektur des Zielprozesses erkennen, um zu entscheiden, welche Opcodes injiziert werden sollen.

Wie geht das?

Danke.

Answer 1

Sie können versuchen, zu P/Invoke:

BOOL WINAPI IsWow64Process( __in HANDLE hProcess, __out PBOOL Wow64Process); 

Answer 2

Sie müssen Win32 rufen diese Informationen zu erhalten:

[System.Runtime.InteropServices.DllImport("kernel32.dll")] 
public static extern bool IsWow64Process(System.IntPtr hProcess, out bool lpSystemInfo); 

public bool IsWow64Process(System.Diagnostics.Process process) 
{ 
    bool retVal = false; 
    IsWow64Process(process.Handle, out retVal); 
    return retVal; 
} 

Aufruf IsWow64Process(process) für jeden Prozess wird Ihnen sagen, ob es 64 -Bit oder nicht. Ich bin nicht auf eine Methode gestoßen, um festzustellen, ob ein Prozess x64 oder IA64 ist, nur seine "Bitness".

Answer 3

Sie könnten p/invoke QueryFullProcessImageName oder GetProcessImageFileName und dann lesen Sie den PE-Header der EXE-Datei.

Answer 4

definieren:

[DllImport("kernel32.dll")] 
    internal static extern void GetNativeSystemInfo(ref SystemInfo lpSystemInfo); 

    [DllImport("kernel32.dll")] 
    internal static extern void GetSystemInfo(ref SystemInfo lpSystemInfo); 

    [StructLayout(LayoutKind.Sequential)] 
    internal struct SystemInfo 
    { 
     public ushort wProcessorArchitecture; 
     public ushort wReserved; 
     public uint dwPageSize; 
     public IntPtr lpMinimumApplicationAddress; 
     public IntPtr lpMaximumApplicationAddress; 
     public UIntPtr dwActiveProcessorMask; 
     public uint dwNumberOfProcessors; 
     public uint dwProcessorType; 
     public uint dwAllocationGranularity; 
     public ushort wProcessorLevel; 
     public ushort wProcessorRevision; 
    } 

    internal const ushort ProcessorArchitectureIntel = 0; 
    internal const ushort ProcessorArchitectureIa64 = 6; 
    internal const ushort ProcessorArchitectureAmd64 = 9; 
    internal const ushort ProcessorArchitectureUnknown = 0xFFFF; 

GetNativeSystemInfo kehren Sie Informationen über die Maschine laufen lassen Sie. GetSystemInfo gibt Ihnen Informationen über die virtualisierte Umgebung zurück, in der Sie sich befinden (die gleiche wie GetNativeSystemInfo, wenn es keine gibt).

Ie: Auf 32-Bit-Windows haben Sie immer wProcessorArchitecture == ProcessorArchitectureIntel.

Auf 64-Bit-Windows werden Sie wProcessorArchitecture == ProcessorArchitectureIntel für GetSystemInfo, aber wProcessorArchitecture == ProcessorArchitectureAmd64 für GetNativeSystemInfo haben, wenn Sie sich als 32-Bit-Prozess ausgeführt werden.

Sie werden offensichtlich beide ProcessorArchitectureAmd64 sein, wenn Sie ein 64-Bit-Prozess auf 64-Bit-Windows sind.

Answer 5

Alastair hat Recht damit, dass Sie nicht nur IsWow64Process aufrufen können, sondern auch nicht direkt eine andere WinApi Funktion aufrufen müssen. Hier ist eine kürzere Lösung.

/// <summary> 
    /// TRUE if the process is running under WOW64. That is if it is a 32 bit process running on 64 bit Windows. 
    /// If the process is running under 32-bit Windows, the value is set to FALSE. 
    /// If the process is a 64-bit application running under 64-bit Windows, the value is also set to FALSE. 
    /// </summary> 
    [DllImport("kernel32.dll")] 
    static extern bool IsWow64Process(System.IntPtr aProcessHandle, out bool lpSystemInfo); 

    /// <summary> 
    /// Indicates if the process is 32 or 64 bit. 
    /// </summary> 
    /// <param name="aProcessHandle">process to query</param> 
    /// <returns>true: process is 64 bit; false: process is 32 bit</returns> 
    public static bool Is64BitProcess(System.IntPtr aProcessHandle) 
    { 
     bool lIs64BitProcess = false; 
     if (System.Environment.Is64BitOperatingSystem) { 
      IsWow64Process(aProcessHandle, out lIs64BitProcess); 
     } 
     return lIs64BitProcess; 
    } 

Answer 6

Ich denke, Sie sind auf der richtigen Spur, aber der Rückgabewert fehlt ein Nicht-Operator. Wenn Sie sich auf einer 64-Bit-Maschine befinden und der Prozess WOW64 ist, handelt es sich um einen 32-Bit-Prozess (siehe Kommentare über IsWow64Process). Außerdem wird die Möglichkeit, dass IsWow64Process einen Fehler zurückgibt, nicht behandelt. Hier ist eine feste Version:

/// <summary> 
/// TRUE if the process is running under WOW64. That is if it is a 32 bit process running on 64 bit Windows. 
/// If the process is running under 32-bit Windows, the value is set to FALSE. 
/// If the process is a 64-bit application running under 64-bit Windows, the value is also set to FALSE. 
/// </summary> 
[DllImport("kernel32.dll", SetLastError=true)] 
static extern bool IsWow64Process(System.IntPtr aProcessHandle, out bool isWow64Process); 

/// <summary> 
/// Indicates if the process is 32 or 64 bit. 
/// </summary> 
/// <param name="aProcessHandle">process to query</param> 
/// <returns>true: process is 64 bit; false: process is 32 bit</returns> 
public static bool Is64BitProcess(System.IntPtr aProcessHandle) 
{ 
    if (!System.Environment.Is64BitOperatingSystem) 
     return false; 

    bool isWow64Process; 
    if (!IsWow64Process(aProcessHandle, out isWow64Process)) 
     throw new Win32Exception(Marshal.GetLastWin32Error()); 

    return !isWow64Process; 
}