Gibt es eine einfache Möglichkeit zu überprüfen, ob eine Binärdatei unter Windows 32 oder 64 Bit ist? Ich muss das überprüfen, bevor ich das Programm auf eine 32-Bit-Maschine verschiebe und dabei einen spektakulären Fehler erlebe.
Nachdem ich Header-Werte aus Richards Antwort untersucht hatte, kam ich zu einer Lösung, die schnell und einfach ist und nur einen Texteditor erfordert. Sogar die Standard-Notepad.exe von Windows würde funktionieren.
Öffnen Sie die ausführbare Datei in einem Texteditor. Möglicherweise müssen Sie per Drag-and-Drop oder mit dem Dialogfeld Open... des Editors arbeiten, da Windows die Option Open with... im Kontextmenü für ausführbare Dateien nicht anzeigt.
Überprüfen Sie die ersten druckbaren Zeichen nach dem ersten Auftreten von PE. Dieser Teil ist höchstwahrscheinlich von mindestens etwas Leerraum umgeben (es könnte eine Menge davon sein), so dass er leicht visuell dargestellt werden kann.
Hier ist, was Sie finden werden:
PE L
PE d†
** Ein Wort der Warnung:** Die Verwendung des Standard-Notizblocks bei großen Dateien kann sehr langsam sein, daher sollte er besser nicht für Dateien verwendet werden, die größer als ein Megabyte oder wenige sind. In meinem Fall dauerte es etwa 30 Sekunden, um eine 12-MiB-Datei anzuzeigen. Notepad++ war jedoch in der Lage, eine 120-MiB-Datei fast augenblicklich anzuzeigen.
Diese Lösung könnte nützlich sein, wenn Sie eine Datei auf einem Rechner inspizieren müssen, auf dem Sie keine zusätzliche Software installieren können.
Wenn Sie einen HEX-Editor zur Verfügung haben, befindet sich der Offset der PE-Signatur bei Offset 0x3C. Die Signatur ist PE0x86640x014c (Buchstaben “P” und “E”, gefolgt von zwei Null-Bytes), gefolgt von einer zwei Byte langen Maschinenschrift in Little Endian.
Die relevanten Werte sind 64 86 für ein 64-Bit-Executable und 4c 01 für ein 32-Bit-Executable (&007 bzw. &007, wenn sie auf Endianität eingestellt sind, aber jeder anständige Hex-Editor wird automatisch mit Endianität umgehen, wenn Sie nach einem Hex-Wert suchen). Es gibt viel mehr mögliche Werte, aber Sie werden wahrscheinlich nie auf einen dieser Werte stoßen oder in der Lage sein, solche ausführbaren Dateien auf Ihrem Windows-PC auszuführen.
Die vollständige Liste der Maschinentypen, zusammen mit dem Rest der .exe-Spezifikationen, finden Sie im Abschnitt Microsoft PE and COFF Specification Machine Types.
Das SDK-Tool dumpbin.exe mit der Option /headers enthält diese Informationen, vergleichen Sie diese beiden (die wichtigsten Informationen habe ich fett gedruckt hinzugefügt)
PS [64] E:\ #4\> dumpbin /headers C:\Windows\system32\cmd.exe Microsoft (R) COFF/PE Dumper Version 10.00.40219.01 Copyright (C) Microsoft Corporation. All rights reserved. Dump of file C:\Windows\system32\cmd.exe PE signature found File Type: EXECUTABLE IMAGE FILE HEADER VALUES **8664 machine (x64)** 6 number of sections 4CE798E5 time date stamp Sat Nov 20 09:46:13 2010 0 file pointer to symbol table 0 number of symbols F0 size of optional header 22 characteristics Executable Application can handle large (\>2GB) addresses [...]
und
PS [64] E:\ #5\> dumpbin /headers C:\Windows\syswow64\cmd.exe Microsoft (R) COFF/PE Dumper Version 10.00.40219.01 Copyright (C) Microsoft Corporation. All rights reserved. Dump of file C:\Windows\syswow64\cmd.exe PE signature found File Type: EXECUTABLE IMAGE FILE HEADER VALUES **14C machine (x86)** 4 number of sections 4CE78E2B time date stamp Sat Nov 20 09:00:27 2010 0 file pointer to symbol table 0 number of symbols E0 size of optional header 102 characteristics Executable 32 bit word machine [...]
Wenn Sie nicht das gesamte Windows SDK oder Visual Studio haben oder wollen, können Sie sigcheck.exe von SysInternals :
sigcheck.exe C:\Windows\Notepad.exe
Ausgabe:
Sigcheck v2.1 - File version and signature viewer
Copyright (C) 2004-2014 Mark Russinovich
Sysinternals - www.sysinternals.com
c:\windows\notepad.exe:
Verified: Signed
Signing date: 8:59 AM 8/22/2013
Publisher: Microsoft Windows
Description: Notepad
Product: Microsoft« Windows« Operating System
Prod version: 6.3.9600.16384
File version: 6.3.9600.16384 (winblue_rtm.130821-1623)
MachineType: 64-bit
``` verwenden
Ich kann bestätigen, dass das Dienstprogramm file (z.B. von cygwin) zwischen 32- und 64-Bit ausführbaren Dateien unterscheidet. Sie sehen wie folgt aus:
32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows
Wie Sie sehen können, ist es sehr offensichtlich, welches welches ist. Zusätzlich wird zwischen ausführbaren Konsolen- und GUI-Dateien unterschieden, wobei auch klar ist, was was ist.
Eine einfache Methode ist es, ihn auszuführen (vorausgesetzt, Sie vertrauen ihm) und einen Blick auf die Registerkarte “Prozess” im Task-Manager zu werfen. 32bit-Prozesse werden “* 32” am Ende des Prozessnamens anzeigen. Wenn Sie nicht bereit sind, sie auf Ihrem Computer auszuführen, können Sie es mit EXE Explorer versuchen. Er wird eine ganze Reihe von Informationen über ausführbare Dateien anzeigen, einschließlich der Information, ob es sich um 32 oder 64bit handelt.
Viele Leute haben das ausgezeichnete 7-zip installiert und den 7-Zip-Ordner zu ihrem PATH hinzugefügt. 7-zip versteht auch andere Dateiformate als ZIP und RAR, wie z.B. MSI-Dateien und ausführbare PE-Dateien. Verwenden Sie einfach die Befehlszeile 7z.exe für die betreffende PE-Datei (Exe oder DLL):
7z l some.exe | more
7z l some.exe | findstr CPU
Die Ausgabe enthält folgende Zeilen, wobei die Zeile CPU entweder x86 oder x64 lautet, was hier abgefragt wird:
Path = C:\Extra\AV\neroAacEnc.exe
Type = PE
CPU = x86
Characteristics = Executable 32-bit
Path = C:\Extra\AV\LAME\lame_enc.dll
Type = PE
CPU = x86
Characteristics = Executable DLL 32-bit
Path = C:\Extra\AV\FFmpeg\bin\ffmpeg.exe
Type = PE
CPU = x64
64-bit = +
Characteristics = Executable LargeAddress NoRelocs NoLineNums NoLocalSyms NoDebugInfo
Path = C:\Extra\AV\FFmpeg\bin\avcodec-56.dll
Type = PE
CPU = x64
64-bit = +
Characteristics = Executable DLL LargeAddress NoLineNums NoLocalSyms NoDebugInfo
Die 64-Bit-Version von Process Explorer kann Ihnen dies mitteilen. Führen Sie einfach die ausführbare Datei aus und öffnen Sie das Eigenschaftenfenster des Prozesses. Auf dem Hauptregister gibt es einen Eintrag mit der Aufschrift “Bild:32 Bit” oder “Bild:64 Bit”.
Most simple way (wenn die Daten nicht vertraulich sind)
Ich finde, dass Virustotal File detail der einfachste Weg ist, um herauszufinden, ob eine Binärdatei 32 Bit oder 64 Bit ist.
Die Option Additional information liefert zusätzlich viele hilfreiche Informationen über die Datei.
Die Methode, eine ausführbare Datei auszuführen und dann einen Prozess-Explorer oder ein ähnliches Tool einzuchecken, hat einige offensichtliche Nachteile:
Die Methode Dumpbin.exe kann den Zweck wahrscheinlich lösen.
Eine andere Alternative wäre die Verwendung des file-Befehls von cygwin. Ich habe ihn jedoch nicht unter Windows getestet. Es funktioniert gut unter Linux.
Usage: file program_under_test.exe
EDIT: Habe gerade file.exe auf window. getestet. funktioniert gut. :)
Hier gibt es eine Powershell-Lösung, keine externen Abhängigkeiten oder ähnliches. Öffnen Sie Powershell, fügen Sie die Funktion dort ein (drücken Sie zweimal Enter, damit Sie zur Eingabeaufforderung zurückkehren) und verwenden Sie sie dann wie in meinen Beispielen unter der Funktion:
function Test-is64Bit {
param($FilePath=“$env:windir\notepad.exe”)
[int32]$MACHINE_OFFSET = 4
[int32]$PE_POINTER_OFFSET = 60
[byte[]]$data = New-Object -TypeName System.Byte[] -ArgumentList 4096
$stream = New-Object -TypeName System.IO.FileStream -ArgumentList ($FilePath, 'Open', 'Read')
$stream.Read($data, 0, 4096) | Out-Null
[int32]$PE_HEADER_ADDR = [System.BitConverter]::ToInt32($data, $PE_POINTER_OFFSET)
[int32]$machineUint = [System.BitConverter]::ToUInt16($data, $PE_HEADER_ADDR + $MACHINE_OFFSET)
$stream.Close()
$result = "" | select FilePath, FileType, Is64Bit
$result.FilePath = $FilePath
$result.Is64Bit = $false
switch ($machineUint)
{
0 { $result.FileType = 'Native' }
0x014c { $result.FileType = 'x86' }
0x0200 { $result.FileType = 'Itanium' }
0x8664 { $result.FileType = 'x64'; $result.is64Bit = $true; }
}
$result
}
Hier ist eine Beispielausgabe:
D:\> Test-is64bit
FilePath FileType Is64Bit
-------- -------- -------
C:\Windows\notepad.exe x64 True
D:\> Test-is64bit 'C:\Program Files (x86)\Mozilla Firefox\firefox.exe'
FilePath FileType Is64Bit
-------- -------- -------
C:\Program Files (x86)\Mozilla Firefox\firefox.exe x86 False
Selbst eine als 32-Bit markierte ausführbare Datei kann als 64-Bit ausgeführt werden, wenn es sich beispielsweise um eine .NET ausführbare Datei handelt, die als 32- oder 64-Bit ausgeführt werden kann. Weitere Informationen finden Sie unter https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , wo es eine Antwort gibt, die besagt, dass das Dienstprogramm CORFLAGS verwendet werden kann, um zu bestimmen, wie eine .NET-Anwendung ausgeführt wird.
CORFLAGS. EXE-Ausgabe
Für ausführbare 32-Bit-Programme:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x3
ILONLY : 1
32BITREQ : 1
32BITPREF : 0
Signed : 0
Für ausführbare 64-Bit-Programme:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32+
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Für ausführbare Programme, die als 32- oder 64-Bit laufen können und wenn möglich als 64-Bit laufen werden:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Für ausführbare Programme, die als 32- oder 64-Bit laufen können, aber als 32-Bit laufen werden, wenn sie nicht in einen 64-Bit-Prozess geladen werden:
Version : v4.0.30319
CLR Header: 2.5
PE : PE32
CorFlags : 0x20003
ILONLY : 1
32BITREQ : 0
32BITPREF : 1
Signed : 0
Meine zwei Cents werden einfach dependency walker herunterladen und überprüfen, was für die Architektur in einer der ausführbaren Dateien verwendet wurde.
Laden Sie einfach die Anwendung herunter, starten Sie sie, klicken Sie auf das offene Symbol → finden Sie ein *. exe-Datei → auswählen und unten, nachdem der Reflexionsscan durchgeführt wurde, sehen Sie ein Raster mit Daten, in dem in einer Spalte “Architektur”-Details enthalten sind (x86, x64)
Öffnen Sie die ausführbare Datei und sehen Sie die Build-Architektur
Wenn Sie unter Windows 7 in einem Windows Explorer arbeiten, klicken Sie mit der rechten Maustaste auf die ausführbare Datei und wählen Sie Eigenschaften. Wählen Sie im Eigenschaftsfenster die Registerkarte Kompatibilität. Wenn unter dem Abschnitt Kompatibilitätsmodus Windows XP angezeigt wird, handelt es sich um eine ausführbare 32-Bit-Datei. Wenn Sie Windows Vista sehen, handelt es sich um eine 64-Bit-Datei.
können Sie das Tool file auch innerhalb des msys-Bündels von mingw verwenden. Es funktioniert wie der Befehl unix. Ähnlich funktioniert das Werkzeug file aus GNUwin32 .
Erstellen Sie eine Textdatei mit dem Namen exetest. reg und diesen Code enthalten:
Windows Registry Editor Version 5.00
; What will appear in the contextual menu when right-clicking on a .exe file
[HKEY_CLASSES_ROOT\exefile\shell\command32_64]
@="32/64 bit test"
; What to do with it
; here, %1 is the file given as argument of the script
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
@="\"c:\temp\x86TestStart.bat\" \"%1\""
Erstellen Sie eine Textdatei namens x86TestStart.bat, die genau diese Codezeile enthält, und speichern Sie sie in C:\temp:
c:\temp\x86or64.vbs %1
Erstellen Sie eine Textdatei namens x86or64.vbs, die diesen Code enthält, und speichern Sie sie in C:\temp:
Doppelklicken Sie auf exetest. reg-Datei: ein neuer Schlüssel wird in der Windows-Registry hinzugefügt:
rem Reading binary file in VBScript: http://stackoverflow.com/questions/21249440/modify-first-two-bytes-of-a-file-using-vbscript
rem Info on executables: https://dmoj.ca/problem/exe
rem x86/64 signature is located dinamycally; its position is addressed
rem from bytes in 0x3C-0x3D position.
rem Possible signatures;
rem "PE..L" (hex code: 50.45.00.00.4C) = 32 bit
rem "PE..d†" (hex code: 50.45.00.00.64.86) = 64 bit
' ------------------------------------
' Source code by Jumpkack 2015
' ------------------------------------
' Read all arguments from command line:
Set args = Wscript.Arguments
' Store first argument (full path to file)
FileName = args(0)
' Find address of executable signature:
FirstChars = readBinary(FileName)
FirstChars = FirstChars
Addr1 = asc(mid(FirstChars,61,1))
Addr2 = asc(mid(FirstChars,62,1))
AddrFinal = Addr2*256 + Addr1 + 1
' Check signature:
if ucase(hex(asc(mid(FirstChars,AddrFinal+4,2)))) = "4C" then Wscript.Echo Filename & " is a 32 bit executable."
if ucase(hex(asc(mid(FirstChars,AddrFinal+4,2)))) = "64" then Wscript.Echo Filename & " is a 64 bit executable."
Function readBinary(path)
Dim a, fso, file, i, ts
Set fso = CreateObject("Scripting.FileSystemObject")
Set file = fso.getFile(path)
If isNull(file) Then
wscript.echo "File not found: " & path
Exit Function
End If
Set ts = file.OpenAsTextStream()
'a = makeArray(file.size)
a=""
i = 0
While (Not ts.atEndOfStream) and (i<60000)
'a(i) = ts.read(1)
a = a + ts.read(1)
i = i + 1
Wend
ts.close
readBinary = a
End Function
Er erscheint als “ 32/64 bit test” im Kontextmenü, wenn Sie mit der rechten Maustaste auf eine ausführbare Datei klicken.
Durch Klicken auf den Eintrag wird die Batch-Datei `c:\temp\x86TestStart.bat# So fügen Sie einen 32/64-Bit-Test zu Ihrem Kontextmenü hinzu
Erstellen Sie eine Textdatei mit dem Namen exetest. reg und diesen Code enthalten:
Windows Registry Editor Version 5.00
; What will appear in the contextual menu when right-clicking on a .exe file
[HKEY_CLASSES_ROOT\exefile\shell\command32_64]
@="32/64 bit test"
; What to do with it
; here, %1 is the file given as argument of the script
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
@="\"c:\temp\x86TestStart.bat\" \"%1\""
Erstellen Sie eine Textdatei namens x86TestStart.bat, die genau diese Codezeile enthält, und speichern Sie sie in C:\temp:
c:\temp\x86or64.vbs %1
Erstellen Sie eine Textdatei namens x86or64.vbs, die diesen Code enthält, und speichern Sie sie in C:\temp:
Doppelklicken Sie auf exetest. reg-Datei: ein neuer Schlüssel wird in der Windows-Registry hinzugefügt:
rem Reading binary file in VBScript: http://stackoverflow.com/questions/21249440/modify-first-two-bytes-of-a-file-using-vbscript
rem Info on executables: https://dmoj.ca/problem/exe
rem x86/64 signature is located dinamycally; its position is addressed
rem from bytes in 0x3C-0x3D position.
rem Possible signatures;
rem "PE..L" (hex code: 50.45.00.00.4C) = 32 bit
rem "PE..d†" (hex code: 50.45.00.00.64.86) = 64 bit
' ------------------------------------
' Source code by Jumpkack 2015
' ------------------------------------
' Read all arguments from command line:
Set args = Wscript.Arguments
' Store first argument (full path to file)
FileName = args(0)
' Find address of executable signature:
FirstChars = readBinary(FileName)
FirstChars = FirstChars
Addr1 = asc(mid(FirstChars,61,1))
Addr2 = asc(mid(FirstChars,62,1))
AddrFinal = Addr2*256 + Addr1 + 1
' Check signature:
if ucase(hex(asc(mid(FirstChars,AddrFinal+4,2)))) = "4C" then Wscript.Echo Filename & " is a 32 bit executable."
if ucase(hex(asc(mid(FirstChars,AddrFinal+4,2)))) = "64" then Wscript.Echo Filename & " is a 64 bit executable."
Function readBinary(path)
Dim a, fso, file, i, ts
Set fso = CreateObject("Scripting.FileSystemObject")
Set file = fso.getFile(path)
If isNull(file) Then
wscript.echo "File not found: " & path
Exit Function
End If
Set ts = file.OpenAsTextStream()
'a = makeArray(file.size)
a=""
i = 0
While (Not ts.atEndOfStream) and (i<60000)
'a(i) = ts.read(1)
a = a + ts.read(1)
i = i + 1
Wend
ts.close
readBinary = a
End Function
Er erscheint als “ 32/64 bit test” im Kontextmenü, wenn Sie mit der rechten Maustaste auf eine ausführbare Datei klicken.
Durch Klicken auf den Eintrag wird die Batch-Datei gestartet, die die VBscript-Datei x86or64.vbs startet, die die exe-Unterschrift liest und das Ergebnis anzeigt.
Wenn Sie die Registry nicht manipulieren können oder wollen, kopieren Sie einfach die .vbs-Datei in der QuickLaunch-Leiste und ziehen Sie die ausführbare Datei darüber.
Dennoch funktioniert der Befehl file von WSL hervorragend.
file /mnt/c/p/bin/rg.exe würde ausgeben:
/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows
file /mnt/c/p/bin/u.exe würde ausgeben:
/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed
Ich habe das nicht erwähnt gesehen. Es gibt ein PE-Viewer-Programm namens CFF Explorer von NTCore , das Ihnen diese Informationen liefern kann. Es kann heruntergeladen und als portabel ausgeführt werden, aber Sie können es auch installieren, wenn Sie möchten.
Klicken Sie mit der rechten Maustaste auf die Binärdatei (.exe, .dll etc.) und wählen Sie “Öffnen mit CFF Explorer”. Gehen Sie zu Nt Header -> File Header -> Klicken Sie im Feld “Eigenschaften” auf “Hier klicken”
Wenn es sich um ein 32bit-Programm handelt, wird das Kästchen “32 bit word machine” angekreuzt. Ich habe z.B. die 32bit-Version von Notepad++ installiert, wie Sie in der Abbildung unten sehen können. Andernfalls ist es 64bit.
meine zwei Cents: als C++ Entwickler ist der Dependency Walker http://www.dependencywalker.com/ ) sehr informativ, zeigt nicht nur 64/32 Bits an, sondern auch jede involvierte Dll:
Links neben jedem Dateinamen sehen Sie 64…
Die Plattformspalte im Task-Manager von Windows 10
Windows 7 hat keine Plattformspalte. Daher wird sie im Task-Manager von Windows 7 nicht angezeigt.
In Windows 10 ist die Spaltenauswahl nicht mehr unter ‘Ansicht’. In Windows 10 klicken Sie in der Registerkarte “Details” mit der rechten Maustaste auf die Spaltenüberschrift und dann auf “Spalten auswählen”. Markieren Sie dann das Kästchen für ‘Plattform’.
.DMP dump in Visual Studio