it-swarm.com.de

Wie überprüfe ich, ob eine Binärdatei unter Windows 32 oder 64 Bit enthält?

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 eine 32-Bit-Maschine verschiebe und einen spektakulären Fehler erleide.

300
Septagram

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 den Open...-Dialog des Editors ziehen und ablegen oder verwenden, da Windows die Option Open with... im Kontextmenü für ausführbare Dateien nicht anzeigt.

  2. Überprüfen Sie die ersten druckbaren Zeichen nach dem ersten Auftreten von PE. Dieser Teil ist höchstwahrscheinlich von mindestens einem Leerzeichen umgeben (könnte eine Menge davon sein), sodass er leicht visuell ausgeführt 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 MiB 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 Offset von PE Signature bei offset 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 sind 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.

Eine vollständige Liste der Maschinentypen sowie der übrigen EXE-Spezifikationen finden Sie im Abschnitt Microsoft PE- und COFF-Spezifikation Maschinentypen .

315
Alexander Revo

Das SDK-Tool dumpbin.exe mit der Option /headers enthält diese Informationen. Vergleichen Sie diese beiden (die wichtigsten Informationen sind fett gedruckt).

 PS [64] E:\# 4> dumpbin/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 
 
 FILE HEADER VALUES 
 8664-Maschine (x64)
 6 Anzahl Abschnitte 
 4CE798E5 Zeitstempel Sa 20.11. 09:46:13 2010 
 0 Dateizeiger auf Symboltabelle 
 0 Anzahl Symbole 
 .] F0 Größe des optionalen Headers 
 22 Merkmale 
 Ausführbare Datei 
 Die Anwendung kann große (> 2 GB) Adressen 
 [...] 

und

 PS [64] E:\# 5> dumpbin/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 
 
 FILE HEADER VALUES 
 14C-Maschine (x86)
 4 Anzahl Abschnitte 
 4CE78E2B Zeitstempel Sa 20.11. 09:00:27 2010 
 0 Dateizeiger auf Symboltabelle 
 0 Anzahl Symbole [.____. .] E0 Größe des optionalen Headers 
 102 Merkmale 
 Ausführbare 
 32-Bit-Word-Maschine 
 [...] 
117
Richard

Wenn Sie nicht das gesamte Windows SDK oder Visual Studio haben oder wollen, können Sie sigcheck.exe von SysInternals 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
43
briantist

Ich kann bestätigen, dass das Dienstprogramm file (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.

36
wmassingham

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 EXE Explorer ausprobieren. Es werden eine ganze Reihe von Informationen zu ausführbaren Dateien angezeigt, einschließlich 32- oder 64-Bit-Dateien.

30
Dracs

Viele Leute haben das exzellente 7-Zip installiert und haben den 7-Zip-Ordner zu ihrer PATH hinzugefügt. 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 in der betreffenden PE-Datei (Exe oder DLL):

7z l some.exe | more
7z l some.exe | findstr CPU

Die Ausgabe umfasst die folgenden Zeilen, wobei in der Zeile CPU entweder x86 oder x64 steht, 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
23
Lumi

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

enter image description here

18
Andrew Lambert

Einfachster Weg (wenn die Daten nicht vertraulich sind)

Ich finde, dass VirustotalFile detail der einfachste Weg ist, um herauszufinden, ob eine Binärdatei 32-Bit oder 64-Bit ist.

Die Option Additional information bietet zusätzlich viele hilfreiche Informationen zur Datei.

Virustotal analysis


[Virustotal TrID

14
marsh-wiggle

Die Methode, eine ausführbare Datei auszuführen und dann 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 (z. B. 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 andere Alternative wäre, den Befehl file von cygwin zu verwenden. Ich habe es jedoch nicht unter Windows getestet. Es funktioniert gut unter Linux.

Usage: file program_under_test.exe

BEARBEITEN: Gerade getestet file.exe am Fenster. funktioniert gut. :)

13
anishsane

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, um zur Eingabeaufforderung zurückzukehren), 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
10
megamorf

Sogar 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 , das eine Antwort hat das besagt, dass das Dienstprogramm CORFLAGS verwandt werden kann, um zu 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 eine ausführbare 64-Bit-Datei:

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
6
BlueMonkMN

sie können das Tool file auch aus dem Paket msys von mingw heraus verwenden. Es funktioniert wie der Unix-Befehl. Ähnlich funktioniert das Tool file von GNUwin32 .

4
Bastian Ebeling

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.

3
axxis

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

Erstellen Sie eine Textdatei mit dem Namen exetest.reg und dem folgenden Code:

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]

Es erscheint als " 32/64 Bit Test " im Kontextmenü, wenn Sie mit der rechten Maustaste auf eine ausführbare Datei klicken.

Durch Klicken auf das Element wird die Batchdatei c:\\temp\\x86TestStart.bat\ gestartet, die die VBscript-Datei x86or64.vbs startet, 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.

2
jumpjack

Meine zwei Cent werden nur herunterladen Dependency Walker 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 Reflexions-Scans 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

 dependency walker screenshot

2
stenly
  • führen Sie die Anwendung aus
  • Öffnen Sie den Task-Manager
  • rechtsklick und Dump-Datei erstellen
  • pfad notieren
  • gehe zu Pfad und .DMP dump in Visual Studio öffnen
  • dort bekommst du alle details
  • prozessarchitektur prüfen:
0
user429538

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.

Klicken Sie mit der rechten Maustaste auf die Binärdatei (.exe, .dll usw.) und wählen Sie "Mit CFF Explorer öffnen". 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-Word-Maschine" aktiviert. Zum Beispiel habe ich die 32-Bit-Version von Notepad ++ installiert, wie Sie im Bild unten sehen können. Ansonsten ist es 64bit.

 enter image description here

0
Nikos

Der Befehl file von WSL funktioniert jedoch sehr gut.

file /mnt/c/p/bin/rg.exe würde folgendes ausgeben:

/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows

file /mnt/c/p/bin/u.exe würde folgendes ausgeben:

/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed
0
Bohr

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:  enter image description here

Sie können 64 links von jedem Dateinamen sehen ...

0
ingconti