¿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.
¿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.
Respuestas:
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.
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.
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:
PE L
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.
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 0x8664
para x64 ejecutable y 0x14c
para 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 .
Microsoft PE and COFF Specification
, que es un contrato documentado, así como instrucciones sobre cómo encontrar la dirección exacta del encabezado PE en cualquier .exe
archivo Si tiene una fuente más confiable que la especificación oficial de Microsoft en el formato ejecutable de Microsoft, me encantaría saber de qué se trata.
La herramienta SDK dumpbin.exe
con la /headers
opció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 [...]
dumpbin /headers | findstr "machine"
en gran medida simplifica la presentación de lo que el control de calidad está buscando ...
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Si no tiene o no desea todo el SDK de Windows o Visual Studio, puede usarlo sigcheck.exe
desde 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 file
utilidad (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.
MZ
lugar de PE
?
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.
main
punto de entrada y, por lo tanto, no se ejecutará como un proceso independiente. Hay una función de inicialización llamada cuando se carga pero que no es "principal".
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.exe
en 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 CPU
lectura de la línea x86
o 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
file
implementación dentro?
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".
Simply run the executable
¿Y qué pasa si no quieres ejecutar el programa?
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 information
opció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:
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. :)
cygwin
paquete completo pueden obtener el paquete gnuwin32file
.
file
simplemente lee los datos del disco en formato binario y comprueba los números mágicos que los identifican, comparándolos con una base de datos. Los programas de Windows de 32 bits aparecen como PE32, y los programas de 64 bits y .NET aparecen como PE32 +. El bitness en file
sí mismo no hace absolutamente ninguna diferencia: tanto las aplicaciones de 32 bits como las de 64 bits pueden leer datos del disco, que es todo lo que necesita.
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
$stream.dispose();
después del cierre? Debería liberar los identificadores de archivo. ( stackoverflow.com/questions/1999858/… )
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
corflags : error CF008 : The specified file does not have a valid managed header
)
También puede usar la file
herramienta desde el paquete msys de mingw . Funciona como el comando unix. Similar funciona la file
herramienta 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.
Windows 8
Windows XP SP2
pero otros se muestran como Vista
o Windows 8
. Entonces este método no es correcto.
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.bat
contenga 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.vbs
contenga 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.
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
, .dll
etc.) 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.
.DMP
volcado en Visual Studiomis 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'.