C'è un modo semplice per verificare se un file binario è a 32 o 64 bit su Windows? Devo controllare prima di spostare il programma su una macchina a 32 bit e sperimentare un errore spettacolare.
C'è un modo semplice per verificare se un file binario è a 32 o 64 bit su Windows? Devo controllare prima di spostare il programma su una macchina a 32 bit e sperimentare un errore spettacolare.
Risposte:
Dopo aver esaminato i valori dell'intestazione dalla risposta di Richard , mi è venuta in mente una soluzione che è veloce, facile e richiede solo un editor di testo. Anche il notepad.exe predefinito di Windows funzionerebbe.
Apri l'eseguibile nell'editor di testo. Potrebbe essere necessario trascinare la selezione o utilizzare la Open...
finestra di dialogo dell'editor , poiché Windows non mostra l' Open with...
opzione nel menu di scelta rapida per gli eseguibili.
Controllare i primi caratteri stampabili dopo la prima occorrenza di PE
. È molto probabile che questa parte sia circondata da almeno alcuni spazi bianchi (potrebbe essere molto), quindi può essere facilmente eseguita visivamente.
Ecco cosa troverai:
PE L
PE d†
Un avvertimento: l' utilizzo del Blocco note predefinito su file di grandi dimensioni può essere molto lento, quindi è meglio non utilizzarlo per file di dimensioni superiori a un megabyte o pochi. Nel mio caso, ci sono voluti circa 30 secondi per visualizzare un file di 12 MiB. Notepad ++, tuttavia, è stato in grado di visualizzare un eseguibile di 120 MiB quasi istantaneamente.
Questa soluzione potrebbe essere utile nel caso in cui sia necessario ispezionare un file su un computer su cui non è possibile installare alcun software aggiuntivo.
Se è disponibile un editor HEX, l'offset della firma PE si trova nell'offset 0x3C
. La firma è PE\0\0
(lettere "P" ed "E" seguite da due byte nulli), seguita da un tipo di macchina a due byte in Little Endian.
I valori rilevanti sono 0x8664
per x64 eseguibile e 0x14c
per x86. Esistono molti più valori possibili, ma probabilmente non li incontrerai mai o non sarai in grado di eseguire tali eseguibili sul tuo PC Windows.
L'elenco completo dei tipi di macchine, insieme al resto delle specifiche .exe è disponibile nella sezione Tipi di macchine per le specifiche Microsoft PE e COFF .
Microsoft PE and COFF Specification
, che è un contratto documentato che può ottenere, così come le istruzioni su come trovare l'indirizzo esatto dell'intestazione PE in qualsiasi .exe
file. Se hai una fonte più affidabile delle specifiche ufficiali di Microsoft sul formato eseguibile di Microsoft, mi piacerebbe sapere di cosa si tratta.
Lo strumento SDK dumpbin.exe
con l' /headers
opzione include queste informazioni, confronta questi due (ho aggiunto il grassetto per le informazioni chiave)
PS [64] E: \ # 4> dumpbin / header C: \ Windows \ system32 \ cmd.exe Dumper Microsoft (R) COFF / PE versione 10.00.40219.01 Copyright (C) Microsoft Corporation. Tutti i diritti riservati. Dump del file C: \ Windows \ system32 \ cmd.exe Firma PE trovata Tipo di file: IMMAGINE ESECUTABILE VALORI DELL'INTESTAZIONE DEL FILE Macchina 8664 (x64) 6 numero di sezioni 4CE798E5 data e ora sab 20 nov 09:46:13 2010 0 puntatore al file nella tabella dei simboli 0 numero di simboli Dimensione F0 dell'intestazione opzionale 22 caratteristiche eseguibile L'applicazione può gestire indirizzi di grandi dimensioni (> 2 GB) [...]
e
PS [64] E: \ # 5> dumpbin / header C: \ Windows \ syswow64 \ cmd.exe Dumper Microsoft (R) COFF / PE versione 10.00.40219.01 Copyright (C) Microsoft Corporation. Tutti i diritti riservati. Dump del file C: \ Windows \ syswow64 \ cmd.exe Firma PE trovata Tipo di file: IMMAGINE ESECUTABILE VALORI DELL'INTESTAZIONE DEL FILE Macchina 14C (x86) 4 numero di sezioni 4CE78E2B data e ora sab 20 nov 09:00:27 2010 0 puntatore al file nella tabella dei simboli 0 numero di simboli Dimensione E0 dell'intestazione opzionale 102 caratteristiche eseguibile Word machine a 32 bit [...]
dumpbin /headers | findstr "machine"
semplifica notevolmente la presentazione di ciò che il QA sta cercando ...
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Se non hai o desideri l'intero Windows SDK o Visual Studio, puoi utilizzare sigcheck.exe
da SysInternals :
sigcheck.exe C:\Windows\Notepad.exe
Produzione:
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
Posso confermare che l' file
utility (ad esempio da Cygwin) distinguerà tra eseguibili a 32 e 64 bit. Appaiono come segue:
32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows
Come puoi vedere, è molto ovvio quale sia quale. Inoltre distingue tra eseguibili console e GUI, anche ovvio quale sia quale.
MZ
invece di PE
?
Un metodo semplice è eseguirlo (supponendo che sia attendibile) e dare un'occhiata alla scheda del processo in Task Manager. I processi a 32 bit mostreranno "* 32" alla fine del nome del processo. Se non è qualcosa che desideri eseguire sul tuo computer, puoi provare EXE Explorer . Mostrerà un sacco di informazioni sugli eseguibili, incluso se è a 32 o 64 bit.
main
punto di ingresso e quindi non verrà eseguita come processo autonomo. C'è una funzione di inizializzazione chiamata quando viene caricata ma non è "principale".
Molte persone hanno installato l'eccellente 7-zip e hanno aggiunto la cartella 7-Zip alla loro PATH
. 7-zip comprende formati di file diversi da ZIP e RAR, come file MSI ed eseguibili PE. Usa semplicemente la riga di comando 7z.exe
sul file PE (Exe o DLL) in questione:
7z l some.exe | more
7z l some.exe | findstr CPU
L'output includerà le righe come segue, con la CPU
riga che legge o x86
o x64
, che è ciò che viene richiesto qui:
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
un'implementazione all'interno?
La versione a 64 bit di Process Explorer può dirti. Basta eseguire il file eseguibile e aprire la finestra delle proprietà del processo. Nella scheda principale c'è una voce che dice "Immagine: 32 bit" o "Immagine: 64 bit".
Simply run the executable
E se non si desidera eseguire il programma?
Il modo più semplice (quando i dati non sono riservati)
Trovo che Virustotal File detail
sia il modo più semplice per scoprire se un binario è a 32 bit o 64 bit.
L' Additional information
opzione fornisce inoltre molte informazioni utili sul file.
Il metodo per eseguire un eseguibile e quindi il check in process explorer o uno strumento simile presenta alcuni ovvi inconvenienti:
Il metodo Dumpbin.exe può risolvere probabilmente lo scopo.
Un'altra alternativa sarebbe usare il comando file di cygwin . Tuttavia, non l'ho testato su Windows. Funziona bene su Linux.
Usage: file program_under_test.exe
EDIT: appena testato file.exe sulla finestra. funziona bene. :)
cygwin
pacchetto possono prendere il pacchetto gnuwin32file
.
file
legge semplicemente i dati dal disco in formato binario e verifica l'eventuale presenza di numeri magici che li identificano, confrontandoli con un database. I programmi di Windows a 32 bit vengono visualizzati come PE32 e i programmi a 64 bit e .NET vengono visualizzati come PE32 +. Il testimone di file
se stesso fa una differenza assolutamente nulla: sia le applicazioni a 32 che a 64 bit possono leggere i dati dal disco, che è tutto ciò di cui ha bisogno.
Ecco una soluzione Powershell, nessuna dipendenza esterna o altro. Apri Powershell, incolla la funzione lì (premi Invio due volte in modo da tornare al prompt), quindi usala come nei miei esempi sotto la funzione:
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
}
Ecco un esempio di output:
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();
dopo la chiusura? Dovrebbe rilasciare handle di file. ( stackoverflow.com/questions/1999858/… )
Anche un eseguibile contrassegnato come 32 bit può essere eseguito come 64 bit se, ad esempio, è un eseguibile .NET che può essere eseguito come 32 o 64 bit. Per maggiori informazioni consultare https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , che ha una risposta che dice che il L'utilità CORFLAGS può essere utilizzata per determinare come verrà eseguita un'applicazione .NET.
Uscita CORFLAGS.EXE
Per eseguibile a 32 bit:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x3
ILONLY : 1
32BITREQ : 1
32BITPREF : 0
Signed : 0
Per eseguibile a 64 bit:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32+
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Per eseguibili che possono essere eseguiti a 32 o 64 bit e verranno eseguiti a 64 bit quando possibile:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Per eseguibili che possono essere eseguiti a 32 o 64 bit, ma verranno eseguiti a 32 bit a meno che non vengano caricati in un processo a 64 bit:
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
)
puoi anche usare lo file
strumento dal pacchetto msys di mingw . Funziona come il comando unix. Simile funziona lo file
strumento di GNUwin32 .
Se sei su Windows 7, su Windows Explorer, fai clic con il pulsante destro del mouse sull'eseguibile e seleziona Proprietà. Nella finestra delle proprietà selezionare la scheda Compatibilità. Se nella sezione Modalità compatibilità vedi Windows XP, questo è un eseguibile a 32 bit. Se vedi Windows Vista, è a 64 bit.
Windows 8
Windows XP SP2
ma altri mostrano come Vista
o Windows 8
. Quindi questo metodo non è corretto.
Crea un file di testo chiamato exetest.reg e contenente questo codice:
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\""
Crea un file di testo chiamato x86TestStart.bat
contenente solo questa riga di codice e salvalo in C: \ temp:
c:\temp\x86or64.vbs %1
Crea un file di testo chiamato x86or64.vbs
contenente questo codice e salvalo 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
Fare doppio clic sul file exetest.reg: una nuova chiave verrà aggiunta nel registro di Windows:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Apparirà come " test a 32/64 bit " nel menu contestuale facendo clic con il tasto destro su un file eseguibile.
Facendo clic sull'elemento, verrà avviato il file batch c:\\temp\\x86TestStart.bat\
, che avvia il file VBscript x86or64.vbs
, che legge la firma exe e mostra il risultato.
Se non puoi o non vuoi manomettere il registro, copia semplicemente il file .vbs nella barra di QuickLaunch e trascina il file eseguibile su di esso.
I miei due centesimi saranno solo scaricare walker delle dipendenze e controllare cosa è stato usato per l'architettura in uno dei file eseguibili.
Basta semplicemente scaricare l'app, avviarla, fare clic sull'icona Apri → trova un file * .exe → selezionare e in fondo dopo aver eseguito la scansione della riflessione si vede una griglia con dati in cui una colonna contiene dettagli di "architettura" (x86, x64)
Apri eseguibile e vedi l'architettura di compilazione
Non l'ho visto menzionato. Esiste un programma di visualizzazione PE chiamato CFF Explorer di NTCore , che può fornirti queste informazioni. Può essere scaricato ed eseguito come portatile, ma è possibile installarlo anche, se lo si desidera.
Fai clic destro sul binario ( .exe
, .dll
ecc.) E seleziona "Apri con CFF Explorer". Vai a Intestazioni Nt -> Intestazione file -> Nel campo "Caratteristiche" fai clic su "Fai clic qui"
Se è un programma a 32 bit, la casella di controllo "Word machine a 32 bit" sarà selezionata. Ad esempio, ho installato la versione a 32 bit di Notepad ++ come puoi vedere nell'immagine qui sotto. Altrimenti, è a 64 bit.
.DMP
dump in Visual Studioi miei due centesimi: come sviluppatore C ++, walker delle dipendenze ( http://www.dependencywalker.com/ ) è molto istruttivo, non mostra solo 64/32 bit, ma anche tutte le DLL coinvolte:
Puoi vedere 64 a sinistra di ogni nome di file ...
La colonna della piattaforma nel task manager di Windows 10
Windows 7 non ha una colonna della piattaforma. Quindi il task manager di Windows 7 non lo mostrerà.
In Windows 10 la scelta delle colonne non è più in "vista". In Windows 10, nella scheda dei dettagli, fai clic con il pulsante destro del mouse sull'intestazione della colonna, quindi seleziona le colonne. Quindi selezionare la casella per "piattaforma".