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.

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.

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

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

x86:

PE  L

x64:

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.

Informação 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 0x8664para executável x64 e 0x14cx86. 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 .

A ferramenta SDK dumpbin.execom a /headersopçã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
[...]

Se você não possui ou deseja todo o SDK do Windows ou o Visual Studio, pode usar o sigcheck.exeSysInternals :

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 fileutilitá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.

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.

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.exeno 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 CPUlinha lendo x86ou 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

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

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 informationopçã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:

1. Temos que executar o processo.
2. Para os processos de curta duração (como os tipos echo hello world.), O Process Explorer pode até não registrar que um novo processo foi iniciado.

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

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

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

você também pode usar a fileferramenta no pacote msys do mingw . Funciona como o comando unix. Similar funciona a fileferramenta 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.

Como adicionar o teste de 32/64 bits ao seu menu de contexto

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.batcontendo apenas essa linha de código e salve-o em C: \ temp:

c:\temp\x86or64.vbs %1

Crie um arquivo de texto chamado x86or64.vbscontendo 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.

Como usá-lo:

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, .dlletc.) 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.

• executar o aplicativo
• abra o Gerenciador de tarefas
• clique com o botão direito e crie um arquivo de despejo
• anote o caminho
• vá para o caminho e abra o .DMPdespejo no Visual Studio
• aí você encontra todos os detalhes
• verifique a arquitetura do processo:

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

No entanto, WSL 's filecomando funciona muito.

file /mnt/c/p/bin/rg.exe produziria:

/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows

file /mnt/c/p/bin/u.exe produziria:

/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed

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