Existe-t-il un moyen simple de vérifier si un binaire est de 32 ou 64 bits sous Windows ? Je dois le vérifier avant de déplacer le programme sur une machine 32 bits et de connaître une défaillance spectaculaire.
Après avoir examiné les valeurs d'en-tête de Richard’s answer , j'ai trouvé une solution qui est rapide, facile et qui ne nécessite qu'un éditeur de texte. Même le notepad.exe 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 le dialogue de l'éditeur Open..., car Windows n'affiche pas l'option Open with... dans le menu contextuel des exécutables.
Vérifiez les premiers caractères imprimables après la première occurrence de PE. Cette partie est très probablement entourée d'au moins quelques espaces (qui peuvent être nombreux), de sorte qu'elle peut être facilement réalisée visuellement. Voici ce que vous allez trouver :
PE L
PE d†
Un mot d'avertissement: utiliser le Bloc-notes par défaut sur les gros fichiers peut être très lent, donc mieux vaut ne pas l'utiliser pour les fichiers de plus d'un mégaoctet ou de peu de taille. Dans mon cas, il a fallu environ 30 secondes pour afficher un fichier de 12 Mo. Notepad++, cependant, a pu afficher un exécutable de 120 Mio presque instantanément.
Cette solution pourrait être utile au cas où vous auriez besoin d'inspecter un fichier sur une machine sur laquelle vous ne pouvez installer aucun logiciel supplémentaire.
Si vous avez un éditeur HEX disponible, l'offset de PE Signature est situé à l'offset 0x3C. La signature est PE0x86640x014c (lettres “P” et “E” suivies de deux octets nuls), suivie d'un type de machine de deux octets en Little Endian.
Les valeurs pertinentes sont 64 86 pour un exécutable 64 bits et 4c 01 pour un exécutable 32 bits (&007 et &007 respectivement lorsqu'ils sont ajustés pour l'endianness, mais tout éditeur hexadécimal décent traitera automatiquement l'endianness lorsque vous recherchez une valeur hexadécimale). Il y a beaucoup plus de valeurs possibles, mais vous ne rencontrerez probablement jamais aucune d'entre elles, ou ne serez pas en mesure d'exécuter de tels exécutables sur votre PC Windows.
La liste complète des types de machines, ainsi que le reste des spécifications .exe, se trouve dans la section Microsoft PE and COFF Specification Machine Types.
L'outil SDK dumpbin.exe avec l'option /headers comprend ces informations, comparez ces deux (j'ai ajouté du gras pour les informations clés)
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 [...]
et
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 [...]
Si vous n'avez pas ou ne voulez pas l'ensemble du SDK Windows ou Visual Studio, vous pouvez utiliser sigcheck.exe 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 (par exemple de cygwin) fera la distinction entre les exécutables 32 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 voir, il est très évident de savoir lequel est lequel. En outre, il fait la distinction entre les exécutables de console et les exécutables d'interface graphique, ce qui est également évident.
Une méthode simple consiste à l'exécuter (en supposant que vous lui faites confiance) et à jeter un coup d'œil à l'onglet “Processus” dans le gestionnaire de tâches. Les processus 32 bits afficheront “* 32” à la fin du nom du processus. Si vous ne souhaitez pas l'exécuter sur votre ordinateur, vous pouvez essayer EXE Explorer . Il affichera tout un tas d'informations sur les exécutables, y compris s'il s'agit d'un processus 32 ou 64 bits.
De nombreuses personnes ont installé l'excellent 7-zip , et ont ajouté le dossier 7-Zip à leur PATH. 7-zip comprend des formats de fichiers autres que ZIP et RAR, tels que les fichiers MSI et les exécutables PE. Il suffit d'utiliser 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 des lignes comme suit, la ligne CPU lisant soit x86 soit x64, ce qui est 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. Il suffit de lancer l'exécutable et d'ouvrir la fenêtre des propriétés du processus. Sur l'onglet principal, il y a une entrée qui dit “Image:32 Bit” ou “Image:64 Bit”.
Moyen le plus simple (lorsque les données ne sont pas confidentielles)
Je trouve que Virustotal File detail est le moyen le plus simple de savoir si un binaire est de 32 bits ou de 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 à enregistrer l'explorateur de processus ou un outil similaire présente quelques inconvénients évidents :
La méthode Dumpbin.exe peut probablement résoudre le problème.
Une autre alternative serait d'utiliser la commande file de cygwin. Cependant, je ne l'ai pas testé sur Windows. Elle fonctionne bien sous Linux.
Usage: file program_under_test.exe
EDIT : Je viens de tester file.exe sous windows. fonctionne bien. :)
Voici une solution Powershell, sans dépendance extérieure ou quoi que ce soit. Ouvrez Powershell, collez la fonction dedans (appuyez deux fois sur Entrée pour revenir à l'invite), puis utilisez-la comme dans mes exemples ci-dessous la fonction :
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é comme 32 bits peut fonctionner en 64 bits si, par exemple, il s'agit d'un exécutable .NET qui peut fonctionner 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 , dont la réponse indique que l'utilitaire CORFLAGS peut être utilisé pour déterminer comment une application .NET s'exécutera.
CORFLAGS. Sortie EXE
Pour un 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 un 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 un exécutable qui peut s'exécuter en 32 ou 64 bits et s'exécutera en 64 bits si possible :
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 0x1
ILONLY : 1
32BITREQ : 0
32BITPREF : 0
Signed : 0
Pour un exécutable qui peut s'exécuter en 32 ou 64 bits, mais s'exécutera en 32 bits à moins d'être chargé 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
Mes deux cents seront juste de télécharger dependency walker et de vérifier ce qui pour l'architecture a été utilisé dans l'un des fichiers exécutables.
Il suffit de télécharger l'application, de la démarrer, de cliquer sur l'icône d'ouverture → trouver un *. fichier exe → sélectionner et en bas après le balayage de réflexion est fait vous voyez une grille avec des données où une colonne a des détails “architecture” en elle (x86, x64)
Ouvrir l'exécutable et voir l'architecture de construction
Si vous êtes sur Windows 7, sur un explorateur Windows, cliquez avec le bouton droit de la souris sur l'exécutable et sélectionnez Propriétés. Dans la fenêtre des propriétés, sélectionnez l'onglet Compatibilité. Si dans la section Mode de compatibilité, vous voyez Windows XP, il s'agit d'un exécutable 32 bits. Si vous voyez Windows Vista, il s'agit d'un exécutable 64 bits.
vous pouvez également utiliser l'outil file dans le cadre du msys bundle of mingw . Il fonctionne comme la commande unix. L'outil file de GNUwin32 fonctionne de la même manière.
Créer 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 exetest. Fichier reg : une nouvelle clé sera ajoutée dans le registre de Windows :
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
Elle apparaîtra sous la forme “ 32/64 bit test” dans le menu contextuel lors d'un clic droit sur un fichier exécutable. Si vous ne pouvez ou ne voulez pas modifier le registre, il suffit de copier le fichier .vbs dans la barre de lancement rapide et de faire glisser l'exécutable par-dessus.
Pourtant, la commande file de [ WSL ]&3 fonctionne très bien.
file /mnt/c/p/bin/rg.exe produirait :
/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows
file /mnt/c/p/bin/u.exe produirait :
/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed
Je n'ai pas vu cela mentionné. Il existe un programme de visualisation des PE appelé CFF Explorer par NTCore , qui peut vous fournir ces informations. Il peut être téléchargé et exécuté comme portable, mais vous pouvez aussi l'installer, si vous le souhaitez.
Faites un clic droit sur le binaire (.exe, .dll etc.) et sélectionnez “Open with CFF Explorer”. Allez dans Nt Headers -> File Header -> Dans le champ “Characteristics”, cliquez sur “Click here”
S'il s'agit d'un programme 32 bits, la case “32 bit word machine” 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 64bit.
my two cents : en tant que développeur C++, dependency walker http://www.dependencywalker.com/ ) est très instructif, non seulement il affiche 64/32 bits, mais aussi chaque Dll concernée:
Vous pouvez voir 64 à gauche de chaque nom de fichier…
La colonne de plate-forme dans le gestionnaire de tâches de Windows 10
Windows 7 n'a pas de colonne de plate-forme. Le gestionnaire de tâches de Windows 7 ne l'affiche donc pas.
Dans Windows 10, le choix des colonnes n'est plus sous “Affichage”. Dans Windows 10, lorsque vous êtes dans l'onglet “Détails”, vous cliquez avec le bouton droit de la souris sur l'en-tête de la colonne puis sur “Sélectionner les colonnes”. Cochez ensuite la case “plate-forme”.
.DMP vider dans Visual Studio