Po zbadaniu wartości nagłówków z Odpowiedź Ryszarda , wymyśliłem rozwiązanie, które jest szybkie, proste i wymaga jedynie edytora tekstu. Zadziałałby nawet domyślny notepad.exe systemu Windows.

1. Otwórz wykonywalny w edytorze tekstowym. Być może trzeba będzie przeciągnąć i upuścić lub skorzystać z okna dialogowego edytora Open..., ponieważ Windows nie pokazuje opcji Open with... w menu kontekstowym dla plików wykonywalnych.

2. Sprawdź pierwsze drukowane znaki po pierwszym wystąpieniu PE. Ta część jest najprawdopodobniej otoczona przynajmniej pewną białą przestrzenią (może być jej dużo), więc można to łatwo zrobić wizualnie.

Here is what you’re going to find:

32-bit:

PE L

64-bit:

PE d†

A word of warning: using default Notepad on big files can be very slow, so better not use it for files larger than a megabyte or few. W moim przypadku wyświetlenie pliku 12 MiB trwało około 30 sekund. Notatnik+++ był jednak w stanie wyświetlić plik 120 MiB wykonywalny niemal natychmiast.

To rozwiązanie może być przydatne w przypadku, gdy trzeba sprawdzić plik na komputerze, na którym nie można zainstalować żadnego dodatkowego oprogramowania.

Dodatkowe informacje:

Jeśli masz dostępny edytor HEX, offset podpisu PE znajduje się na offsetie 0x3C. Podpisem jest PE0x86640x014c (litery “P” i “E”, po których następują dwa bajty zerowe), po których następują dwa bajty typu Maszyna w Little Endian.

Odpowiednie wartości to 64 86 dla 64-bitowej wartości wykonywalnej oraz 4c 01 dla 32-bitowej (odpowiednio &007 i &007 po dostosowaniu do wartości końcowej, ale każdy przyzwoity edytor szesnastkowy automatycznie obsłuży wartość końcową podczas wyszukiwania wartości szesnastkowej). Możliwych jest znacznie więcej wartości, ale prawdopodobnie nigdy nie napotkasz żadnej z nich, ani nie będziesz w stanie uruchomić takich plików wykonywalnych na swoim komputerze z systemem Windows.

Pełna lista typów maszyn, wraz z resztą specyfikacji .exe, znajduje się w sekcji Microsoft PE i COFF Specification Machine Types.

Narzędzie SDK dumpbin.exe z opcją /headers zawiera te informacje, porównaj je (dodałem pogrubioną czcionkę dla kluczowych informacji)

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

i

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

Jeśli nie masz lub nie chcesz mieć całego Windows SDK lub Visual Studio, możesz użyć sigcheck.exe z SysInternals :

sigcheck.exe C:\Windows\Notepad.exe

Wyjście:

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

Mogę potwierdzić, że narzędzie file (np. z cygwin) będzie rozróżniało pomiędzy 32- i 64-bitowymi plikami wykonywalnymi. Pojawiają się one w następujący sposób:

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

Jak widzisz, jest bardzo oczywiste, który jest który. Dodatkowo rozróżnia on pomiędzy plikami wykonywalnymi z konsoli a plikami wykonywalnymi z interfejsem graficznym, również oczywiste jest, które jest które.

Prostą metodą jest uruchomienie go (zakładając, że mu zaufasz) i zapoznanie się z zakładką procesu w menedżerze zadań. Procesy 32-bitowe wyświetlają “* 32” na końcu nazwy procesu. Jeśli nie jest to coś, co chcesz uruchomić na swoim komputerze, możesz spróbować EXE Explorer . Pokaże on całą masę informacji o plikach wykonywalnych, w tym czy jest to 32 czy 64-bitowy proces.

Wiele osób ma zainstalowany doskonały 7-zip , i dodało folder 7-Zip do swojego PATH. 7-zip rozumie formaty plików inne niż ZIP i RAR, takie jak pliki MSI i pliki wykonywalne PE. Po prostu użyj linii poleceń 7z.exe na danym pliku PE (Exe lub DLL):

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

Wyjście będzie zawierało linie w następujący sposób, z linią CPU odczytującą albo x86 albo x64, co jest tutaj pytane:

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

64-bitowa wersja Process Explorer może Ci to powiedzieć. Wystarczy uruchomić program wykonywalny i otworzyć okno właściwości procesu. Na karcie głównej znajduje się wpis “Image:32 Bit” lub “Image:64 Bit”.

Najprostszy sposób (gdy dane nie są poufne)

Stwierdzam, że Virustotal File detail jest najprostszym sposobem, aby dowiedzieć się czy binarny jest 32-bitowy czy 64-bitowy.

Opcja Additional information dostarcza dodatkowo wiele pomocnych informacji o pliku.

• *

![Virustotal TrID

Metoda uruchamiania narzędzia wykonywalnego, a następnie sprawdzania w eksploratorze procesów lub podobnym narzędziu, ma pewne oczywiste wady:

1. Musimy wykonać proces.
2. W przypadku krótkotrwałych procesów (np. typu echo hello world), eksplorator procesów może nawet nie zarejestrować, że rozpoczął się nowy proces.

Metoda Dumpbin.exe prawdopodobnie rozwiąże ten problem.

Inną alternatywą jest użycie polecenia file cygwina. Nie testowałem jej jednak na oknach. Działa dobrze na Linuksach.

Usage: file program_under_test.exe

EDIT: Właśnie przetestowałem plik.exe na windows. działa dobrze. :)

Oto rozwiązanie Powershell, żadnych zewnętrznych zależności ani nic. Otwórz Powershell, wklej tam funkcję (naciśnij dwukrotnie Enter, aby wrócić do prompa), a następnie użyj jej jak w moich przykładach poniżej funkcji:

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
}

Oto przykładowe wyjście:

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

Nawet program wykonywalny oznaczony jako 32-bitowy może działać jako 64-bitowy, jeśli na przykład jest to program wykonywalny .NET, który może działać jako 32- lub 64-bitowy. Więcej informacji na ten temat można znaleźć w https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , gdzie znajduje się odpowiedź, że narzędzie CORFLAGS może być użyte do określenia, jak będzie działać aplikacja .NET.

CORFLAGS. EXE output

For 32-bit executable:

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

For 64-bit executable:

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

For executable that can run as 32- or 64-bit and will run as 64-bit when possible:

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

For executable that can run as 32- or 64-bit, but will run as 32-bit unless loaded into a 64-bit process:

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

Moje dwa centy po prostu pobierz walker zależności i sprawdź co dla architektury zostało użyte w jednym z plików wykonywalnych.

Jak go używać:

Po prostu pobierz aplikację, uruchom ją, kliknij na otwartą ikonę → znajdź *. exe file → select and on the bottom after reflection scan is done you see a grid with data where one column has “architecture” details in it (x86, x64)

Open executable and see the build architecture

Jeśli jesteś w Windows 7, w Eksploratorze Windows, kliknij prawym przyciskiem myszy na wykonywalny i wybierz Właściwości. W oknie właściwości wybierz zakładkę Kompatybilność. Jeśli w sekcji Tryb zgodności widzisz Windows XP, jest to 32-bitowy program wykonywalny. Jeśli widzisz Windows Vista, jest to 64-bitowy plik.

Możesz również użyć narzędzia file z wnętrza msys bundle mingw . Działa ono jak komenda uniksowa. Podobnie działa narzędzie file z GNUwin32 .

Jak dodać 32/64-bitowy test do swojego menu kontekstowego

Utwórz plik tekstowy o nazwie exetest. reg i zawierający ten kod:

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

Stwórz plik tekstowy o nazwie x86TestStart.bat zawierający właśnie tę linię kodu i zapisz go w C:\temp:

c:\temp\x86or64.vbs %1

Stwórz plik tekstowy o nazwie x86or64.vbs zawierający ten kod i zapisz go w 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

Kliknij dwukrotnie na exetest. reg file: nowy klucz zostanie dodany w rejestrze Windows:

[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]

Pojawi się on jako “ 32/64 bit test” w menu kontekstowym po kliknięciu prawym przyciskiem myszy na plik wykonywalny.

Kliknięcie elementu spowoduje uruchomienie pliku wsadowego `c:\temp\x86TestStart.bat# Jak dodać 32/64-bitowy test do swojego menu kontekstowego

Utwórz plik tekstowy o nazwie exetest. reg i zawierający ten kod:

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

Stwórz plik tekstowy o nazwie x86TestStart.bat zawierający właśnie tę linię kodu i zapisz go w C:\temp:

c:\temp\x86or64.vbs %1

Stwórz plik tekstowy o nazwie x86or64.vbs zawierający ten kod i zapisz go w 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

Kliknij dwukrotnie na exetest. reg file: nowy klucz zostanie dodany w rejestrze Windows:

[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]

Pojawi się on jako “ 32/64 bit test” w menu kontekstowym po kliknięciu prawym przyciskiem myszy na plik wykonywalny.

Kliknięcie elementu spowoduje uruchomienie pliku wsadowego , który uruchamia plik VBscript x86or64.vbs , który odczytuje sygnaturę exe i pokazuje wynik.

Jeśli nie możesz lub nie chcesz ingerować w rejestr, skopiuj plik .vbs w pasku QuickLaunch i przeciągnij nad nim plik wykonywalny.

Jednak komenda file WSL ’s file /mnt/c/p/bin/rg.exe działa bardzo dobrze.

file /mnt/c/p/bin/u.exe would output:

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

&007 would output:

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

Nie widziałem o tym wzmianki. Istnieje program do oglądania PE o nazwie CFF Explorer by NTCore , który może dostarczyć Ci tych informacji. Można go pobrać i uruchomić jako przenośny, ale można go również zainstalować, jeśli chcesz.

Kliknij prawym przyciskiem myszy na binarny (.exe, .dll itd.) i wybierz “Otwórz za pomocą CFF Explorera”. Przejdź do Nt Headers -> File Header -> W polu “Characteristics” kliknij “Click here”

Jeśli jest to program 32-bitowy, zostanie zaznaczone pole wyboru “32 bit word machine”. Na przykład, zainstalowałem 32-bitową wersję Notatnika++, jak widać na obrazku poniżej. W przeciwnym razie, jest to 64bit.

moje dwa centy: jako programista C++, dependency walker http://www.dependencywalker.com/ ) jest bardzo pouczający, nie tylko wyświetla 64/32 bity, ale także każdy Dll biorący udział:

Możesz zobaczyć 64 po lewej stronie każdej nazwy pliku…

Kolumna platformy w menedżerze zadań Windows 10

Windows 7 nie posiada kolumny platformy. Tak więc menedżer zadań Windows 7 nie pokaże jej.

W Windows 10 wybieranie kolumn nie jest już pod “view”. W Windows 10, gdy w zakładce szczegółów, klikamy prawym przyciskiem myszy nagłówek kolumny, a następnie “wybierz kolumny”. Następnie zaznaczamy pole “platforma”.

• Uruchom aplikację
• otwórz Task Manager
• kliknij prawym przyciskiem myszy i utwórz plik zrzutu
• zanotuj ścieżkę
• przejdź do ścieżki i otwórz zrzut .DMP w Visual Studio
• tam uzyskasz wszystkie szczegóły
• sprawdź architekturę procesu: