Est-il possible de trouver toutes les fonctions exposées par une dll

Il faut un peu de travail, mais vous pouvez le faire programmaticly à l'aide de la DbgHelp bibliothèque de Microsoft.

Le débogage d'Applications pour Microsoft .Net et Microsoft Windows, par John Robbins est un excellent (même si un peu plus), livre qui contient des détails sur l'utilisation et la totalité du code source. Et, vous pouvez le ramasser sur Amazon pour le prix!

Il existe trois types distincts de Dll sous Windows:

1. Classique Dll qui exposent chaque fonction disponible dans les exportations de la table de la DLL. Vous pouvez utiliser dumpbin.exe ou depends.exe à partir de Visual Studio, ou la libre dependency walker à l'examen de ces types. Matt Pietrek a écrit de nombreux articles et des utilitaires pour creuser dans Win32 fichiers PE. Jetez un oeil à son classique MSDN Magazine articles. C++ Dll qui contiennent des classes exportées seront à l'exportation de chaque méthode dans la classe. Malheureusement, il exporte les noms déformés, de sorte que la sortie de dumpbin est pratiquement illisible. Vous aurez besoin d'utiliser un programme comme vc++_filt.exe pour demangle la sortie.

2. COM Dll qui exposent des objets COM. Ces Dll exposer une poignée de régulier des fonctions exportées (DllRegisterServer etc) qui permettent au système de COM pour instancier des objets. Il existe de nombreux utilitaires qui peuvent regarder ces Dll, mais à moins qu'ils ont intégré de bibliothèques de types, ils peuvent être très difficiles à examiner. 4Developers ont un certain nombre de bonnes COM/ActiveX outils

3. .NET Dll qui contiennent .NET assemblées. Typiically vous pouvez utiliser un outil comme .NET Réflecteur à plonger dans ces.

Edit: 4Developers lien ne fonctionne pas.

Essayez ceci (Linux) code 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;
}

Il suit les références à l'intérieur le fichier PE, et enfin appelle une fonction de rappel d'export pour chaque symbole. Pour un aperçu de la PE format de fichier voir ceci: http://www.openrce.org/reference_library/files/reference/PE%20Format.pdf

- Je utiliser dumpbinGUI, qui vous donne la liste des exportations (et beaucoup plus) à partir d'un clic droit dans l'Explorateur Windows. dumpbin et depends permettra à la fois de vous donner les listes ainsi.

il y a un programme appelé dll export viewer, vous pouvez utiliser: http://www.nirsoft.net/utils/dll_export_viewer.html

Vous pouvez également utiliser la fonction "objdump" linux outil sous windows, mais vous pouvez avoir à installer cygwin premier.

- Je utiliser les commandes suivantes:

# 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

Vous n'avez besoin d'aucun outil et vous n'avez pas besoin d'analyser PE.
Juste une utilisation standard de l'api Win32 (D)

Le code (en C) a été publié à de nombreuses reprises sur Inter. Win32 api ng (
news://comp.os.ms-windows.programmeur.win32) (depuis 1992...)