Инструмент SDK dumpbin.exe с /headers опция включает эту информацию, сравните эти два (я добавил жирный шрифт для ключевой информации)

PS [64] E: \ # 4> свалка / заголовки C:\Windows\system32\cmd.exe
Microsoft (R) COFF/PE Dumper Версия 10.00.40219.01
Авторское право (C) Microsoft Corporation. Все права защищены.


Дамп файла C: \ Windows \ system32 \ cmd.exe

PE подпись найдена

Тип файла: EXECUTABLE IMAGE

Значения заголовка файла
            8664 машина (x64)
               6 количество секций
        4CE798E5 отметка даты времени сб 20 ноября 09:46:13 2010
               0 указатель файла на таблицу символов
               0 количество символов
              Размер F0 необязательного заголовка
              22 характеристики
                   исполнимый
                   Приложение может обрабатывать большие (>2 ГБ) адреса
[...]

а также

PS [64] E:\ #5> свалка / заголовки C:\Windows\syswow64\cmd.exe
Microsoft (R) COFF/PE Dumper Версия 10.00.40219.01
Авторское право (C) Microsoft Corporation. Все права защищены.


Дамп файла C: \ Windows \ syswow64 \ cmd.exe

PE подпись найдена

Тип файла: EXECUTABLE IMAGE

Значения заголовка файла
             14C машина (x86)
               4 количество разделов
        4CE78E2B отметка даты и времени сб 20 ноября 09:00:27 2010
               0 указатель файла на таблицу символов
               0 количество символов
              E0 размер необязательного заголовка
             102 характеристики
                   исполнимый
                   32-битный словарь
[...]

Если у вас нет или вам не нужен весь Windows SDK или Visual Studio, вы можете использовать sigcheck.exe от SysInternals:

sigcheck.exe C:\Windows\Notepad.exe

Выход:

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

Я могу подтвердить, что file Утилита (например, Cygwin) будет различать 32- и 64-битные исполняемые файлы. Они выглядят следующим образом:

32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows

Как видите, очень очевидно, что есть что. Кроме того, он различает исполняемые файлы консоли и графического интерфейса, что также очевидно.

У многих людей установлен отличный 7-zip, и они добавили папку 7-Zip в свои PATH, 7-zip понимает форматы файлов, отличные от ZIP и RAR, такие как файлы MSI и исполняемые файлы PE. Просто используйте командную строку 7z.exe на PE-файл (Exe или DLL) в вопросе:

7z l some.exe | more
7z l some.exe | findstr CPU

Вывод будет включать строки следующим образом, с CPU чтение строки либо x86 или же x64, о чем здесь спрашивают:

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

Простой способ - запустить его (если вы доверяете ему) и взглянуть на вкладку процесса в диспетчере задач. 32-битные процессы покажут "* 32" в конце имени процесса. Если вы не хотите запускать его на своем компьютере, попробуйте EXE Explorer . Он покажет целую кучу информации об исполняемых файлах, включая 32-разрядную или 64-разрядную.

Вот решение Powershell, никаких внешних зависимостей или чего-либо еще. Откройте Powershell, вставьте туда функцию (дважды нажмите Enter, чтобы вернуться к приглашению), затем используйте ее, как в моих примерах ниже функции:

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
}

Вот пример вывода:

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

64-разрядная версия Process Explorer может сказать вам. Просто запустите исполняемый файл и откройте окно свойств процесса. На главной вкладке есть запись с надписью "Изображение: 32-разрядная" или "Изображение: 64-разрядная".

Самый простой способ (когда данные не являются конфиденциальными)

Я считаю, что Virustotal File detail это самый простой способ узнать, является ли двоичный файл 32-разрядным или 64-разрядным.

Additional information опция предоставляет дополнительно много полезной информации о файле.

Метод запуска исполняемого файла и последующей проверки в проводнике процессов или аналогичном инструменте имеет некоторые очевидные недостатки:

1. Мы должны выполнить процесс.
2. Для недолговечных процессов (таких как echo hello world types.) Обозреватель процессов может даже не регистрировать, что новый процесс запущен.

Метод Dumpbin.exe может решить цель возможно.

Другой альтернативой может быть использование команды file в cygwin. Тем не менее, я не проверял это на Windows. Это хорошо работает на Linux.

Usage: file program_under_test.exe

РЕДАКТИРОВАТЬ: Только что протестировал file.exe в окне. работает отлично.:)

Даже исполняемый файл, помеченный как 32-битный, может работать как 64-битный, если, например, это исполняемый файл.NET, который может работать как 32- или 64-битный. Для получения дополнительной информации см. https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit, в котором есть ответ, что Утилита CORFLAGS может использоваться для определения того, как будет работать приложение.NET.

Вывод CORFLAGS.EXE

Для 32-битного исполняемого файла:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x3
ILONLY    : 1
32BITREQ  : 1
32BITPREF : 0
Signed    : 0

Для 64-битного исполняемого файла:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32+
CorFlags  : 0x1
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 0
Signed    : 0

Для исполняемого файла, который может работать как 32- или 64-разрядный и будет работать как 64-разрядный, когда это возможно:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x1
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 0
Signed    : 0

Для исполняемого файла, который может работать как 32- или 64-разрядный, но будет работать как 32-разрядный, если не загружен в 64-разрядный процесс:

Version   : v4.0.30319
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x20003
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 1
Signed    : 0

Если вы работаете в Windows 7, в проводнике Windows щелкните правой кнопкой мыши исполняемый файл и выберите "Свойства". В окне свойств выберите вкладку "Совместимость". Если в разделе "Режим совместимости" вы видите Windows XP, это 32-битный исполняемый файл. Если вы видите Windows Vista, она 64-битная.

Мои два цента будут просто скачать обходчик зависимостей и проверить, что за архитектура использовалась в одном из исполняемых файлов.

Как это использовать:

Просто загрузите приложение, запустите его, нажмите на значок "Открыть" → найдите файл * .exe → выберите и внизу после сканирования отражений вы увидите сетку с данными, в которой один столбец содержит детали "архитектуры" (x86, x64)

Откройте исполняемый файл и посмотрите архитектуру сборки

Как добавить 32/64 битный тест в ваше контекстное меню

Создайте текстовый файл с именем exetest.reg и содержащий этот код:

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

Создать текстовый файл с именем x86TestStart.bat содержащий только эту строку кода и сохранить его в C:\temp:

c:\temp\x86or64.vbs %1

Создать текстовый файл с именем x86or64.vbs содержащий этот код и сохранить его в 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

Дважды щелкните файл exetest.reg: новый ключ будет добавлен в реестр Windows:

[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]

Он будет отображаться как "32/64 битный тест" в контекстном меню после щелчка правой кнопкой мыши по исполняемому файлу.

Нажатие на элемент приведет к запуску командного файла c:\\temp\\x86TestStart.bat\, который запускает файл VBscript x86or64.vbs, который читает подпись exe и показывает результат.

Если вы не можете или не хотите вмешиваться в реестр, просто скопируйте файл.vbs на панель быстрого запуска и перетащите исполняемый файл поверх него.

Тем не менее, WSLfile Команда работает отлично.

file /mnt/c/p/bin/rg.exe будет выводить:

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

file /mnt/c/p/bin/u.exe будет выводить:

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

Вы также можете использовать file инструмент из пакета MSY MINGW . Это работает как команда unix. Подобные работы file инструмент от GNUwin32 .

Столбец платформы в диспетчере задач Windows 10

Windows 7 не имеет столбца платформы. Так что диспетчер задач Windows 7 не будет показывать это.

В Windows 10 выбор столбцов больше не находится под "видом". В Windows 10, когда вы находитесь на вкладке сведений, вы щелкаете правой кнопкой мыши заголовок столбца, а затем выбираете столбцы. Затем установите флажок "платформа".

Самое простое решение заключается в том, что в 32-разрядной версии Windows XP указана на вкладке совместимости свойств (проверено в Windows 7 и 10) исполняемого файла.

Firefox 32 бит:

Firefox 64 бит:

Я не видел это упоминалось. Существует программа просмотра PE под названием CFF Explorer от NTCore, которая может предоставить вам эту информацию. Его можно скачать и запустить как переносной, но вы также можете установить его, если хотите.

Щелкните правой кнопкой мыши по двоичному файлу (.exe, .dll и т. д.) и выберите "Открыть с помощью CFF Explorer". Перейдите к Nt Headers -> File Header -> В поле "Характеристики" нажмите "Нажмите здесь"

Если это 32-битная программа, будет установлен флажок "32-битное слово". Например, я установил 32-битную версию Notepad++, как вы можете видеть на изображении ниже. В противном случае это 64 бит.

Моя простая версия на Powershell, по результатам моих тестов, кажется на 100% надежной.

Clear-Host
$Check32Bit = $null
$Check64Bit = $null

$File = "C:\WINDOWS\system32\notepad.exe"

$ExeData = get-content $File -totalcount 50

$Check32Bit = $ExeData | select-string -Pattern "PE..L" -Quiet
$Check64Bit = $ExeData | select-string -Pattern "PE..d†" -Quiet

if ($Check32Bit) {
"File is 32bit (x86)"
}
elseif ($Check64Bit) {
"File is 64bit (x64)"
}
else {
"Couldn't identify if the file is 32bit or 64bit"
}

Уже много отличных ответов, некоторые утверждают, что они «самые простые», но самый простой способ — проверить путь к папке.

C:\Program Files (x86)\есть только 32-битные вещи

Два моих цента: как разработчик C++, обходчик зависимостей ( http://www.dependencywalker.com/) очень информативен, отображает не только 64/32 бита, но и каждый участвующий Dll:

Вы можете увидеть 64 слева от каждого имени файла...

Как указано в комментарии @user1055604, самый простой готовый способ сделать это в Windows 10:

      dumpbin /headers yourfile.lib | findstr "machine"

Эта однострочная строка выдаст интуитивно понятный результат. Например, в 64-битной библиотеке, которую я только что протестировал, она напечатала следующее:

Машина 8664 (x64)

Вы можете использовать corflags из командной строки VS для изменения типа машины

https://docs.microsoft.com/en-us/dotnet/framework/tools/corflags-exe-corflags-conversion-tool

Изменить тип машины:

corflags d:\abc.exe /32BITREQ- 

Проверить с помощью corflags:

corflags d:\abc.exe 

32BITREQ : 0 ** 0 означает 64 бит

Что-то отличается от всех отличных ответов выше, но использовать PowerShell для поиска контрольного сообщения «Эта программа должна быть запущена под Win32»?

      PS C:\Program Files\Snap Inc> ls -R . -filter *.exe | % { $file = $_; Select-String -Path $_ -Encoding 'oem' -Pattern 'under Win32' -SimpleMatch -Quiet } | % { Write-Output "$file is Win32: $_" }

Snap Camera.exe is Win32: False
unins000.exe is Win32: True
installer.exe is Win32: False

Это также соответствует результатамPE LиPE d†обманывать.

• запустить приложение
• открыть диспетчер задач
• щелкните правой кнопкой мыши и создайте файл дампа
• записать путь
• идти по пути и открыть .DMP дамп в Visual Studio
• там вы получите все детали
• проверить архитектуру процесса:

Если вы хотите просканировать структуру папок на наличие 32/64-битных DLL или исполняемых файлов, вы также можете попробовать бесплатный инструмент ScanFor64bit, который можно найти по адресу: https://canservices.nl/download-tools . ScanFor64bit позволяет вам вводить букву диска. или путь к каталогу и одну или несколько масок файлов для сканирования на предмет разрядности 32 или 64. Результатом является список, отсортированный сначала по 32-битным файлам, а затем по 64-битным. Я часто использовал его для проверки компьютеров с Java, чтобы убедиться, что используется 64-битная версия.

Пример вывода ScanFor64bit:

Я знаю, что здесь есть много ответов, но ни один из них не является действительно портативным и требует использования какого-либо инструмента. Я хотел решить эту проблему программным способом для всех платформ. Это будет работать с чем угодно с компилятором C.

#include <stdio.h>
#include <fstream>      // std::fstream
#include <stdio.h>
#include <string.h>


char Header      [0x200];
char Elf32Magic  [20] = "\x7f\x45\x4c\x46\01";  //7F 45 4C 46  01 // ELF32 
char Elf64Magic  [20] = "\x7f\x45\x4c\x46\02";  //7F 45 4C 46  02 // ELF64
char Win32Magic  [20] = "\x50\x45\x00\x00\x4C\x01";// PE32
char Win64Magic  [20] = "\x50\x45\x00\x00\x64\x86";// PE64

char PeHeader[20] = {};
void CheckWinHeader(){
  int k = 0;
  for (int i = 0; i < 0x200; i++)
  {
   if(Header[i] == 0x50 && Header[i+1] == 0x45) // PE     
     {

      for(int j = i; j < i + 6; j++)
      {
        PeHeader[k] = Header[j];
        k++;
       //printf("%hhx", Header[j]); 
      }
     }
  }
}


int main(){
  std::fstream fs; 
  fs.open ("/home/PATH/TO/YOUR/BINARY", std::fstream::in | std::fstream::out | std::fstream::app);
  fs.read( Header , 0x200);
 
  if(memcmp ( Header, Elf32Magic, 5 ) == 0 ){
    printf("ELF 32 Match Found ! \n");
  }
  if(memcmp ( Header, Elf64Magic, 5 ) == 0 ){
    printf("Elf 64 Match Found ! \n");
  }

  CheckWinHeader();

  if(memcmp ( &PeHeader, Win32Magic, 6 ) == 0 ){
    printf("Win 32 Match Found ! \n");
  }

  if(memcmp ( &PeHeader, Win64Magic, 6 ) == 0 ){
    printf("Win 64 Match Found ! \n");
  }

 fs.close();
 return 0;
}

компилировать с помощью любого компилятора. Я использовал g++.

g++ Bincheck.cpp -o bincheck
./bincheck