Is er een eenvoudige manier om te controleren of een binary 32 of 64 bit is op Windows? Ik moet controleren voordat ik het programma naar een 32bit machine verplaats en een spectaculaire storing ervaar.
Na bestudering van de header-waarden van Richard’s antwoord , kwam ik met een oplossing die snel en eenvoudig is en waarvoor alleen een tekstverwerker nodig is. Zelfs de standaard notitieblok.exe van Windows zou werken.
Open... dialoogvenster van de editor moet slepen of gebruiken, omdat Windows de Open with... optie niet toont in het contextmenu voor uitvoerbare bestanden. PE. Dit deel is waarschijnlijk omgeven door ten minste wat witruimte (zou veel kunnen zijn), dus het kan gemakkelijk visueel worden gedaan. Hier is wat je gaat vinden:
PE L
PE d†
Een waarschuwing: het gebruik van standaard kladblok op grote bestanden kan erg traag zijn, dus gebruik het beter niet voor bestanden die groter zijn dan een megabyte of een paar. In mijn geval duurde het ongeveer 30 seconden om een 12 MiB bestand weer te geven. Notepad++ was echter in staat om vrijwel direct een 120 MiB uitvoerbaar bestand weer te geven.
Dit is een oplossing voor het geval je een bestand moet inspecteren op een machine waar je geen extra software op kunt installeren.
Als je een HEX-Editor beschikbaar hebt, staat de offset van PE Signature op offset 0x3C. De handtekening is PE0x86640x014c (letters “P” en “E” gevolgd door twee null bytes), gevolgd door een twee byte Machine Type in Little Endian.
De relevante waarden zijn 64 86 voor een 64-bit executable en 4c 01 voor een 32-bit (&007 en &007 respectievelijk wanneer aangepast voor endianness, maar elke fatsoenlijke hex-editor zal automatisch endianness behandelen wanneer je zoekt naar een hex-waarde). Er zijn nog veel meer mogelijke waarden, maar u zult waarschijnlijk nooit een van deze waarden tegenkomen, of in staat zijn om dergelijke uitvoerbare bestanden op uw Windows PC uit te voeren.
Een volledige lijst van machinetypes, samen met de rest van de .exe specificaties, kunt u vinden in Microsoft PE en COFF Specificatie Machine Types sectie.
De SDK tool dumpbin.exe met de /headers optie bevat deze informatie, vergelijk deze twee (ik heb vetgedrukt toegevoegd voor de belangrijkste informatie)
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 [...]
en
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 [...]
Als u niet de hele Windows SDK of Visual Studio hebt of wilt hebben, kunt u sigcheck.exe van 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
``` gebruiken.
Ik kan bevestigen dat de file utility (bijvoorbeeld van cygwin) onderscheid zal maken tussen 32- en 64-bits executables. Ze verschijnen als volgt:
32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows
Zoals je kunt zien, is het heel duidelijk welke welke is. Daarnaast maakt het onderscheid tussen console en GUI executables, ook is het duidelijk welke welke is.
Een eenvoudige methode is om het uit te voeren (in de veronderstelling dat je het vertrouwt) en een kijkje te nemen op het proces tabblad in task manager. 32bit processen zal aan het einde van de procesnaam “32” laten zien. Als het niet iets is wat u op uw computer wilt uitvoeren, kunt u EXE Explorer proberen. Het zal een heleboel informatie over uitvoerbare bestanden tonen, inclusief of het 32 of 64bit is.
Veel mensen hebben de uitstekende 7-zip geïnstalleerd, en hebben de 7-Zip-map toegevoegd aan hun PATH. 7-zip begrijpt andere bestandsformaten dan ZIP en RAR, zoals MSI-bestanden en PE-uitvoeringen. Gebruik gewoon de opdrachtregel 7z.exe op het PE-bestand (Exe of DLL) in kwestie:
7z l some.exe | more
7z l some.exe | findstr CPU
Uitgang bevat regels als volgt, waarbij de CPU-regel ofwel x86 of x64 leest, wat hier wordt gevraagd:
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
De 64-bits versie van Process Explorer kan u dat vertellen. Voer gewoon de uitvoerbare versie uit en open het venster met de eigenschappen van het proces. Op het hoofdtabblad staat de vermelding “Afbeelding:32 bit” of “Afbeelding:64 bit”.
Meest eenvoudige manier (wanneer de gegevens niet vertrouwelijk zijn)
Ik vind dat Virustotal File detail de eenvoudigste manier is om erachter te komen of een binary 32 bit of 64 bit is.
De Additional information-optie biedt bovendien veel nuttige informatie over het bestand.
De methode van het uitvoeren van een uitvoerbare & dan het controleren in proces explorer of soortgelijke tool, heeft een aantal duidelijke nadelen:
Dumpbin.exe methode kan het doel waarschijnlijk oplossen.
Een ander alternatief zou zijn om het commando cygwin’s file te gebruiken. Ik heb het echter niet getest op windows. Het werkt goed op Linuxes.
Usage: file program_under_test.exe
EDIT: Net getest file.exe op window. werkt prima. :)
Hier is een Powershell oplossing, geen externe afhankelijkheden of iets dergelijks. Open Powershell, plak de functie daar in (druk twee keer op Enter zodat je teruggaat naar de prompt), gebruik het dan zoals in mijn voorbeelden onder de functie:
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
}
Hier is de voorbeeld uitvoer:
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
Zelfs een uitvoerbaar bestand gemarkeerd als 32-bits kan als 64-bits worden uitgevoerd als het bijvoorbeeld een .NET-uitvoerbaar bestand is dat als 32- of 64-bits kan worden uitgevoerd. Zie voor meer informatie https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , waarop staat dat het hulpprogramma CORFLAGS kan worden gebruikt om te bepalen hoe een .NET-toepassing zal worden uitgevoerd.
CORFLAGS. EXE-uitvoer
Voor 32-bit uitvoerbaar:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x3
ILONLY : 1
32BITREQ : 1
32BITPREF : 0
Signed : 0
Voor 64-bit uitvoerbaar:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32+
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Voor uitvoerbaar die als 32- of 64-bit kan draaien en indien mogelijk als 64-bit zal draaien:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Voor uitvoerbaar die als 32- of 64-bit kan draaien, maar als 32-bit zal draaien tenzij deze in een 64-bit proces wordt geladen:
Version : v4.0.30319
CLR Header: 2.5
PE : PE32
CorFlags : 0x20003
ILONLY : 1
32BITREQ : 0
32BITPREF : 1
Signed : 0
Mijn twee centen zullen gewoon downloaden dependency walker en controleren wat voor architectuur is gebruikt in een van de uitvoerbare bestand.
Gewoon downloaden app, start het op, klik op open pictogram → vind een *. exe bestand → selecteer en aan de onderkant zie je na de reflectiescan een raster met gegevens waar een kolom “architectuur” details in zit (x86, x64)
Open executable en zie de build architectuur
Als u zich op Windows 7 bevindt, klik dan met de rechtermuisknop op het uitvoerbare bestand en selecteer Eigenschappen. Selecteer in het venster Eigenschappen het tabblad Compatibiliteit. Als u onder de sectie Compatibiliteitsmodus Windows XP ziet, is dit een 32-bits uitvoerbaar bestand. Als u Windows Vista ziet, is dit 64 bit.
u kunt ook het gereedschap file gebruiken binnen de msys-bundel van mingw . Het werkt net als het unix-commando. Het gereedschap file van GNUwin32 werkt net als het gereedschap &007.
Maak een tekstbestand aan met de naam exetest. reg en met deze code:
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\""
Maak een tekstbestand met de naam x86TestStart.bat met alleen deze regel code en sla het op in C:\temp:
c:\temp\x86or64.vbs %1
Maak een tekstbestand met de naam x86or64.vbs met deze code en sla het op in 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
Dubbelklik op exetest. reg bestand: een nieuwe sleutel zal worden toegevoegd in het windows register:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Het zal verschijnen als “ 32/64 bit test” in het contextmenu bij het rechtsklikken op een uitvoerbaar bestand.
Als u op het item klikt, wordt het batchbestand `c:\temp\x86TestStart.bat# Hoe voeg je 32/64 bit test toe aan je contextmenu
Maak een tekstbestand aan met de naam exetest. reg en met deze code:
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\""
Maak een tekstbestand met de naam x86TestStart.bat met alleen deze regel code en sla het op in C:\temp:
c:\temp\x86or64.vbs %1
Maak een tekstbestand met de naam x86or64.vbs met deze code en sla het op in 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
Dubbelklik op exetest. reg bestand: een nieuwe sleutel zal worden toegevoegd in het windows register:
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Het zal verschijnen als “ 32/64 bit test” in het contextmenu bij het rechtsklikken op een uitvoerbaar bestand.
Als u op het item klikt, wordt het batchbestand gestart, dat het VBscript-bestand x86or64.vbs start, dat de exe handtekening leest en het resultaat toont.
Als u niet kunt of wilt knoeien met het register, kopieer dan gewoon het .vbs-bestand in de QuickLaunch-balk, en sleep het uitvoerbare bestand eroverheen.
Maar toch, WSL de opdracht file werkt zeer.
file /mnt/c/p/bin/rg.exe zou output:
/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows
file /mnt/c/p/bin/u.exe zou output:
/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed
Ik heb dit niet zien noemen. Er is een PE-programma genaamd CFF Explorer van NTCore , dat u deze informatie kan verschaffen. Het kan worden gedownload en uitgevoerd als portable, maar u kunt het ook installeren, als u dat wenst.
Klik met de rechtermuisknop op de binary (.exe, .dll etc.) en selecteer “Open met CFF Explorer”. Ga naar Nt Headers -> File Header -> Klik in het veld “Characteristics” op “Klik hier”
Als het een 32bit programma is, wordt het selectievakje “32 bit word machine” aangevinkt. Ik heb bijvoorbeeld de 32bit versie van Notepad++ geïnstalleerd zoals je in de afbeelding hieronder kunt zien. Anders is het 64bit.
mijn twee cent: als C++ ontwikkelaar, dependency walker http://www.dependencywalker.com/ ) is zeer informatief, geeft niet alleen 64/32 bits weer, maar ook elke betrokken Dll:
Je kunt 64 links van elke bestandsnaam zien…
De platform kolom in de task manager van windows 10
Windows 7 heeft geen platform kolom. Dus Windows 7 task manager laat het niet zien.
In windows 10 staat het kiezen van kolommen niet meer onder ‘view’. In Windows 10 klikt u in het detail tabblad met de rechtermuisknop op de kolomkop en vervolgens op ‘kies kolommen’. Vink dan het vakje aan voor ‘platform’.
.DMP dump in Visual Studio