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

1. 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.

2. 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: 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.

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 de machine de deux octets dans Little Endian.

Les valeurs pertinentes 0x8664concernent l'exécutable x64 et 0x14cx86. 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 .

Le SDK dumpbin.exeavec l' /headersoption 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
[...]

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.exedepuis 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' fileutilitaire (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.

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 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.exesur 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 CPUligne de lecture soit x86ou 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 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".

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 informationoption 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:

1. Nous devons exécuter le processus.
2. Pour les processus de courte durée (tels que echo hello world types.), L'explorateur de processus 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 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. :)

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

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

vous pouvez également utiliser l' fileoutil à partir du groupe msys de mingw . Cela fonctionne comme la commande unix. Travaux similaires l' fileoutil 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.batcontenant uniquement cette ligne de code et enregistrez-le dans C: \ temp:

c:\temp\x86or64.vbs %1

Créez un fichier texte nommé x86or64.vbscontenant 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.

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, 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, .dlletc.) 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.

• 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 .DMPvidage dans Visual Studio.
• là vous obtenez tous les détails
• vérifier l'architecture du processus:

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

Pourtant, la commande de WSLfile fonctionne grandement.

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

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'.