Como posso testar um arquivo DLL do Windows para determinar se ele é de 32 bits ou 64 bits? [duplicado]

Question

Esta questão já tem uma resposta aqui:

• Como posso determinar para qual plataforma um executável é compilado? 10 respostas

Eu gostaria de escrever um script de teste ou programa que afirma que todos os arquivos DLL em um determinado diretório são de um determinado tipo de compilação.

Eu usaria isso como uma verificação de sanidade, no final de um processo de construção de um SDK para se certificar de que a versão de 64 bits não tem de alguma forma tem alguns arquivos de 32 bits DLL na mesma e vice-versa.

Existe uma maneira fácil de olhar para um arquivo DLL e determinar o seu tipo?

A solução deve trabalhar em ambos XP32 e XP64.

Answer 1

Detalhes Gory

A DLL usa o formato executável PE, e não é muito complicado para ler essa informação para fora do arquivo.

Veja este href="http://reversingproject.info/wp-content/uploads/2009/05/an_in-depth_look_into_the_win32_portable_executable_file_format_part_1.pdf" artigo MSDN sobre o formato PE Arquivo para uma visão geral. Você precisa ler o cabeçalho MS-DOS, em seguida, ler o IMAGE_NT_HEADERS estrutura . Este contém a estrutura IMAGE_FILE_HEADER que contém as informações que você necessidade no membro máquina que contém um dos seguintes valores

• IMAGE_FILE_MACHINE_I386 (0x014c)
• IMAGE_FILE_MACHINE_IA64 (0x0200)
• IMAGE_FILE_MACHINE_AMD64 (0x8664)

Esta informação deve estar em um deslocamento fixo no arquivo, mas eu ainda recomendo atravessando o arquivo e verificar a assinatura do cabeçalho do MS-DOS e os IMAGE_NT_HEADERS para ter certeza de que você lidar com quaisquer alterações futuras.

Use ImageHelp para ler os cabeçalhos ...

Você também pode usar o ImageHelp API para fazer isso - carregar a DLL com LoadImage você vai ter um href="http://msdn.microsoft.com/en-us/library/ms680349(VS.85).aspx" rel="noreferrer"> LOADED_IMAGE estrutura que conterá um ponteiro para uma estrutura IMAGE_NT_HEADERS. Desalocar o LOADED_IMAGE com ImageUnload.

... ou adaptar este script Perl áspero

Aqui está script Perl áspero que começa o trabalho feito. Ele verifica o arquivo tem um cabeçalho DOS, em seguida, lê o PE deslocamento a partir do IMAGE_DOS_HEADER 60 bytes para o arquivo.

Em seguida, ele procura o início da parte PE, lê a assinatura e verifica-lo, e, em seguida, extrai o valor que estamos interessados.

#!/usr/bin/perl
#
# usage: petype <exefile>
#
$exe = $ARGV[0];

open(EXE, $exe) or die "can't open $exe: $!";
binmode(EXE);
if (read(EXE, $doshdr, 64)) {

   ($magic,$skip,$offset)=unpack('a2a58l', $doshdr);
   die("Not an executable") if ($magic ne 'MZ');

   seek(EXE,$offset,SEEK_SET);
   if (read(EXE, $pehdr, 6)){
       ($sig,$skip,$machine)=unpack('a2a2v', $pehdr);
       die("No a PE Executable") if ($sig ne 'PE');

       if ($machine == 0x014c){
            print "i386\n";
       }
       elsif ($machine == 0x0200){
            print "IA64\n";
       }
       elsif ($machine == 0x8664){
            print "AMD64\n";
       }
       else{
            printf("Unknown machine type 0x%lx\n", $machine);
       }
   }
}

close(EXE);

Answer 2

Uma maneira bruto seria chamar dumpbin com a opção cabeçalhos das ferramentas do Visual Studio em cada DLL e olhar para a saída apropriada:

dumpbin /headers my32bit.dll

PE signature found

File Type: DLL

FILE HEADER VALUES
             14C machine (x86)
               1 number of sections
        45499E0A time date stamp Thu Nov 02 03:28:10 2006
               0 file pointer to symbol table
               0 number of symbols
              E0 size of optional header
            2102 characteristics
                   Executable
                   32 bit word machine
                   DLL

OPTIONAL HEADER VALUES
             10B magic # (PE32)

Você pode ver algumas pistas em que a saída que é uma DLL de 32 bits, incluindo o valor de 14C que Paulo menciona. Deve ser fácil de procurar em um script.

Answer 3

Se você tiver Cygwin instalada (que eu recomendo fortemente para uma variedade de razões), você poderia usar o ' arquivo utilidade' na DLL

file <filename>

o que daria uma saída como esta:

icuuc36.dll: MS-DOS executable PE  for MS Windows (DLL) (GUI) Intel 80386 32-bit

Answer 4

Dependência Walker diz tudo (bem, quase). http://www.dependencywalker.com/

Não "instalar" -apenas obtê-lo, extraí-lo e executar o exec. Ele funciona para qualquer x32 ou x64 janelas módulo |. Aplicação

Se bem me lembro, é bastante simples para ver todas as dependências, ou seja, os módulos DLL, e uma vez que os Appl. é uma soma das dependências um pode determinar se ele está cheio x64, x32 (x 86) ou um pouco de cada.

Tipo de CPU que o módulo foi construído para está na coluna "CPU". A maioria dos aps 64-bit são ainda um pouco de cada um, mas ap 32 bits w / b x 86 tudo.

Programa bonito para geeks / programadores e é gratuito ...

Answer 5

Eu escrevi uma ferramenta muito simples que faz exatamente isso - ele é chamado PE Deconstructor

.

Basta aquecê-la e carregar o arquivo DLL:

No exemplo acima, o DLL carregado é de 32 bits.

Você pode baixá-lo aqui (eu só tenho a versão de 64-bit compilada ATM):
http://files.quickmediasolutions.com/exe/pedeconstructor_0.1_amd64.exe

Uma versão mais antiga de 32 bits está disponível aqui:
http://dl.dropbox.com/u/31080052/pedeconstructor.zip