Comment vérifier si un binaire est 32 ou 64 bits sous Windows?

319

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.

Septagram
la source
Cette question est similaire , mais il faut un peu de travail pour la vérifier.
ST3
3
@Guillaume: Les images exécutables ne sont pas des processus. Task Manager affiche uniquement les processus.
Incontournable le

Réponses:

346

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 .

Alexander Revo
la source
21
Hé, c'est plutôt hacky. Et pour le mieux, puisque cela semble en fait être la solution la plus rapide et la plus simple dans la grande majorité des cas :)
Septagram
4
Une instance rare lorsque notepad a battu notepad ++. Le Bloc-notes le montre bien. Dans le Bloc-notes, vous avez mal à encoder pour le faire apparaître, mais cela a fonctionné!
zar
2
@ CoDEmanX cette option signifie que l'EDI ou JIT fait le choix pour vous. Voir cette question ou cet article de blog pour plus de détails.
Alexander Revo
2
@Ispectable Si vous aviez pris la peine de lire l'intégralité du message avant de le voter, vous auriez vu le lien vers 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 .exefichier. 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.
Alexander Revo
6
Pour les fichiers commençant par "MZ", vous devez regarder un peu plus loin. J'ai trouvé PE..L au décalage 0x110, juste après "RichMQ _........".
Jnnnnn
120

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
[...]
Richard
la source
1
Vous pouvez également voir (IA64) pour un exe 64 bits Itanium.
Darryl Braaten
21
comme je l'ai lu ailleurs sur le superutilisateur, l'utilisation dumpbin /headers | findstr "machine"simplifie grandement la présentation de ce que le contrôle qualité recherche ...
user1055604
3
Dumpbin.exe se trouve ici:C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Devid
3
@David: pas nécessairement (version différente de VS, n'utilisant pas l'emplacement d'installation par défaut, utilisant la version du SDK Windows): c'est pourquoi je n'ai pas précisé.
Richard
6
Il est plus facile d'utiliser dumpbin si vous le lancez à partir de la ligne de commande de visual studio: stackoverflow.com/a/477389/1390430
Ben
46

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
briantiste
la source
4
Cela ne semble pas toujours exact: essayez de l'utiliser avec LinqPad.exe (version AnyCPU-64bit) et Sigcheck vous dira qu'il s'agit d'un "32 bit" ...
Matt
@ Matt intéressant. LinqPad ressemble à une application .net; Je me demande si sigcheck ne fonctionne correctement que sur les exécutables natifs (à cet effet).
Briantist
2
Oui, c'est une application .NET. Dans .NET, s'il n'est pas précompilé, vous pouvez cibler "x86" ou "AnyCPU". "x86" sera toujours exécuté en 32 bits, mais AnyCPU en 64 bits sur un système 64 bits, mais en 32 bits sur un système 32 bits. SigCheck devrait en tenir compte et afficher au moins ".NET 32 bits ou 64 bits (AnyCPU)". Par exemple, ILSpy indique dans ce cas "Architecture: AnyCPU (64 bits préféré)" - mais ILSpy ne fonctionnera pas pour les EXE non.NET.
Matt
1
Ce pourrait être le cas, comme le vieil en-tête "MZ" qui n'existe que pour les OS non-Windows ("DOS") disant "Cette application nécessite Microsoft Windows" ... ;-)
Matt
2
Oui, le bon vieux temps, où vous aviez un débogueur DOS dans le shell et pouviez désassembler le code (qui ne contenait qu'un seul appel DOS imprimant ce message) ... et remplacer le texte par "La réponse est 42". :-D
Matt
38

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.

Wmassingham
la source
1
Cette solution est généralement disponible pour tous les développeurs qui ont installé msysgit.
FrontierPsycho
Pourquoi les fichiers exécutables dans Windows ont-ils MZau lieu de PE?
BattleTested
Il est à noter que les utilitaires GNU peuvent être obtenus en tant que fichiers binaires individuels si vous n’avez pas besoin de Cygwin. gnuwin32.sourceforge.net/packages/file.htm
MJ Walsh Le
32

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.

Dracs
la source
8
Malheureusement, cela nécessite que vous exécutiez le fichier exécutable. Peut-être devriez-vous vérifier l'architecture du programme en tant que méthode de dépannage pour savoir pourquoi il ne fonctionne pas.
Mike Christiansen
6
Comment exécutez- vous une DLL?
user34660
1
@samusarin qui devrait être dans le post.
user34660
@ user34660 Vous êtes techniquement correct, une DLL n'a pas de mainpoint 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".
samis
24

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
Lumi
la source
wow je n'ai jamais su que 7z peut le faire. Probablement qu'il contient une fileimplémentation à l'intérieur?
phuclv
17

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

entrez la description de l'image ici

Andrew Lambert
la source
23
Simply run the executableEt si vous ne voulez pas exécuter le programme?
Synetech
3
@ Synetech La question initiale n'implique pas que ce soit le cas.
Andrew Lambert
C’est pour moi la méthode la plus simple, à moins que l’exécutable ne se termine trop rapidement.
starbeamrainbowlabs
7
Comment exécutez- vous une DLL?
user34660
15

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.

Analyse virustotale


[TRID Virustotal

remue-marais
la source
12

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

anishsane
la source
1
Je voulais juste dire qu'il y a des situations où la méthode de Dracs ne sera pas très utile.
Anishsane
3
>> Cela nécessite toujours d'exécuter le programme que l'auteur voulait éviter: non .. nous le
lançons
1
Et ceux qui souhaitent éviter d'installer tout le cygwinpaquet peuvent récupérer le paquet gnuwin32file .
Bob
6
@anishsane Complètement faux. filelit 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 filebits 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.
Bob
1
@MarcH Ha! C'est intéressant. Je suppose que cela signifie que le stub d'exécution .NET est 32 bits. Donc, il exécute un processus 32 bits pendant une fraction de seconde, mais tout ce processus ne fait que lancer le runtime .NET, qui crée un processus natif 64 bits.
Clacke
10

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
Megamorf
la source
Slickness. Le script ci-dessus semble laisser une référence au fichier ouvert. Impossible de construire avant la première fermeture de powershell (script exécuté pour interroger la DLL dans \ bin).
Samis
1
Très cool. +1 Itanium est définitivement 64bit cependant :)
Rich Homolka
@samusarin: peut-être ajouter $stream.dispose();après la clôture? Doit libérer les descripteurs de fichier. ( stackoverflow.com/questions/1999858/… )
Yorik
1
une version plus complète peut être trouvée dans Vérifier si le fichier exe est en 64 bits
phuclv
6

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
BlueMonkMN
la source
Commande cool, mais cela ne fonctionnera pas pour les exécutables / dll natifs (non gérés). ( corflags : error CF008 : The specified file does not have a valid managed header)
Tomasz Gandor
@TomaszGandor Oui, le contexte de cette réponse était uniquement du code géré. Le code non géré est répondu par les autres réponses. Autant que je sache, seul le code géré peut basculer entre l'exécution 32 bits et 64 bits.
BlueMonkMN
4

vous pouvez également utiliser l' fileoutil à partir du groupe msys de mingw . Cela fonctionne comme la commande unix. Travaux similaires l' fileoutil de GNUwin32 .

Bastian Ebeling
la source
3

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.

axxis
la source
-1 pas vrai du tout. Divers fichiers binaires 32 et 64 bits présentent tous un mode de compatibilité deWindows 8
Peter Hahndorf
@ Peter J'ai essayé pas mal de choses sur Windows 7 et cela a toujours fonctionné pour moi. Pourriez-vous donner un exemple de binaire où le mode de compatibilité par défaut est Windows 8? Aussi sur quelles fenêtres êtes-vous? Merci.
axxis
Je suis sur Server 2012 R2 et j'ai essayé quelques fichiers binaires aléatoires. Certains 32 bits montrent comme Windows XP SP2mais d'autres montrent comme Vistaou Windows 8. Donc, cette méthode n'est pas correcte.
Peter Hahndorf
3

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.

saut d'obstacles
la source
3

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

dépendance walker capture d'écran

sévèrement
la source
1

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.

entrez la description de l'image ici

Nikos
la source
Il existe un moyen plus rapide avec CFF explorer: immédiatement lors du chargement d’un fichier, sous "type de fichier", vous avez "Portable Executable 64" ou "Portable Executable 32"
Arthur.V
0
  • 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:
utilisateur429538
la source
3
Je me sens obligé de souligner le fait que cette réponse nécessite l'exécution de l'application. Les commentateurs précédents ont suggéré que cela pourrait être indésirable. De plus, Visual Studio ne sera pas automatiquement disponible sur toutes les plates-formes Windows.
G-Man
0

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: entrez la description de l'image ici

Vous pouvez voir 64 à gauche de chaque nom de fichier ...

ingconti
la source
1
La capture d'écran ne montre pas la réponse - 32bit vs 64bit info ...
TomEus
0

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
Bohr
la source
0

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

entrez la description de l'image ici

entrez la description de l'image ici

barlop
la source