Gibt es eine einfache Möglichkeit, unter Windows zu überprüfen, ob eine Binärdatei 32 oder 64 Bit enthält? Ich muss das überprüfen, bevor ich das Programm auf einen 32-Bit-Computer verschiebe und einen spektakulären Fehler erleide.
Gibt es eine einfache Möglichkeit, unter Windows zu überprüfen, ob eine Binärdatei 32 oder 64 Bit enthält? Ich muss das überprüfen, bevor ich das Programm auf einen 32-Bit-Computer verschiebe und einen spektakulären Fehler erleide.
Antworten:
Nachdem ich die Header-Werte aus Richards Antwort untersucht hatte , kam ich zu einer Lösung, die schnell und einfach ist und nur einen Texteditor erfordert. Sogar Windows 'Standardnotepad.exe würde funktionieren.
Öffnen Sie die ausführbare Datei im Texteditor. Möglicherweise müssen Sie das Open...
Dialogfeld des Editors ziehen und ablegen oder verwenden , da die Open with...
Option für ausführbare Dateien in Windows nicht im Kontextmenü angezeigt wird.
Überprüfen Sie die ersten druckbaren Zeichen nach dem ersten Auftreten von PE
. Dieser Teil wird höchstwahrscheinlich von mindestens einem Leerzeichen umgeben sein (könnte viel davon sein), so dass es leicht visuell gemacht werden kann.
Folgendes werden Sie finden:
PE L
PE d†
Ein Wort der Warnung: Die Verwendung des Standard-Editor für große Dateien kann sehr langsam sein. Verwenden Sie ihn daher besser nicht für Dateien, die größer als ein Megabyte oder weniger sind. In meinem Fall dauerte es ungefähr 30 Sekunden, bis eine 12-MiB-Datei angezeigt wurde. Notepad ++ war jedoch in der Lage, eine ausführbare Datei mit 120 MB fast sofort anzuzeigen.
Diese Lösung kann hilfreich sein, wenn Sie eine Datei auf einem Computer überprüfen müssen, auf dem Sie keine zusätzliche Software installieren können.
Wenn Sie einen HEX-Editor zur Verfügung haben, befindet sich der Versatz von PE Signature am Versatz 0x3C
. Die Signatur lautet PE\0\0
(Buchstaben "P" und "E", gefolgt von zwei Null-Bytes), gefolgt von einem Zwei-Byte-Maschinentyp in Little Endian.
Die relevanten Werte gelten 0x8664
für x64-ausführbare Dateien und 0x14c
für x86. Es gibt viel mehr mögliche Werte, aber Sie werden wahrscheinlich nie auf einen dieser Werte stoßen oder solche ausführbaren Dateien auf Ihrem Windows-PC ausführen können.
Die vollständige Liste der Maschinentypen sowie die übrigen EXE-Spezifikationen finden Sie im Abschnitt Maschinentypen mit Microsoft PE- und COFF-Spezifikation .
Microsoft PE and COFF Specification
, der so gut es geht ein dokumentierter Vertrag, sowie Anweisungen, wie Sie die genaue Adresse des PE-Headers finden in einer beliebigen .exe
Datei. Wenn Sie eine zuverlässigere Quelle als die offizielle Spezifikation von Microsoft für das von Microsoft selbst ausführbare Format haben, würde ich gerne wissen, was das ist.
Das SDK-Tool dumpbin.exe
mit der /headers
Option enthält diese Informationen. Vergleichen Sie diese beiden (die wichtigsten Informationen sind fett gedruckt).
PS [64] E: \ # 4> Mülleimer / Header C: \ Windows \ system32 \ cmd.exe Microsoft® COFF / PE-Dumper Version 10.00.40219.01 Copyright (C) Microsoft Corporation. Alle Rechte vorbehalten. Speicherauszug der Datei C: \ Windows \ system32 \ cmd.exe PE-Signatur gefunden Dateityp: EXECUTABLE IMAGE DATEI-HEADER-WERTE 8664-Maschine (x64) 6 Anzahl der Abschnitte 4CE798E5 Zeitstempel Datum Sa 20.11. 09:46:13 2010 0 Dateizeiger auf Symboltabelle 0 Anzahl der Symbole F0 Größe des optionalen Headers 22 Eigenschaften Ausführbar Die Anwendung kann große Adressen (> 2 GB) verarbeiten [...]
und
PS [64] E: \ # 5> Mülleimer / Header C: \ Windows \ syswow64 \ cmd.exe Microsoft® COFF / PE-Dumper Version 10.00.40219.01 Copyright (C) Microsoft Corporation. Alle Rechte vorbehalten. Speicherauszug der Datei C: \ Windows \ syswow64 \ cmd.exe PE-Signatur gefunden Dateityp: EXECUTABLE IMAGE DATEI-HEADER-WERTE 14C-Maschine (x86) 4 Anzahl der Abschnitte 4CE78E2B Zeitstempel Sa 20.11. 09:00:27 2010 0 Dateizeiger auf Symboltabelle 0 Anzahl der Symbole E0 Größe des optionalen Headers 102 Eigenschaften Ausführbar 32-Bit-Wortmaschine [...]
dumpbin /headers | findstr "machine"
vereinfacht die Verwendung die Darstellung dessen, wonach die
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Wenn Sie nicht das gesamte Windows SDK oder Visual Studio haben oder wollen, können Sie sigcheck.exe
von SysInternals Folgendes verwenden :
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
Ich kann bestätigen, dass das file
Dienstprogramm (z. B. von Cygwin) zwischen ausführbaren 32-Bit- und 64-Bit-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. Außerdem wird zwischen ausführbaren Konsolen- und GUI-Dateien unterschieden.
MZ
statt PE
?
Eine einfache Methode besteht darin, sie auszuführen (vorausgesetzt, Sie vertrauen ihr) und sich die Registerkarte process im Task-Manager anzusehen. Bei 32-Bit-Prozessen wird am Ende des Prozessnamens "* 32" angezeigt. Wenn Sie nicht bereit sind, auf Ihrem Computer zu laufen, können Sie den EXE-Explorer ausprobieren . Es werden eine ganze Reihe von Informationen zu ausführbaren Dateien angezeigt, einschließlich 32- oder 64-Bit-Dateien.
main
Einstiegspunkt und wird daher nicht als eigenständiger Prozess ausgeführt. Beim Laden wird eine Initialisierungsfunktion aufgerufen, die jedoch nicht "main" ist.
Viele Leute haben die exzellente 7-Zip-Version installiert und den 7-Zip-Ordner hinzugefügt PATH
. 7-zip versteht andere Dateiformate als ZIP und RAR, 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 umfasst die folgenden Zeilen, wobei die CPU
Zeile 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
file
Implementierung im Inneren?
Die 64-Bit-Version von Process Explorer kann es Ihnen sagen. Führen Sie einfach die ausführbare Datei aus und öffnen Sie das Eigenschaftenfenster des Prozesses. Auf der Hauptregisterkarte befindet sich ein Eintrag mit der Aufschrift "Image: 32 Bit" oder "Image: 64 Bit".
Simply run the executable
Und wenn Sie das Programm nicht ausführen möchten ?
Einfachster Weg (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 Additional information
Option liefert zusätzlich viele hilfreiche Informationen zur Datei.
Die Methode, eine ausführbare Datei auszuführen und anschließend den Prozess-Explorer oder ein ähnliches Tool einzuchecken, weist einige offensichtliche Nachteile auf:
Die Methode Dumpbin.exe kann den Zweck wahrscheinlich lösen.
Eine weitere Alternative wäre Cygwin zu verwenden Datei - Befehl. Ich habe es jedoch nicht unter Windows getestet. Es funktioniert gut unter Linux.
Usage: file program_under_test.exe
BEARBEITEN: Gerade getestet file.exe auf Fenster. funktioniert gut. :)
cygwin
Pakets verzichten möchte, kann sich das Paket gnuwin32 zulegenfile
.
file
Liest einfach Daten im Binärformat von der Festplatte und sucht nach magischen Zahlen, die sie identifizieren, und vergleicht sie mit einer Datenbank. Die 32-Bit-Programme von Windows werden als PE32 und die 64-Bit- und .NET-Programme als PE32 + angezeigt. Die Bit-Qualität file
macht keinen Unterschied - sowohl 32-Bit- als auch 64-Bit-Anwendungen können Daten von der Festplatte lesen, was alles ist, was sie benötigt.
Hier ist eine Powershell-Lösung, keine externen Abhängigkeiten oder ähnliches. Öffnen Sie Powershell, fügen Sie die Funktion dort ein (drücken Sie zweimal die Eingabetaste, 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
$stream.dispose();
nach dem schließen hinzufügen ? Sollte Dateihandles freigeben. ( stackoverflow.com/questions/1999858/… )
Sogar eine als 32-Bit markierte ausführbare Datei kann als 64-Bit ausgeführt werden, wenn es sich beispielsweise um eine ausführbare .NET-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 . Die Antwort lautet: the Mit dem Dienstprogramm CORFLAGS können Sie bestimmen, wie eine .NET-Anwendung ausgeführt wird.
CORFLAGS.EXE-Ausgabe
Für ausführbare 32-Bit-Dateien:
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-Dateien:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32+
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Für ausführbare Dateien, die als 32- oder 64-Bit-Datei ausgeführt werden können und wenn möglich als 64-Bit-Datei ausgeführt 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 Dateien, die als 32- oder 64-Bit-Datei ausgeführt werden können, jedoch als 32-Bit-Datei ausgeführt werden, sofern 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
corflags : error CF008 : The specified file does not have a valid managed header
)
Sie können das file
Tool auch im msys-Bundle von mingw verwenden . Es funktioniert wie der Unix-Befehl. Ähnlich funktioniert das file
Tool von GNUwin32 .
Wenn Sie unter Windows 7 arbeiten, klicken Sie mit der rechten Maustaste auf die ausführbare Datei und wählen Sie Eigenschaften. Wählen Sie im Eigenschaftenfenster die Registerkarte Kompatibilität. Wenn Sie im Abschnitt "Kompatibilitätsmodus" Windows XP sehen, handelt es sich um eine 32-Bit-ausführbare Datei. Wenn Sie Windows Vista sehen, ist es 64-Bit.
Windows 8
Windows XP SP2
, andere zeigen als Vista
oder Windows 8
. Diese Methode ist also nicht korrekt.
Erstellen Sie eine Textdatei mit dem Namen exetest.reg, die den folgenden Code enthält:
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 mit dem Namen, x86TestStart.bat
die nur diese Codezeile enthält, und speichern Sie sie in C: \ temp:
c:\temp\x86or64.vbs %1
Erstellen Sie eine Textdatei mit dem Namen, x86or64.vbs
die diesen Code enthält, und speichern Sie sie in C: \ temp:
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
Doppelklicken Sie auf die Datei exetest.reg: In der Windows-Registrierung wird ein neuer Schlüssel hinzugefügt:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Wenn Sie mit der rechten Maustaste auf eine ausführbare Datei klicken, wird sie im Kontextmenü als " 32/64-Bit-Test " angezeigt.
Durch Klicken auf das Element wird die Batch-Datei c:\\temp\\x86TestStart.bat\
gestartet, die die VBscript-Datei startet x86or64.vbs
, die die exe-Signatur liest und das Ergebnis anzeigt.
Wenn Sie die Registrierung nicht manipulieren können oder möchten, kopieren Sie einfach die VBS-Datei in die QuickLaunch-Leiste und ziehen Sie die ausführbare Datei darüber.
Meine zwei Cent werden nur Abhängigkeits-Walker herunterladen und überprüfen, was für die Architektur in einer der ausführbaren Dateien verwendet wurde.
Laden Sie einfach die App herunter, starten Sie sie und klicken Sie auf das Symbol zum Öffnen. → Suchen Sie eine * .exe-Datei. → Wählen Sie diese aus. Nach Abschluss des Reflexionsscans wird unten ein Raster mit Daten angezeigt, in dem sich in einer Spalte Details zur Architektur befinden. x64)
Öffnen Sie die ausführbare Datei und sehen Sie sich die Build-Architektur an
Ich habe das nicht erwähnt gesehen. Es gibt ein PE-Viewer-Programm namens CFF Explorer von NTCore , das Ihnen diese Informationen zur Verfügung stellen kann. Es kann heruntergeladen und als portable Version ausgeführt werden, aber Sie können es auch installieren, wenn Sie möchten.
Rechtsklick auf dem binären ( .exe
, .dll
etc.) und wählen Sie „Öffnen mit CFF Explorer“. Gehen Sie zu Nt Headers -> File Header -> Klicken Sie im Feld "Characteristics" auf "Click here".
Wenn es sich um ein 32-Bit-Programm handelt, ist das Kontrollkästchen "32-Bit-Wortmaschine" aktiviert. Zum Beispiel habe ich die 32-Bit-Version von Notepad ++ installiert, wie Sie im Bild unten sehen können. Ansonsten ist es 64bit.
.DMP
Dump in Visual StudioMeine zwei Cent: Als C ++ - Entwickler ist Dependency Walker ( http://www.dependencywalker.com/ ) sehr informativ und zeigt nicht nur 64/32 Bit an, sondern auch jede beteiligte Dll:
Sie können 64 links von jedem Dateinamen sehen ...
Die Plattformspalte im Task-Manager von Windows 10
Windows 7 hat keine Plattformspalte. Der Windows 7 Task-Manager zeigt es also nicht an.
In Windows 10 ist das Auswählen von Spalten nicht mehr unter "Ansicht". In Windows 10 klicken Sie auf der Registerkarte "Details" mit der rechten Maustaste auf die Spaltenüberschrift und wählen dann "Spalten auswählen". Aktivieren Sie dann das Kontrollkästchen für "Plattform".