2011-11-17 10:29:58 +0000 2011-11-17 10:29:58 +0000
341
341

Come verificare se un binario è a 32 o 64 bit su Windows?

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.

Risposte (20)

377
377
377
2015-03-13 17:08:57 +0000

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.

    1. Aprire l'eseguibile nell'editor di testo. Potrebbe essere necessario trascinare o usare la finestra di dialogo Open... dell'editor, perché Windows non mostra l'opzione Open with... nel menu contestuale per gli eseguibili.
  1. 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:

32-bit:

PE L

64-bit:

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**.
129
129
129
2011-11-17 12:14:43 +0000

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 [...]
50
50
50
2014-09-06 15:02:25 +0000

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
46
46
46
2014-01-17 02:08:47 +0000

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.
33
33
33
2011-11-17 10:39:49 +0000

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.

28
28
28
2015-10-04 10:56:52 +0000

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
21
21
21
2011-11-17 13:36:05 +0000

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

17
17
17
2015-01-05 16:53:58 +0000

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.


![Virustotal TrID

14
14
14
2012-09-27 07:08:26 +0000

Il metodo di esecuzione di un eseguibile e poi il controllo in process explorer o strumento simile, ha alcuni ovvi svantaggi:

  1. Dobbiamo eseguire il processo.
  2. Per i processi di breve durata (come i tipi di mondo echo hello.), process explorer potrebbe anche non registrare che un nuovo processo è iniziato.

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. :)
13
13
13
2015-03-19 12:09:30 +0000

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
9
9
9
2015-10-07 15:32:36 +0000

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

6
6
6
2016-06-14 00:19:11 +0000

I miei due centesimi saranno solo scaricare dependency walker e controllare cosa per l'architettura è stato usato in uno dei file eseguibili.

Come usarlo:

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

5
5
5
2015-05-06 08:51:55 +0000

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.

5
5
5
2015-01-05 13:54:17 +0000

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

5
5
5
2016-01-16 11:20:03 +0000

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

2
2
2
2017-10-10 00:41:35 +0000

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
2
2
2
2017-02-01 22:27:17 +0000

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.

1
1
1
2017-09-28 07:37:39 +0000

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…

0
0
0
2019-08-02 22:55:25 +0000

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

0
0
0
2015-03-19 11:39:51 +0000
  • eseguire l'applicazione
  • aprire Task Manager
  • fare clic con il tasto destro del mouse e creare il file dump
  • annotare il percorso
  • andare al percorso e aprire .DMP dump in Visual Studio
  • lì si ottengono tutti i dettagli
  • controllare l'architettura del processo: