#include <stdio.h>
#include <windows.h>
 
int main(int argc, char *argv[])
{
    FILE *fp;
    IMAGE_NT_HEADERS ntheader;
    IMAGE_SECTION_HEADER **sections;
    IMAGE_SECTION_HEADER section,*SecET;    
    int i,j,inicio,final;
    unsigned char *buffer;
    IMAGE_EXPORT_DIRECTORY  descriptor;
    int d,inicioET,tamET,OffSetET,n,pos,offset;
    HANDLE hStdout;
 
    hStdout=GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute (hStdout,15);
    printf("Listar Funciones de Exportacion by "); 
    SetConsoleTextAttribute (hStdout,FOREGROUND_BLUE|FOREGROUND_INTENSITY);
    printf("Ferchu");
    SetConsoleTextAttribute (hStdout,15);
    printf("\n(\x9f) Copyleft 2006 - 2008 Gema Soft\n\n");
    SetConsoleTextAttribute (hStdout,7);
 
    if(argc<2){printf("ListarFunc Archivo\n\n"
                          "       Archivo     Nombre y Ruta del archivo.\n\n");
                return 0; }
 
    fp=fopen(argv[1],"rb");
    if(!fp){ printf("Error al abrir el archivo.\n"); return 0; }
    fseek(fp, 0x3C,0);
    fread(&d, 4, 1, fp);        
    fseek(fp, d,0);       
    fread(&ntheader, sizeof(ntheader), 1, fp);  
 
    if(!(ntheader.FileHeader.Characteristics & IMAGE_FILE_DLL)){
                                               printf("No es una libreria Dll Valida.\n");
                                               return 0;
                                               }
 
    sections=(IMAGE_SECTION_HEADER **)malloc(ntheader.FileHeader.NumberOfSections);
    printf("\n\tNombre\tDir Fisica\tSize\n"); 
    for(i=0;i<ntheader.FileHeader.NumberOfSections;i++){
 
                     sections[i]=(IMAGE_SECTION_HEADER *)malloc(sizeof(IMAGE_SECTION_HEADER));
                     fread((*sections+i), sizeof(IMAGE_SECTION_HEADER),1,fp);
                     printf("\n\t%s\t0x%.8x\t%d",(*sections +i)->Name,(*sections +i)->PointerToRawData,(*sections +i)->SizeOfRawData);
 
                     pos=ntheader.OptionalHeader.DataDirectory[0].VirtualAddress;
                     inicio=(*sections +i)->VirtualAddress;
                     final = inicio + (*sections +i)->Misc.VirtualSize;
                     if((pos >= inicio) && (pos < final))SecET=(*sections +i);
 
    }
 
    inicioET= ntheader.OptionalHeader.DataDirectory[0].VirtualAddress - SecET->VirtualAddress + SecET->PointerToRawData ;  //; //0x6a04; 
    tamET= ntheader.OptionalHeader.DataDirectory[0].Size; 
    OffSetET=ntheader.OptionalHeader.DataDirectory[0].VirtualAddress ; 
 
    printf("\n\nInicio FisicalAddress de la ET: 0x%x\n",inicioET );
    printf("Final FisicalAddress de la ET:  0x%x\n",inicioET+tamET);
    printf("Inicio VirtualAddress de la ET: 0x%x\n",ntheader.OptionalHeader.DataDirectory[0].VirtualAddress+ntheader.OptionalHeader.ImageBase);
    printf("Final VirtualAddress de la ET:  0x%x\n",ntheader.OptionalHeader.DataDirectory[0].VirtualAddress+ tamET+ntheader.OptionalHeader.ImageBase);
    printf("OffSet de la ET: 0x%x\n",OffSetET);
    printf("Size de la ET: 0x%x\n\n",tamET);    
 
    fseek(fp,SecET->PointerToRawData,0);     
    buffer=(unsigned char *)malloc(SecET->SizeOfRawData);
 
    fread(buffer, SecET->SizeOfRawData,1 , fp);  
    fseek(fp,inicioET,0);     
    fread(&descriptor, sizeof(IMAGE_EXPORT_DIRECTORY),1 , fp);
 
    char *Libreria = (char *)(buffer + ((long)descriptor.Name) - SecET->VirtualAddress);
    char *DirTabla = (char*)(buffer + (long)descriptor.AddressOfNames - SecET->VirtualAddress);
    char *DirFunciones  = (char *)(buffer + ((long)descriptor.AddressOfFunctions) - SecET->VirtualAddress);
    char *nombre;
    long Direccion;
    long RVA;
 
    char *Sec=( char*)buffer;
    long *TablaNombres = (long*)DirTabla;
    long *TablaDirecciones = (long*)DirFunciones;
 
 
    printf("Libreria: %s\n",Libreria);
    printf("Cantidad de Funciones: %d\n\n",descriptor.NumberOfFunctions);   
 
    printf("   Ordinal    RVA         Direccion   Nombre\n");
    printf("   ------------------------------------------------------\n");
 
    for(i=0;(i<descriptor.NumberOfFunctions)&&(i<descriptor.NumberOfNames);i++,TablaNombres++,TablaDirecciones++){    
    RVA = *TablaDirecciones; 
    Direccion = *TablaDirecciones + SecET->VirtualAddress + ntheader.OptionalHeader.ImageBase;
    nombre= Sec + *TablaNombres - SecET->VirtualAddress;
    printf("    %.4d      %.8x    %.8x    %s\n",i+1,RVA,Direccion,nombre);
    }
 
    return EXIT_SUCCESS;
}
 

; ************************************************************************************
; ***  Código que muestra un MessageBox obteniendo la dirección de todas las apis  ***
; ***  así como de las variables independientemente del lugar de memoria donde lo  ***
; ***  carguemos o del archivo en el que esté alojado :P                           ***
; ***                                                                      by E0N  ***
; ************************************************************************************
 
include 'C:\archivos de programa\fasm\include\win32ax.inc'
entry main
 
 
proc main
  locals
     mzKernel         dd ?  ; Desde donde esta cargada la kernel32.dll en memoria
     miGetProcAddres  dd ?  ; Api GetProcAddress
     miLoadLibrary    dd ?
     mzUser dd ?
  endl
 
        ; Obtenemos la direccin de LoadLibrary y GetProcAddress
        stdcall DirApis, dword[ebp+4]
        mov [mzKernel], eax
        mov [miGetProcAddres], ebx
 
        ; Mostramos un mensaje (para probar)
        invoke miGetProcAddres, [mzKernel], 'LoadLibraryA'
        mov [miLoadLibrary], eax
        invoke miLoadLibrary, 'user32.dll'
        mov [mzUser], eax
        invoke miGetProcAddres, [mzUser], 'MessageBoxA'
        stdcall eax, 0,0,0,0
 
        ret
endp
 
 
 
 
 
; ***************************************************************************************
; ***  Funcion que devuelve en eax la direccion de la kernell32.dll en memoria
; ***  y en ebx la direccion del api GetProcAddres.
; ***************************************************************************************
proc DirApis, originalEBP
  locals
     mzKernel dd ?  ; Direccion desde donde esta cargada la kernel32.dll (MZ)
     peKernel dd ?  ; Pe signature de kernel32.dll
     etKernel dd ?  ; Direccin de la export table de kernel32.dll
     anKernel dd ?  ; El AddressOfNames de la kernel32.dll
     dirGPA   dd ?  ; Direccion de GetProcAddres
  endl
 
        ; Obtenemos el dos siganute y el pe siganature de la kernel32.dll
        ;mov esi, dword[esp]
        mov esi, [originalEBP]
        and esi, 0xFFFF0000
        DIR_KERNEL:
                sub esi, 0x1000
                cmp word[esi], 'MZ'
        jne DIR_KERNEL
        mov [mzKernel], esi
        mov eax, esi
        add esi, dword[eax+0x3C]
        mov [peKernel], esi
 
        ; Obtenemos la direccion del Export Table (eax=MZ, esi=PE)
        add esi, 0x78
        add eax, dword[esi]
        mov [etKernel], eax
 
        ; Obtenemos el puntero al primer RVA de los nombres de las apis (eax=ExporTable)
        mov ebx, [mzKernel]
        add ebx, dword[eax+0x20] ; AddressOfNames
        mov [anKernel], ebx
 
        ; Localizamos GetProcAddress
        mov edi, [anKernel]
        xor ecx, ecx
 
        DIR_GPA:
                mov ebx, [mzKernel]
                add ebx, dword[edi]
                cmp dword[ebx], 'GetP'
                je PUEDE_SER
        NO_ES:
                add edi, 4
                inc ecx
                jmp DIR_GPA
        PUEDE_SER:
                cmp dword[ebx+4]  , 'rocA'
                jne NO_ES
                cmp dword[ebx+8], 'ddre'
        mov edi, ecx
 
        ; Obtenemos el ordinal de GetProcAddress
        mov eax, [etKernel]
        mov ebx, [mzKernel]
        add eax, 0x24 ; AddressOfOrdinals
        add ebx, dword[eax]
        rol ecx, 1 ; ecx*2
        add ebx, ecx
 
        ; Obtenemos la dirección de GetProcAdress
        xor ecx, ecx
        movzx ecx, word[ebx]
        rol ecx, 2 ; ecx*4
        mov eax, [etKernel]
        mov ebx, [mzKernel]
        add eax, 0x1C ; AddressOfFunctions
        add ebx, dword[eax]
        add ebx, ecx ; ebx = Puntero a la dirección de GetProcAddress
        mov eax, dword[ebx]
        add eax, [mzKernel]
        mov [dirGPA], eax
 
        ; Devolvemos los valores
        mov eax, [mzKernel]
        mov ebx, [dirGPA]
        ret
endp