¿Cómo determinar si se construyó un ensamblado .NET para x86 o x64?

Question

Tengo una lista arbitraria de ensamblados .NET.

Necesito comprobar programáticamente si cada DLL se construyó para x86 (a diferencia de x64 o cualquier CPU). es posible?

Answer 1

Mira System.Reflection.AssemblyName.GetAssemblyName(string assemblyFile)

Puede examinar los metadatos de montaje de la instancia AssemblyName devuelto:

Usando PowerShell:

 
[36] C:\> [reflection.assemblyname]::GetAssemblyName("${pwd}\Microsoft.GLEE.dll") | fl 

Name     : Microsoft.GLEE 
Version    : 1.0.0.0 
CultureInfo   : 
CodeBase    : file:///C:/projects/powershell/BuildAnalyzer/... 
EscapedCodeBase  : file:///C:/projects/powershell/BuildAnalyzer/... 
ProcessorArchitecture : MSIL 
Flags     : PublicKey 
HashAlgorithm   : SHA1 
VersionCompatibility : SameMachine 
KeyPair    : 
FullName    : Microsoft.GLEE, Version=1.0.0.0, Culture=neut... 

Aquí, ProcessorArchitecture identifica plataforma de destino.

Estoy usando PowerShell en este ejemplo para llamar al método.

Answer 2

Puede usar la herramienta CorFlagsCLI (por ejemplo, C: \ Archivos de programa \ Microsoft SDKs \ Windows \ v7.0 \ Bin \ CorFlags.exe) para determinar el estado de un ensamblaje, en función de su salida y apertura un conjunto como un activo binaria que debe ser capaz de determinar dónde tiene que tratar de determinar si el indicador 32BIT se establece en 1 (x 86) o 0 (Cualquier CPU o x64, dependiendo de PE):

Option | PE | 32BIT 
----------|-------|--------- 
x86  | PE32 | 1 
Any CPU | PE32 | 0 
x64  | PE32+ | 0 

La publicación del blog x64 Development with .NET tiene alguna información sobre corflags.

Aún mejor, puede use Module.GetPEKind para determinar si un conjunto es PortableExecutableKinds valor PE32Plus (64 bits), Required32Bit (32 bits y WOW), o ILOnly (cualquier CPU), junto con otros atributos.

Answer 3

Solo para aclaración, CorFlags.exe es parte de .NET Framework SDK. Tengo las herramientas de desarrollo en mi máquina, y la forma más sencilla para mí determinar si un archivo DLL es sólo de 32 bits es:

1. Abra el Visual Studio de comandos (en Windows: menú Inicio/Programas/Microsoft visual Studio/visual Studio Tools/visual Studio 2008 Command Prompt)

2. CD en el directorio que contiene el archivo DLL en cuestión

3. corflags ejecuta de la siguiente: corflags MyAssembly.DLL

obtendrá algo salida como esta:

Microsoft (R) .NET Framework CorFlags Conversion Tool. Version 3.5.21022.8 
Copyright (c) Microsoft Corporation. All rights reserved. 

Version : v2.0.50727 
CLR Header: 2.5 
PE  : PE32 
CorFlags : 3 
ILONLY : 1 
32BIT  : 1 
Signed : 0 

De acuerdo con los comentarios de las banderas más arriba se van a leer de la siguiente manera:

• Cualquier CPU: PE = PE32 y 32BIT = 0
• x86: PE = PE32 y 32BIT = 1
• 64-bit: PE = PE32 + y 32BIT = 0

Answer 4

Otra forma de comprobar la plataforma de destino de un ensamblado de .NET está inspeccionando el conjunto con .NET Reflector ...

@ # ~ # ~ €! ¡Me acabo de dar cuenta de que la nueva versión no es gratis! Entonces, corrección, si tiene una versión gratuita de .NET reflector, puede usarla para verificar la plataforma de destino.

Answer 5

¿Qué tal si solo te escribes? El núcleo de la arquitectura PE no ha sido cambiado en serio desde su implementación en Windows 95. He aquí un ejemplo de C#:

public static ushort GetPEArchitecture(string pFilePath) 
    { 
     ushort architecture = 0; 
     try 
     { 
      using (System.IO.FileStream fStream = new System.IO.FileStream(pFilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read)) 
      { 
       using (System.IO.BinaryReader bReader = new System.IO.BinaryReader(fStream)) 
       { 
        if (bReader.ReadUInt16() == 23117) //check the MZ signature 
        { 
         fStream.Seek(0x3A, System.IO.SeekOrigin.Current); //seek to e_lfanew. 
         fStream.Seek(bReader.ReadUInt32(), System.IO.SeekOrigin.Begin); //seek to the start of the NT header. 
         if (bReader.ReadUInt32() == 17744) //check the PE\0\0 signature. 
         { 
          fStream.Seek(20, System.IO.SeekOrigin.Current); //seek past the file header, 
          architecture = bReader.ReadUInt16(); //read the magic number of the optional header. 
         } 
        } 
       } 
      } 
     } 
     catch (Exception) { /* TODO: Any exception handling you want to do, personally I just take 0 as a sign of failure */} 
     //if architecture returns 0, there has been an error. 
     return architecture; 
    } 
} 

Ahora las constantes actuales son:

0x10B - PE32 format. 
0x20B - PE32+ format. 

Sin embargo, con este método que permite para las posibilidades de nuevas constantes, simplemente valide la devolución como mejor le parezca.

Answer 6

Intente utilizar CorFlagsReader from this project at CodePlex. No tiene referencias a otros ensambles y puede usarse tal cual.

Answer 7

cfeduke toma nota de la posibilidad de llamar a GetPEKind. Es potencialmente interesante hacer esto desde PowerShell.

Aquí, por ejemplo, es el código para un cmdlet que podría ser utilizado: https://stackoverflow.com/a/16181743/64257

Como alternativa, al https://stackoverflow.com/a/4719567/64257 se señala que "también hay el cmdlet Get-PEHeader en el PowerShell Community Extensions que se puede utilizar para probar imágenes ejecutables ".

Answer 8

[TestMethod] 
public void EnsureKWLLibrariesAreAll64Bit() 
{ 
    var assemblies = Assembly.GetExecutingAssembly().GetReferencedAssemblies().Where(x => x.FullName.StartsWith("YourCommonProjectName")).ToArray(); 
    foreach (var assembly in assemblies) 
    { 
     var myAssemblyName = AssemblyName.GetAssemblyName(assembly.FullName.Split(',')[0] + ".dll"); 
     Assert.AreEqual(ProcessorArchitecture.MSIL, myAssemblyName.ProcessorArchitecture); 
    } 
} 

Answer 9

A continuación se muestra un archivo por lotes que ejecutará corflags.exe contra todos dlls y exes en el directorio de trabajo actual y todos los subdirectorios, analizar los resultados y mostrar la arquitectura de destino de cada uno.

Dependiendo de la versión de corflags.exe que se utiliza, los elementos de línea en la salida, o bien incluir 32BIT, o32BITREQ (y 32BITPREF). Cualquiera de estos dos incluidos en el resultado es la línea de pedido crítica que se debe marcar para diferenciar entre Any CPU y x86. Si está utilizando una versión anterior de corflags.exe (anterior a Windows SDK v8.0A), solo la línea de pedido 32BIT estará presente en la salida, como otros han indicado en las respuestas anteriores. De lo contrario, 32BITREQ y 32BITPREF reemplazarlo.

Esto supone que corflags.exe está en el %PATH%.La forma más sencilla de garantizar esto es usar un Developer Command Prompt. Alternativamente, puede copiarlo de default location.

Si el archivo por lotes a continuación está dirigido contra un administrado dll o exe, se mostrará de forma incorrecta como x86, ya que la salida real de Corflags.exe será un mensaje de error similar al siguiente:

corflags : error CF008 : The specified file does not have a valid managed header

@echo off 

echo. 
echo Target architecture for all exes and dlls: 
echo. 

REM For each exe and dll in this directory and all subdirectories... 
for %%a in (.exe, .dll) do forfiles /s /m *%%a /c "cmd /c echo @relpath" > testfiles.txt 

for /f %%b in (testfiles.txt) do (
    REM Dump corflags results to a text file 
    corflags /nologo %%b > corflagsdeets.txt 

    REM Parse the corflags results to look for key markers 
    findstr /C:"PE32+">nul .\corflagsdeets.txt && (  
     REM `PE32+` indicates x64 
     echo %%~b = x64 
    ) || (
     REM pre-v8 Windows SDK listed only "32BIT" line item, 
     REM newer versions list "32BITREQ" and "32BITPREF" line items 
     findstr /C:"32BITREQ : 0">nul /C:"32BIT  : 0" .\corflagsdeets.txt && (
      REM `PE32` and NOT 32bit required indicates Any CPU 
      echo %%~b = Any CPU 
     ) || (
      REM `PE32` and 32bit required indicates x86 
      echo %%~b = x86 
     ) 
    ) 

    del corflagsdeets.txt 
) 

del testfiles.txt 
echo. 

Answer 10

Una aplicación más avanzada para que pueda encontrar aquí: CodePlex - ApiChange

Ejemplos:

C:\Downloads\ApiChange>ApiChange.exe -CorFlags c:\Windows\winhlp32.exe 
File Name; Type; Size; Processor; IL Only; Signed 
winhlp32.exe; Unmanaged; 296960; X86 

C:\Downloads\ApiChange>ApiChange.exe -CorFlags c:\Windows\HelpPane.exe 
File Name; Type; Size; Processor; IL Only; Signed 
HelpPane.exe; Unmanaged; 733696; Amd64 

Answer 11

una forma más sería utilizar dumpbin de las herramientas de Visual Studio en DLL y buscar la salida apropiada

dumpbin.exe /HEADERS <your dll path> 
    FILE HEADER VALUE 
       14C machine (x86) 
        4 number of sections 
      5885AC36 time date stamp Mon Jan 23 12:39:42 2017 
        0 file pointer to symbol table 
        0 number of symbols 
        E0 size of optional header 
       2102 characteristics 
         Executable 
         32 bit word machine 
         DLL 

Nota: Por encima de O/P es para la DLL de 32 bits

Uno más útil opción con Dumpbin.exe está/EXPORTACIONES, se le mostrará la función expuesta por el DLL

dumpbin.exe /EXPORTS <PATH OD THE DLL> 

Answer 12

dotPeek de JetBrians proporciona una forma rápida y fácil de ver msil (Cualquier CPU), x86, x64