MemoryDLL
1.0.0
Esta biblioteca não funciona mais no Windows 11 versão 24h2. Os novos aprimoramentos de segurança o tornam não funcional. Ainda não encontrei uma correção!
A unidade MemoryDLL fornece funcionalidade avançada para carregar bibliotecas de link dinâmico (DLLs) diretamente da memória nos ambientes Win64. Diferentemente dos métodos tradicionais que envolvem o carregamento de DLLs do sistema de arquivos, o MemoryDll permite carregar DLLs de matrizes de bytes ou fluxos de memória?, Recuperar endereços de função e descarregá-los-tudo em memória. Esta biblioteca é ideal para desenvolvedores Delphi/Freepascal que precisam gerenciar DLLs sem confiar no sistema de arquivos, aprimorando o desempenho ⚡ e a segurança.
O MemoryDll permite o carregamento e o redirecionamento da DLL na memória usando DLLs de espaço reservado e carregamento baseado em gancho para ignorar o carregamento tradicional de DLL baseado em arquivos:
advapi32res.dll ). Esta DLL atua como um gatilho para o gancho interceptar e manipular redirecionamento para uma DLL na memória. Compatibilidade? : A unidade MemoryDLL é compatível com interfaces de DLL padrão, permitindo fácil integração com aplicativos existentes. O método de redirecionamento na memória também reduz os riscos de segurança, como a injeção de código?, Oferecendo uma alternativa segura para o gerenciamento da DLL.
Carrega um módulo a partir de uma imagem de memória, imitando o comportamento da função Windows API LoadLibrary . Ele analisa o formato PE, realiza as realocações necessárias, resolve as importações e inicializa o módulo.
Data: Pointer - Um ponteiro para a imagem da memória em conformidade com o formato PE.THandle representando o módulo carregado ou 0 na falha.Para integrar com êxito o MemoryDll ao seu projeto, siga estas etapas:
Baixe a versão mais recente?
Descompacte o pacote
Adicione MemoryDll ao seu projeto ➕
uses do seu projeto. Essa inclusão disponibilizará a unidade MemoryDLL para uso em seu aplicativo. Verifique se o caminho para o arquivo de origem MemoryDLL está definido corretamente nas configurações do seu projeto para evitar erros de compilação.Integração perfeita com compatibilidade da API do Windows
MemoryLoadLibrary para carregar DLLs diretamente da memória. Uma vez carregado, as chamadas da API do Windows padrão, como FreeLibrary e GetProcAddress podem ser usadas para gerenciar a DLL na memória, como se fosse carregada do sistema de arquivos. Esse design garante alterações mínimas no código existente, mantendo a compatibilidade com as convenções da API do Windows, ao mesmo tempo em que permite o manuseio eficiente da DLL na memória.Teste a integração ✅
Para instanciar o MemoryDLL , inclua o código a seguir no final da seção de implementação da unidade. Este código tenta carregar a DLL como um recurso incorporado:
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 unidade é baseada no projeto MemoryDLL-DLLredirect original pelo A-Normal-User. Agradecemos o trabalho fundamental que esta unidade se baseia.
Este projeto está licenciado sob a licença de BSD-3-cláusula ?, Que permite a redistribuição e uso em formulários de origem e binária, com ou sem modificação, desde que certas condições sejam atendidas. Ele atinge um equilíbrio entre permissividade e proteção dos direitos dos colaboradores.
As contribuições para o MemoryDll são altamente encorajadas. Sinta -se à vontade para enviar questões, sugerir novos recursos ou criar solicitações de tração para expandir suas capacidades e robustez.
Feito com ❤️ em Delphi
