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.
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.
Réponses:
Après avoir examiné les valeurs d'en-tête de la réponse de Richard , j'ai proposé 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 glisser-déposer ou utiliser la Open...
boîte de dialogue de l'éditeur , car Windows n'affiche pas l' Open with...
option 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:
PE L
PE d†
Un mot d'avertissement: l' utilisation du bloc-notes par défaut sur les gros fichiers peut être très lente, il est donc préférable de ne pas l'utiliser pour des fichiers plus volumineux qu'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.
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 de machine de deux octets dans Little Endian.
Les valeurs pertinentes 0x8664
concernent l'exécutable x64 et 0x14c
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 le reste des spécifications .exe, se trouvent dans la section Types de machines de spécifications PE PE et COFF .
Microsoft PE and COFF Specification
, qui est un contrat aussi documenté que possible, ainsi que des instructions sur la façon de trouver l'adresse exacte de l'en-tête PE. dans n'importe quel .exe
fichier. Si vous avez une source plus fiable que les spécifications officielles de Microsoft sur le propre format exécutable de Microsoft, j'aimerais savoir ce que c'est.
Le SDK dumpbin.exe
avec l' /headers
option inclut cette information, comparez ces deux (j'ai ajouté en gras pour l'information clé)
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 les droits sont réservés. Dump du fichier C: \ Windows \ system32 \ cmd.exe Signature PE trouvée Type de fichier: EXECUTABLE IMAGE VALEURS EN-TÊTE DE FICHIER 8664 machine (x64) 6 nombre de sections 4CE798E5 heure timbre date samedi 20 nov. 09:46:13 2010 0 pointeur de fichier sur la table des symboles 0 nombre de symboles F0 taille de l'en-tête optionnel 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 les droits sont réservés. Dump du fichier C: \ Windows \ syswow64 \ cmd.exe Signature PE trouvée Type de fichier: EXECUTABLE IMAGE VALEURS EN-TÊTE DE FICHIER Machine 14C (x86) 4 nombre de sections 4CE78E2B heure timbre date samedi 20 nov. 09:00:27 2010 0 pointeur de fichier sur la table des symboles 0 nombre de symboles E0 taille de l'en-tête facultatif 102 caractéristiques Exécutable Machine à mots 32 bits [...]
dumpbin /headers | findstr "machine"
simplifie grandement la présentation de ce que le contrôle qualité recherche ...
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Si vous ne possédez pas ou ne voulez pas tout le Kit de développement logiciel (SDK) Windows ou Visual Studio, vous pouvez utiliser sigcheck.exe
depuis 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' file
utilitaire (de cygwin, par exemple) 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 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.
MZ
au lieu de PE
?
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.
main
point d'entrée et ne s'exécutera donc pas en tant que processus autonome. Il y a une fonction d'initialisation appelée quand il est chargé mais ce n'est pas "main".
Beaucoup de gens ont l'excellent 7-zip installé et ont ajouté le dossier 7-Zip à leur dossier 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
Sortie comprendra des lignes comme suit, avec la CPU
ligne de lecture soit x86
ou 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
file
implémentation à l'intérieur?
La version 64 bits de Process Explorer peut vous en informer. 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".
Simply run the executable
Et si vous ne voulez pas exécuter le programme?
Manière la plus simple (quand 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 32 bits ou 64 bits.
L' Additional information
option 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:
La méthode Dumpbin.exe peut probablement résoudre le problème.
Une autre alternative serait d'utiliser la commande de 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. :)
cygwin
paquet peuvent récupérer le paquet gnuwin32file
.
file
lit simplement les données du disque au format binaire et vérifie si des nombres magiques les identifient et les comparent à une base de données. Les programmes 32 bits de Windows apparaissent en tant que PE32 et les programmes 64 bits et .NET en tant que PE32 +. Le nombre de file
bits en lui-même ne fait aucune différence - les applications 32 bits et 64 bits peuvent lire les données du disque, ce qui est tout ce dont il a besoin.
Voici une solution Powershell, aucune dépendance externe ou quoi que ce soit. Ouvrez Powershell, collez la fonction là-bas (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
$stream.dispose();
après la clôture? Doit libérer les descripteurs de fichier. ( stackoverflow.com/questions/1999858/… )
Même un exécutable marqué en 32 bits peut être exécuté en 64 bits si, par exemple, il s'agit d'un exécutable .NET pouvant être exécuté 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 , qui contient une réponse indiquant que le 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
corflags : error CF008 : The specified file does not have a valid managed header
)
vous pouvez également utiliser l' file
outil à partir du groupe msys de mingw . Cela fonctionne comme la commande unix. Travaux similaires l' file
outil 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.
Windows 8
Windows XP SP2
mais d'autres montrent comme Vista
ou Windows 8
. Donc, cette méthode n'est pas correcte.
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 comme " test 32/64 bits " 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 démarrera c:\\temp\\x86TestStart.bat\
, ce qui démarrera le fichier VBscript x86or64.vbs
, qui lira la signature exe et affichera 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 dépendance dépendance et vérifier ce qui pour l'architecture a été utilisé dans l'un des fichiers exécutables.
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, une grille contenant des données dans laquelle une colonne contient des détails «d’architecture» (x86, x64)
Ouvrir l'exécutable et voir l'architecture de construction
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 CFF Explorer". 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 à 32 mots" 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.
.DMP
vidage dans Visual Studio.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 impliquées:
Vous pouvez voir 64 à gauche de chaque nom de fichier ...
La colonne de la plateforme dans le gestionnaire de tâches de Windows 10
Windows 7 n'a pas de colonne de plate-forme. Donc, le gestionnaire de tâches de Windows 7 ne l'affichera pas.
Dans Windows 10, le choix des colonnes n’est plus dans la vue. Sous 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 colonne, puis sur "sélectionner les colonnes". Cochez ensuite la case 'plateforme'.