¿Hay alguna manera fácil de verificar si un binario es de 32 o 64 bits en Windows? Necesito verificar antes de mover el programa a una máquina de 32 bits y experimentar una falla espectacular.

Después de examinar los valores de encabezado de la respuesta de Richard , se me ocurrió una solución que es rápida, fácil y solo requiere un editor de texto. Incluso el notepad.exe predeterminado de Windows funcionaría.

1. Abra el ejecutable en el editor de texto. Puede que tenga que arrastrar y soltar o usar el Open...cuadro de diálogo del editor , porque Windows no muestra la Open with...opción en el menú contextual para los ejecutables.

2. Verifique los primeros caracteres imprimibles después de la primera aparición de PE. Es muy probable que esta parte esté rodeada por al menos un espacio en blanco (podría ser mucho), por lo que se puede hacer fácilmente de forma visual.

Esto es lo que vas a encontrar:

x86:

PE  L

x64:

PE  d†

Una advertencia: el uso del Bloc de notas predeterminado en archivos grandes puede ser muy lento, por lo que es mejor no usarlo para archivos de más de un megabyte o pocos. En mi caso, tardé unos 30 segundos en mostrar un archivo de 12 MiB. Notepad ++, sin embargo, pudo mostrar un ejecutable de 120 MiB casi al instante.

Esta solución puede ser útil en caso de que necesite inspeccionar un archivo en una máquina en la que no puede instalar ningún software adicional.

Información adicional:

Si tiene un editor HEX disponible, el desplazamiento de PE Signature se encuentra en el desplazamiento 0x3C. La firma es PE\0\0(letras "P" y "E" seguidas de dos bytes nulos), seguidas de un tipo de máquina de dos bytes en Little Endian.

Los valores relevantes son 0x8664para x64 ejecutable y 0x14cpara x86. Hay muchos más valores posibles, pero probablemente nunca se encuentre con ninguno de estos, ni podrá ejecutar dichos ejecutables en su PC con Windows.

La lista completa de tipos de máquina, junto con el resto de especificaciones .exe se puede encontrar en la sección Tipos de máquina de especificación de Microsoft PE y COFF .

La herramienta SDK dumpbin.execon la /headersopción incluye esta información, compare estos dos (he agregado negrita para la información clave)

PS [64] E: \ # 4> basurero / encabezados C: \ Windows \ system32 \ cmd.exe
Microsoft (R) COFF / PE Dumper Versión 10.00.40219.01
Derechos de autor (C) Microsoft Corporation. Todos los derechos reservados.


Volcado del archivo C: \ Windows \ system32 \ cmd.exe

Firma de PE encontrada

Tipo de archivo: IMAGEN EJECUTABLE

VALORES DEL ENCABEZADO DE ARCHIVO
            Máquina 8664 (x64)
               6 número de secciones
        4CE798E5 sello de fecha y hora sábado 20 de noviembre 09:46:13 2010
               0 puntero de archivo a la tabla de símbolos
               0 número de símbolos
              Tamaño F0 del encabezado opcional
              22 características
                   Ejecutable
                   La aplicación puede manejar direcciones grandes (> 2GB)
[...]

y

PS [64] E: \ # 5> basurero / encabezados C: \ Windows \ syswow64 \ cmd.exe
Microsoft (R) COFF / PE Dumper Versión 10.00.40219.01
Derechos de autor (C) Microsoft Corporation. Todos los derechos reservados.


Volcado del archivo C: \ Windows \ syswow64 \ cmd.exe

Firma de PE encontrada

Tipo de archivo: IMAGEN EJECUTABLE

VALORES DEL ENCABEZADO DE ARCHIVO
             Máquina 14C (x86)
               4 número de secciones
        4CE78E2B sello de fecha y hora sáb 20 nov 09:00:27 2010
               0 puntero de archivo a la tabla de símbolos
               0 número de símbolos
              Tamaño E0 del encabezado opcional
             102 características
                   Ejecutable
                   Máquina de palabras de 32 bits
[...]

Si no tiene o no desea todo el SDK de Windows o Visual Studio, puede usarlo sigcheck.exedesde SysInternals :

sigcheck.exe C:\Windows\Notepad.exe

Salida:

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

Puedo confirmar que la fileutilidad (por ejemplo, de cygwin) distinguirá entre ejecutables de 32 y 64 bits. Aparecen de la siguiente manera:

32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows

Como puede ver, es muy obvio cuál es cuál. Además, distingue entre ejecutables de consola y GUI, también es obvio cuál es cuál.

Un método simple es ejecutarlo (suponiendo que confía en él) y echar un vistazo a la pestaña de proceso en el administrador de tareas. Los procesos de 32 bits mostrarán "* 32" al final del nombre del proceso. Si no es algo que esté dispuesto a ejecutar en su computadora, puede probar EXE Explorer . Mostrará un montón de información sobre ejecutables, incluso si es de 32 o 64 bits.

Muchas personas tienen instalado el excelente 7-zip y han agregado la carpeta 7-Zip a su PATH. 7-zip comprende formatos de archivo que no sean ZIP y RAR, como archivos MSI y ejecutables PE. Simplemente use la línea de comando 7z.exeen el archivo PE (Exe o DLL) en cuestión:

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

La salida incluirá líneas de la siguiente manera, con la CPUlectura de la línea x86o x64, que es lo que se solicita aquí:

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 versión de 64 bits de Process Explorer puede decírtelo. Simplemente ejecute el ejecutable y abra la ventana de propiedades del proceso. En la pestaña principal hay una entrada que dice "Imagen: 32 bits" o "Imagen: 64 bits".

La forma más simple (cuando los datos no son confidenciales)

Me parece que Virustotal File detail es la forma más sencilla de averiguar si un binario es de 32 bits o de 64 bits.

La Additional informationopción proporciona además mucha información útil sobre el archivo.

El método de ejecutar un ejecutable y luego registrar el explorador de procesos o una herramienta similar tiene algunos inconvenientes obvios:

1. Tenemos que ejecutar el proceso.
2. Para los procesos de corta duración (como los tipos echo hello world), el explorador de procesos podría ni siquiera registrar que un nuevo proceso ha comenzado.

El método Dumpbin.exe puede resolver el propósito probablemente.

Otra alternativa sería usar el comando de archivo de cygwin . Sin embargo, no lo he probado en Windows. Funciona bien en Linux.

Usage: file program_under_test.exe

EDITAR: Acabo de probar file.exe en la ventana. funciona bien. :)

Aquí hay una solución Powershell, sin dependencias externas ni nada. Abra Powershell, pegue la función allí (presione Entrar dos veces para volver al indicador), luego úsela como en mis ejemplos debajo de la función:

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
}

Aquí hay un ejemplo de salida:

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

Incluso un ejecutable marcado como 32 bits puede ejecutarse como 64 bits si, por ejemplo, es un ejecutable .NET que puede ejecutarse como 32 o 64 bits. Para obtener más información, consulte https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , que tiene una respuesta que dice que el La utilidad CORFLAGS se puede usar para determinar cómo se ejecutará una aplicación .NET.

Salida CORFLAGS.EXE

Para ejecutable de 32 bits:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x3
ILONLY    : 1
32BITREQ  : 1
32BITPREF : 0
Signed    : 0

Para ejecutable de 64 bits:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32+
CorFlags  : 0x1
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 0
Signed    : 0

Para el ejecutable que puede ejecutarse como 32 o 64 bits y se ejecutará como 64 bits cuando sea posible:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x1
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 0
Signed    : 0

Para el ejecutable que puede ejecutarse como 32 o 64 bits, pero se ejecutará como 32 bits a menos que se cargue en un proceso de 64 bits:

Version   : v4.0.30319
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x20003
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 1
Signed    : 0

También puede usar la fileherramienta desde el paquete msys de mingw . Funciona como el comando unix. Similar funciona la fileherramienta de GNUwin32 .

Si está en Windows 7, en un Explorador de Windows, haga clic derecho en el ejecutable y seleccione Propiedades. En la ventana de propiedades, seleccione la pestaña Compatibilidad. Si en la sección Modo de compatibilidad ve Windows XP, este es un ejecutable de 32 bits. Si ve Windows Vista, es de 64 bits.

Cómo agregar una prueba de 32/64 bits a su menú contextual

Cree un archivo de texto llamado exetest.reg y que contenga este código:

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

Cree un archivo de texto llamado que x86TestStart.batcontenga solo esta línea de código y guárdelo en C: \ temp:

c:\temp\x86or64.vbs %1

Cree un archivo de texto llamado que x86or64.vbscontenga este código y guárdelo en 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

Haga doble clic en el archivo exetest.reg: se agregará una nueva clave en el registro de Windows:

[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]

Aparecerá como " prueba de 32/64 bits " en el menú contextual al hacer clic derecho en un archivo ejecutable.

Al hacer clic en el elemento, se iniciará el archivo por lotes c:\\temp\\x86TestStart.bat\, que inicia el archivo VBscript x86or64.vbs, que lee la firma exe y muestra el resultado.

Si no puede o no quiere alterar el registro, simplemente copie el archivo .vbs en la barra de QuickLaunch y arrastre el archivo ejecutable sobre él.

Mis dos centavos serán solo descargar el caminante de dependencia y verificar qué arquitectura se ha utilizado en uno de los archivos ejecutables.

Cómo usarlo:

Simplemente descargue la aplicación, iníciela, haga clic en el ícono abrir → encuentre un archivo * .exe → seleccione y en la parte inferior después de realizar el escaneo de reflexión verá una cuadrícula con datos donde una columna tiene detalles de "arquitectura" (x86, x64)

Abra el ejecutable y vea la arquitectura de construcción

No he visto esto mencionado. Hay un programa de visualización PE llamado CFF Explorer por NTCore , que puede proporcionarle esta información. Se puede descargar y ejecutar como portátil, pero también puede instalarlo, si lo desea.

Haga clic derecho en el binario ( .exe, .dlletc.) y seleccione "Abrir con CFF Explorer". Vaya a Nt Headers -> File Header -> En el campo "Características" haga clic en "Haga clic aquí"

Si se trata de un programa de 32 bits, se marcará la casilla de verificación "máquina de palabras de 32 bits". Por ejemplo, he instalado la versión de 32 bits de Notepad ++ como puede ver en la imagen a continuación. De lo contrario, es de 64 bits.

• ejecuta la aplicación
• abrir el Administrador de tareas
• haga clic derecho y cree un archivo de volcado
• anotar camino
• ir a la ruta y abrir el .DMPvolcado en Visual Studio
• ahí tienes todos los detalles
• comprobar la arquitectura del proceso:

mis dos centavos: como desarrollador de C ++, el caminante de dependencia ( http://www.dependencywalker.com/ ) es muy informativo, no solo muestra 64/32 bits, sino también cada Dll involucrado:

Puede ver 64 a la izquierda de cada nombre de archivo ...

Sin embargo, el comando de WSLfile funciona en gran medida.

file /mnt/c/p/bin/rg.exe daría salida:

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

file /mnt/c/p/bin/u.exe daría salida:

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

La columna de plataforma en el administrador de tareas de windows 10

Windows 7 no tiene una columna de plataforma. Entonces el administrador de tareas de Windows 7 no lo mostrará.

En Windows 10, la elección de columnas ya no está en 'vista'. En Windows 10, cuando está en la pestaña de detalles, hace clic derecho en el encabezado de la columna y luego 'selecciona columnas'. Luego marque la casilla 'plataforma'.