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

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

• 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.

//-------------------------------------------------------------------------------------------
//					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);
}
 

section '.reloc' fixups data discardable