¿Existe una forma fácil de comprobar si un binario es de 32 o 64 bits en Windows? Necesito comprobarlo antes de mover el programa a una máquina de 32 bits y experimentar un fallo espectacular.
Después de examinar los valores de los encabezados de la respuesta de Richard, se me ocurrió una solución que es rápida, fácil y sólo requiere un editor de texto. Incluso el notepad.exe por defecto de Windows funcionaría.
Abrir el ejecutable en el editor de texto. Puede que tengas que arrastrar y soltar o usar el diálogo Open... del editor, porque Windows no muestra la opción Open with... en el menú contextual de los ejecutables.
Compruebe los primeros caracteres imprimibles después de la primera aparición de PE. Lo más probable es que esta parte esté rodeada de al menos algunos espacios en blanco (podrían ser muchos), por lo que se puede hacer fácilmente de forma visual.
Esto es lo que vas a encontrar:
PE L
PE d†
Una palabra de advertencia: usar el Notepad por defecto en archivos grandes puede ser muy lento, así que mejor no lo uses para archivos más grandes que un megabyte o pocos. En mi caso en tomó cerca de 30 segundos para mostrar un archivo de 12 MiB. Notepad++, sin embargo, fue capaz de mostrar un ejecutable de 120 MiB casi instantáneamente.
Esta es una solución que 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 hexadecimal disponible, el desplazamiento de la firma PE se encuentra en el desplazamiento 0x3C. La firma es PE0x86640x014c (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 64 86 para un ejecutable de 64 bits y 4c 01 para uno de 32 bits (&007 y &007 respectivamente cuando se ajusta para la “endianidad”, pero cualquier editor hexadecimal decente manejará automáticamente la “endianidad” cuando busque un valor hexadecimal). Hay muchos más valores posibles, pero probablemente nunca encontrarás ninguno de ellos, o serás capaz de ejecutar tales ejecutables en tu PC con Windows.
La lista completa de tipos de máquinas, junto con el resto de especificaciones .exe, se puede encontrar en la sección Especificaciones de Microsoft PE y COFF Tipos de máquinas.
La herramienta SDK dumpbin.exe con la opción /headers incluye esta información, compara estos dos (he añadido la negrita para la información clave)
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 [...]
y
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 [...]
Si no tienes o quieres todo el SDK de Windows o Visual Studio, puedes usar sigcheck.exe de 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 utilidad file (por ejemplo de cygwin) distinguirá entre los 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 pueden ver, es muy obvio cuál es cuál. Además distingue entre los ejecutables de consola y los de la interfaz gráfica de usuario, también es obvio cuál es cuál.
Un método sencillo es ejecutarlo (suponiendo que confíes en él) y echar un vistazo a la pestaña de proceso en el gestor de tareas. Los procesos de 32 bits mostrarán “* 32” al final del nombre del proceso. Si no es algo que quieras ejecutar en tu ordenador puedes probar con EXE Explorer . Mostrará un montón de información sobre los ejecutables, incluyendo si es de 32 o 64 bits.
Mucha gente tiene el excelente 7-zip instalado, y han añadido la carpeta 7-Zip a su PATH. 7-zip entiende otros 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á las líneas como sigue, con la línea CPU leyendo ya sea x86 o x64, que es lo que se pregunta 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írselo. Simplemente ejecute el ejecutable y abra la ventana de propiedades del proceso. En la pestaña principal hay una entrada que dice “Imagen:32 Bit” o “Imagen:64 Bit”.
La forma más simple (cuando los datos no son confidenciales)
Encuentro que Virustotal File detail es la forma más simple de averiguar si un binario es de 32 o 64 bits.
La opción Additional information proporciona además mucha información útil sobre el archivo.
El método de ejecutar un ejecutable y luego comprobar en proceso explorador o herramienta similar, tiene algunos inconvenientes obvios:
El método Dumpbin.exe puede resolver el propósito probablemente.
Otra alternativa sería usar el comando fichero de cygwin. Sin embargo, no lo he probado en Windows. Funciona bien en Linux.
Usage: file program_under_test.exe
EDITAR: Acabo de probar el archivo.exe en windows. funciona bien. :)
Aquí hay una solución Powershell, sin dependencias externas ni nada. Abra Powershell, pegue la función ahí (pulse Enter dos veces para volver al aviso), y 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í está el 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 de 32 bits puede funcionar como de 64 bits si, por ejemplo, es un ejecutable .NET que puede funcionar como de 32 o 64 bits. Para más información ver 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 la utilidad CORFLAGS puede ser usada para determinar cómo se ejecutará una aplicación .NET.
CORFLAGS. Salida EXE
Para el 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 el 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 funcionar 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 funcionar 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
Mis dos centavos serán sólo descargar caminante de dependencia y comprobar lo que para la arquitectura se ha utilizado en uno de los archivos ejecutables.
Sólo tienes que descargar la aplicación, iniciarla, hacer clic en el icono de apertura → encontrar un *. archivo exe → seleccionar y en la parte inferior después de la reflexión se hace el análisis se ve una cuadrícula con los datos donde una columna tiene detalles de “arquitectura” en ella (x86, x64)
Abrir el ejecutable y ver la arquitectura de construcción
Si está en Windows 7, en un Explorador de Windows, haga clic con el botón derecho del ratón en el ejecutable y seleccione Propiedades. En la ventana de propiedades selecciona la pestaña Compatibilidad. Si en la sección Modo de Compatibilidad ves Windows XP, este es un ejecutable de 32 bits. Si ves Windows Vista, es de 64 bits.
también puedes usar la herramienta file desde dentro del msys bundle of mingw . Funciona como el comando unix. Funciona de manera similar a la herramienta file de GNUwin32 .
Crear 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\""
Crear un archivo de texto llamado x86TestStart.bat que contenga sólo esta línea de código y guardarlo en C:\temp:
c:\temp\x86or64.vbs %1
Crear un archivo de texto llamado x86or64.vbs que contenga este código y guardarlo 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
Doble click en exetest. reg file: se añadirá una nueva clave en el registro de Windows:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Aparecerá como “ 32/64 bit test” en el menú contextual al hacer clic con el botón derecho del ratón en un archivo ejecutable.
Al hacer clic en el elemento se iniciará el archivo batch `c:\temp\x86TestStart.bat# Cómo añadir 32/64 bit test a tu menú contextual
Crear 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\""
Crear un archivo de texto llamado x86TestStart.bat que contenga sólo esta línea de código y guardarlo en C:\temp:
c:\temp\x86or64.vbs %1
Crear un archivo de texto llamado x86or64.vbs que contenga este código y guardarlo 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
Doble click en exetest. reg file: se añadirá una nueva clave en el registro de Windows:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Aparecerá como “ 32/64 bit test” en el menú contextual al hacer clic con el botón derecho del ratón en un archivo ejecutable.
Al hacer clic en el elemento se iniciará el archivo batch , que inicia el archivo VBscript x86or64.vbs , que lee la firma exe y muestra el resultado.
Si no puede o no quiere manipular el registro, simplemente copie el archivo .vbs en la barra de inicio rápido y arrastre el ejecutable sobre él.
No he visto que se mencione esto. Hay un programa visor de PE llamado CFF Explorer de NTCore , que puede proporcionarle esta información. Puede ser descargado y ejecutado como portátil, pero también puede instalarlo, si lo desea.
Haga clic con el botón derecho del ratón en el binario (.exe, .dll etc.) y seleccione “Abrir con CFF Explorer”. Ve a Nt Headers -> File Header -> En el campo “Characteristics” haz clic en “Click here”
Si es un programa de 32 bits, la casilla “32 bit word machine” estará marcada. Por ejemplo, he instalado la versión de 32 bits de Notepad++ como puedes ver en la imagen de abajo. De lo contrario, es de 64 bits.
mis dos centavos: como desarrollador de C++, el caminador de dependencias http://www.dependencywalker.com/ ) es muy informativo, no sólo muestra 64/32 bits, sino también cada Dll involucrado:
Puedes ver 64 a la izquierda de cada nombre de archivo…
La columna de plataforma en el administrador de tareas de Windows 10
Windows 7 no tiene una columna de plataforma. Así que el administrador de tareas de Windows 7 no la mostrará.
En Windows 10 la elección de las columnas ya no está en “ver”. En Windows 10, cuando estés en la pestaña de detalles, haz clic con el botón derecho del ratón en el encabezado de la columna y luego en “seleccionar columnas”. A continuación, marca la casilla “plataforma”.
.DMP volcado en Visual Studio