Usuario del software
2011-11-17 10:29:58 +0000 2011-11-17 10:29:58 +0000

Respuestas [20]

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

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.

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

  2. 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:

32-bit:

PE L

64-bit:

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.

Información 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.

377
129
2011-11-17 12:14:43 +0000

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

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

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.

46
33
2011-11-17 10:39:49 +0000

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.

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

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

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

enter image description here

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

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.

Virustotal analysis


![Virustotal TrID

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

El método de ejecutar un ejecutable y luego comprobar en proceso explorador o herramienta similar, tiene algunos inconvenientes obvios:

  1. Tenemos que ejecutar el proceso.
  2. Para los procesos de corta duración (como los tipos de eco hola mundo.), 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 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. :)

14
13
2015-03-19 12:09:30 +0000

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

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
9
6
2016-06-14 00:19:11 +0000

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.

Cómo usarlo:

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

dependency walker screenshot

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

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.

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

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

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

Sin embargo, el comando file de WSL funciona en gran medida.

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

/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows
2
2
2017-02-01 22:27:17 +0000

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.

enter image description here

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

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:enter image description here

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

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

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

enter image description here

enter image description here

0
0
2015-03-19 11:39:51 +0000
  • Ejecuta la aplicación
  • abre el Administrador de Tareas
  • haz clic con el botón derecho del ratón y crea el archivo de volcado
  • anota la ruta
  • ve a la ruta y abre .DMP volcado en Visual Studio
  • allí obtienes todos los detalles
  • comprueba la arquitectura del proceso:
0