You can use libPeConv to manually load a PE file (EXE or DLL) from either a file path or a memory buffer and execute it. The process typically involves:
- Loading the PE: Use
peconv::load_pe_executable to map the PE into memory. If loading from a file, use peconv::load_file first to get a buffer. - PEB Integration: If the loaded PE needs to access resources, call
peconv::set_main_module_in_peb to connect it to the Process Environment Block (PEB). - Handling Imports: Use
peconv::load_delayed_imports to resolve delayed imports. - TLS Callbacks: If the PE uses Thread Local Storage, run
peconv::run_tls_callbacks before reaching the Entry Point. - Execution: Retrieve the Entry Point RVA using
peconv::get_entry_point_rva, calculate its Virtual Address (VA), and call it.
Note: Applications using MUI (Multilingual User Interface) are not supported.
#include <Windows.h>
#include <iostream>
#include <peconv.h>
int main(int argc, char *argv[])
{
if (argc < 2) {
std::cout << "Args: <path to the exe>" << std::endl;
return 0;
}
LPCSTR pe_path = argv[1];
// manually load the PE file using libPeConv:
size_t v_size = 0;
#ifdef LOAD_FROM_PATH
//if the PE is dropped on the disk, you can load it from the file:
BYTE* my_pe = peconv::load_pe_executable(pe_path, v_size);
#else
size_t bufsize = 0;
BYTE *buffer = peconv::load_file(pe_path, bufsize);
// if the file is NOT dropped on the disk, you can load it directly from a memory buffer:
BYTE* my_pe = peconv::load_pe_executable(buffer, bufsize, v_size);
#endif
if (!my_pe) {
return -1;
}
// if the loaded PE needs to access resources, you may need to connect it to the PEB:
peconv::set_main_module_in_peb((HMODULE)my_pe);
// load delayed imports (if present):
const ULONGLONG load_base = (ULONGLONG)my_pe;
peconv::load_delayed_imports(my_pe, load_base);
// if needed, you can run TLS callbacks before the Entry Point:
peconv::run_tls_callbacks(my_pe, v_size);
//calculate the Entry Point of the manually loaded module
DWORD ep_rva = peconv::get_entry_point_rva(my_pe);
if (!ep_rva) {
return -2;
}
ULONG_PTR ep_va = ep_rva + (ULONG_PTR) my_pe;
//assuming that the payload is an EXE file (not DLL) this will be the simplest prototype of the main:
int (*new_main)() = (int(*)())ep_va;
//call the Entry Point of the manually loaded PE:
return new_main();
}
