diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 4f96c20dc..ad681ba95 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -260,6 +260,7 @@ - [Ad Certificates](windows-hardening/active-directory-methodology/ad-certificates.md) - [AD information in printers](windows-hardening/active-directory-methodology/ad-information-in-printers.md) - [AD DNS Records](windows-hardening/active-directory-methodology/ad-dns-records.md) + - [Adws Enumeration](windows-hardening/active-directory-methodology/adws-enumeration.md) - [ASREPRoast](windows-hardening/active-directory-methodology/asreproast.md) - [BloodHound & Other AD Enum Tools](windows-hardening/active-directory-methodology/bloodhound.md) - [Constrained Delegation](windows-hardening/active-directory-methodology/constrained-delegation.md) diff --git a/src/windows-hardening/active-directory-methodology/adws-enumeration.md b/src/windows-hardening/active-directory-methodology/adws-enumeration.md new file mode 100644 index 000000000..111a4b187 --- /dev/null +++ b/src/windows-hardening/active-directory-methodology/adws-enumeration.md @@ -0,0 +1,106 @@ +# Active Directory Web Services (ADWS) Enumeration & Stealth Collection + +{{#include ../../banners/hacktricks-training.md}} + +## Che cos'è ADWS? + +Active Directory Web Services (ADWS) è **abilitato per impostazione predefinita su ogni Domain Controller da Windows Server 2008 R2** e ascolta su TCP **9389**. Nonostante il nome, **non è coinvolto alcun HTTP**. Invece, il servizio espone dati in stile LDAP attraverso un insieme di protocolli di incapsulamento proprietari .NET: + +* MC-NBFX → MC-NBFSE → MS-NNS → MC-NMF + +Poiché il traffico è incapsulato all'interno di questi frame SOAP binari e viaggia su una porta poco comune, **l'enumerazione tramite ADWS è molto meno probabile che venga ispezionata, filtrata o firmata rispetto al traffico LDAP classico/389 & 636**. Per gli operatori questo significa: + +* Ricognizione più furtiva – I team Blue spesso si concentrano sulle query LDAP. +* Libertà di raccogliere da **host non Windows (Linux, macOS)** tunnelando 9389/TCP attraverso un proxy SOCKS. +* Gli stessi dati che otterresti tramite LDAP (utenti, gruppi, ACL, schema, ecc.) e la possibilità di eseguire **scritture** (ad es. `msDs-AllowedToActOnBehalfOfOtherIdentity` per **RBCD**). + +> NOTA: ADWS è utilizzato anche da molti strumenti GUI/PowerShell RSAT, quindi il traffico può mescolarsi con l'attività amministrativa legittima. + +## SoaPy – Client Python Nativo + +[SoaPy](https://github.com/logangoins/soapy) è una **re-implementazione completa dello stack di protocolli ADWS in puro Python**. Crea i frame NBFX/NBFSE/NNS/NMF byte per byte, consentendo la raccolta da sistemi simili a Unix senza toccare il runtime .NET. + +### Caratteristiche Principali + +* Supporta **il proxy attraverso SOCKS** (utile da impianti C2). +* Filtri di ricerca a grana fine identici a LDAP `-q '(objectClass=user)'`. +* Operazioni di **scrittura** opzionali ( `--set` / `--delete` ). +* Modalità di output **BOFHound** per l'ingestione diretta in BloodHound. +* Flag `--parse` per abbellire i timestamp / `userAccountControl` quando è necessaria la leggibilità umana. + +### Installazione (host operatore) +```bash +python3 -m pip install soapy-adws # or git clone && pip install -r requirements.txt +``` +## Stealth AD Collection Workflow + +Il seguente flusso di lavoro mostra come enumerare **oggetti di dominio e ADCS** tramite ADWS, convertirli in JSON di BloodHound e cercare percorsi di attacco basati su certificati – tutto da Linux: + +1. **Tunnel 9389/TCP** dalla rete target al tuo box (ad esempio tramite Chisel, Meterpreter, SSH dynamic port-forward, ecc.). Esporta `export HTTPS_PROXY=socks5://127.0.0.1:1080` o usa `--proxyHost/--proxyPort` di SoaPy. + +2. **Raccogli l'oggetto del dominio radice:** +```bash +soapy ludus.domain/jdoe:'P@ssw0rd'@10.2.10.10 \ +-q '(objectClass=domain)' \ +| tee data/domain.log +``` +3. **Raccogliere oggetti correlati a ADCS dalla Configuration NC:** +```bash +soapy ludus.domain/jdoe:'P@ssw0rd'@10.2.10.10 \ +-dn 'CN=Configuration,DC=ludus,DC=domain' \ +-q '(|(objectClass=pkiCertificateTemplate)(objectClass=CertificationAuthority) \\ +(objectClass=pkiEnrollmentService)(objectClass=msPKI-Enterprise-Oid))' \ +| tee data/adcs.log +``` +4. **Converti in BloodHound:** +```bash +bofhound -i data --zip # produces BloodHound.zip +``` +5. **Carica il ZIP** nell'interfaccia grafica di BloodHound ed esegui query cypher come `MATCH (u:User)-[:Can_Enroll*1..]->(c:CertTemplate) RETURN u,c` per rivelare i percorsi di escalation dei certificati (ESC1, ESC8, ecc.). + +### Scrittura di `msDs-AllowedToActOnBehalfOfOtherIdentity` (RBCD) +```bash +soapy ludus.domain/jdoe:'P@ssw0rd'@dc.ludus.domain \ +--set 'CN=Victim,OU=Servers,DC=ludus,DC=domain' \ +msDs-AllowedToActOnBehalfOfOtherIdentity 'B:32:01....' +``` +Combina questo con `s4u2proxy`/`Rubeus /getticket` per una completa **Resource-Based Constrained Delegation** chain. + +## Rilevamento e Indurimento + +### Logging Verboso di ADDS + +Abilita le seguenti chiavi di registro sui Domain Controllers per evidenziare ricerche costose / inefficienti provenienti da ADWS (e LDAP): +```powershell +New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Diagnostics' -Name '15 Field Engineering' -Value 5 -Type DWORD +New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Parameters' -Name 'Expensive Search Results Threshold' -Value 1 -Type DWORD +New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Parameters' -Name 'Search Time Threshold (msecs)' -Value 0 -Type DWORD +``` +Gli eventi appariranno sotto **Directory-Service** con il filtro LDAP completo, anche quando la query è arrivata tramite ADWS. + +### Oggetti SACL Canary + +1. Crea un oggetto fittizio (ad es. utente disabilitato `CanaryUser`). +2. Aggiungi un **Audit** ACE per il principale _Everyone_, auditato su **ReadProperty**. +3. Ogni volta che un attaccante esegue `(servicePrincipalName=*)`, `(objectClass=user)` ecc., il DC emette **Event 4662** che contiene il vero SID dell'utente – anche quando la richiesta è proxy o proviene da ADWS. + +Esempio di regola predefinita di Elastic: +```kql +(event.code:4662 and not user.id:"S-1-5-18") and winlog.event_data.AccessMask:"0x10" +``` +## Riepilogo degli Strumenti + +| Scopo | Strumento | Note | +|-------|-----------|------| +| Enumerazione ADWS | [SoaPy](https://github.com/logangoins/soapy) | Python, SOCKS, lettura/scrittura | +| Ingestione BloodHound | [BOFHound](https://github.com/bohops/BOFHound) | Converte i log di SoaPy/ldapsearch | +| Compromissione Cert | [Certipy](https://github.com/ly4k/Certipy) | Può essere proxy attraverso lo stesso SOCKS | + +## Riferimenti + +* [SpecterOps – Assicurati di usare SOAP(y) – Una guida per operatori alla raccolta stealth di AD usando ADWS](https://specterops.io/blog/2025/07/25/make-sure-to-use-soapy-an-operators-guide-to-stealthy-ad-collection-using-adws/) +* [SoaPy GitHub](https://github.com/logangoins/soapy) +* [BOFHound GitHub](https://github.com/bohops/BOFHound) +* [Microsoft – Specifiche MC-NBFX, MC-NBFSE, MS-NNS, MC-NMF](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-nbfx/) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/bloodhound.md b/src/windows-hardening/active-directory-methodology/bloodhound.md index 7b97a0896..198f4356b 100644 --- a/src/windows-hardening/active-directory-methodology/bloodhound.md +++ b/src/windows-hardening/active-directory-methodology/bloodhound.md @@ -1,87 +1,78 @@ -# BloodHound & Other AD Enum Tools +# BloodHound & Altri Strumenti di Enumerazione di Active Directory {{#include ../../banners/hacktricks-training.md}} +{{#ref}} +adws-enumeration.md +{{#endref}} + +> NOTA: Questa pagina raggruppa alcune delle utility più utili per **enumerare** e **visualizzare** le relazioni di Active Directory. Per la raccolta attraverso il canale stealthy **Active Directory Web Services (ADWS)** controlla il riferimento sopra. + +--- + ## AD Explorer -[AD Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/adexplorer) è parte della Sysinternal Suite: +[AD Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/adexplorer) (Sysinternals) è un avanzato **visualizzatore e editor di AD** che consente: -> Un visualizzatore e editor avanzato di Active Directory (AD). Puoi utilizzare AD Explorer per navigare facilmente in un database AD, definire posizioni preferite, visualizzare proprietà e attributi degli oggetti senza aprire finestre di dialogo, modificare permessi, visualizzare uno schema di oggetto ed eseguire ricerche sofisticate che puoi salvare e rieseguire. +* Navigazione GUI dell'albero della directory +* Modifica degli attributi degli oggetti e dei descrittori di sicurezza +* Creazione / confronto di snapshot per analisi offline -### Snapshots +### Utilizzo rapido -AD Explorer può creare snapshot di un AD in modo da poterlo controllare offline.\ -Può essere utilizzato per scoprire vulnerabilità offline o per confrontare diversi stati del database AD nel tempo. +1. Avvia lo strumento e connettiti a `dc01.corp.local` con qualsiasi credenziale di dominio. +2. Crea uno snapshot offline tramite `File ➜ Create Snapshot`. +3. Confronta due snapshot con `File ➜ Compare` per individuare le variazioni di permessi. -Ti verranno richiesti il nome utente, la password e la direzione per connetterti (è richiesto un qualsiasi utente AD). - -Per prendere uno snapshot di AD, vai su `File` --> `Create Snapshot` e inserisci un nome per lo snapshot. +--- ## ADRecon -[**ADRecon**](https://github.com/adrecon/ADRecon) è uno strumento che estrae e combina vari artefatti da un ambiente AD. Le informazioni possono essere presentate in un **report** Microsoft Excel **formattato in modo speciale** che include viste riassuntive con metriche per facilitare l'analisi e fornire un quadro olistico dello stato attuale dell'ambiente AD target. -```bash -# Run it -.\ADRecon.ps1 +[ADRecon](https://github.com/adrecon/ADRecon) estrae un ampio set di artefatti da un dominio (ACL, GPO, trust, modelli CA …) e produce un **report Excel**. +```powershell +# On a Windows host in the domain +PS C:\> .\ADRecon.ps1 -OutputDir C:\Temp\ADRecon ``` -## BloodHound +--- -From [https://github.com/BloodHoundAD/BloodHound](https://github.com/BloodHoundAD/BloodHound) +## BloodHound (visualizzazione grafica) -> BloodHound è un'applicazione web Javascript a pagina singola, costruita su [Linkurious](http://linkurio.us/), compilata con [Electron](http://electron.atom.io/), con un database [Neo4j](https://neo4j.com/) alimentato da un raccoglitore di dati C#. +[BloodHound](https://github.com/BloodHoundAD/BloodHound) utilizza la teoria dei grafi + Neo4j per rivelare relazioni di privilegio nascoste all'interno di AD on-prem e Azure AD. -BloodHound utilizza la teoria dei grafi per rivelare le relazioni nascoste e spesso non intenzionali all'interno di un ambiente Active Directory o Azure. Gli attaccanti possono utilizzare BloodHound per identificare facilmente percorsi di attacco altamente complessi che altrimenti sarebbero impossibili da identificare rapidamente. I difensori possono utilizzare BloodHound per identificare ed eliminare quegli stessi percorsi di attacco. Sia i team blue che red possono utilizzare BloodHound per ottenere facilmente una comprensione più profonda delle relazioni di privilegio in un ambiente Active Directory o Azure. - -Quindi, [Bloodhound](https://github.com/BloodHoundAD/BloodHound) è uno strumento straordinario che può enumerare automaticamente un dominio, salvare tutte le informazioni, trovare possibili percorsi di escalation dei privilegi e mostrare tutte le informazioni utilizzando grafici. - -BloodHound è composto da 2 parti principali: **ingestors** e **l'applicazione di visualizzazione**. - -Gli **ingestors** vengono utilizzati per **enumerare il dominio ed estrarre tutte le informazioni** in un formato che l'applicazione di visualizzazione comprenderà. - -L'**applicazione di visualizzazione utilizza neo4j** per mostrare come tutte le informazioni siano correlate e per mostrare diversi modi per escalare i privilegi nel dominio. - -### Installazione - -Dopo la creazione di BloodHound CE, l'intero progetto è stato aggiornato per facilitare l'uso con Docker. Il modo più semplice per iniziare è utilizzare la sua configurazione Docker Compose preconfigurata. - -1. Installa Docker Compose. Questo dovrebbe essere incluso con l'installazione di [Docker Desktop](https://www.docker.com/products/docker-desktop/). -2. Esegui: +### Distribuzione (Docker CE) ```bash curl -L https://ghst.ly/getbhce | docker compose -f - up +# Web UI ➜ http://localhost:8080 (user: admin / password from logs) ``` -3. Trova la password generata casualmente nell'output del terminale di Docker Compose. -4. In un browser, vai su http://localhost:8080/ui/login. Accedi con il nome utente **`admin`** e una **`password generata casualmente`** che puoi trovare nei log di docker compose. +### Raccoltori -Dopo questo, dovrai cambiare la password generata casualmente e avrai l'interfaccia nuova pronta, da cui puoi scaricare direttamente gli ingestors. +* `SharpHound.exe` / `Invoke-BloodHound` – variante nativa o PowerShell +* `AzureHound` – enumerazione di Azure AD +* **SoaPy + BOFHound** – raccolta ADWS (vedi link in alto) -### SharpHound +#### Modalità comuni di SharpHound +```powershell +SharpHound.exe --CollectionMethods All # Full sweep (noisy) +SharpHound.exe --CollectionMethods Group,LocalAdmin,Session,Trusts,ACL +SharpHound.exe --Stealth --LDAP # Low noise LDAP only +``` +I collezionisti generano JSON che viene ingerito tramite l'interfaccia grafica di BloodHound. -Hanno diverse opzioni, ma se vuoi eseguire SharpHound da un PC unito al dominio, utilizzando il tuo utente attuale e estrarre tutte le informazioni, puoi fare: -``` -./SharpHound.exe --CollectionMethods All -Invoke-BloodHound -CollectionMethod All -``` -> Puoi leggere di più su **CollectionMethod** e sulla sessione loop [qui](https://support.bloodhoundenterprise.io/hc/en-us/articles/17481375424795-All-SharpHound-Community-Edition-Flags-Explained) - -Se desideri eseguire SharpHound utilizzando credenziali diverse, puoi creare una sessione CMD netonly ed eseguire SharpHound da lì: -``` -runas /netonly /user:domain\user "powershell.exe -exec bypass" -``` -[**Scopri di più su Bloodhound in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-with-bloodhound-on-kali-linux) +--- ## Group3r -[**Group3r**](https://github.com/Group3r/Group3r) è uno strumento per trovare **vulnerabilità** in Active Directory associate a **Group Policy**. \ -È necessario **eseguire group3r** da un host all'interno del dominio utilizzando **qualsiasi utente del dominio**. +[Group3r](https://github.com/Group3r/Group3r) enumera **Group Policy Objects** e mette in evidenza le configurazioni errate. ```bash -group3r.exe -f -# -s sends results to stdin -# -f send results to file +# Execute inside the domain +Group3r.exe -f gpo.log # -s to stdout ``` +--- + ## PingCastle -[**PingCastle**](https://www.pingcastle.com/documentation/) **valuta la postura di sicurezza di un ambiente AD** e fornisce un bel **report** con grafici. - -Per eseguirlo, puoi eseguire il file binario `PingCastle.exe` e inizierà una **sessione interattiva** presentando un menu di opzioni. L'opzione predefinita da utilizzare è **`healthcheck`** che stabilirà una **panoramica** di base del **dominio**, e troverà **misconfigurazioni** e **vulnerabilità**. - +[PingCastle](https://www.pingcastle.com/documentation/) esegue un **health-check** di Active Directory e genera un report HTML con punteggio di rischio. +```powershell +PingCastle.exe --healthcheck --server corp.local --user bob --password "P@ssw0rd!" +``` {{#include ../../banners/hacktricks-training.md}}