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