Como verificar se um binário é 32 ou 64 bits no Windows?

Question

Existe uma maneira fácil de verificar se um binário é de 32 ou 64 bits no Windows? Eu preciso verificar antes de mover o programa para uma máquina de 32 bits e experimentar uma falha espetacular.

    

Answer 1

Depois de examinar os valores de cabeçalho da resposta de Richard , eu criei uma solução que é rápida, fácil e requer apenas um editor de texto. Mesmo o notepad.exe padrão do Windows funcionaria.

1. Abra o executável no editor de texto. Você pode ter que arrastar e soltar ou usar o diálogo Open... do editor, porque o Windows não mostra a opção Open with... no menu de contexto para executáveis.

2. Verifique os primeiros caracteres imprimíveis após a primeira ocorrência de PE . É mais provável que essa parte esteja cercada por pelo menos alguns espaços em branco (pode ser muito disso), por isso pode ser facilmente feita visualmente.

Aqui está o que você vai encontrar:

x86:

PE  L

x64:

PE  d†

Uma palavra de aviso: usando o bloco de notas padrão em arquivos grandes pode ser muito lento, então é melhor não usá-lo para arquivos maiores que um megabyte ou poucos. No meu caso, levou 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.

Esta é uma solução que pode ser útil caso você precise inspecionar um arquivo em uma máquina na qual não é possível instalar nenhum software adicional.

Informação adicional:

Se você tiver um editor HEX disponível, o deslocamento da assinatura PE está localizado no deslocamento 0x3C . A assinatura é PE0x86640x14c (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 %code% para o executável x64 e %code% para x86. Há muito mais valores possíveis, mas você provavelmente nunca encontrará nenhum desses, ou poderá executar tais executáveis no seu PC Windows.

A lista completa de tipos de máquinas, juntamente com o restante das especificações do .exe, pode ser encontrada em Especificação Microsoft PE e COFF Secção Tipos de Máquina .

    

Answer 2

A ferramenta do SDK dumpbin.exe com a opção /headers inclui essas informações, compare essas duas (adicionei negrito para as principais informações)

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
[...]

    

Answer 3

Se você não tem ou quer o SDK do Windows inteiro ou o Visual Studio, pode usar sigcheck.exe de 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

    

Answer 4

Posso confirmar que o utilitário file (por exemplo, do cygwin) fará distinção 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 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.

    

Answer 5

Um método simples é executá-lo (supondo que você confie nele) e dê uma olhada na guia do processo no gerenciador de tarefas. Processos de 32 bits mostrarão "* 32" no final do nome do processo. Se não é algo que você deseja usar no seu computador, você pode tentar o EXE Explorer . Ele mostrará um monte de informações sobre executáveis, incluindo 32 ou 64 bits.

    

Answer 6

Muitas pessoas têm o excelente 7-zip instalado e adicionaram a pasta 7-Zip ao seu PATH . O 7-zip entende formatos de arquivos diferentes de 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 maneira, com a linha CPU lendo x86 ou x64 , que é o que está sendo perguntado 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

    

Answer 7

A versão de 64 bits do Process Explorer pode informá-lo. Basta executar o executável e abrir a janela de propriedades do processo. Na aba principal há uma entrada que diz "Image: 32 Bit" ou "Image: 64 Bit".

    

Answer 8

A maneira mais simples (quando os dados não são confidenciais)

Eu acho que Virustotal File detail é a maneira mais simples de descobrir se um binário é de 32 ou 64 bits.

A opção Additional information fornece, além disso, muitas informações úteis sobre o arquivo.

    

Answer 9

O método de executar um executável & em seguida, verificar no explorador de processos ou ferramenta semelhante, tem algumas desvantagens óbvias:

1. Temos que executar o processo.
2. Para os processos de curta duração (como echo hello world types.), o explorador de processos pode nem mesmo registrar que um novo processo foi iniciado.

O método Dumpbin.exe pode resolver o propósito, provavelmente.

Outra alternativa seria usar o comando arquivo do cygwin. No entanto, eu não testei no windows. Funciona bem em Linuxes.

Usage: file program_under_test.exe

EDIT: Apenas testado file.exe na janela. funciona bem. :)

    

Answer 10

Aqui está uma solução Powershell, sem dependências externas ou qualquer coisa. Abra o Powershell, cole a função lá dentro (pressione Enter duas vezes para retornar ao prompt) e use-a como nos 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
}

Veja 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

    

Answer 11

Até mesmo um executável marcado como 32 bits pode ser executado como 64 bits se, por exemplo, ele for um executável .NET que pode ser executado como 32 ou 64 bits. Para obter mais informações, consulte link , que tem uma resposta que diz que o utilitário CORFLAGS pode ser usado para determinar como um aplicativo .NET será executado.

saída CORFLAGS.EXE

Para o 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 o 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áveis que podem ser executados como 32 ou 64 bits e serão executados 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ável que pode ser executado como 32 ou 64 bits, mas será executado como 32 bits, a menos que seja 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

    

Answer 12

você também pode usar a ferramenta file do pacote msys do mingw . Funciona como o comando unix. Trabalhos similares a ferramenta file de GNUwin32 .

    

Answer 13

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, 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, ele é de 64 bits.

    

Answer 14

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.bat contendo apenas esta 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 em um arquivo executável.

Clicar no item resultará na inicialização 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 puder ou não quiser adulterar o registro, basta copiar o arquivo .vbs na barra do QuickLaunch e arrastar o arquivo executável sobre ele.

    

Answer 15

Meus dois centavos serão apenas baixar o passer de dependência e verificar o que a arquitetura usou em um dos arquivos executáveis.

Como usar:

Simplesmente faça o download do aplicativo, inicie-o, clique no ícone abrir → encontre um arquivo * .exe → selecione e na parte inferior após a verificação de reflexão é feito você vê uma grade com dados onde uma coluna tem detalhes de "arquitetura" (x86, x64)

Abra o executável e veja a arquitetura de construção

    

Answer 16

• 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 .DMP dump no Visual Studio
• lá você recebe todos os detalhes
• verificar a arquitetura do processo:

Answer 17

Eu não vi isso mencionado. Existe um programa de visualizador de PE chamado CFF Explorer por NTCore , que pode fornecer essas informações. Ele pode ser baixado e executado como portátil, mas você pode instalá-lo também, se desejar.

Clique com o botão direito no binário ( .exe , .dll etc.) e selecione "Abrir com o CFF Explorer". Vá para Nt Headers - > Cabeçalho do arquivo - > No campo "Características", clique em "Clique aqui"

Se for um programa de 32 bits, a caixa de seleção "32 bit word machine" será marcada. Por exemplo, eu instalei a versão de 32 bits do Notepad ++ como você pode ver na imagem abaixo. Caso contrário, é 64 bits.

    

Answer 18

meus dois centavos: como um desenvolvedor C ++, o walker de dependência ( link ) é 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 ...

    

Answer 19

No entanto, o comando WSL file funciona muito bem.

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

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

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

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