Existe uma forma fácil de verificar se um binário é 32 ou 64 bits no Windows? Preciso de verificar antes de mover o programa para uma máquina de 32 bits e experimentar uma falha espectacular.
Após examinar os valores do cabeçalho de Richard’s answer , cheguei a uma solução que é rápida, fácil e requer apenas um editor de texto. Mesmo o notepad.exe padrão do Windows funcionaria.
Open..., porque o Windows não mostra a opção Open with... no menu de contexto para executáveis. Verifique os primeiros caracteres imprimíveis após a primeira ocorrência do PE. É muito provável que esta parte esteja rodeada de pelo menos alguns espaços em branco (pode ser muito), para que possa ser feita visualmente com facilidade.
Aqui está o que vai encontrar:
PE L
PE d†
Uma palavra de aviso: usando o Bloco de Notas padrão em ficheiros grandes pode ser muito lento, por isso é melhor não o usar para ficheiros maiores do que um megabyte ou poucos. No meu caso, demorou cerca de 30 segundos a mostrar um ficheiro de 12 MiB. O Notepad++, no entanto, foi capaz de mostrar um executável de 120 MiB quase instantaneamente.
Esta solução pode ser útil no caso de ter de inspeccionar um ficheiro numa máquina onde não possa instalar qualquer software adicional.
Se tiver um HEX-Editor disponível, o offset do PE Signature está localizado no offset 0x3C. A assinatura é PE0x86640x014c (letras “P” e “E” seguidas de dois bytes nulos), seguida de um tipo de máquina de dois bytes em Little Endian.
Os valores relevantes são 64 86 para um executável de 64 bits e 4c 01 para um executável de 32 bits (&007 e &007, respectivamente, quando ajustado para endianness, mas qualquer editor hexadecimal decente lidará automaticamente com endianness quando procurar por um valor hexadecimal). Existem muito mais valores possíveis, mas provavelmente nunca encontrará nenhum destes, ou será capaz de executar tais executáveis no seu PC Windows.
A lista completa dos tipos de máquinas, juntamente com o resto das especificações .exe, pode ser encontrada em Microsoft PE e COFF Specification Machine Types section.
A ferramenta SDK dumpbin.exe com a opção /headers inclui esta informação, compare estas duas (adicionei negrito para a informação chave)
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 [...]
Se não tem ou não quer todo o Windows SDK ou Visual Studio, pode usar sigcheck.exe da SysInternals :
sigcheck.exe C:\Windows\Notepad.exe
Saída:
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
Posso confirmar que a utilidade file (por exemplo, do cygwin) distinguirá entre executáveis de 32 e 64 bits. Eles aparecem da seguinte forma:
32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows
Como pode ver, é muito óbvio qual é qual. Adicionalmente distingue entre os executáveis de consola e GUI, também é óbvio qual é qual.
Um método simples é executá-lo (assumindo que você confia nele) e dar uma olhada no separador processo no gestor de tarefas. Os processos de 32 bits mostrarão “* 32” no final do nome do processo. Se não é algo que esteja disposto a executar no seu computador pode tentar EXE Explorer . Irá mostrar um monte de informações sobre executáveis, incluindo se é 32 ou 64bit.
Muitas pessoas têm o excelente 7-zip instalado, e adicionaram a pasta 7-Zip ao seu PATH. O 7-zip compreende outros formatos de ficheiros além do ZIP e RAR, tais como ficheiros MSI e executáveis PE. Basta usar a linha de comando 7z.exe no ficheiro PE (Exe ou DLL) em questão:
7z l some.exe | more
7z l some.exe | findstr CPU
A saída incluirá as seguintes linhas, com a leitura da linha CPU ou x86, que é o que está a ser pedido aqui:
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
A versão de 64 bits do Process Explorer pode dizer-lhe. Basta executar o executável e abrir a janela de propriedades do processo. No separador principal existe uma entrada que diz “Image:32 Bit” ou “Image:64 Bit”.
A forma mais simples (quando os dados não são confidenciais)
Descobri que Virustotal File detail é a forma mais simples de descobrir se um binário é 32 bit ou 64 bit.
A opção Additional information fornece, além disso, informações muito úteis sobre o ficheiro.
O método de executar um executável e depois verificar no explorador de processos ou ferramenta similar, tem alguns inconvenientes óbvios:
O método Dumpbin.exe pode resolver o propósito provavelmente.
Outra alternativa seria usar o comando cygwin’s file. No entanto, ainda não o testei no windows. Funciona bem em Linuxes.
Usage: file program_under_test.exe
EDIT: Apenas o ficheiro.exe testado em window. funciona bem. :)
Aqui está uma solução Powershell, sem dependências externas nem nada. Abra Powershell, cole a função ali (pressione Enter duas vezes para voltar ao prompt), depois use-a como nos meus exemplos abaixo da função:
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
}
Aqui está o exemplo de saída:
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
Mesmo um executável marcado como 32-bit pode correr como 64-bit se, por exemplo, for um executável .NET que pode correr como 32- ou 64-bit. Para mais informações veja https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , que tem uma resposta que diz que o utilitário CORFLAGS pode ser usado para determinar como uma aplicação .NET irá correr.
CORFLAGS. EXE output
Para executáveis de 32 bits:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x3
ILONLY : 1
32BITREQ : 1
32BITPREF : 0
Signed : 0
Para executáveis de 64 bits:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32+
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Para executáveis que podem correr como 32 ou 64 bits e que correrão como 64 bits quando possível:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Para executáveis que podem correr como 32 ou 64 bits, mas que correrão como 32 bits a menos que sejam carregados num processo de 64 bits:
Version : v4.0.30319
CLR Header: 2.5
PE : PE32
CorFlags : 0x20003
ILONLY : 1
32BITREQ : 0
32BITPREF : 1
Signed : 0
Os meus dois cêntimos serão apenas para download dependency walker e verifique o que para arquitectura foi utilizado num dos ficheiros executáveis.
Basta descarregar a aplicação, iniciá-la, clicar no ícone aberto → encontrar um *. exe file → seleccione e no fundo depois de fazer o scan de reflexão veja uma grelha com dados onde uma coluna tem detalhes de “arquitectura” (x86, x64)
Abra o executável e veja a arquitectura de construção
Se você estiver no Windows 7, em um Windows Explorer, clique com o botão direito do mouse no executável e selecione Propriedades. Na janela de propriedades seleccione o separador Compatibilidade. Se na secção Modo Compatibilidade vir o Windows XP, este é um executável de 32 bits. Se vir o Windows Vista, é um executável de 64 bits.
também pode utilizar a ferramenta file do pacote msys de mingw . Funciona como o comando unix. Funciona da mesma forma que a ferramenta file de GNUwin32 .
Criar um ficheiro de texto com o nome exetest. reg e contendo 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\""
Crie um ficheiro de texto com o nome x86TestStart.bat contendo apenas esta linha de código e guarde-o em C:\temp:
c:\temp\x86or64.vbs %1
Criar um ficheiro de texto com o nome x86or64.vbs contendo este código e guarde-o em 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
Clique duas vezes no exetest. reg file: será adicionada uma nova chave no registo do windows:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Aparecerá como “ 32/64 bit test” no menu de contexto ao clicar com o botão direito do rato sobre um ficheiro executável.
Clicando no item resultará em iniciar o ficheiro de lote `c:\temp\x86TestStart.bat# Como adicionar 32/64 bit teste ao seu menu de contexto
Criar um ficheiro de texto com o nome exetest. reg e contendo 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\""
Crie um ficheiro de texto com o nome x86TestStart.bat contendo apenas esta linha de código e guarde-o em C:\temp:
c:\temp\x86or64.vbs %1
Criar um ficheiro de texto com o nome x86or64.vbs contendo este código e guarde-o em 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
Clique duas vezes no exetest. reg file: será adicionada uma nova chave no registo do windows:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Aparecerá como “ 32/64 bit test” no menu de contexto ao clicar com o botão direito do rato sobre um ficheiro executável.
Clicando no item resultará em iniciar o ficheiro de lote , que inicia o ficheiro VBscript x86or64.vbs , que lê a assinatura do exe e mostra o resultado.
Se não pode ou não quer mexer no registo, basta copiar o ficheiro .vbs na barra QuickLaunch, e arrastar o executável sobre ele.
No entanto, o comando WSL ’s file funciona muito.
file /mnt/c/p/bin/rg.exe sairia:
/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows
file /mnt/c/p/bin/u.exe sairia:
/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed
Ainda não vi isto mencionado. Existe um programa de visualização do PE chamado CFF Explorer da NTCore , que lhe pode fornecer esta informação. Pode ser descarregado e correr como portátil, mas também pode instalá-lo, se desejar.
Clique com o botão direito no binário (.exe, .dll etc.) e seleccione “Abrir com CFF Explorer”. Vá para Nt Headers -> File Header -> No campo “Characteristics” clique em “Click here”
Se for um programa de 32bit, a caixa de verificação “32 bit word machine” será assinalada. Por exemplo, eu instalei a versão 32bit do Notepad++ como pode ver na imagem abaixo. Caso contrário, é 64bit.
os meus dois cêntimos: como desenvolvedor C++, o andarilho de dependência http://www.dependencywalker.com/ ) é muito informativo, não só mostra 64/32 bits, mas também todos os Dll envolvidos:
Pode ver 64 à esquerda de cada nome de ficheiro…
A coluna da plataforma no gestor de tarefas do Windows 10
Windows 7 não tem uma coluna de plataforma. Por isso o gestor de tarefas do Windows 7 não a mostra.
No Windows 10 a escolha das colunas já não se encontra em ‘view’. No Windows 10, quando no separador de detalhes, clique com o botão direito do rato no cabeçalho da coluna e depois em ‘select columns’ (seleccionar colunas). Depois marque a caixa ‘plataforma’.
.DMP dump no Visual Studio