Comment vérifier si un binaire est 32 ou 64 bits sous Windows?
Existe-t-il un moyen simple de vérifier si un binaire est au format 32 ou 64 bits sous Windows? Je dois vérifier avant de transférer le programme sur une machine 32 bits et de subir un échec spectaculaire.
Après avoir examiné les valeurs d'en-tête de Réponse de Richard , je suis parvenu à une solution rapide, simple et ne nécessitant qu'un éditeur de texte. Même le bloc-notes par défaut de Windows fonctionnerait.
Ouvrez l'exécutable dans l'éditeur de texte. Vous devrez peut-être faire un glisser-déposer ou utiliser la boîte de dialogue
Open...de l'éditeur, car Windows n'affiche pas l'optionOpen with...dans le menu contextuel des exécutables.Vérifiez les premiers caractères imprimables après la première occurrence de
PE. Il est fort probable que cette partie soit entourée d'au moins quelques espaces (cela pourrait en être beaucoup), de sorte qu'elle peut être facilement réalisée visuellement.
Voici ce que vous allez trouver:
x86:
PE L
x64:
PE d†
Un mot d'avertissement: utiliser le bloc-notes par défaut sur les gros fichiers peut être très lent, il est donc préférable de ne pas l'utiliser pour des fichiers de plus d'un mégaoctet ou peu. Dans mon cas, il a fallu environ 30 secondes pour afficher un fichier de 12 Mo. Notepad ++, cependant, était capable d'afficher un exécutable de 120 Mio presque instantanément.
Cette solution peut être utile si vous devez inspecter un fichier sur une machine sur laquelle vous ne pouvez installer aucun logiciel supplémentaire.
Information additionnelle:
Si vous disposez d'un éditeur HEX, le décalage de PE Signature est situé au décalage 0x3C. La signature est PE\0\0 (lettres "P" et "E" suivies de deux octets nuls), suivies d'un type d'ordinateur à deux octets en Little Endian.
Les valeurs pertinentes sont 0x8664 pour l'exécutable x64 et 0x14c pour x86. Il y a beaucoup plus de valeurs possibles, mais vous ne rencontrerez probablement jamais aucune de ces valeurs, ni ne pourrez exécuter de tels exécutables sur votre PC Windows.
La liste complète des types de machines, ainsi que les autres spécifications .exe, se trouve dans Spécification Microsoft PE et COFF Types de machines .
L'outil SDK dumpbin.exe avec l'option /headers inclut ces informations, comparez-les (j'ai ajouté des informations en gras pour les informations clés)
PS [64] E:\# 4> dumpbin/headers C:\Windows\system32\cmd.exe Dumper Microsoft (R) COFF/PE version 10.00.40219.01 Copyright (C) Microsoft Corporation. Tous droits réservés. Sauvegarde du fichier C:\Windows\system32\cmd.exe Signature de PE trouvée Type de fichier: IMAGE EXÉCUTABLE VALEURS EN-TÊTE DE FICHIER 8664 machine (x64) 6 nombre de sections 4CE798E5 heure horodatage sam 20 nov. 09:46:13 2010 0 pointeur de fichier sur la table des symboles 0 nombre de symboles Taille F0 de l'en-tête facultatif 22 caractéristiques Exécutable L'application peut gérer des adresses volumineuses (> 2 Go) [...]
et
PS [64] E:\# 5> dumpbin/headers C:\Windows\syswow64\cmd.exe Dumper Microsoft (R) COFF/PE version 10.00.40219.01 Copyright (C) Microsoft Corporation. Tous droits réservés. Dump du fichier C:\Windows\syswow64\cmd.exe Signature de PE trouvée Type de fichier: IMAGE EXÉCUTABLE VALEURS EN-TÊTE DE FICHIER Machine 14C (x86) 4 nombre de sections 4CE78E2B heure horodatage sam 20 nov 09 09:00:27 2010 0 pointeur de fichier sur la table des symboles 0 nombre de symboles Taille E0 de l'en-tête facultatif 102 caractéristiques Exécutable Machine de traitement de texte 32 bits [...]
Si vous ne possédez pas ou ne voulez pas tout le SDK Windows ou Visual Studio, vous pouvez utiliser sigcheck.exe à partir de SysInternals :
sigcheck.exe C:\Windows\Notepad.exe
Sortie:
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
Je peux confirmer que l'utilitaire file (de cygwin, par exemple) distinguera les exécutables 32 bits et 64 bits. Ils apparaissent comme suit:
32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows
Comme vous pouvez le constater, il est très évident de savoir lequel est lequel. De plus, il fait la distinction entre les exécutables de la console et de l’interface graphique, ce qui est également évident.
Une méthode simple consiste à l'exécuter (en supposant que vous y faites confiance) et à consulter l'onglet Processus du gestionnaire de tâches. Les processus 32 bits afficheront "* 32" à la fin du nom du processus. Si ce n'est pas quelque chose que vous voulez exécuter sur votre ordinateur, vous pouvez essayer EXE Explorer . Il montrera une foule d'informations sur les exécutables, y compris s'il s'agit de 32 ou 64 bits.
Beaucoup de gens ont l'excellent 7-Zip installé et ont ajouté le dossier 7-Zip à leur PATH. 7-Zip comprend les formats de fichiers autres que Zip et RAR, tels que les fichiers MSI et les exécutables PE. Utilisez simplement la ligne de commande 7z.exe sur le fichier PE (Exe ou DLL) en question:
7z l some.exe | more
7z l some.exe | findstr CPU
La sortie comprendra les lignes suivantes, la ligne CPU indiquant soit x86 ou x64, ce qui est demandé ici:
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
La version 64 bits de Process Explorer peut vous le dire. Exécutez simplement l'exécutable et ouvrez la fenêtre de propriétés du processus. Dans l'onglet principal, une entrée indique "Image: 32 bits" ou "Image: 64 bits".
Manière la plus simple (lorsque les données ne sont pas confidentielles)
Je trouve que VirustotalFile detail est le moyen le plus simple de savoir si un binaire est 32 bits ou 64 bits.
L'option Additional information fournit en outre de nombreuses informations utiles sur le fichier.
La méthode consistant à exécuter un exécutable puis à archiver l’explorateur de processus ou un outil similaire présente certains inconvénients évidents:
- Nous devons exécuter le processus.
- Pour les processus de courte durée (tels que echo hello world types.), Process Explorer peut même ne pas enregistrer le début d'un nouveau processus.
La méthode Dumpbin.exe peut probablement résoudre le problème.
Une autre solution consisterait à utiliser la commande fichier de cygwin. Cependant, je ne l'ai pas testé sur Windows. Cela fonctionne bien sur les Linux.
Usage: file program_under_test.exe
EDIT: Je viens de tester le fichier.exe sur la fenêtre. fonctionne bien. :)
Voici une solution Powershell, aucune dépendance externe ou quoi que ce soit. Ouvrez Powershell, collez-y la fonction (appuyez deux fois sur Entrée pour revenir à l'invite), puis utilisez-la comme dans mes exemples ci-dessous:
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
}
Voici un exemple de sortie:
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
Même un exécutable marqué en 32 bits peut s'exécuter en 64 bits si, par exemple, il s'agit d'un exécutable .NET pouvant s'exécuter en 32 ou 64 bits. Pour plus d'informations, voir https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , avec une réponse cela signifie que l’utilitaire CORFLAGS peut être utilisé pour déterminer le fonctionnement d’une application .NET.
Sortie CORFLAGS.EXE
Pour l'exécutable 32 bits:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x3
ILONLY : 1
32BITREQ : 1
32BITPREF : 0
Signed : 0
Pour l'exécutable 64 bits:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32+
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Pour les exécutables pouvant fonctionner en 32 ou 64 bits et exécutés en 64 bits lorsque cela est possible:
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Pour les exécutables pouvant fonctionner en 32 ou 64 bits, mais s'exécutant en 32 bits sauf s'ils sont chargés dans un processus 64 bits:
Version : v4.0.30319
CLR Header: 2.5
PE : PE32
CorFlags : 0x20003
ILONLY : 1
32BITREQ : 0
32BITPREF : 1
Signed : 0
vous pouvez également utiliser l'outil file à partir du paquet msys de mingw . Cela fonctionne comme la commande unix. Des travaux similaires utilisent l’outil file de GNUwin32 .
Si vous êtes sous Windows 7, dans un explorateur Windows, cliquez avec le bouton droit sur l'exécutable et sélectionnez Propriétés. Dans la fenêtre des propriétés, sélectionnez l’onglet Compatibilité. Si vous voyez Windows XP dans la section Mode de compatibilité, il s'agit d'un exécutable 32 bits. Si vous voyez Windows Vista, il est en 64 bits.
Comment ajouter un test 32/64 bits à votre menu contextuel
Créez un fichier texte nommé exetest.reg et contenant ce 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\""
Créez un fichier texte nommé x86TestStart.bat contenant uniquement cette ligne de code et enregistrez-le dans C:\temp:
c:\temp\x86or64.vbs %1
Créez un fichier texte nommé x86or64.vbs contenant ce code et enregistrez-le dans 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
Double-cliquez sur le fichier exetest.reg: une nouvelle clé sera ajoutée dans le registre de Windows:
[HKEY_CLASSES_ROOT\exefile\Shell\command32_64\command]
Il apparaîtra sous la forme " 32/64 bit test " dans le menu contextuel en cliquant avec le bouton droit de la souris sur un fichier exécutable.
En cliquant sur l'élément, le fichier de commandes c:\\temp\\x86TestStart.bat\ démarre, ce qui démarre le fichier VBscript x86or64.vbs, qui lit la signature exe et affiche le résultat.
Si vous ne pouvez pas ou ne voulez pas altérer le registre, copiez simplement le fichier .vbs dans la barre QuickLaunch et faites glisser le fichier exécutable dessus.
Mes deux cents seront juste télécharger dependency walker et vérifier quelle architecture a été utilisée dans l’un des fichiers exécutables.
Comment l'utiliser:
Téléchargez simplement l’application, démarrez-la, cliquez sur l’icône ouverte → trouvez un fichier * .exe → sélectionnez et en bas, une fois l’analyse par réflexion terminée, vous voyez une grille contenant des données dans lesquelles une colonne contient des détails «d’architecture» (x86, x64)
Ouvrir l'exécutable et voir l'architecture de construction
- lancer l'application
- ouvrir le gestionnaire de tâches
- clic droit et créer un fichier de vidage
- noter le chemin
- accédez au chemin d'accès et ouvrez le
.DMPdump dans Visual Studio. - là vous obtenez tous les détails
- vérifier l'architecture du processus:
Je n'ai pas vu cela mentionné. Il existe un programme de visualisation PE appelé CFF Explorer par NTCore , qui peut vous fournir ces informations. Il peut être téléchargé et exécuté en mode portable, mais vous pouvez également l'installer si vous le souhaitez.
Faites un clic droit sur le fichier binaire (.exe, .dll etc.) et sélectionnez "Ouvrir avec l'explorateur CFF". Allez à Nt En-têtes -> En-tête de fichier -> Dans le champ "Caractéristiques", cliquez sur "Cliquez ici".
S'il s'agit d'un programme 32 bits, la case à cocher "Machine Word 32 bits" sera cochée. Par exemple, j'ai installé la version 32 bits de Notepad ++ comme vous pouvez le voir dans l'image ci-dessous. Sinon, c'est 64 bits.
Pourtant, la commande file de WSL / fonctionne grandement.
file /mnt/c/p/bin/rg.exe afficherait:
/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows
file /mnt/c/p/bin/u.exe afficherait:
/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed
mes deux cents: en tant que développeur C++, Dependency Walker ( http://www.dependencywalker.com/ ) est très informatif. Il affiche non seulement les 64/32 bits, mais également toutes les Dll concernées: 
Vous pouvez voir 64 à gauche de chaque nom de fichier ...