c# - Compruebe si DLL no administrado es de 32 bits o de 64 bits.

64bit 32-bit

Question

¿Cómo puedo contar programáticamente en C # si un archivo DLL no administrado es x86 o x64?

Answer 1

Aún más fácil: consulte la clase System.Reflection.Module. Incluye el método GetPEKind, que devuelve 2 enumeraciones que describen el tipo de código y el objetivo de la CPU. ¡No más hex!

(El resto de esta publicación muy informativa fue copiada descaradamente de http://www.developersdex.com/vb/message.asp?p=2924&r=6413567 )

Código de muestra:

Assembly assembly = Assembly.ReflectionOnlyLoadFrom(@"<assembly Path>");
PortableExecutableKinds kinds;
ImageFileMachine imgFileMachine;
assembly.ManifestModule.GetPEKind(out kinds, out imgFileMachine);

PortableExecutableKinds se puede usar para verificar qué tipo de ensamblaje. Tiene 5 valores:

ILOnly: el ejecutable contiene solo el lenguaje intermedio de Microsoft (MSIL) y, por lo tanto, es neutral con respecto a las plataformas de 32 bits o de 64 bits.

NotAPortableExecutableImage: el archivo no está en formato de archivo ejecutable portátil (PE).

PE32Plus: el ejecutable requiere una plataforma de 64 bits.

Required32Bit: el archivo ejecutable se puede ejecutar en una plataforma de 32 bits o en el entorno de Windows en Windows (WOW) de 32 bits en una plataforma de 64 bits.

Unmanaged32Bit: el ejecutable contiene código puro no administrado.

Los siguientes son los enlaces:

Método Module.GetPEKind: http://msdn.microsoft.com/en-us/library/system.reflection.module.getpekind.aspx

Enumeración de PortableExecutableKinds: http://msdn.microsoft.com/en-us/library/system.reflection.portableexecutablekinds(VS.80).aspx

Enumeración de ImageFileMachine: http://msdn.microsoft.com/en-us/library/system.reflection.imagefilemachine.aspx

Answer 2

Con un símbolo del sistema de Visual Studio, dumpbin / headers dllname.dll también funciona. En mi máquina, el comienzo de la salida decía:

FILE HEADER VALUES
8664 machine (x64)
5 number of sections
47591774 time date stamp Fri Dec 07 03:50:44 2007

Answer 3

Consulte las especificaciones . Aquí hay una implementación básica:

public static MachineType GetDllMachineType(string dllPath)
{
// See http://www.microsoft.com/whdc/system/platform/firmware/PECOFF.mspx
// Offset to PE header is always at 0x3C.
// The PE header starts with "PE/0/0" = 0x50 0x45 0x00 0x00,
// followed by a 2-byte machine type field (see the document above for the enum).
//
FileStream fs = new FileStream(dllPath, FileMode.Open, FileAccess.Read);
BinaryReader br = new BinaryReader(fs);
fs.Seek(0x3c, SeekOrigin.Begin);
Int32 peOffset = br.ReadInt32();
fs.Seek(peOffset, SeekOrigin.Begin);
UInt32 peHead = br.ReadUInt32();
if (peHead!=0x00004550) // "PE/0/0", little-endian
throw new Exception("Can''t find PE header");
MachineType machineType = (MachineType) br.ReadUInt16();
br.Close();
fs.Close();
return machineType;
}

La enumeración MachineType se define como:

public enum MachineType : ushort
{
IMAGE_FILE_MACHINE_UNKNOWN = 0x0,
IMAGE_FILE_MACHINE_AM33 = 0x1d3,
IMAGE_FILE_MACHINE_AMD64 = 0x8664,
IMAGE_FILE_MACHINE_ARM = 0x1c0,
IMAGE_FILE_MACHINE_EBC = 0xebc,
IMAGE_FILE_MACHINE_I386 = 0x14c,
IMAGE_FILE_MACHINE_IA64 = 0x200,
IMAGE_FILE_MACHINE_M32R = 0x9041,
IMAGE_FILE_MACHINE_MIPS16 = 0x266,
IMAGE_FILE_MACHINE_MIPSFPU = 0x366,
IMAGE_FILE_MACHINE_MIPSFPU16 = 0x466,
IMAGE_FILE_MACHINE_POWERPC = 0x1f0,
IMAGE_FILE_MACHINE_POWERPCFP = 0x1f1,
IMAGE_FILE_MACHINE_R4000 = 0x166,
IMAGE_FILE_MACHINE_SH3 = 0x1a2,
IMAGE_FILE_MACHINE_SH3DSP = 0x1a3,
IMAGE_FILE_MACHINE_SH4 = 0x1a6,
IMAGE_FILE_MACHINE_SH5 = 0x1a8,
IMAGE_FILE_MACHINE_THUMB = 0x1c2,
IMAGE_FILE_MACHINE_WCEMIPSV2 = 0x169,
}

Solo necesitaba tres de estos, pero los incluí a todos para completarlos. Verificación final de 64 bits:

// Returns true if the dll is 64-bit, false if 32-bit, and null if unknown
public static bool? UnmanagedDllIs64Bit(string dllPath)
{
switch (GetDllMachineType(dllPath))
{
case MachineType.IMAGE_FILE_MACHINE_AMD64:
case MachineType.IMAGE_FILE_MACHINE_IA64:
return true;
case MachineType.IMAGE_FILE_MACHINE_I386:
return false;
default:
return null;
}
}

Answer 4

En lugar de Assembly.LoadFile , use Assembly.ReflectionOnlyLoadFrom . Esto le permitirá trabajar alrededor de las excepciones de "Formato de imagen malo".