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

319

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.

Septagramm
quelle
Diese Frage ist ähnlich , erfordert jedoch einige Arbeit, um sie zu überprüfen.
ST3
3
@ Guillaume: Ausführbare Bilder sind keine Prozesse. Der Task-Manager zeigt nur Prozesse an.
IInspectable

Antworten:

346

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 .

Alexander Revo
quelle
21
Hey, das ist ziemlich abgedreht. Und zum Besseren, da dies tatsächlich die schnellste und einfachste Lösung für die überwiegende Mehrheit der Fälle zu sein scheint :)
Septagram
4
Seltene Instanz, wenn Notepad Notepad ++ schlagen. Notepad zeigt dieses Recht, im Notepad haben Sie Unordnung mit der Kodierung, um es zu zeigen, aber es hat funktioniert!
zar
2
@CoDEmanX Diese Option bedeutet, dass die IDE oder JIT die Wahl für Sie trifft. Weitere Informationen finden Sie in dieser Frage oder in diesem Blogbeitrag .
Alexander Revo
2
@IInspectable Wenn Sie sich tatsächlich die Mühe gemacht hätten, den gesamten Beitrag zu lesen, bevor Sie ihn abgelehnt haben, hätten Sie den Link zu gesehen 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 .exeDatei. 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.
Alexander Revo
6
Für Dateien, die mit "MZ" beginnen, müssen Sie etwas weiter suchen. Ich habe PE..L bei Offset 0x110 gefunden, direkt nach "RichMQ _........".
jnnnnn
120

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
[...]
Richard
quelle
1
Sie könnten auch (IA64) für eine 64-Bit-Itanium-Exe sehen.
Darryl Braaten
21
Wie ich an anderer Stelle über Superuser gelesen habe, dumpbin /headers | findstr "machine"vereinfacht die Verwendung die Darstellung dessen, wonach die
Qualitätssicherung
3
Dumpbin.exe befindet sich hier:C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Devid
3
@David: nicht unbedingt (andere VS-Version, nicht der Standardinstallationspfad, Version aus dem Windows SDK): Aus diesem Grund habe ich keine Angabe gemacht.
Richard
6
Die Verwendung von dumpbin ist am einfachsten, wenn Sie es über die Visual Studio-Befehlszeile starten: stackoverflow.com/a/477389/1390430
Ben
46

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
Briantist
quelle
4
Scheint nicht immer genau zu sein: Versuchen Sie es mit LinqPad.exe (AnyCPU-64bit Version) und Sigcheck wird Ihnen sagen, dass es "32 bit" ist ...
Matt
@ Matt interessant. LinqPad klingt wie eine .NET-App. Ich frage mich, ob Sigcheck nur auf nativen ausführbaren Dateien (für diesen Zweck) korrekt funktioniert.
Briantist
2
Ja, es ist eine .NET-App. Wenn es in .NET nicht vorkompiliert ist, können Sie entweder "x86" oder "AnyCPU" als Ziel festlegen. "x86" wird immer als 32-Bit-Version ausgeführt, aber AnyCPU wird auf einem 64-Bit-System als 64-Bit-Version ausgeführt, auf einem 32-Bit-System jedoch als 32-Bit-Version. SigCheck sollte dies berücksichtigen und mindestens ".NET 32-Bit oder 64-Bit (AnyCPU)" anzeigen. ILSpy sagt in diesem Fall beispielsweise "Architektur: AnyCPU (64-Bit bevorzugt)" - ILSpy funktioniert jedoch nicht für Nicht-.NET-EXE-Dateien.
Matt
1
Das könnte der Fall sein, wie der alte "MZ" -Header, der nur für Nicht-Windows-Betriebssysteme ("DOS") verfügbar ist und sagt "Diese Anwendung erfordert Microsoft Windows" ... ;-)
Matt
2
Ja, die guten alten Zeiten, in denen Sie einen DOS-Debugger in der Shell hatten und den Code zerlegen konnten (der nur einen einzigen DOS-Aufruf enthielt, der diese Meldung druckte) ... und den Text durch "Die Antwort ist 42" ersetzen. :-D
Matt
38

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.

Wmassingham
quelle
1
Diese Lösung ist ziemlich häufig für Entwickler verfügbar, die msysgit installiert haben.
FrontierPsycho
Warum haben ausführbare Dateien in Windows MZstatt PE?
BattleTested
Beachten Sie, dass GNU-Dienstprogramme als einzelne Binärdateien erhältlich sind, wenn Sie Cygwin ansonsten nicht benötigen. gnuwin32.sourceforge.net/packages/file.htm
MJ Walsh
32

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.

Dracs
quelle
8
Leider müssen Sie dazu die ausführbare Datei ausführen. Möglicherweise müssen Sie die Architektur des Programms als Fehlerbehebungsmethode überprüfen, um festzustellen, warum es nicht ausgeführt wird.
Mike Christiansen
6
Wie führe ich eine DLL aus?
user34660
1
@ user34660 RUNDLL32.EXE <DLL-Name>, <Eintrittspunkt>
samis
1
@samusarin das sollte in der post sein.
user34660
@ user34660 Sie sind technisch korrekt. Eine DLL hat keinen mainEinstiegspunkt und wird daher nicht als eigenständiger Prozess ausgeführt. Beim Laden wird eine Initialisierungsfunktion aufgerufen, die jedoch nicht "main" ist.
Samis
24

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
Lumi
quelle
wow ich habe nie gewusst, dass 7z das kann. Wahrscheinlich enthält es eine fileImplementierung im Inneren?
Phuclv
17

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

Bildbeschreibung hier eingeben

Andrew Lambert
quelle
23
Simply run the executableUnd wenn Sie das Programm nicht ausführen möchten ?
Synetech
3
@Synetech Die ursprüngliche Frage impliziert nicht, dass dies der Fall ist.
Andrew Lambert
Dies ist meiner Meinung nach die einfachste Methode, es sei denn, die ausführbare Datei wird zu schnell beendet.
starbeamrainbowlabs
7
Wie führe ich eine DLL aus?
user34660
15

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.

Virustotale Analyse


Virustotal TrID

Sumpfwackeln
quelle
12

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

anishsane
quelle
1
Ich wollte nur sagen, dass es einige Situationen gibt, in denen Dracs Methode nicht sehr hilfreich sein wird.
Anishsane
3
>> Dazu muss noch das Programm ausgeführt werden, das der Autor vermeiden wollte: Nein. Wir führen es wie folgt aus: file.exe program_under_test.exe
anishsane
1
Und wer auf die Installation des gesamten cygwinPakets verzichten möchte, kann sich das Paket gnuwin32 zulegenfile .
Bob
6
@anishsane Völlig falsch. fileLiest 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 filemacht keinen Unterschied - sowohl 32-Bit- als auch 64-Bit-Anwendungen können Daten von der Festplatte lesen, was alles ist, was sie benötigt.
Bob
1
@MarcH Ha! Das ist interessant Ich vermute, das bedeutet, dass der .NET-Laufzeitstub 32-Bit ist. Daher wird ein 32-Bit-Prozess für den Bruchteil einer Sekunde ausgeführt. Mit diesem Prozess wird jedoch nur die .NET-Laufzeit gestartet, wodurch ein nativer 64-Bit-Prozess erstellt wird.
16.12.14
10

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
Megamorf
quelle
Glätte. Das obige Skript scheint einen Verweis auf die Datei offen zu lassen. Konnte nicht erstellen, bis ich Powershell zum ersten Mal geschlossen habe (Skript zum Abfragen der DLL in \ bin ausgeführt).
Samis
1
Sehr cool. +1. Itanium ist definitiv 64bit obwohl :)
Rich Homolka
@samusarin: vielleicht $stream.dispose();nach dem schließen hinzufügen ? Sollte Dateihandles freigeben. ( stackoverflow.com/questions/1999858/… )
Yorik
1
Eine vollständigere Version finden Sie unter Überprüfen, ob die Exe-
Datei
6

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
BlueMonkMN
quelle
Cooler Befehl, funktioniert aber nicht für native (nicht verwaltete) ausführbare Dateien / DLLs. ( corflags : error CF008 : The specified file does not have a valid managed header)
Tomasz Gandor
@TomaszGandor Ja, der Kontext dieser Antwort bestand nur aus verwaltetem Code. Nicht verwalteter Code wird von den anderen Antworten beantwortet. Soweit ich weiß, kann nur verwalteter Code zwischen 32- und 64-Bit-Ausführung wechseln.
BlueMonkMN
4

Sie können das fileTool auch im msys-Bundle von mingw verwenden . Es funktioniert wie der Unix-Befehl. Ähnlich funktioniert das fileTool von GNUwin32 .

Bastian Ebeling
quelle
3

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.

Achse
quelle
-1 trifft überhaupt nicht zu. Verschiedene 32- und 64-Bit-Binärdateien werden alle im Kompatibilitätsmodus vonWindows 8
Peter Hahndorf,
@Peter Ich habe schon einige unter Windows 7 ausprobiert und es hat immer bei mir funktioniert. Können Sie ein Beispiel für eine Binärdatei nennen, bei der der Standardkompatibilitätsmodus Windows 8 ist? Auch auf welchem ​​Windows bist du? Vielen Dank.
Achse
Ich bin auf Server 2012 R2 und habe ein paar zufällige Binärdateien ausprobiert. Einige 32bit zeigen als Windows XP SP2, andere zeigen als Vistaoder Windows 8. Diese Methode ist also nicht korrekt.
Peter Hahndorf
3

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.

Jumpjack
quelle
3

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

Abhängigkeits-Walker-Screenshot

stenly
quelle
1

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.

Bildbeschreibung hier eingeben

Nikos
quelle
Mit CFF Explorer gibt es einen schnelleren Weg: Sofort beim Laden einer Datei haben Sie unter "Dateityp" "Portable Executable 64" oder "Portable Executable 32"
Arthur.V
0
  • 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:
user429538
quelle
3
Ich fühle mich verpflichtet, die Tatsache zu unterstreichen, dass für diese Antwort die Ausführung der Anwendung erforderlich ist. Frühere Kommentatoren schlugen vor, dass dies unerwünscht sein könnte. Außerdem ist Visual Studio nicht automatisch auf allen Windows-Plattformen verfügbar.
G-Man
0

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: Bildbeschreibung hier eingeben

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

ingconti
quelle
1
Screenshot zeigt die Antwort nicht an - 32bit vs 64bit info ...
TomEus
0

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
Bohr
quelle
0

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

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

barlop
quelle