Existe uma maneira fácil de verificar se um binário é de 32 ou 64 bits no Windows? Preciso verificar antes de mover o programa para uma máquina de 32 bits e experimentar uma falha espetacular.
Existe uma maneira fácil de verificar se um binário é de 32 ou 64 bits no Windows? Preciso verificar antes de mover o programa para uma máquina de 32 bits e experimentar uma falha espetacular.
Respostas:
Depois de examinar os valores dos cabeçalhos da resposta de Richard , criei uma solução que é rápida, fácil e requer apenas um editor de texto. Até o notepad.exe padrão do Windows funcionaria.
Abra o executável no editor de texto. Pode ser necessário arrastar e soltar ou usar a Open...
caixa de diálogo do editor , porque o Windows não mostra a Open with...
opção no menu de contexto para executáveis.
Verifique os primeiros caracteres imprimíveis após a primeira ocorrência de PE
. É provável que esta parte esteja cercada por pelo menos algum espaço em branco (pode ser muito), para que possa ser feita facilmente visualmente.
Aqui está o que você encontrará:
PE L
PE d†
Uma palavra de aviso: o uso do bloco de notas padrão em arquivos grandes pode ser muito lento, por isso é melhor não usá-lo para arquivos maiores que um megabyte ou poucos. No meu caso, demorou cerca de 30 segundos para exibir um arquivo de 12 MiB. O Notepad ++, no entanto, conseguiu exibir um executável de 120 MiB quase instantaneamente.
Essa solução pode ser útil caso você precise inspecionar um arquivo em uma máquina na qual não possa instalar nenhum software adicional.
Se você tiver um editor HEX disponível, o deslocamento da assinatura do PE estará localizado no deslocamento 0x3C
. A assinatura é PE\0\0
(letras "P" e "E" seguidas por dois bytes nulos), seguidas por um Tipo de máquina de dois bytes em Little Endian.
Os valores relevantes são 0x8664
para executável x64 e 0x14c
x86. Existem muito mais valores possíveis, mas você provavelmente nunca encontrará nenhum desses, nem poderá executar esses executáveis no seu PC com Windows.
A lista completa de tipos de máquinas, juntamente com o restante das especificações .exe, pode ser encontrada na seção Tipos de Máquinas de Especificação do Microsoft PE e COFF .
Microsoft PE and COFF Specification
, que é o contrato mais documentado possível, além de instruções sobre como encontrar o endereço exato do cabeçalho do PE em qualquer .exe
arquivo. Se você tem uma fonte mais confiável que a especificação oficial da Microsoft no próprio formato executável da Microsoft, eu adoraria saber o que é isso.
A ferramenta SDK dumpbin.exe
com a /headers
opção inclui essas informações, compare essas duas (adicionei negrito para as informações principais)
PS [64] E: \ # 4> dumpbin / cabeçalhos C: \ Windows \ system32 \ cmd.exe Dumper Microsoft (R) COFF / PE versão 10.00.40219.01 Copyright (C) Microsoft Corporation. Todos os direitos reservados. Despejo do arquivo C: \ Windows \ system32 \ cmd.exe Assinatura PE encontrada Tipo de arquivo: IMAGEM EXECUTÁVEL VALORES DO CABEÇA DE ARQUIVO 8664 máquinas (x64) 6 número de seções Carimbo de data e hora 4CE798E5 sáb 20 nov 09:46:13 2010 Ponteiro de 0 arquivo para tabela de símbolos 0 número de símbolos Tamanho F0 do cabeçalho opcional 22 características Executável O aplicativo pode lidar com endereços grandes (> 2 GB) [...]
e
PS [64] E: \ # 5> dumpbin / headers C: \ Windows \ syswow64 \ cmd.exe Dumper Microsoft (R) COFF / PE versão 10.00.40219.01 Copyright (C) Microsoft Corporation. Todos os direitos reservados. Despejo do arquivo C: \ Windows \ syswow64 \ cmd.exe Assinatura PE encontrada Tipo de arquivo: IMAGEM EXECUTÁVEL VALORES DO CABEÇA DE ARQUIVO Máquina 14C (x86) 4 número de seções Carimbo de data e hora 4CE78E2B sáb 20 nov 09:00:27 2010 Ponteiro de 0 arquivo para tabela de símbolos 0 número de símbolos Tamanho E0 do cabeçalho opcional 102 características Executável Máquina de palavras de 32 bits [...]
dumpbin /headers | findstr "machine"
simplifica a apresentação do que o QA está procurando ...
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Se você não possui ou deseja todo o SDK do Windows ou o Visual Studio, pode usar o sigcheck.exe
SysInternals :
sigcheck.exe C:\Windows\Notepad.exe
Resultado:
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 o file
utilitário (por exemplo, do cygwin) fará a distinção entre executáveis de 32 e 64 bits. Eles aparecem da seguinte maneira:
32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows
Como você pode ver, é muito óbvio qual é qual. Além disso, ele distingue entre os executáveis do console e da GUI, também óbvio qual é qual.
MZ
vez de PE
?
Um método simples é executá-lo (supondo que você confie nele) e dar uma olhada na guia de processo no gerenciador de tarefas. Os processos de 32 bits exibirão "* 32" no final do nome do processo. Se não for algo que você deseja executar no seu computador, tente o EXE Explorer . Ele mostrará várias informações sobre os executáveis, incluindo 32 ou 64 bits.
main
ponto de entrada e, portanto, não será executada como um processo autônomo. Há uma função de inicialização chamada quando carregada, mas que não é "principal".
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 arquivo que não ZIP e RAR, como arquivos MSI e executáveis PE. Basta usar a linha de comando 7z.exe
no arquivo PE (Exe ou DLL) em questão:
7z l some.exe | more
7z l some.exe | findstr CPU
A saída incluirá linhas da seguinte forma, com a CPU
linha lendo x86
ou x64
, ou seja , o que está sendo solicitado 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
file
implementação dentro?
A versão de 64 bits do Process Explorer pode lhe dizer. Basta executar o executável e abrir a janela de propriedades do processo. Na guia principal, há uma entrada que diz "Imagem: 32 bits" ou "Imagem: 64 bits".
Simply run the executable
E se você não quiser executar o programa?
Maneira mais simples (quando os dados não são confidenciais)
Acho que o Virustotal File detail
é a maneira mais simples de descobrir se um binário é de 32 ou 64 bits.
A Additional information
opção fornece, além disso, muitas informações úteis sobre o arquivo.
O método de executar um executável e, em seguida, fazer o check-in no Process Explorer ou ferramenta similar, tem algumas desvantagens óbvias:
O método Dumpbin.exe pode provavelmente resolver o objetivo.
Outra alternativa seria usar o comando file do cygwin . No entanto, eu não testei no Windows. Funciona bem em Linux.
Usage: file program_under_test.exe
EDIT: Apenas testado file.exe na janela. funciona bem. :)
cygwin
pacote podem pegar o pacote gnuwin32file
.
file
simplesmente lê os dados do disco em formato binário e verifica os números mágicos que os identificam, comparando-os com um banco de dados. Os programas de 32 bits do Windows aparecem como PE32 e os de 64 bits e .NET como PE32 +. O testemunho de file
si mesmo faz absolutamente nenhuma diferença - aplicativos de 32 e 64 bits podem ler dados do disco, o que é tudo o que precisa.
Aqui está uma solução Powershell, sem dependências externas ou qualquer coisa. Abra o PowerShell, cole a função lá (pressione Enter duas vezes para retornar ao prompt) e 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á um 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
$stream.dispose();
após o fechamento? Deve liberar identificadores de arquivo. ( stackoverflow.com/questions/1999858/… )
Mesmo um executável marcado como 32 bits pode ser executado como 64 bits se, por exemplo, for um executável .NET que pode ser executado como 32 ou 64 bits. Para obter mais informações, consulte https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , que possui uma resposta que diz que o O utilitário CORFLAGS pode ser usado para determinar como um aplicativo .NET será executado.
Saída CORFLAGS.EXE
Para executável 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ável 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ável que pode ser executado em 32 ou 64 bits e em 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ável que pode ser executado em 32 ou 64 bits, mas em 32 bits, a menos que esteja carregado em um processo 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
)
você também pode usar a file
ferramenta no pacote msys do mingw . Funciona como o comando unix. Similar funciona a file
ferramenta do GNUwin32 .
Se você estiver no Windows 7, no Windows Explorer, clique com o botão direito do mouse no executável e selecione Propriedades. Na janela de propriedades, selecione a guia Compatibilidade. Se na seção Modo de compatibilidade você vir o Windows XP, este é um executável de 32 bits. Se você vir o Windows Vista, é de 64 bits.
Windows 8
Windows XP SP2
mas outros mostram como Vista
ou Windows 8
. Portanto, este método não está correto.
Crie um arquivo de texto chamado 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 arquivo de texto chamado x86TestStart.bat
contendo apenas essa linha de código e salve-o em C: \ temp:
c:\temp\x86or64.vbs %1
Crie um arquivo de texto chamado x86or64.vbs
contendo esse código e salve-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 arquivo exetest.reg: uma nova chave será adicionada no registro do Windows:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Ele aparecerá como " teste de 32/64 bits " no menu de contexto ao clicar com o botão direito do mouse em um arquivo executável.
Clicar no item resultará no início do arquivo em lote c:\\temp\\x86TestStart.bat\
, que inicia o arquivo VBscript x86or64.vbs
, que lê a assinatura exe e mostra o resultado.
Se você não pode ou não deseja adulterar o registro, basta copiar o arquivo .vbs na barra QuickLaunch e arrastar o executável sobre ele.
Meus dois centavos serão apenas baixar o walker de dependência e verificar o que a arquitetura foi usada em um dos arquivos executáveis.
Simplesmente faça o download do aplicativo, inicie-o, clique no ícone aberto → encontre um arquivo * .exe → selecione e, na parte inferior, após a verificação da reflexão, você verá uma grade com dados em que uma coluna possui detalhes de "arquitetura" (x86, x64)
Abra o executável e veja a arquitetura de compilação
Eu não vi isso mencionado. Existe um programa visualizador de PE chamado CFF Explorer da NTCore , que pode fornecer essas informações. Ele pode ser baixado e executado como portátil, mas você também pode instalá-lo, se desejar.
Clique com o botão direito do mouse no binário ( .exe
, .dll
etc.) e selecione "Abrir com o CFF Explorer". Vá para Nt Headers -> File Header -> No campo "Características", clique em "Clique aqui"
Se for um programa de 32 bits, a caixa de seleção "máquina de palavras de 32 bits" será marcada. Por exemplo, eu instalei a versão de 32 bits do Notepad ++, como você pode ver na imagem abaixo. Caso contrário, é de 64 bits.
.DMP
despejo no Visual Studiomeus dois centavos: como desenvolvedor de C ++, o dependency walker ( http://www.dependencywalker.com/ ) é muito informativo, não apenas exibe 64/32 bits, mas também todas as DLLs envolvidas:
Você pode ver 64 à esquerda de cada nome de arquivo ...
A coluna da plataforma no gerenciador de tarefas do windows 10
O Windows 7 não possui uma coluna de plataforma. Portanto, o gerenciador de tarefas do Windows 7 não mostrará isso.
No Windows 10, a escolha de colunas não está mais em 'visualização'. No Windows 10, quando na guia detalhes, clique com o botão direito do mouse no cabeçalho da coluna e depois em 'selecionar colunas'. Em seguida, marque a caixa para 'plataforma'.