MemoryDLL
1.0.0
Esta biblioteca ya no funciona en Windows 11 versión 24h2. Las nuevas mejoras de seguridad lo hacen no funcional. ¡No he encontrado una solución todavía!
La unidad MemoryDLL proporciona funcionalidad avanzada para cargar bibliotecas de enlace dinámico (DLL) directamente desde la memoria en entornos Win64. A diferencia de los métodos tradicionales que implican la carga de DLL desde el sistema de archivos, MemoryDLL le permite cargar DLL de matrices de bytes o secuencias de memoria, recuperar direcciones de función y descargarlas, toda en memoria. Esta biblioteca es ideal para los desarrolladores de Delphi/Freepascal que necesitan administrar DLL sin depender del sistema de archivos, mejorando tanto el rendimiento ⚡ como la seguridad.
MemoryDLL habilita la carga y redirección de DLL en memoria utilizando DLLS de marcador de posición y carga basada en gancho para evitar la carga de DLL basada en archivos tradicional:
advapi32res.dll ). Esta DLL actúa como un desencadenante para que el gancho intercepte y maneje la redirección a una DLL en memoria. Compatibilidad? : La unidad MemoryDLL es compatible con las interfaces DLL estándar, lo que permite una fácil integración con las aplicaciones existentes. El método de redirección en memoria también reduce los riesgos de seguridad, como la inyección de código?, Ofreciendo una alternativa segura para el manejo de DLL.
Carga un módulo de una imagen de memoria, imitando el comportamiento de la función LoadLibrary API de Windows. Analiza el formato PE, realiza reubicaciones necesarias, resuelve las importaciones e inicializa el módulo.
Data: Pointer : un puntero a la imagen de memoria que se ajusta al formato PE.THandle que representa el módulo cargado o 0 en la falla.Para integrar con éxito memoria en su proyecto, siga estos pasos:
¿Descargar la última versión?
Descompensar el paquete
Agregue MemoryDLL a su proyecto ➕
uses de su proyecto. Esta inclusión pondrá a disposición la unidad MemoryDll para su uso en su aplicación. Asegúrese de que la ruta al archivo fuente de MemoryDLL esté configurada correctamente en la configuración de su proyecto para evitar errores de compilación.Integración perfecta con la compatibilidad de la API de Windows
MemoryLoadLibrary para cargar DLL directamente desde la memoria. Una vez cargado, las llamadas de API de Windows estándar, como FreeLibrary y GetProcAddress se pueden usar para administrar la DLL en memoria como si se cargara desde el sistema de archivos. Este diseño garantiza cambios mínimos en el código existente, manteniendo la compatibilidad con las convenciones de la API de Windows al tiempo que permite un manejo eficiente de DLL en memoria.Prueba la integración ✅
Para instanciar MemoryDLL , incluya el siguiente código al final de la sección de implementación de la unidad. Este código intenta cargar la DLL como un recurso integrado:
uses
Windows,
MemoryDLL;
...
implementation
{
This code is an example of using MemoryDLL to load an embedded a DLL directly
from an embedded resource in memory, ensuring that no filesystem access is
required. It includes methods for loading, initializing, and unloading the
DLL. The DLL is loaded from a resource with a GUID name, providing a measure
of security by obfuscating the resource’s identity.
Variables:
- DLLHandle: THandle
- A handle to the loaded DLL. Initialized to 0, indicating the DLL has
not been loaded. It is updated with the handle returned from
LoadLibrary when the DLL is successfullyloaded from memory.
Functions:
- LoadDLL: Boolean
- Loads the DLL from an embedded resource and initializes it by
retrieving necessary exported functions. Returns True if the DLL is
loaded successfully, otherwise False.
- b6eb28fd6ebe48359ef93aef774b78d1: string
- A GUID-named helper function that returns the resource name for the DLL.
This GUID-like name helps avoid easy detection of the resource.
- UnloadDLL: procedure
- Unloads the DLL by freeing the library associated with DLLHandle. Resets
DLLHandle to 0 to indicate the DLL is unloaded.
Initialization:
- The LoadDLL function is called during initialization, and the program will
terminate with code 1 if the DLL fails to load.
Finalization:
- The UnloadDLL procedure is called upon finalization, ensuring the DLL is
unloaded before program termination.
}
var
DLLHandle: THandle = 0 ; // Global handle to the loaded DLL, 0 when not loaded.
{
LoadDLL
--------
Attempts to load a DLL directly from a resource embedded within the executable
file. This DLL is expected to be stored as an RCDATA resource under a specific
GUID-like name.
Returns:
Boolean - True if the DLL is successfully loaded, False otherwise.
}
function LoadDLL (): Boolean;
var
LResStream: TResourceStream; // Stream to access the DLL data stored in the
resource.
{
b6eb28fd6ebe48359ef93aef774b78d1
---------------------------------
Returns the name of the embedded DLL resource. Uses a GUID-like name for
obfuscation.
Returns:
string - The name of the resource containing the DLL data.
}
function b6eb28fd6ebe48359ef93aef774b78d1 (): string;
const
// GUID-like resource name for the embedded DLL.
CValue = ' b87deef5bbfd43c3a07379e26f4dec9b ' ;
begin
Result := CValue;
end ;
begin
Result := False;
// Check if the DLL is already loaded.
if DLLHandle <> 0 then Exit;
// Ensure the DLL resource exists.
if not Boolean((FindResource(HInstance,
PChar(b6eb28fd6ebe48359ef93aef774b78d1()), RT_RCDATA) <> 0 )) then Exit;
// Create a stream for the DLL resource data.
LResStream := TResourceStream.Create(HInstance,
b6eb28fd6ebe48359ef93aef774b78d1(), RT_RCDATA);
try
// Attempt to load the DLL from the resource stream.
DLLHandle := MemoryLoadLibrary(LResStream.Memory);
if DLLHandle = 0 then Exit; // Loading failed.
// Retrieve and initialize any necessary function exports from the DLL.
GetExports(DLLHandle);
Result := True; // Successful load and initialization.
finally
LResStream.Free(); // Release the resource stream.
end ;
end ;
{
UnloadDLL
---------
Frees the loaded DLL, releasing any resources associated with DLLHandle,
and resets DLLHandle to 0.
}
procedure UnloadDLL ();
begin
if DLLHandle <> 0 then
begin
FreeLibrary(DLLHandle); // Unload the DLL.
DLLHandle := 0 ; // Reset DLLHandle to indicate the DLL is no longer loaded.
end ;
end ;
initialization
// Attempt to load the DLL upon program startup. Halt execution with error
// code 1 if it fails.
if not LoadDLL() then
begin
Halt( 1 );
end ;
finalization
// Ensure the DLL is unloaded upon program termination.
UnloadDLL();
Esta unidad se basa en el proyecto original MemoryDll-Dllredirect por un usuario normal. Agradecemos el trabajo fundamental sobre el que se basa esta unidad.
¿Este proyecto tiene licencia bajo la licencia de cláusula BSD-3 ?, Que permite redistribución y uso en formularios de origen y binarios, con o sin modificación, siempre que se cumplan ciertas condiciones. Se logra un equilibrio entre la permisividad y la protección de los derechos de los contribuyentes.
Las contribuciones a MemoryDLL están muy alentadas. No dude en enviar problemas, sugerir nuevas funciones o crear solicitudes de extracción para expandir sus capacidades y robustez.
Hecho con ❤️ en Delphi
