Hay una manera de encontrar todas las funciones expuestas por un dll

Question

He estado buscando una manera de obtener todas las cadenas que se asignan a nombres de funciones en un dll.

Quiero decir con esto todas las cadenas a las que puede llamar GetProcAddress. Si haces un volcado hexadecimal de un dll, los símbolos (cadenas) están ahí, pero supongo que debe haber una llamada al sistema para adquirir esos nombres.

Answer 1

Se necesita un poco de trabajo, pero se puede hacer esto utilizando la biblioteca programmaticly DbgHelp de Microsoft.

Debugging Applications for Microsoft .Net and Microsoft Windows, by John Robbins es un libro excelente (aunque un poco más antiguo) que contiene detalles de uso y fuente completa. ¡Y puedes comprarlo en Amazon por poco dinero!

Answer 2

Si tiene MS Visual Studio, hay una herramienta de línea de comandos llamada DUMPBIN.

dumpbin /exports <nameofdll>

Answer 3

También existe el programa depende en http://www.dependencywalker.com/

Answer 4

utilizo dumpbinGUI, que le da la lista de las exportaciones (y mucho más) de un clic derecho en el Explorador de Windows. dumpbin y depends le proporcionarán las listas también.

Answer 5

No conozco una API WIn32 para hacerlo: en su lugar, usted (o una de las herramientas mencionadas en otras publicaciones) lo hace conociendo el formato binario de un archivo PE y leyendo el archivo: consulte http://msdn.microsoft.com/en-us/magazine/cc301808.aspx (y ese artículo menciona una utilidad "PEDUMP").

Answer 6

Supongo que terminarás analizando el archivo PE y te exigirás si quieres encontrar los nombres de las funciones de un dll desconocido en el sistema de ejecución o extremadamente inútil ("dumpbin"); magia.

Debe tener más claro lo que quiere.

BFD biblioteca hace lo que quiere (y el fregadero de la cocina) que es el componente principal de varias herramientas GNU binutils. No puedo estar seguro de si se ajustará a tu problema.

Answer 7

Necesita inspeccionar el encabezado PE de .dll, ya que, en última instancia, es lo que hace Windows de todos modos.

Asumiendo que tiene un puntero a la .dll de IMAGE_OPTIONAL_HEADER (se puede utilizar la función de dbghelp ImageNtHeader con un identificador a un .dll cargado a través de LoadLibrary o intentar encontrar por sí mismo si se conoce el trazado del mismo .dll), querrá mirar optional_header->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT], encontrar la tabla de exportación relativa al encabezado opcional con el desplazamiento allí, luego caminar la tabla de exportación (es un IMAGE_EXPORT_DIRECTORY).

Para divertirse, una imagen PE compatible con versiones anteriores comienza con IMAGE_DOS_HEADER; el desplazamiento al IMAGE_NT_HEADER es IMAGE_DOS_HEADER::e_lfanew, y el IMAGE_OPTIONAL_HEADER está incrustado en el encabezado NT.

Answer 8

hay un programa llamado DLL visor de exportación, se puede utilizar: http://www.nirsoft.net/utils/dll_export_viewer.html

Answer 9

usted no necesita ninguna herramienta y que no necesita analizar PE. Sólo tiene que utilizar la API de Win32 estándar (D)

El código (en C) se ha publicado muchas veces en Adv.Win32 API ng ( noticia: //comp.os.ms-windows.programmer.win32) (desde 1992 ...)

Answer 10

Hay tres tipos distintos de archivos DLL en Windows: DLL

1. clásicas que exponen todas las funciones disponibles en la tabla de las exportaciones de la DLL. Puedes usar dumpbin.exe o depende.exe de Visual Studio, o el dependency walker gratuito para examinar estos tipos. Matt Pietrek escribió muchos artículos y utilidades para profundizar en archivos Win32 PE. Eche un vistazo a su clásico MSDN Magazine articles. C++ DLL que contienen clases exportadas exportará todos los métodos en la clase. Desafortunadamente, exporta los nombres destrozados, por lo que la salida de dumpbin es prácticamente ilegible. Deberá usar un programa como vC++ _ filt.exe para exigir la salida.

2. DLL COM que exponen objetos COM. Estas DLL exponen un puñado de funciones exportadas regularmente (DllRegisterServer, etc.) que permiten que el sistema COM cree instancias de objetos. Hay muchas utilidades que pueden ver estos archivos DLL, pero a menos que tengan bibliotecas de tipos incrustados, pueden ser bastante difíciles de examinar. 4Developers tiene una serie de buenas herramientas COM/ActiveX

3. .NET DLL que contienen ensamblados .NET. Normalmente, utilizaría una herramienta como .NET Reflector para profundizar en estos.

Answer 11

Siempre tengo que hacer esto. Solo voy a uno de estos sitios. Ellos alojan la información que generalmente necesitamos.

Windows 7 DLL File Information

Windows XP DLL File Information

Answer 12

Prueba esto (Linux) de código C:

#include <fcntl.h> 
#include <stdio.h> 
#include <sys/mman.h> 
#include <sys/stat.h> 
#include <sys/types.h> 
#include <unistd.h> 

unsigned int vpe2offset(void * base, unsigned int vpe) { 
    unsigned int * ptr = base; 
    unsigned int pe_offset; 
    unsigned short num_sections; 

    pe_offset = ptr[0x3c/4];        //PE header offset 
    ptr = base + pe_offset;        //PE header address 
    num_sections = ((unsigned short*)ptr)[6/2];   //Section count 
    ptr = ((void*)base) + 0x18 + 0x60 + 16*8 + pe_offset;//Address of first section 

    while (num_sections--) { 
     if (vpe >= ptr[0x0c/4] && vpe < ptr[0x0c/4] + ptr[0x10/4]) { 
      return vpe - ptr[0x0c/4] + ptr[0x14/4]; 
     } 
     ptr += 0x28/4; 
    } 

    return 0; 
} 

void iterate_exports(void * base, int(*iterator)(char*)) { 
    unsigned int * ptr = base; 
    unsigned int pe_offset, 
       exports_offset, 
       number_of_names, 
       address_of_names; 

    pe_offset = ptr[0x3c/4]; 
    ptr = base + pe_offset; 
    exports_offset = ptr[0x78/4]; 
    ptr = base + vpe2offset(base, exports_offset); 
    number_of_names = ptr[0x18/4]; 
    address_of_names = ptr[0x20/4]; 
    ptr = base + vpe2offset(base, address_of_names); 
    while (number_of_names-- && iterator((char*)(base + vpe2offset(base, ptr++[0])))) { 
     /* Do nothing */ 
    } 
} 

int print_symbol_name(char * name) { 
    printf("%s\n", name); 
    return 1; 
} 

int main(int argc, char const *argv[]) { 
    int fd; 
    struct stat st; 
    void * base; 

    if (argc == 1) { 
     printf("Usage: %s <dll>\n", argv[0]); 
    } else if (stat(argv[1], &st) == 0 && (fd = open(argv[1], O_RDONLY)) >= 0) { 
     base = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
     if (base != MAP_FAILED) { 
      iterate_exports(base, print_symbol_name); 
      munmap(base, st.st_size); 
     } else { 
      fprintf(stderr, "Could not map \"%s\".\n", argv[1]); 
     } 
     close(fd); 
    } else { 
     fprintf(stderr, "Could not open \"%s\" for reading.\n", argv[1]); 
    } 
    return 0; 
} 

De ello se desprende referencias dentro del archivo PE y finalmente llama a una función de devolución de llamada para cada símbolo exportado. Para obtener una descripción general del formato de archivo PE, consulte esto: http://www.openrce.org/reference_library/files/reference/PE%20Format.pdf

Answer 13

También puede usar la herramienta "objdump" de Linux bajo Windows, pero es posible que primero tenga que instalar cygwin.

utilizo los siguientes comandos:

# feed the output to less 
objdump -x nameOfThe.Dll| less 
# or use egrep to filter 
objdump -x /cygdrive/c/Windows/system32/user32.dll | \ 
    egrep "^\s*\[[ [:digit:]]{4}\] \w{1,}" | less