Esiste un modo semplice per verificare se un binario è a 32 o 64 bit su Windows? Devo controllare prima di spostare il programma su una macchina a 32 bit e sperimentare un guasto spettacolare.
Dopo aver esaminato i valori delle intestazioni della risposta di Richard , ho trovato una soluzione che è veloce, facile e richiede solo un editor di testo. Anche il blocco note.exe predefinito di Windows funzionerebbe.
Open... dell'editor, perché Windows non mostra l'opzione Open with... nel menu contestuale per gli eseguibili. Aprire l'eseguibile nel menu contestuale. 2. Controllare i primi caratteri stampabili dopo la prima occorrenza di PE. Questa parte è molto probabilmente circondata da almeno alcuni spazi bianchi (potrebbero essere molti), quindi può essere facilmente eseguita visivamente.
Ecco cosa troverete:
PE L
PE d†
``` &001
** Una parola di avvertimento:** usando il blocco note predefinito sui file grandi può essere molto lento, quindi meglio non usarlo per file più grandi di 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 si debba ispezionare un file su una macchina su cui non è possibile installare alcun software aggiuntivo.
# Informazioni aggiuntive:
Se si dispone di un HEX-Editor, l'offset di PE Signature si trova all'offset `0x3C`. La firma è `PE`0x8664``0x014c`` (lettere "P" ed "E" seguite da due byte nulli), seguite da un tipo di macchina a due byte in Little Endian.
I valori rilevanti sono `64 86` per un eseguibile a 64 bit e `4c 01` per un eseguibile a 32 bit (&007 e &007 rispettivamente se regolato per l'endianness, ma qualsiasi editor hex decente gestirà automaticamente l'endianness quando si cerca un valore hex). Ci sono molti più valori possibili, ma probabilmente non incontrerete mai nessuno di questi, o sarete in grado di eseguire tali eseguibili sul vostro PC Windows.
L'elenco completo dei tipi di macchina, insieme al resto delle specifiche .exe, può essere trovato nella sezione [ Microsoft PE e COFF Specification ](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680547%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396#machine_types) **Tipi di macchina**.
Lo strumento SDK dumpbin.exe con l'opzione /headers include queste informazioni, confrontare questi due (ho aggiunto il grassetto per le informazioni chiave)
PS [64] E:\ #4\> dumpbin /headers C:\Windows\system32\cmd.exe Microsoft (R) COFF/PE Dumper Version 10.00.40219.01 Copyright (C) Microsoft Corporation. All rights reserved. Dump of file C:\Windows\system32\cmd.exe PE signature found File Type: EXECUTABLE IMAGE FILE HEADER VALUES **8664 machine (x64)** 6 number of sections 4CE798E5 time date stamp Sat Nov 20 09:46:13 2010 0 file pointer to symbol table 0 number of symbols F0 size of optional header 22 characteristics Executable Application can handle large (\>2GB) addresses [...]
e
PS [64] E:\ #5\> dumpbin /headers C:\Windows\syswow64\cmd.exe Microsoft (R) COFF/PE Dumper Version 10.00.40219.01 Copyright (C) Microsoft Corporation. All rights reserved. Dump of file C:\Windows\syswow64\cmd.exe PE signature found File Type: EXECUTABLE IMAGE FILE HEADER VALUES **14C machine (x86)** 4 number of sections 4CE78E2B time date stamp Sat Nov 20 09:00:27 2010 0 file pointer to symbol table 0 number of symbols E0 size of optional header 102 characteristics Executable 32 bit word machine [...]
Se non si dispone o non si desidera l'intero Windows SDK o Visual Studio, è possibile utilizzare sigcheck.exe di SysInternals :
sigcheck.exe C:\Windows\Notepad.exe
Uscita:
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'utilità file (ad es. di cygwin) distinguerà tra eseguibili a 32 e 64 bit. Essi appaiono come segue:
32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows
``` &001
Come si può vedere, è molto ovvio quale sia quale. Inoltre distingue tra eseguibili da console e GUI, è ovvio anche quale sia quale.
Un metodo semplice è quello di eseguirlo (supponendo che ci si fidi) e dare un'occhiata alla scheda del processo nel task manager. I processi a 32 bit mostreranno “* 32” alla fine del nome del processo. Se non è qualcosa che si desidera eseguire sul proprio computer si può provare EXE Explorer . Mostrerà tutta una serie di informazioni sugli eseguibili, incluso se è a 32 o 64bit.
Molte persone hanno installato l'eccellente 7-zip e hanno aggiunto la cartella 7-Zip al loro PATH. 7-zip capisce formati di file diversi da ZIP e RAR, come i file MSI e gli eseguibili PE. Basta usare 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'uscita includerà le righe come segue, con la riga CPU che legge o x86 o x64, che è quello che viene chiesto 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
La versione a 64 bit di Process Explorer può dirvelo. Basta eseguire l'eseguibile e aprire la finestra delle proprietà del processo. Sulla scheda principale c'è una voce che dice “Image:32 Bit” o “Image:64 Bit”.
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 a 64 bit.
L'opzione Additional information fornisce in aggiunta molte informazioni utili sul file.
Il metodo di esecuzione di un eseguibile e poi il controllo in process explorer o strumento simile, ha alcuni ovvi svantaggi:
Il metodo Dumpbin.exe può risolvere probabilmente lo scopo.
Un'altra alternativa sarebbe quella di usare il comando file di cygwin. Tuttavia, non l'ho testato su Windows. Funziona bene su Linux.
Usage: file program_under_test.exe
``` &001
EDIT: appena testato file.exe su window. funziona bene. :)
Ecco una soluzione Powershell, nessuna dipendenza esterna o altro. Aprite Powershell, incollate la funzione lì dentro (premete due volte Enter in modo da tornare al prompt), poi usatela 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 l'uscita di esempio:
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
Anche un eseguibile marcato come 32-bit può funzionare come 64-bit se, per esempio, è un eseguibile .NET che può funzionare come 32- o 64-bit. Per ulteriori informazioni si veda 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 l'utility CORFLAGS può essere utilizzata per determinare come verrà eseguita un'applicazione .NET.
CORFLAGS. Uscita 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
``` ```
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Per eseguibile che può funzionare a 32 o 64 bit e funzionerà a 64 bit quando possibile:
Version : v4.0.30319
CLR Header: 2.5
PE : PE32
CorFlags : 0x20003
ILONLY : 1
32BITREQ : 0
32BITPREF : 1
Signed : 0
Per eseguibile che può funzionare a 32 o 64 bit, ma funzionerà a 32 bit a meno che non sia caricato in un processo a 64 bit:
&001
I miei due centesimi saranno solo scaricare dependency walker e controllare cosa per l'architettura è stato usato in uno dei file eseguibili.
Basta semplicemente scaricare l'applicazione, avviarla, cliccare sull'icona aperta → trovare un *. exe file → selezionare e nella parte inferiore dopo che la scansione di riflessione è stata fatta si vede una griglia con i dati dove una colonna ha i dettagli dell’“architettura” (x86, x64)
Apri l'eseguibile e vedi la build architecture
Se vi trovate su Windows 7, in Esplora risorse, cliccate con il tasto destro del mouse sull'eseguibile e selezionate Proprietà. Nella finestra delle proprietà selezionare la scheda Compatibilità. Se nella sezione Modalità compatibilità si vede Windows XP, questo è un eseguibile a 32 bit. Se vedete Windows Vista, è a 64 bit.
è anche possibile utilizzare l'utensile file dall'interno del pacchetto msys bundle di mingw . Funziona come il comando unix. Simile funziona il tool file di GNUwin32 .
Creare 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\""
``` ```
c:\temp\x86or64.vbs %1
Creare un file di testo denominato x86TestStart.bat contenente solo questa riga di codice e salvarlo 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
``` ```
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Creare un file di testo denominato x86or64.vbs contenente questo codice e salvarlo in C:\temp:
&001
Doppio clic su exetest. file di registro: una nuova chiave verrà aggiunta nel registro di Windows:
&001 &001
Appare come “ 32/64 bit test” nel menu contestuale cliccando con il tasto destro del mouse su un file eseguibile.
Cliccando sulla voce si aprirà il file batch `c:\temp\x86TestStart.bat# Come aggiungere un test a 32/64 bit al vostro menu contestuale
Creare 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\""
``` ```
c:\temp\x86or64.vbs %1
Creare un file di testo denominato x86TestStart.bat contenente solo questa riga di codice e salvarlo 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
``` ```
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Creare un file di testo denominato x86or64.vbs contenente questo codice e salvarlo in C:\temp:
&001
Doppio clic su exetest. file di registro: una nuova chiave verrà aggiunta nel registro di Windows:
&001 &001
Appare come “ 32/64 bit test” nel menu contestuale cliccando con il tasto destro del mouse su un file eseguibile.
Cliccando sulla voce si aprirà il file batch , che avvia il file VBscript x86or64.vbs , che legge la firma exe e mostra il risultato.
Se non si può o non si vuole manomettere il registro di sistema, basta copiare il file .vbs nella barra QuickLaunch, e trascinare l'eseguibile su di esso.
Eppure, il comando WSL &003 file funziona molto.
file /mnt/c/p/bin/rg.exe produrrebbe:
/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows
file /mnt/c/p/bin/u.exe produrrebbe:
/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed
Non ne ho mai sentito parlare. Esiste un programma di visualizzazione PE chiamato CFF Explorer di NTCore , che può fornire queste informazioni. Può essere scaricato ed eseguito come portatile, ma si può anche installare, se lo si desidera.
Cliccare con il tasto destro del mouse sul binario (.exe, .dll ecc.) e selezionare “Apri con CFF Explorer”. Vai a Nt Headers -> File Header -> Nel campo “Characteristics” clicca “Click here”
Se si tratta di un programma a 32 bit, la casella “32 bit word machine” sarà spuntata. Per esempio, ho installato la versione a 32 bit di Notepad++ come potete vedere nell'immagine qui sotto. Altrimenti, è a 64bit.
i miei due centesimi: come sviluppatore C++, dependency walker http://www.dependencywalker.com/ ) è molto informativo, non solo visualizza 64/32 bit, ma anche ogni Dll coinvolto:
Si possono 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 la mostrerà.
In windows 10 la scelta delle colonne non è più sotto ‘vista’. In Windows 10, quando nella scheda dei dettagli, si clicca con il tasto destro del mouse sull'intestazione della colonna e poi ‘seleziona colonne’. Poi spuntate la casella per ‘piattaforma’.
.DMP dump in Visual Studio