MemoryDLL
1.0.0
Cette bibliothèque ne fonctionne plus dans Windows 11 version 24h2. Les nouvelles améliorations de la sécurité rendent l'informatique non fonctionnelle. Je n'ai pas encore trouvé de correctif!
L'unité MemoryDLL fournit des fonctionnalités avancées pour charger des bibliothèques (DLL) dynamique-link directement à partir de la mémoire dans les environnements Win64. Contrairement aux méthodes traditionnelles qui impliquent le chargement des DLL à partir du système de fichiers, MemoryDll vous permet de charger les DLL à partir de tableaux d'octets ou de flux de mémoire?, Récupérer des adresses de fonction et les décharger - toutes en mémoire. Cette bibliothèque est idéale pour les développeurs Delphi / Freepascal qui ont besoin de gérer les DLL sans compter sur le système de fichiers, améliorant les performances ⚡ et la sécurité.
MemoryDll permet le chargement et la redirection de la DLL en mémoire en utilisant les DLL d'espace réservé et le chargement basé sur le crochet pour contourner le chargement de DLL basé sur des fichiers:
advapi32res.dll ). Cette DLL agit comme un déclencheur pour le crochet pour intercepter et gérer la redirection vers une DLL en mémoire. Compatibilité? : L'unité MemoryDLL est compatible avec les interfaces DLL standard, permettant une intégration facile avec les applications existantes. La méthode de redirection en mémoire réduit également les risques de sécurité, tels que l'injection de code?, Offrant une alternative sécurisée pour la gestion DLL.
Charge un module à partir d'une image de mémoire, imitant le comportement de la fonction LoadLibrary de l'api Windows. Il analyse le format PE, effectue les délocalisations nécessaires, résout les importations et initialise le module.
Data: Pointer - un pointeur vers l'image de mémoire se conformant au format PE.THandle représentant le module chargé ou 0 en panne.Pour intégrer avec succès MemoryDll dans votre projet, veuillez suivre ces étapes:
Télécharger la dernière version?
Décomposer le package
Ajouter MemoryDll à votre projet ➕
uses de votre projet. Cette inclusion mettra l'unité MemoryDll disponible pour une utilisation dans votre application. Assurez-vous que le chemin d'accès au fichier source MemoryDLL est correctement configuré dans les paramètres de votre projet pour éviter les erreurs de compilation.Intégration transparente avec la compatibilité de l'API Windows
MemoryLoadLibrary pour charger les DLL directement à partir de la mémoire. Une fois chargés, les appels API Windows standard tels que FreeLibrary et GetProcAddress peuvent être utilisés pour gérer la DLL en mémoire comme s'il avait été chargé à partir du système de fichiers. Cette conception garantit des modifications minimales au code existant, en maintenant la compatibilité avec les conventions de l'API Windows tout en permettant une manipulation efficace de DLL en mémoire.Testez l'intégration ✅
Pour instancier MemoryDll , incluez le code suivant à la fin de la section d'implémentation de l'unité. Ce code tente de charger la DLL en tant que ressource intégrée:
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();
Cette unité est basée sur le projet MemoryDll-Dllredirect d'origine par A-Normal-User. Nous remercions le travail fondamental sur lequel cette unité s'appuie.
Ce projet est licencié en vertu de la licence de clause BSD-3 ?, Qui permet la redistribution et l'utilisation dans les formulaires source et binaire, avec ou sans modification, à condition que certaines conditions soient remplies. Il établit un équilibre entre la permissivité et la protection des droits des contributeurs.
Les contributions à MemoryDLL sont fortement encouragées. N'hésitez pas à soumettre des problèmes, à suggérer de nouvelles fonctionnalités ou à créer des demandes de traction pour étendre ses capacités et sa robustesse.
Fait avec ❤️ à Delphi
