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.

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.

1. Ö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.

2. Ü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:

x86:

PE  L

x64:

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.

Zusätzliche Information:

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 0x8664für x64-ausführbare Dateien und 0x14cfü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 .

Das SDK-Tool dumpbin.exemit der /headersOption 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
[...]

Wenn Sie nicht das gesamte Windows SDK oder Visual Studio haben oder wollen, können Sie sigcheck.exevon 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 fileDienstprogramm (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.

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.

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.exefü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 CPUZeile entweder x86oder x64lautet, 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 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".

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 informationOption 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:

1. Wir müssen den Prozess ausführen.
2. Bei kurzlebigen Prozessen (wie Echo-Hallo-Welttypen) registriert der Prozess-Explorer möglicherweise nicht einmal, dass ein neuer Prozess gestartet wurde.

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. :)

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

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

Sie können das fileTool auch im msys-Bundle von mingw verwenden . Es funktioniert wie der Unix-Befehl. Ähnlich funktioniert das fileTool 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.

So fügen Sie Ihrem Kontextmenü einen 32/64-Bit-Test hinzu

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.batdie 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.vbsdie 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.

Wie man es benutzt:

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, .dlletc.) 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.

• Führen Sie die Anwendung aus
• Öffnen Sie den Task-Manager
• Rechtsklick und Dump-Datei erstellen
• Pfad notieren
• Gehe zu Pfad und öffne .DMPDump in Visual Studio
• dort bekommst du alle details
• Prozessarchitektur prüfen:

Meine 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 ...

Doch WSL ‚s fileBefehl funktioniert sehr.

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

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".