Test Foro de elhacker.net SMF 2.1

Bueno, hago éste texto para explicar un poco en que consiste el método y a la vez para que no haya gente que se limite a copiar el código sin más. Todo lo que voy a decir está basado en lo siguiente, el cual será necesario leer antes de éste texto para comprender bien el código.

http://www.joachim-bauch.de/tutorials/load_dll_memory.html

A la vez, para comprender todo lo que diré, será necesario tener conocimientos sobre el formato PE, y el único texto que encontré que habla un poco de la Base Relocation es el de microsoft:

http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/pecoff_v8.docx

---

Vale, imaginémonos que estamos programando un crypter. El stub del crypter, al ser ejecutado, descifra el archivo en memoria, y llegamos al momento, en que tenemos el archivo que habíamos cifrado, descifrado y mapeado en memoria, pero no podemos ejecutarlo, puesto no está cargado en su ImageBase, y por lo tanto, todas las instrucciones relativas al ImageBase saltarán a un punto que vete tu a saber que hay. Entre éstas instrucciónes, están las llamadas a las API's (llamadas a punteros de la IAT), y al haberse mapeado y no cargado, la IAT no se cargó con las direcciones de las API's, otro problema  :-\.


Para entender lo que vamos a hacer, vamos a ver antes que es lo que hace windows para ejecutar un archivo cuando nosotros se lo indicamos:

• Lee el archivo y busca la cabecera DOS, la cabecera PE y las cabeceras de las secciones.
  
• Intenta reservar espacio en memoria en la dirección del ImageBase, y si ya está en uso, la reserva en otra dirección. La cantidad de memoria que reserva está marcado por el SizeOfImage.
  
• Mapea las distintas secciones de acuerdo con su VirtualOffset y VirtualSize y los Flags.
  
• Si el archivo no está cargado en su ImageBase, hace una reubicación de la base del ejecutable.
  
• Recorre la Import Table y carga las librerías que importa en ejecutable.
  
• Rellena la IAT con las direcciones de las funciones que importa.
  
• Crea el hilo inicial de ejecución y lanza el proceso.
  

Si emulamos el Loader de Windows a base de código, podemos arrancar el ejecutable desde memoria sin necesidad de guardarlo en disco y ejecutarlo o tener que crear otro proceso para tener el ImageBase origianal libre.

Aquí pongo el código que hice, y subo el proyecto. El archivo lleva en el resource un ejecutable que emite un messagebox. Al arrancar el archivo, la sección de resource se mapea en memoria con todo el ejecutable, y emulando el loader de windows, carga el archivo reubicando la ImageBase y pasandole la ejecución a éste  ;-). Comenté mucho el código para que no haya problemas de comprensión, pero es necesario tener muy claro el formato PE  :P.


//-------------------------------------------------------------------------------------------
// PoC - [Base Relocation]
//
//Descripción: Ejecuta un archivo mapeado en memoria sin guardarlo en disco
//Autor: Hacker_Zero
//Fecha: 18-8-2009
//Basado en: http://www.joachim-bauch.de/tutorials/load_dll_memory.html
//-------------------------------------------------------------------------------------------

#pragma optimize("gsy", on)
#pragma comment(linker, "/ENTRY:main")

#include <windows.h>
#include "resource.h"

void main()
{
//Cargamos ejecutable del resource
HRSRC hResource=FindResourceA(NULL,(LPCSTR)MAKEINTRESOURCE(IDR_EXE1),"EXE");
HGLOBAL hGlob=LoadResource(NULL,hResource);
DWORD FileSize=SizeofResource(NULL,hResource);
LPSTR lpFileMaped=(LPSTR)LockResource(hGlob);

PIMAGE_DOS_HEADER IDH;
PIMAGE_NT_HEADERS INTH;
PIMAGE_SECTION_HEADER ISH;

//Obtenemos la cabecera DOS y PE en las estructuras
IDH=(PIMAGE_DOS_HEADER)&lpFileMaped[0];
INTH=(PIMAGE_NT_HEADERS)&lpFileMaped[IDH->e_lfanew];

//Creamos el buffer del tamaño del SizeOfImage en el que cargaremos el ejecutable
LPSTR ExeBuffer=(LPSTR)VirtualAlloc(NULL,INTH->OptionalHeader.SizeOfImage,MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);
//LPSTR ExeBuffer=(LPSTR)GlobalAlloc(GPTR,INTH->OptionalHeader.SizeOfImage);

//Copiamos la cabecera DOS y PE al buffer
CopyMemory(&ExeBuffer[0],&lpFileMaped[0],INTH->OptionalHeader.SizeOfHeaders);

//Copiamos las secciones en su VirtualOffset en el buffer
for(DWORD i=0;i<INTH->FileHeader.NumberOfSections;i++)
{
ISH=(PIMAGE_SECTION_HEADER)&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
CopyMemory(&ExeBuffer[ISH->VirtualAddress],&lpFileMaped[ISH->PointerToRawData],ISH->SizeOfRawData);
}

//Calculamos el delta entre la dirección del buffer y el ImageBase
DWORD Delta=(((DWORD)ExeBuffer)-INTH->OptionalHeader.ImageBase);

//------------------------------------------------------------
/* -Reubicamos la dirección base del ejecutable :D- */
//------------------------------------------------------------

//Si no hay tabla de reubicación, salimos
if(INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size==0)
{
MessageBoxA(0,"No se ha encontrado Tabla de Reubicaciones\nImposible cargar el archivo",0,0);
ExitProcess(0);
}

//Obteemos el Image Base Relocation
PIMAGE_BASE_RELOCATION IBR=(PIMAGE_BASE_RELOCATION)(ExeBuffer+INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);

//Vamos recorriendo todas las etradas del bloque
for (;IBR->VirtualAddress>0; )
{
//Obtenemos el Bloque de reubicación
LPSTR RelocationBlock=(LPSTR)(ExeBuffer+IBR->VirtualAddress);

//Obtenemos la primera entrada del bloque
LPWORD RelocationEntry=(LPWORD)((LPSTR)IBR+sizeof(IMAGE_BASE_RELOCATION));

//Recorremos todas las entradas del bloque
for (DWORD i=0;i<((IBR->SizeOfBlock-sizeof(IMAGE_BASE_RELOCATION))/2);i++,RelocationEntry++)
{
//Obtenemos los 4 bits que definen el tipo de reubicación
DWORD type=*RelocationEntry>>12;

//Obtenemos los 12 bits que definen la dirección de la reubicación
DWORD offset=*RelocationEntry&0xfff;

//Si el tipo de reubicación es relativo a la dirección base, añadimso el delta
switch (type)
{
case IMAGE_REL_BASED_HIGHLOW:
//Añadimos a la dirección que depende del imagebase original
//el delta entre el imagebase y nuestra dirección base
LPDWORD newAddr=(LPDWORD)(RelocationBlock+offset);
*newAddr=Delta+(DWORD)*newAddr;
break;
}
}
//Vamos al siguiente bloque
IBR = (PIMAGE_BASE_RELOCATION)(((DWORD)IBR) + IBR->SizeOfBlock);
}


//---------------------------------------------------------------------
/* -Cargamos los valores de la IAT para poder llamar a las apis- */
//---------------------------------------------------------------------

PIMAGE_THUNK_DATA ITD;
PIMAGE_IMPORT_BY_NAME IIBN;

//Comprobamos si hay Import Data Descriptor
if (INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size>0)
{
//Si lo hay lo obtenemos en la estructura
PIMAGE_IMPORT_DESCRIPTOR IID=(PIMAGE_IMPORT_DESCRIPTOR)(ExeBuffer+INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

//Vamos recorriendo todas las Dll's importadas por el ejecutable
for (;IID->Name;IID++)
{
//Cargamos la dll
HMODULE hLib=LoadLibraryA((LPCSTR)(ExeBuffer+IID->Name));

//Obtenemos la dirección al primer miembro del array Image Thunk Data's
ITD=(PIMAGE_THUNK_DATA)((DWORD)ExeBuffer+IID->FirstThunk);

//Vamos recorriendo las funciones importadas
for (;ITD->u1.Ordinal;ITD++)
{
//Cargamos el Image Import By Name para obtener el nombre
IIBN=(PIMAGE_IMPORT_BY_NAME)(ExeBuffer+ITD->u1.Function);
//Obtenemos la dirección de la función y la guardamos en la IAT
ITD->u1.Function=(DWORD)GetProcAddress(hLib,(LPCSTR)&IIBN->Name);
}
}
}

//Obteemos el EntryPoint de ejecutable que cargamos en el buffer
DWORD EntryPoint=((DWORD)ExeBuffer)+INTH->OptionalHeader.AddressOfEntryPoint;

//Llamamos al EntryPoint
__asm
{
mov eax,EntryPoint
call eax
}

ExitProcess(0);
}


---

# Cabe destacar que para que el archivo pueda ser ejecutado en un ImageBase distinto al original, es necesario que el archivo tenga tabla de reubicación, el VC++ 2008 la pone en los ejecutables por defecto, y en Fasm se puede añadir con la siguiente línea:

section '.reloc' fixups data discardable

En VB no se si se pude poner, al menos no lo hace por defecto  :P.

---

---

# Los antivirus suelen Hookear las API's de manejo de memoria en un proceso remoto, por eso, la mayoría de crypters que usan API's como WriteProcessMemory o CreateRemoteThread son detectados por las heurísticas. Con éste método se evita tener que llamar a esas API's, por lo que (no lo probé) debería de poder saltarse las heurísticas  ;-).

---

---

# Pronto actualizaré el post con un código que solucionará el problema de que el archivo deba tener tabla de reubicaciones  ;D.

---

Descargar proyecto de ejemplo (http://www.megaupload.com/?d=3S7ZOFVB)

---

---

Bueno, pues terminé el código que ejecuta archivos desde memoria aunque éstos no tengan Relocation Table. Tiene un pequeño fallo, y es que con ejecutables en VB crashea debido a que hay algo raro en el import table, no sé muy bien aún a que se debe pero se puede solucionar.

Lo que hace el código es ejecutar un Loader que tiene Relocation Table desde una posición de memoria diferente a su ImageBase. El loader ejecuta el archivo que queremos inyectar desde memoria librerando memoria en el ImageBase original (00400000, desde donde habíamos llamado al loader) y carga ahí el ejecutable, por lo que no es necesario reubicar la ImageBase y funciona  ;D.


Descargar Código Fuente (http://www.megaupload.com/?d=733RQDOA)

Saludos

Muy bueno ;D ;D ;D

Lastima que haga falta lo del .reloc :( Sino harias un crypter fenomenal :xD

Le pongo una chincheta... ya estara bien de hacer tutos... como hagas uno solo mas me va a tocar hacerte un recopilatorio para ti solo :¬¬ :xD, nah, es broma, sigue asi ;)

Lo de reloc está solucionado virtualmente, falta el código jeje. Pronto actualizo con el código que soluciona ese problema y a ver si hago un crypter de muestra (el builder ya lo tengo de una vez asíque...  :xD).

Saludos y gracias por la chincheta  :xD

Edito: Bueno, lo intenté con ésto (http://foro.elhacker.net/programacion_cc/duda_olly_debug_y_ntunmapviewofsection-t264601.0.html), pero al parecer no fue buena idea, pensaré en otra cosa  :-\.

 :o

  Valla pedazo de aportacion jeje




  Descargando.........  :xD

Actualicé el post, ahora ejecuta cualquier archivo tenga o no Relocation Table (salvo ejecutables en VB  :¬¬).

Saludos

Muy bueno  ;D Gracias a vosotros esto esta cogiendo nivel.

Saludos.

Ooops, mi sexto sentido me dice que esto me interesa.... aunque tendre que leermelo 7 u 8 veces y alguna mas  :xD

Gracias por la aportacion! ^^

 ;-) Muy bueno el articulo, de veras. Felicitaciones.
Estoy teniendo un pequeño problema al intentar saltar a la direccion en memoria con


_asm
{
    mov eax, AddEntryPoint
    call eax
}

o similarmente también:

_asm
{
    mov eax, AddEntryPoint
    push eax
    ret
}

Me salta Violación de Acceso (0x0000005 Error), porqué?
Que pena si es un poco tarde para preguntar pero no he podido resolver el problemilla

Cita de: plaganegra en 12 Diciembre 2009, 19:13 PM
;-) Muy bueno el articulo, de veras. Felicitaciones.
Estoy teniendo un pequeño problema al intentar saltar a la direccion en memoria con

Código [Seleccionar] Expandir


_asm
{
    mov eax, AddEntryPoint
    call eax
}

o similarmente también:

Código [Seleccionar] Expandir

o
_asm
{
    mov eax, AddEntryPoint
    push eax
    ret
}

Me salta Violación de Acceso (0x0000005 Error), porqué?
Que pena si es un poco tarde para preguntar pero no he podido resolver el problemilla

Hm es raro, como lo estás probando? Quizás no tenga permisos de ejecución a donde estás saltando o no obtienes bien el EntryPoint. Intenta debugear y mira a ver que es lo que pasa. Yo tuve problemas en el segundo ejemplo que inyecta sin relocation table, necesité darle permisos de debug para que funcionara, estás probando el primero o el segundo ejemplo?

Saludos  :)

Estoy viendo con el debbuger y el problema es precisamente eso, no hay permisos, aunque realmente la memoria se esta reservando en el mismo espacio de proceso y estoy obteniendo los permisos "SeDebugPrivilege", "SeCreatePagefilePrivilege", "SeTcbPrivilege"; mediante el uso de OpenProcessToken, LookupPrivilegeValue y AdjustTokenPrivileges. :-\

Con respecto al entrypoint lo revise con el PEditor 1.7 y efectivamente si es el entry point correcto.

También escaneo la memoria en la direccion retornada por VirtualAlloc y efectivamente se encuentra el MZ y PE después de haber escrito esa parte en la memoria. :huh:

No se que puede ser, que consejos me puedas dar, alguna experiencia similar? :-\

Saludos  ;D

Pero estás usando el primero o el segundo ejemplo? Yo tuve problemas con el primero pero lo solucioné con RtlAdjustTokenPrivileges, dando permisos a esa zona de SeDebugPrivilege. Con el primero no tuve problema, VirtualAlloc debería de dejar bien los permisos en esa zona, prueba a llamar a VirtualProtect a ver, pero es extraño  :P.

Saludos

use VirtualProtect y RtlAdjustTokenPrivileges pero nada.
A que te refieres con el primero o el segundo ejemplo, no se cual es cada uno  ;D
De pronto uno es el que llamaste Loader y el otro es el ExecutableRunner, el que carga el loader?
Saludos ;)

Si te fijas en el post principal hay dos apartados, un Ejecucion de Archivos con Relocation Table y otro sin ella. Por lo que dices del "Loader" supongo que te bajaste el segundo. Ese código es bastante inestable, tendrás que depurarlo bastante si quieres que funcione con todos los ejecutables. Por ejemplo falla obteniendo las apis de la IAT y al cargar la IAT, y supongo habrá algun otro fallo  :P. Lo mejor es que intentes hacer uno de 0 basándote en ese, ya que no es un código ejemplar  :xD.

Saludos  :P

Oh,it's really cool advice)  ;D

A mi parecer la dependencia exacta de que todas las direcciónes físicas sean realocadas da un porcentaje muy alto de fallar al cargar un ejecutable en otro espacio de memoria diferente a su ImageBase, tenía que prácticar Relocations así que decidí intentarlo en Delphi y vaya trabajo me ha dado. Gracias [Zero]
IMAGE_IMPORT_DESCRIPTOR = packed record
    OriginalFirstThunk: DWORD;
    TimeDateStamp: DWORD;
    ForwarderChain: DWORD;
    Name: DWORD;
    FirstThunk: DWORD;
end;

IMAGE_RELOCATIONS = packed record
    PageRVA: DWORD;
    Size:    DWORD;
end;

type
TArrayOfByte = array of byte;
TArrayOfISH = array of TIMAGESECTIONHEADER;
PIMAGEIMPORTDESCRIPTOR = ^IMAGE_IMPORT_DESCRIPTOR;
PIMAGERELOCATIONS = ^IMAGE_RELOCATIONS;

function RVATOOFFSET(RVA:DWORD): DWORD;
var
i,n: integer;
begin
     for i:= 0 to IFH.NumberOfSections-1 do
     begin
          n:= (ish[i].VirtualAddress + ish[i].SizeOfRawData)-RVA ;
          if n > 0 then
          begin
               Result:=(RVA - ish[i].VirtualAddress) + ish[i].PointerToRawData;
               break;
          end;
     end;
     if RVA < ish[0].VirtualAddress then Result:= RVA;
end;


procedure Execute();
var
IDH:         PIMAGEDOSHEADER;
IOH:         PIMAGEOPTIONALHEADER;
IDD:         Array[0..15] of PIMAGEDATADIRECTORY;
IID:         PIMAGEIMPORTDESCRIPTOR;
IR:          PIMAGERELOCATIONS;
aBuffer:     TArrayOfByte;
FileLen:     DWORD;
hFile:       THANDLE;
BytesRead:   DWORD;
Signature:   PDWORD;
i:           DWORD;
Acumulador:  DWORD;
BaseAddress: Pointer;
lFunction:   PDWORD;
TempAddress: DWORD;
EP:          DWORD;
aBlock:      DWORD;
rBlock:      PWORD;
dType:       DWORD;
Offset:      PDWORD;
Delta:       DWORD;
rOffset:     DWORD;
Ordinal:     DWORD;
GPA:         function(hModule: Cardinal; Ordinal: Cardinal): Pointer; stdcall;
begin
     hFile:= CreateFileA('C:\Archivos de programa\Opera\opera.exe',GENERIC_READ, FILE_SHARE_READ,nil, OPEN_EXISTING,0,0);
     If hFile <> INVALID_HANDLE_VALUE then
     begin
          FileLen:= GetFileSize(hFile,nil);
          SetLength(aBuffer,FileLen);
          ReadFile(hFile,aBuffer[0],FileLen,BytesRead,nil);
     end;
     GPA:= GetProcAddress(GetModuleHandle('kernel32'),'GetProcAddress');
     CloseHandle(hFile);
     IDH:= Pointer(aBuffer);
     if IDH.e_magic = IMAGE_DOS_SIGNATURE then
     begin
          Signature := @aBuffer[IDH._lfanew];
          if Signature^ = IMAGE_NT_SIGNATURE then
          begin
               IFH:= @aBuffer[IDH._lfanew + 4];
               IOH:= @aBuffer[IDH._lfanew + 24];
               Acumulador:= 0;
               for i:=0 to 15 do
               begin
                    IDD[i]:= @aBuffer[IDH._lfanew + 120 + Acumulador];
                    Acumulador:= Acumulador+8;
               end;
               SetLength(ISH, IFH.NumberOfSections-1);
               Acumulador := 0;
               for i:=0 to IFH.NumberOfSections-1 do
               begin
                    CopyMemory(@ISH[i], @aBuffer[IDH._lfanew + 248 + Acumulador], 40);
                    Acumulador:= Acumulador + 40;
               end;
               BaseAddress:= VirtualAlloc(nil, IOH.SizeOfImage, MEM_RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE);
               CopyMemory(BaseAddress, @aBuffer[0], IOH.SizeOfHeaders);
               for i:=0 to IFH.NumberOfSections-1 do
               begin
                    CopyMemory(Pointer(DWORD(BaseAddress)+ISH[i].VirtualAddress), @aBuffer[ISH[i].PointerToRawData], ISH[i].SizeOfRawData);
               end;
                              Delta:= DWORD(BaseAddress) - IOH.ImageBase;
               rOffset:= RVATOOFFSET(IDD[5].VirtualAddress);
               IR:= @aBuffer[rOffset];
               While(IR.PageRVA <> 0) do
               begin
                    aBlock:= (IR.Size - 8)div 2;
                    rBlock:= Pointer(DWORD(IR) + 8);
                    While(aBlock > 0) do
                    begin
                         dType:= (rBlock^ and $F000) div $1000;
                         Offset:= Pointer(DWORD(rBlock^ and $FFF) + IR.PageRVA + DWORD(BaseAddress));
                         if dType = 3 then
                         begin
                              Offset^:= Offset^ + Delta;
                         end;
                         rBlock:= Pointer(DWORD(rBlock)+ 2);
                         aBlock:= aBlock - 1;
                    end;
                    IR:= Pointer(DWORD(IR)+ IR.Size);
               end;
               IID:= @aBuffer[RVATOOFFSET(IDD[1].VirtualAddress)];
               While(IID.Name <> 0) do
               begin
                    lFunction:= Pointer(DWORD(BaseAddress) + IID.FirstThunk);
                    While(lFunction^ <> 0) do
                    begin
                         if lFunction^ > $80000000 then
                         begin
                              Ordinal:= lFunction^-$80000000;
                              TempAddress:= DWORD(GPA(LoadLibraryA(@aBuffer[RVATOOFFSET(IID.Name)]),Ordinal));
                         end else
                         begin
                              TempAddress:= DWORD(GetProcAddress(LoadLibraryA(@aBuffer[RVATOOFFSET(IID.Name)]),@aBuffer[RVATOOFFSET(lFunction^+2)]));
                         end;
                         lFunction^:= TempAddress;
                         lFunction:= Pointer(DWORD(lFunction)+4);
                    end;
                    IID:= Pointer(DWORD(IID)+20);
               end;
               EP:= IOH.AddressOfEntryPoint + DWORD(BaseAddress);
               asm
               mov eax, EP
               jmp eax;
               end;
          end;
     end;
end;

PD: Algunos errores corregidos, añadido soporte para importación por ordinales.

¿Seria posible que resubieseis los links? Gracias y un saludo

Que faena, no  conservo los archivos, si alguien los conserva y los pudiera resubir sería perfecto. De todas formas, con el código puedes compilarlo perfectamente, croe que no faltaba nada, incluso el ejemplo está.

Saludos

Que rabia... yo lo tuve hace tiempo en el pc pero formateé  :( :(

Intentaré compilarlo entonces, pero ¿que programa uso? Visual Studio?

salu2

Sí, con Visual Studio, la 2008 o la 2010 deberían de ir perfectas.

Saludos

hay dos problemas con el código, 1º que no tiene en cuenta los imports que usan ordinal en vez de nombres y el segundo son los Forwarder imports

acá tienen una versión que hice de un "full"  GetProcAddress manual:

FARPROC WINAPI GetProcAddress(HMODULE hModule,LPCSTR lpProcName){
 DWORD index,dwExportSize,dwOrdinal=0;
 if(!hModule)return NULL;
 PIMAGE_DOS_HEADER pDosHeader;
 PIMAGE_NT_HEADERS pNTHeader;
 PIMAGE_EXPORT_DIRECTORY pExportDir;
pDosHeader=(PIMAGE_DOS_HEADER)hModule;
if(pDosHeader->e_magic!=IMAGE_DOS_SIGNATURE)
return NULL;
 pNTHeader=RVAPTR(PIMAGE_NT_HEADERS,pDosHeader,pDosHeader->e_lfanew);
if(pNTHeader->Signature!=IMAGE_NT_SIGNATURE)
return NULL;
 pExportDir=RVAPTR(PIMAGE_EXPORT_DIRECTORY,pDosHeader,pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
 dwExportSize=pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
 if(!pExportDir)
   return NULL;
 PCHAR* pszName=RVAPTR(PCHAR*,pDosHeader,pExportDir->AddressOfNames);
 PDWORD pdwAddress=RVAPTR(PDWORD,pDosHeader,pExportDir->AddressOfFunctions);
 PWORD pwOrdinals=RVAPTR(PWORD,pDosHeader,pExportDir->AddressOfNameOrdinals);
 if(!pszName||!pwOrdinals||!pdwAddress)
   return NULL;
 if(HIWORD(lpProcName)==0){
   // Look up by ordinal
   dwOrdinal=(LOWORD((DWORD)lpProcName)-pExportDir->Base);
 }else{
   // Look up by name
   for(index=0;index<pExportDir->NumberOfNames;index++){
     if(!lstrcmpA(RVAPTR(PCHAR,pDosHeader,pszName[index]),lpProcName)){
       dwOrdinal=pwOrdinals[index];
       break;
     }
   }
 }
 //Get Func Address
 DWORD dwFunction=RVAPTR(DWORD,pDosHeader,pdwAddress[dwOrdinal]);
 // Let's Check if is Forwarder
 if((dwFunction>(ULONG_PTR)pExportDir)&&(dwFunction<((ULONG_PTR)pExportDir+dwExportSize))){
   CHAR ForwarderDllName[MAX_PATH],*ForwardImportName;USHORT len;
   ForwardImportName=strchr((LPSTR)dwFunction,'.');
   len=ForwardImportName++-(LPSTR)dwFunction;
   strncpy(ForwarderDllName,(LPSTR)dwFunction,len);
   strcpy(&ForwarderDllName[len],".dll");
   // Find the module associated to it (should be already loaded)
   return GetProcAddress(GetModuleHandleA(ForwarderDllName),ForwardImportName);
 }
 return (FARPROC)dwFunction;
}

capaz lo pueden adaptar...

S2

Gracias Karman, y sí, lo de las importaciones por ordinal lo supe poco después de publicar el código, lo de los Forwareder Imports no se me había ocurrido. The Swash había publicado una corrección a éste código teniendo en cuenta las importaciones por ordinal, creo que en este foro también está publicado.

Pero bueno, gracias una vez más, leer código tuyo siempre es interesante, cuando tenga más tiempo publicaré una nueva versión de éste código y de la ClsHookAPI, que hace mucho tiempo que los hice y ya no me gusta demasiado como están hechos.

Saludos

Edito: Leyendolo por encima, una micro-mejora:


    strncpy(ForwarderDllName,(LPSTR)dwFunction,len);
    strcpy(&ForwarderDllName[len],".dll");
    // Find the module associated to it (should be already loaded)
    return GetProcAddress(GetModuleHandleA(ForwarderDllName),ForwardImportName)


El ".dll" no es necesario para llamar a GetModuleHandle ni a LoadLibrary, si no se especifica extensión la API toma por defecto siempre ".dll" :) .

Cita de: [Zero] en  8 Junio 2012, 23:48 PM
El ".dll" no es necesario para llamar a GetModuleHandle ni a LoadLibrary, si no se especifica extensión la API toma por defecto siempre ".dll" :) .

si y no, lo que pasa es que tengo mi custom GetModuleHandle también y para no tener que comprobar dos veces en la misma busco la dll con el nombre completo :P, pero si, si usás el GetModuleHandle original no es necesario...

S2