---
title: "IAM cloud: chi può fare cosa"
domain: cloud-computing
level: intermediate
duration: "50 min"
objectives:
  - "Spiegare gli elementi di base dell'IAM cloud: principal (utenti, gruppi, ruoli, service account), autenticazione e autorizzazione, e come viene valutata una richiesta."
  - "Leggere e scrivere policy di accesso JSON con azioni, risorse, effetti e condizioni, e prevedere il risultato quando istruzioni di consenso e di negazione si sovrappongono."
  - "Applicare il principio del privilegio minimo e confrontare il controllo degli accessi basato sui ruoli (RBAC) e quello basato sugli attributi (ABAC)."
  - "Spiegare le credenziali temporanee e la federazione (SAML 2.0, OpenID Connect) e perché sono più sicure delle chiavi di accesso di lunga durata."
  - "Valutare gli errori IAM più comuni (policy con caratteri jolly, chiavi trapelate, account inutilizzati, assenza di MFA) e come rilevarli."
lang: it
source_hash: 3b4a802e0a01
---

# IAM cloud: chi può fare cosa

## Perché è importante
Un venerdì pomeriggio una sviluppatrice invia una piccola correzione a un repository pubblico di codice. Nel commit si nasconde un file con una chiave di accesso al cloud, quella che aveva creato due anni prima "solo per fare una prova". In pochi minuti alcuni scanner automatici la trovano. Il sabato mattina l'account sta eseguendo centinaia di server per un miner di criptovalute, e il bucket con le esportazioni dei clienti è stato copiato altrove. Nessuno ha "violato" nulla nel senso dei film: l'attaccante ha semplicemente chiesto al cloud di eseguire delle operazioni, e il cloud ha verificato che la chiave fosse valida e che la policy associata consentisse le azioni richieste. La policy le consentiva, perché la chiave apparteneva a un amministratore.

Nel cloud, la console e l'interfaccia di programmazione delle applicazioni (API, Application Programming Interface) sono raggiungibili da qualsiasi punto di Internet. Non esiste una rete aziendale dietro cui nascondersi, quindi l'**identità** diventa il vero perimetro. La **gestione delle identità e degli accessi (IAM, Identity and Access Management)** è la parte di ogni cloud che decide chi sta facendo la richiesta e che cosa può fare. Conoscerla a fondo ti permette di dare a ogni persona e a ogni programma esattamente l'accesso di cui ha bisogno, preferibilmente per pochi minuti invece che per sempre, e di leggere la policy di qualcun altro capendo che cosa consenta davvero.

## Obiettivi di apprendimento
- Spiegare gli elementi di base dell'IAM cloud: principal (utenti, gruppi, ruoli, service account), autenticazione e autorizzazione, e come viene valutata una richiesta.
- Leggere e scrivere policy di accesso JSON con azioni, risorse, effetti e condizioni, e prevedere il risultato quando istruzioni di consenso e di negazione si sovrappongono.
- Applicare il principio del privilegio minimo e confrontare il controllo degli accessi basato sui ruoli (RBAC) e quello basato sugli attributi (ABAC).
- Spiegare le credenziali temporanee e la federazione (SAML 2.0, OpenID Connect) e perché sono più sicure delle chiavi di accesso di lunga durata.
- Valutare gli errori IAM più comuni (policy con caratteri jolly, chiavi trapelate, account inutilizzati, assenza di MFA) e come rilevarli.

## Concetti chiave

### Principal: chi sta facendo la richiesta?
Pensa a un edificio con un lettore di badge su ogni porta. Ogni badge appartiene a qualcuno o a qualcosa, e ogni porta ha una regola su quali badge la aprono. Nel cloud, il titolare del badge è un **principal**: qualsiasi identità che può inviare una richiesta al cloud ed essere riconosciuta. La maggior parte dei cloud offre gli stessi quattro tipi:

| Principal | Che cos'è | Uso tipico |
|---|---|---|
| **Utente** | Un'identità con nome per una singola persona, di solito con una password e un secondo fattore. Può avere anche **chiavi di accesso** per la riga di comando e per i programmi. | Un ingegnere che accede alla console. |
| **Gruppo** | Un insieme di utenti. Un gruppo non è esso stesso un principal: non puoi accedere come gruppo. Gli associ delle policy e ogni membro le eredita. | `analysts`, `network-admins`. |
| **Ruolo** | Un'identità con permessi ma **senza password e senza chiavi permanenti**. Qualcuno o qualcosa la *assume* e riceve credenziali temporanee. | Una persona che ha bisogno di un accesso elevato per un'ora; un server; un utente di un altro account. |
| **Service account** (detto anche identità del carico di lavoro o identità di macchina) | L'identità di un programma anziché di una persona: un'applicazione, una macchina virtuale (VM), un container, una pipeline. | Un'applicazione web che legge un bucket. |

![IAM cloud in sintesi. A sinistra i principal: un utente (una persona con password e MFA), un gruppo (un insieme di utenti, con le policy associate una sola volta), un ruolo (assunto temporaneamente, senza password né chiave) e un service account (identità di un'applicazione o di una VM). Al centro il motore di autorizzazione: autentica chi chiama, valuta le policy, consente o nega; legge le policy sottostanti, una policy di identità sul principal e una policy sulla risorsa. A destra le risorse: il bucket lab-data con ARN arn:aws:s3:::lab-data e una macchina virtuale, raggiunti solo se la richiesta è consentita. Una striscia in basso mostra che cosa trasporta una richiesta: principal, azione s3:GetObject, risorsa arn:aws:s3:::lab-data/reports/q3.txt e contesto come ora, IP di origine e MFA](../../../assets/diagrams/iam-who-what-resource.it.svg)

*Figura 1. Ogni richiesta trasporta un principal, un'azione, una risorsa e un contesto; il motore di autorizzazione li confronta con le policy e risponde consenti o nega.*

Ogni principal ha un nome univoco nel formato del provider. In Amazon Web Services (AWS) è un **Amazon Resource Name (ARN)** come `arn:aws:iam::123456789012:user/bob`: `arn`, la partizione, il servizio, la regione (vuota per IAM), l'ID dell'account e la risorsa. Altri provider usano formati propri (un indirizzo simile a un'email per un service account di Google Cloud, un ID oggetto per Microsoft Entra), ma l'idea è la stessa.

Al vertice di ogni account c'è un'altra identità: l'**utente root** (chiamato proprietario o amministratore globale in altri cloud). Viene creato insieme all'account, può fare qualsiasi cosa e non può essere limitato dalle normali policy. Lo proteggi e non lo usi quasi mai.

> [!NOTE]
> Questo modulo usa il vocabolario e la sintassi delle policy di AWS IAM perché sono i più diffusi: molti servizi di storage compatibili con S3 presso altri provider accettano lo stesso JSON per le bucket policy, e strumenti open source lo emulano, motivo per cui il laboratorio può girare sul tuo portatile. Gli altri provider usano parole diverse per gli stessi concetti: Google Cloud IAM associa ruoli a membri su una risorsa, Microsoft Azure assegna ruoli con il controllo degli accessi basato sui ruoli a un determinato ambito, e OpenStack Keystone emette token per gli utenti nei progetti. Dove è rilevante, la lezione indica come differiscono.

> [!CHECK]
> Un'azienda vuole che un'applicazione web in esecuzione su una VM legga file da un bucket di storage, senza memorizzare alcuna password o chiave sulla VM. Quale principal è la scelta più adatta?
>
> - [ ] Un utente per l'applicazione, con la sua chiave di accesso salvata in un file di configurazione
> - [ ] Un gruppo, perché i gruppi possono contenere policy per molti programmi
> - [x] Un ruolo (o service account) associato alla VM, che le fornisce credenziali temporanee
> - [ ] L'utente root, perché non ha mai bisogno di una policy
>
> Un ruolo o un service account non ha password e rilascia automaticamente credenziali di breve durata. Un gruppo non può effettuare richieste, e l'utente root è decisamente troppo potente.

### Autenticazione e autorizzazione
A ogni richiesta vengono poste due domande diverse, e confonderle è all'origine di molte configurazioni errate.

- L'**autenticazione (authN)** risponde a "chi sei?" Chi chiama dimostra la propria identità con qualcosa che conosce (una password), che possiede (una chiave hardware, un telefono) o che è (un'impronta digitale), oppure, per i programmi, con una firma crittografica o un token.
- L'**autorizzazione (authZ)** risponde a "che cosa ti è consentito fare?" Il cloud confronta il principal autenticato, l'azione richiesta e la risorsa di destinazione con le policy.

L'autenticazione viene sempre per prima, e superarla non concede nulla di per sé. La differenza si vede nell'errore che ricevi. Una richiesta con una chiave sconosciuta o revocata fallisce l'autenticazione (nel laboratorio: `InvalidClientTokenId`). Una chiave valida senza permessi fallisce l'autorizzazione (`AccessDenied`). Se vedi `AccessDenied`, il cloud sa esattamente chi sei e ha deciso che non ti è consentito.

I programmi di solito si autenticano **firmando** ogni richiesta con una chiave segreta, per esempio con AWS Signature Version 4: il segreto non viaggia mai sulla rete, ma solo una firma calcolata sulla richiesta, che impedisce anche a chiunque di alterarla in transito. I token funzionano in modo diverso: un token è un'attestazione firmata, valida per un tempo limitato, che chi la riceve può verificare senza interpellare nessuno.

> [!CHECK]
> Uno script riceve `AccessDenied` quando elenca il contenuto di un bucket. Che cosa ti dice questo errore?
>
> - [ ] La chiave di accesso non è valida o è stata eliminata
> - [x] Il cloud ha autenticato chi chiama, ma nessuna policy consente quell'azione su quella risorsa
> - [ ] La richiesta è stata alterata in transito
> - [ ] Chi chiama deve accedere di nuovo con la propria password
>
> `AccessDenied` è un risultato di autorizzazione: l'identità è stata riconosciuta. Una chiave non valida o sconosciuta fallirebbe prima, all'autenticazione, con un errore diverso.

### Come viene valutata una richiesta
Una volta autenticato chi chiama, il cloud valuta le **policy**: documenti che elencano che cosa è consentito o negato. Due famiglie sono importanti:

- Le **policy basate sull'identità** sono associate a un principal (utente, gruppo o ruolo): "Bob può leggere la cartella dei report."
- Le **policy basate sulla risorsa** sono associate a una risorsa, come una bucket policy: "Il ruolo di Carol può leggere questo bucket." Indicano il principal a cui si applicano.

Le regole di valutazione sono semplici e sono le stesse in ogni grande cloud:

1. **Rifiuto predefinito.** Se nulla menziona la richiesta, questa viene negata. I permessi non sono mai impliciti.
2. **Consenso esplicito.** Un'istruzione corrispondente con effetto `Allow` autorizza la richiesta.
3. **Il deny esplicito vince.** Un'istruzione corrispondente con effetto `Deny` blocca la richiesta, anche se altre dieci istruzioni la consentono.

![La valutazione delle policy in quattro passi: autenticare (dimostrare chi sei con una firma, un token o una password; se fallisce, la richiesta viene respinta), raccogliere le policy (le policy di identità del principal più la policy sulla risorsa di destinazione), esiste un Deny esplicito (sì: NEGATA, ci si ferma qui), esiste un Allow esplicito (sì: CONSENTITA, no: NEGATA). Sotto, tre esiti: un Deny corrispondente significa NEGATA e vince sempre; un Allow corrispondente senza Deny significa CONSENTITA; nessuna corrispondenza significa NEGATA per impostazione predefinita](../../../assets/diagrams/iam-evaluation-flow.it.svg)

*Figura 2. Il deny batte l'allow, e il silenzio equivale a un rifiuto. Quest'ordine non cambia mai, per quante policy si applichino.*

All'interno di un singolo account, un allow nella policy di identità *oppure* nella policy sulla risorsa è sufficiente, purché nulla lo neghi. Tra due account, entrambe le parti devono consentire: il proprietario della risorsa deve far entrare il principal esterno, e l'account del principal deve permettergli di effettuare la chiamata.

I cloud reali aggiungono **barriere di protezione (guardrail)** al di sopra: i permissions boundary e le service control policy di AWS, i management group e i deny assignment di Azure, le organization policy e le deny policy di Google Cloud. Una barriera di protezione non concede mai nulla; limita soltanto il massimo che un principal può ottenere, a prescindere dalle sue policy. È così che un'organizzazione può stabilire una volta per tutti "nessuno, in nessun progetto, può usare queste regioni".

> [!CHECK]
> La policy del gruppo di Alice consente `s3:*` su un bucket. Il suo utente ha anche una policy con un `Deny` per `s3:DeleteObject` su quel bucket. Lei tenta di eliminare un oggetto. Che cosa succede?
>
> - [ ] Riesce, perché l'allow più ampio copre l'azione specifica
> - [ ] Riesce, perché prevale la policy associata più di recente
> - [x] Viene negato, perché un deny esplicito prevale su qualsiasi allow
> - [ ] Viene negato solo se lei non fa parte del gruppo
>
> Il deny esplicito vince sempre, indipendentemente da quanti allow corrispondano o da dove siano associati.

### Leggere una policy JSON
Le policy in stile AWS sono documenti JavaScript Object Notation (JSON). La stessa struttura compare nelle policy IAM, nelle trust policy dei ruoli e nelle bucket policy, e anche i servizi compatibili con S3 di molti provider la accettano.

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadReports",
      "Effect": "Allow",
      "Principal": { "AWS": "arn:aws:iam::123456789012:user/carol" },
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::lab-data/reports/*",
      "Condition": { "Bool": { "aws:MultiFactorAuthPresent": "true" } }
    }
  ]
}
```

![Anatomia di una policy di accesso JSON: una bucket policy per lab-data con Version 2012-10-17, un'istruzione con Sid ReadReports, Effect Allow, Principal l'utente carol, Action s3:GetObject, Resource arn:aws:s3:::lab-data/reports/* e una Condition che richiede la MFA. Ogni elemento è evidenziato e spiegato: Version è la versione del linguaggio; Sid un'etichetta facoltativa; Effect Allow o Deny; Principal chi, solo nelle policy sulla risorsa e di trust; Action quali operazioni; Resource quali oggetti, come ARN; Condition test aggiuntivi come MFA, IP, ora e tag](../../../assets/diagrams/iam-policy-anatomy.it.svg)

*Figura 3. Un'istruzione risponde a quattro domande: effetto, chi, che cosa e su quale risorsa, e facoltativamente "solo se".*

| Elemento | Significato |
|---|---|
| `Version` | La versione del linguaggio delle policy. Sempre `2012-10-17`: non è una data che scegli tu, e la più vecchia `2008-10-17` non ha funzionalità come le variabili di policy. |
| `Statement` | Una singola istruzione o un elenco. Ognuna viene valutata separatamente. |
| `Sid` | Etichetta facoltativa, utile negli audit. |
| `Effect` | `Allow` o `Deny`. Nient'altro. |
| `Principal` | A chi si riferisce l'istruzione. Usato solo nelle policy **basate sulla risorsa** e nelle policy di **trust**; in una policy di identità il principal è il soggetto a cui è associata, quindi lì l'elemento non è ammesso. |
| `Action` | Le operazioni, scritte `servizio:Operazione`: `s3:GetObject`, `iam:CreateUser`. I caratteri jolly funzionano: `s3:Get*`. |
| `Resource` | A che cosa si applica l'azione, come ARN. I caratteri jolly funzionano. |
| `Condition` | Test aggiuntivi che devono risultare veri: l'indirizzo IP di origine, l'ora, l'uso della MFA, i tag e altro. |

Due dettagli mettono in difficoltà quasi tutti:

- **Le azioni a livello di bucket e di oggetto richiedono ARN diversi.** `s3:ListBucket` si applica al bucket, `arn:aws:s3:::lab-data`. `s3:GetObject` si applica agli oggetti, `arn:aws:s3:::lab-data/reports/*`. Una policy che mette `GetObject` sull'ARN del bucket, o `ListBucket` su `lab-data/*`, non corrisponde silenziosamente a nulla.
- **`Action` e `Resource` vengono confrontate insieme.** Un'istruzione si applica solo se l'azione richiesta *e* la risorsa richiesta corrispondono entrambe (e la condizione è vera). Un allow per `s3:GetObject` su `reports/*` non dice nulla su `secret/*`.

Una **Condition** ha un operatore, una chiave di condizione e un valore. `Bool` con `aws:MultiFactorAuthPresent` verifica che chi chiama abbia effettuato l'accesso con un secondo fattore; `IpAddress` con `aws:SourceIp` limita le chiamate a un intervallo di rete come `203.0.113.0/24`; `DateLessThan` con `aws:CurrentTime` fa scadere l'accesso. Una richiesta deve soddisfare tutte le condizioni di un'istruzione perché questa si applichi.

> [!CHECK]
> Un'istruzione ha `"Effect": "Allow"`, `"Action": "s3:GetObject"` e `"Resource": "arn:aws:s3:::lab-data"`. Un utente con questa policy tenta di scaricare `reports/q3.txt` da `lab-data`. Qual è il risultato?
>
> - [ ] Consentito: l'utente può leggere l'intero bucket
> - [x] Negato: `GetObject` agisce sugli oggetti, quindi l'ARN della risorsa richiede `/*` (o un percorso) dopo il nome del bucket
> - [ ] Consentito, ma solo per gli oggetti nella cartella `reports/`
> - [ ] La policy viene rifiutata come non valida quando viene salvata
>
> L'ARN `arn:aws:s3:::lab-data` indica il bucket stesso, non gli oggetti al suo interno. L'istruzione è valida, ma non corrisponde mai a una richiesta su un oggetto, quindi si applica il rifiuto predefinito.

### Privilegio minimo, RBAC e ABAC
Il **principio del privilegio minimo** stabilisce che ogni principal riceva solo i permessi necessari per il proprio compito, e solo per il tempo in cui gli servono. Limita il **raggio d'impatto (blast radius)**: se una credenziale trapela o una persona commette un errore, il danno è circoscritto a ciò che quell'identità poteva fare.

In pratica lo applichi così:
- partendo da zero e aggiungendo permessi per un compito noto, anziché partire dall'amministratore e togliere;
- indicando azioni e risorse specifiche invece di `*`;
- usando gruppi e ruoli per funzione lavorativa anziché per persona;
- aggiungendo condizioni (MFA, rete di origine, orario) per le azioni sensibili;
- verificando ciò che viene effettivamente usato e riducendo il resto.

Due modelli determinano come vengono assegnati i permessi:

| | **Controllo degli accessi basato sui ruoli (RBAC)** | **Controllo degli accessi basato sugli attributi (ABAC)** |
|---|---|---|
| Decide in base a | Il ruolo o il gruppo a cui appartiene il principal | Gli attributi del principal, della risorsa, dell'azione e dell'ambiente |
| Regola di esempio | "I membri di `analysts` possono leggere il bucket dei report." | "Un utente può avviare una VM se il tag `project` della VM è uguale al tag `project` dell'utente." |
| Punto di forza | Facile da capire e da sottoporre ad audit; corrisponde alle mansioni. | Scala senza nuove policy: un nuovo progetto richiede nuovi tag, non nuovi ruoli. Granulare e dinamico. |
| Punto debole | I ruoli si moltiplicano ("esplosione dei ruoli") man mano che compaiono le eccezioni. | Più difficile da analizzare; dipende da attributi affidabili, quindi chi può modificare i tag diventa una questione di sicurezza. |
| Uso tipico | La maggior parte dei carichi di lavoro, un buon punto di partenza. | Ambienti grandi con più team. |

L'ABAC è definito dal National Institute of Standards and Technology (NIST) degli Stati Uniti nella Special Publication (SP) 800-162, *Guide to Attribute Based Access Control (ABAC) Definition and Considerations*. La maggior parte degli ambienti reali combina entrambi i modelli: ruoli per la struttura generale, attributi per i dettagli. Ecco un'istruzione ABAC in stile AWS, che consente a un principal di avviare e arrestare solo le VM con il tag del proprio progetto:

```json
{
  "Effect": "Allow",
  "Action": ["ec2:StartInstances", "ec2:StopInstances"],
  "Resource": "arn:aws:ec2:*:*:instance/*",
  "Condition": {
    "StringEquals": { "aws:ResourceTag/project": "${aws:PrincipalTag/project}" }
  }
}
```

`${aws:PrincipalTag/project}` è una variabile di policy: il cloud sostituisce il tag del progetto di chi chiama al momento della richiesta. Un'unica istruzione serve tutti i progetti.

> [!CHECK]
> Un'azienda ha 200 progetti e vuole che ogni team gestisca solo le risorse del proprio progetto, senza scrivere una nuova policy per ciascun progetto. Quale approccio è il più adatto?
>
> - [ ] Un gruppo per progetto, ciascuno con la propria policy scritta a mano
> - [ ] Dare a ogni ingegnere l'accesso da amministratore e affidarsi alla fiducia
> - [x] ABAC: assegnare il tag `project` a principal e risorse, e consentire le azioni quando i tag corrispondono
> - [ ] Condividere una chiave di accesso per ogni team
>
> L'ABAC confronta gli attributi al momento della richiesta, quindi un'unica policy copre tutti i progetti. I gruppi per progetto funzionano (RBAC) ma moltiplicano le policy da mantenere.

### Credenziali temporanee e assunzione di un ruolo
Le chiavi di accesso di lunga durata sono il singolo rischio maggiore dell'IAM cloud: non scadono, vengono copiate in script, portatili e repository, e nessuno si accorge quando trapelano. La soluzione sono le **credenziali temporanee**: un insieme composto da un ID della chiave di accesso, un segreto e un **token di sessione** che smette di funzionare dopo poco tempo, da pochi minuti a qualche ora.

Le ottieni **assumendo un ruolo**, tramite un **security token service**: un'API di tipo STS (AWS Security Token Service). Il ruolo ha due tipi di policy:

- Una **trust policy** stabilisce *chi può assumere il ruolo* (l'elemento principal, come nell'esempio della Figura 3).
- Una **policy dei permessi** stabilisce *che cosa può fare il ruolo* una volta assunto.

![Sequenza tra Carol, un utente IAM, il token service (STS) e il bucket lab-data. 1. Carol chiama AssumeRole per il ruolo reader, firmando con la propria chiave; STS verifica la trust policy e il suo permesso. 2. STS restituisce credenziali temporanee: una chiave di accesso che inizia con ASIA, un segreto e un token di sessione, con scadenza a 900 secondi. 3. Carol chiama GetObject su reports/q3.txt con le credenziali temporanee; lo storage valuta la policy del ruolo e risponde 200 OK. Un PutObject su reports/c.txt riceve 403 AccessDenied perché il ruolo è di sola lettura. Alla scadenza le credenziali smettono di funzionare, quindi non c'è nulla da revocare o ruotare](../../../assets/diagrams/iam-assume-role.it.svg)

*Figura 4. Finché la sessione dura, Carol agisce come il ruolo, con i permessi del ruolo e non con i propri. Alla scadenza l'accesso termina da solo.*

L'identità di chi chiama cambia: dopo `AssumeRole`, l'API segnala chi chiama come `arn:aws:sts::123456789012:assumed-role/reader/carol-lab`, non come l'utente. I log di audit registrano il nome della sessione, quindi puoi comunque stabilire chi ha fatto cosa. Le chiavi di accesso che iniziano con `AKIA` sono di lunga durata; quelle che iniziano con `ASIA` sono temporanee e richiedono anche il token di sessione.

Assumere ruoli è anche il modo in cui una persona ottiene un accesso elevato solo quando serve (accesso "break glass" o just-in-time), e il modo in cui i carichi di lavoro ricevono le credenziali dalla piattaforma: un instance profile su una VM, un service account associato a un pod Kubernetes o un'identità gestita su Azure. Il programma richiede credenziali aggiornate a un endpoint locale dei metadati; nessun segreto viene memorizzato da nessuna parte.

> [!NOTE]
> La trust policy del ruolo indica chi *può* assumerlo. In AWS reale, una trust policy che indica uno specifico utente o ruolo nello stesso account è sufficiente da sola. Se invece indica l'intero account (`arn:aws:iam::<account-id>:root`), ogni principal ha bisogno anche di una policy di identità che consenta `sts:AssumeRole`. Molte organizzazioni aggiungono comunque una policy di identità che consente `sts:AssumeRole` sullo specifico ruolo, in modo che il permesso sia visibile anche sul principal. Il laboratorio fa così, perché l'emulatore lo richiede.

> [!CHECK]
> Quale affermazione sulle credenziali temporanee ottenute con `AssumeRole` è vera?
>
> - [ ] Mantengono i permessi dell'utente che le ha richieste
> - [ ] Non scadono mai finché il ruolo esiste
> - [x] Hanno i permessi del ruolo e smettono di funzionare dopo un tempo stabilito
> - [ ] Sono valide solo insieme alla password dell'utente
>
> La sessione agisce come il ruolo, quindi si applicano i permessi del ruolo, non quelli di chi chiama. La scadenza è incorporata nelle credenziali e nel token di sessione.

### Federazione: SAML 2.0 e OpenID Connect
Creare un utente cloud distinto per ogni dipendente, ogni collaboratore esterno e ogni pipeline non scala, e le password e le chiavi si accumulano. La **federazione** permette al cloud di fidarsi di un **identity provider (IdP)** esterno: la directory aziendale, un accesso tramite social network o un sistema di CI. L'utente accede presso l'IdP, e l'IdP garantisce per lui con un token firmato. Il cloud non vede mai la password; verifica solo il token e associa l'utente a un ruolo.

![Sequenza di federazione tra un utente o un carico di lavoro, l'identity provider, l'IAM del cloud con il suo token service e una risorsa cloud. 1. L'utente accede presso l'IdP con password e MFA, oppure un job di CI presenta il proprio token. 2. L'IdP restituisce un token firmato: un token ID OIDC (JWT) o un'asserzione SAML 2.0. 3. L'utente scambia il token con un ruolo tramite AssumeRoleWithWebIdentity o AssumeRoleWithSAML; l'IAM del cloud verifica la firma con la chiave pubblica dell'IdP, controlla emittente, destinatario e scadenza, e confronta il risultato con la trust policy del ruolo. 4. Tornano credenziali temporanee, valide da pochi minuti a qualche ora. 5. L'utente chiama la risorsa cloud con tali credenziali, consentito dalla policy del ruolo](../../../assets/diagrams/iam-federation.it.svg)

*Figura 5. L'identity provider autentica; il cloud autorizza. Il risultato sono credenziali temporanee, senza alcuna chiave di lunga durata.*

Due standard dominano:

| | **SAML 2.0** | **OpenID Connect (OIDC)** |
|---|---|---|
| Nome completo | Security Assertion Markup Language 2.0 (standard OASIS) | OpenID Connect Core 1.0 |
| Token | Un'**asserzione**: un documento Extensible Markup Language (XML) firmato | Un **token ID**: un JSON Web Token (JWT, RFC 7519) firmato |
| Basato su | XML e reindirizzamenti del browser | OAuth 2.0 (RFC 6749), a cui aggiunge un livello di autenticazione |
| Uso tipico | Single sign-on (SSO) aziendale per l'accesso delle persone alla console | App web e mobili, e **federazione delle identità dei carichi di lavoro** per pipeline e programmi |
| Esempio | Un dipendente accede al portale aziendale e si ritrova nella console del cloud | Un job di CI dimostra "sono il branch `main` di questo repository" e ottiene un ruolo per un deployment |

OAuth 2.0 da solo riguarda l'*autorizzazione delegata* (consentire a un'app di agire per tuo conto), non la dimostrazione di chi sei. OIDC aggiunge al di sopra il livello di identità mancante.

La federazione delle identità dei carichi di lavoro sostituisce la chiave di deployment memorizzata. Una piattaforma di CI emette per ogni job un token OIDC di breve durata i cui claim indicano la provenienza, per esempio `sub: repo:example-org/example-repo:ref:refs/heads/main`. La trust policy del ruolo cloud accetta solo quell'emittente, quel destinatario e quel soggetto. Un repository diverso, o un branch diverso, non può assumere il ruolo.

> [!CHECK]
> Che cosa verifica un cloud quando riceve da un identity provider un token ID OIDC o un'asserzione SAML?
>
> - [ ] La password dell'utente, che l'identity provider inoltra
> - [x] La firma (con la chiave pubblica dell'IdP), l'emittente, il destinatario e la scadenza, poi la trust policy del ruolo
> - [ ] Solo che il token sia un documento JSON o XML ben formato
> - [ ] Che l'utente abbia una chiave di accesso nell'account cloud
>
> Il cloud si fida della firma dell'IdP, non di una password. Verifica comunque che il token sia destinato a lui, sia ancora valido e corrisponda alla trust policy del ruolo.

### Autenticazione a più fattori
L'**autenticazione a più fattori (MFA, multi-factor authentication)** richiede due o più tipi diversi di prova: qualcosa che conosci, qualcosa che possiedi e qualcosa che sei. Una password rubata da sola non apre più la porta. I secondi fattori più comuni, dal più debole al più forte:

- **Codici SMS.** Meglio di niente, ma vulnerabili allo scambio di SIM (SIM swapping) e all'intercettazione.
- **Password monouso basate sul tempo (TOTP, RFC 6238)** generate da un'app di autenticazione. Soggette a phishing: un sito falso può chiedere il codice e riutilizzarlo subito.
- **Chiavi hardware FIDO2 / WebAuthn e passkey.** La chiave firma una sfida che include il nome del sito autentico, quindi un sito contraffatto non ottiene nulla di utile. Questa è una MFA **resistente al phishing**.

Applica la MFA a ogni utente umano, sempre all'utente root e alle azioni sensibili tramite una condizione (`aws:MultiFactorAuthPresent`). I programmi non possono usare la MFA, ed è un ulteriore motivo per dare loro credenziali temporanee invece di chiavi.

> [!CHECK]
> Perché una chiave di sicurezza FIDO2 è considerata più robusta di un codice TOTP generato da un'app?
>
> - [ ] Il codice è più lungo, quindi è più difficile da indovinare
> - [ ] La chiave funziona senza Internet, quindi nessuno può intercettarla
> - [x] La chiave firma una sfida legata al sito autentico, quindi un sito di phishing non può riutilizzarla
> - [ ] Il cloud memorizza il segreto della chiave per poterlo reimpostare
>
> Un codice TOTP può essere digitato in una pagina falsa e riutilizzato. Una risposta FIDO2 è legata all'origine del sito autentico, quindi una copia non ha alcun valore altrove.

## Come funziona
Segui una richiesta dall'inizio alla fine. Bob, il cui utente ha la policy a privilegio minimo del laboratorio, esegue `aws s3api get-object --bucket lab-data --key reports/q3.txt`:

1. **Firma.** Lo strumento da riga di comando costruisce la richiesta HTTP e la firma con la chiave segreta di Bob. L'ID della chiave di accesso viaggia nella richiesta; il segreto no.
2. **Autenticazione.** Il servizio cerca l'ID della chiave di accesso, ricalcola la firma con il segreto corrispondente e la confronta. Una discordanza o una chiave sconosciuta termina la richiesta con un errore di autenticazione.
3. **Costruzione del contesto.** Il servizio registra chi (`arn:aws:iam::123456789012:user/bob`), che cosa (`s3:GetObject`), su quale risorsa (`arn:aws:s3:::lab-data/reports/q3.txt`) e l'ambiente (indirizzo IP di origine, ora, se sono stati usati MFA e TLS).
4. **Raccolta delle policy.** Le policy dell'utente di Bob, quelle dei suoi gruppi, la bucket policy di `lab-data` ed eventuali barriere di protezione dell'organizzazione.
5. **Valutazione.** Si cerca un `Deny` corrispondente: nessuno. Si cerca un `Allow` corrispondente: l'istruzione per `GetObject` su `lab-data/reports/*` corrisponde. Risultato: consentito.
6. **Esecuzione e registrazione.** L'oggetto viene restituito, e il log di audit registra la chiamata con il principal, l'azione, la risorsa, l'indirizzo IP di origine e il risultato.

> [!CHECK]
> Quale fase della vita di una richiesta avviene per prima?
>
> - [ ] Il cloud raccoglie le policy che si applicano
> - [ ] Il cloud cerca un deny esplicito corrispondente
> - [x] Il cloud autentica chi chiama dalla firma o dal token
> - [ ] Il cloud verifica se il ruolo di chi chiama è scaduto
>
> Le policy vengono valutate per un principal *noto*, quindi l'autenticazione viene sempre per prima. Una sessione scaduta fallisce in quello stesso passaggio di autenticazione.

## Esempio pratico
Gestisci il bucket `lab-data` con due prefissi, `reports/` e `secret/`. Bob ha questa policy di identità (è quella che costruisci nel laboratorio):

```json
{
  "Version": "2012-10-17",
  "Statement": [
    { "Sid": "ListTheBucket", "Effect": "Allow", "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::lab-data" },
    { "Sid": "EverythingInReports", "Effect": "Allow", "Action": "s3:*",
      "Resource": "arn:aws:s3:::lab-data/reports/*" },
    { "Sid": "NeverDelete", "Effect": "Deny", "Action": "s3:DeleteObject",
      "Resource": "*" }
  ]
}
```

Il bucket ha anche una policy sulla risorsa che rifiuta qualsiasi richiesta non cifrata in transito (una base di partenza comune):

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "DenyPlainHttp",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:*",
      "Resource": ["arn:aws:s3:::lab-data", "arn:aws:s3:::lab-data/*"],
      "Condition": { "Bool": { "aws:SecureTransport": "false" } }
    }
  ]
}
```

Prevedi l'esito di ciascuna richiesta di Bob, poi controlla il ragionamento:

| # | Richiesta | Risultato | Perché |
|---|---|---|---|
| 1 | `GetObject` `reports/q3.txt` via HTTPS | **Consentita** | `EverythingInReports` la consente; nessun deny corrisponde (`SecureTransport` è true, quindi `DenyPlainHttp` non si applica). |
| 2 | `GetObject` `reports/q3.txt` via HTTP semplice | **Negata** | `DenyPlainHttp` corrisponde: il deny esplicito vince sull'allow. |
| 3 | `PutObject` `reports/q4.txt` via HTTPS | **Consentita** | `s3:*` su `reports/*` la copre. |
| 4 | `DeleteObject` `reports/q3.txt` via HTTPS | **Negata** | `NeverDelete` è un deny esplicito; prevale sull'allow `s3:*`. |
| 5 | `GetObject` `secret/passwords.txt` via HTTPS | **Negata** | Nessuna istruzione consente `secret/*`: rifiuto predefinito. |
| 6 | `ListBucket` su `lab-data` | **Consentita** | `ListTheBucket` la consente, per l'intero bucket: Bob vede anche i *nomi* degli oggetti in `secret/`. |

La riga 6 è una classica sorpresa. L'elenco è un'azione a livello di bucket, quindi questa policy non può limitarlo a `reports/` con la sola risorsa. Nei cloud reali si aggiunge una `Condition` sul prefisso della chiave (per AWS, `s3:prefix`) per restringerlo.

## Errori comuni
- **Mettere `*` in `Action` o `Resource` "per farlo funzionare"** — funziona perché consente tutto. Individua l'azione esatta dall'errore o dal log di audit e indicala per nome.
- **Confondere l'ARN del bucket con l'ARN dell'oggetto** — `ListBucket` richiede `arn:aws:s3:::name`, `GetObject` richiede `arn:aws:s3:::name/*`. Se metà di una policy funziona e l'altra no, controlla prima questo aspetto.
- **Aspettarsi che un allow successivo o più ristretto prevalga su un deny** — non succede mai. Per ripristinare l'accesso devi rimuovere o restringere il deny.
- **Dimenticare che un gruppo non è un'identità** — non puoi accedere come gruppo, e non puoi indicarlo come `Principal` di una policy sulla risorsa o di trust. Gli associ delle policy e i suoi membri le ereditano.
- **Verificare con l'identità di amministratore** — può fare qualsiasi cosa, quindi non noti mai il permesso mancante. Verifica con l'identità che eseguirà realmente il compito.
- **Presumere che le condizioni siano sempre applicate da ogni strumento** — alcuni emulatori e alcuni servizi parzialmente compatibili con S3 le ignorano. Verifica le condizioni sul servizio reale prima di farvi affidamento.

## Considerazioni sulla sicurezza
La maggior parte delle violazioni del cloud inizia dall'identità, non da una vulnerabilità del software. Questi sono gli errori che si ripresentano di continuo, e il modo per individuarli.

### Errori più frequenti
- **Policy con caratteri jolly.** `"Action": "*"` su `"Resource": "*"` trasforma ogni credenziale che la contiene in una chiave maestra. Persino `s3:*` su `*` permette a chi la possiede di leggere, modificare ed eliminare ogni bucket dell'account.
- **Chiavi di lunga durata e trapelate.** Chiavi di accesso incluse nei repository, incollate in una chat, incorporate nelle immagini dei container o lasciate per anni in una variabile di CI. I repository pubblici vengono scansionati alla ricerca di chiavi, spesso entro pochi minuti da un push. Preferisci ruoli, federazione e credenziali temporanee; dove una chiave è inevitabile, ruotala e limitala con delle condizioni.
- **Account e credenziali inutilizzati.** Ex dipendenti, utenti di prova abbandonati e vecchie chiavi restano validi finché qualcuno non li elimina. Ogni identità inutilizzata è un accesso non monitorato.
- **Usare ogni giorno l'account root o proprietario.** Non può essere limitato. Proteggilo con una password robusta e una MFA resistente al phishing, non dargli chiavi di accesso e riservalo ai pochi compiti che lo richiedono.
- **Assenza di MFA, o MFA debole.** Una password rubata equivale allora a una compromissione totale. Richiedi la MFA a ogni utente umano, e preferisci FIDO2 per gli amministratori.
- **Trust policy troppo ampie.** Un ruolo che si fida di un intero account, o di `"Principal": "*"`, può essere assunto da chiunque in quell'account, o da chiunque in assoluto. Indica il principal esatto e, per la federazione, l'emittente, il destinatario e il soggetto esatti.
- **Permessi concessi tramite la possibilità di modificare i permessi.** Un principal autorizzato a usare `iam:PutUserPolicy`, o `iam:AttachUserPolicy`, può assegnarsi diritti di amministratore. Tratta le azioni IAM di scrittura come azioni da amministratore.

### Rilevamento
- **Log di audit.** Ogni chiamata API viene registrata con chi, che cosa, quando e da dove: AWS CloudTrail, Azure Activity Log e i log di accesso di Microsoft Entra, Google Cloud Audit Logs. Conservali in un account separato e protetto dalla scrittura, e genera avvisi sugli eventi sensibili: uso dell'account root, accesso alla console senza MFA, nuove chiavi di accesso, modifiche alle policy, chiamate da paesi insoliti.
- **Revisioni degli accessi.** Con cadenza periodica (quella trimestrale è comune) il responsabile di ciascuna risorsa conferma chi ha ancora bisogno di accesso, e tu rimuovi gli altri. Includi i service account e i trust tra account, che si dimenticano facilmente.
- **Report sull'igiene delle credenziali.** Elenca utenti, chiavi, la loro età e l'ultimo utilizzo (il laboratorio usa `get-access-key-last-used`). Elimina le chiavi che nessuno ha usato per 90 giorni, ruota quelle che devono restare, e confronta i permessi concessi con quelli usati; la maggior parte dei cloud può suggerire una policy più ristretta in base al log delle attività (per esempio IAM Access Analyzer su AWS, gli strumenti di analisi delle policy su Google Cloud).
- **Rotazione delle chiavi.** Crea la nuova chiave, sposta l'applicazione sulla nuova, verifica che la vecchia non sia più usata, poi eliminala. In nessun momento devi arrestare l'applicazione. La rotazione abbrevia la durata di una fuga ma non elimina la necessità di evitare chiavi di lunga durata.
- **Scansione dei segreti.** Analizza repository e immagini alla ricerca di chiavi prima che vengano pubblicate, e tratta come compromessa qualsiasi chiave che sia mai arrivata in un luogo pubblico: eliminala, senza limitarti a riscrivere la cronologia.

> [!WARNING]
> Se una chiave di accesso trapela, disattivala o eliminala subito, poi esamina il log di audit per vedere che cosa ha fatto tra la fuga e la revoca. Modificare il codice o eliminare il repository non annulla l'esposizione.

## Riepilogo
- L'IAM risponde a due domande: chi sei (autenticazione) e che cosa puoi fare (autorizzazione). `AccessDenied` significa che l'autenticazione è riuscita e l'autorizzazione no.
- Una richiesta è consentita solo se qualche istruzione la consente e nessuna la nega: rifiuto predefinito, consenso esplicito, il deny esplicito vince.
- Un'istruzione di una policy JSON ha un effetto, un principal (nelle policy sulla risorsa e di trust), azioni, risorse e condizioni facoltative. Presta attenzione alla differenza tra ARN di bucket e di oggetto.
- Applica il privilegio minimo: azioni e risorse specifiche, ambiti ristretti, gruppi e ruoli, condizioni e revisioni periodiche. Usa l'RBAC per la struttura generale e l'ABAC per regole granulari e scalabili.
- Preferisci ruoli e credenziali temporanee (un `AssumeRole` di tipo STS) alle chiavi di lunga durata, e federa persone e pipeline con SAML 2.0 o OpenID Connect, così il cloud non detiene mai le loro password.
- Applica la MFA, proteggi l'account root, elimina le identità inutilizzate, ruota le chiavi inevitabili e monitora i log di audit.

## Glossario
| Termine | Definizione |
|---|---|
| Gestione delle identità e degli accessi (IAM) | Il servizio cloud e la disciplina che decide chi sta facendo la richiesta e che cosa può fare. |
| Identità | Un attore riconosciuto in un sistema: una persona, un programma o un ruolo. |
| Principal | Qualsiasi identità che può effettuare una richiesta: utente, membro di un gruppo, sessione di un ruolo o service account. |
| Utente | Un'identità con nome per una singola persona, con credenziali come una password e chiavi di accesso. |
| Gruppo | Un insieme di utenti a cui sono associate delle policy; i membri le ereditano. Non può effettuare richieste da sé. |
| Ruolo | Un'identità con permessi ma senza credenziali permanenti, assunta temporaneamente. |
| Service account | Un'identità non umana per un'applicazione, una VM o una pipeline. Detto anche identità del carico di lavoro o identità di macchina. |
| Utente root | L'identità onnipotente creata insieme all'account (proprietario o amministratore globale in altri cloud). |
| Amazon Resource Name (ARN) | Il nome univoco di una risorsa o di un principal in AWS, come `arn:aws:iam::123456789012:user/bob`. |
| Chiave di accesso | Una coppia di chiavi (ID e segreto) che firma le richieste API. Di lunga durata, a meno che non sia emessa come parte di credenziali temporanee. |
| Autenticazione (authN) | Dimostrare chi è chi chiama. |
| Autorizzazione (authZ) | Decidere che cosa può fare chi chiama una volta autenticato. |
| Policy | Un documento che elenca le azioni consentite o negate sulle risorse. |
| Policy basata sull'identità | Una policy associata a un utente, un gruppo o un ruolo. |
| Policy basata sulla risorsa | Una policy associata a una risorsa, come una bucket policy; indica i principal a cui si applica. |
| Rifiuto predefinito | La regola per cui tutto ciò che non è esplicitamente consentito è negato. |
| Deny esplicito | Un'istruzione con `Effect: Deny`; prevale su ogni allow. |
| Istruzione | Una regola in una policy: effetto, principal, azione, risorsa e condizione facoltativa. |
| Condizione | Un test aggiuntivo in un'istruzione (MFA, intervallo IP, ora, tag) che deve risultare vero perché questa si applichi. |
| Barriera di protezione (guardrail) | Un limite a livello di organizzazione (come i permissions boundary o le service control policy) che pone un tetto a ciò che i principal possono ottenere. |
| Principio del privilegio minimo | Dare a ogni principal solo i permessi di cui ha bisogno, per il tempo in cui gli servono. |
| Raggio d'impatto (blast radius) | La quantità di danno possibile se una singola identità o credenziale viene compromessa. |
| Controllo degli accessi basato sui ruoli (RBAC) | Concedere permessi in base ai ruoli o ai gruppi a cui appartiene un principal. |
| Controllo degli accessi basato sugli attributi (ABAC) | Concedere permessi confrontando gli attributi del principal, della risorsa, dell'azione e dell'ambiente (NIST SP 800-162). |
| Credenziali temporanee | Una chiave di accesso, un segreto e un token di sessione che scadono dopo poco tempo. |
| Token di sessione | Il valore aggiuntivo che deve accompagnare le credenziali temporanee a ogni richiesta. |
| Security token service (STS) | L'API che emette credenziali temporanee, per esempio tramite `AssumeRole`. |
| Assumere un ruolo | Scambiare la propria identità con credenziali temporanee che hanno i permessi di un ruolo. |
| Trust policy | La policy di un ruolo che stabilisce chi può assumerlo. |
| Federazione | Fidarsi di un identity provider esterno per autenticare gli utenti, così il cloud non detiene password per loro. |
| Identity provider (IdP) | Il sistema che autentica gli utenti ed emette token o asserzioni firmati. |
| SAML 2.0 | Uno standard basato su XML per asserzioni firmate, molto usato per il single sign-on aziendale. |
| OpenID Connect (OIDC) | Un livello di autenticazione sopra OAuth 2.0 che emette token ID JWT firmati. |
| Federazione delle identità dei carichi di lavoro | Consentire a una pipeline o a un programma di scambiare un token di breve durata della propria piattaforma con credenziali cloud, senza alcuna chiave memorizzata. |
| Autenticazione a più fattori (MFA) | Autenticazione che richiede due o più tipi di prova. |
| MFA resistente al phishing | MFA, come le chiavi FIDO2, la cui risposta è legata al sito autentico e non può essere riutilizzata da uno falso. |
| Log di audit | Il registro delle chiamate API: chi, che cosa, quando, da dove e con quale risultato. |
| Revisione degli accessi | Una verifica periodica che ogni identità abbia ancora bisogno dell'accesso che possiede. |
| Rotazione delle chiavi | Sostituire una credenziale con una nuova e ritirare la vecchia. |

## Verifica la comprensione
1. La policy di un collega ha `"Action": "s3:*"` e `"Resource": "*"` "perché era l'unico modo in cui funzionava lo script di caricamento." Spiega come individueresti i permessi realmente necessari allo script e scriveresti una sostituzione a privilegio minimo.
2. Un utente appartiene a due gruppi. Il gruppo A consente `s3:GetObject` su `reports/*`. Il gruppo B ha un `Deny` esplicito per `s3:*` sull'intero bucket per chiunque non usi la MFA. Che cosa può fare l'utente quando accede senza MFA, e con la MFA? Quale elemento fa la differenza?
3. Progetta l'accesso per una pipeline di CI che esegue il deployment nel tuo account cloud. Quale principal, quali credenziali, quali condizioni di trust? Che cosa elimini rispetto al memorizzare una chiave di accesso in una variabile di CI?
4. Spiega, con parole tue, perché `AccessDenied` e `InvalidClientTokenId` indicano problemi diversi, e che cosa controlleresti in ciascun caso.
5. La tua azienda ha 40 sviluppatori e 5 team. Quando sceglieresti l'RBAC, quando l'ABAC, e che cosa devi controllare perché l'ABAC sia sicuro?
6. Scopri che una chiave di accesso appartenente a un dipendente che ha lasciato l'azienda un anno fa è stata usata per l'ultima volta ieri. Descrivi, in ordine, che cosa faresti nella prima ora.

## Riferimenti
- [NIST SP 800-162](https://csrc.nist.gov/pubs/sp/800/162/upd2/final) — Guide to Attribute Based Access Control (ABAC) Definition and Considerations: guida al controllo degli accessi basato sugli attributi.
- [NIST SP 800-63-4](https://pages.nist.gov/800-63-4/) — Digital Identity Guidelines: linee guida sull'identità digitale (autenticazione, federazione).
- [OpenID Connect Core 1.0](https://openid.net/specs/openid-connect-core-1_0.html).
- [SAML 2.0 Technical Overview](https://docs.oasis-open.org/security/saml/Post2.0/sstc-saml-tech-overview-2.0.html) — OASIS.
- [RFC 6749](https://www.rfc-editor.org/rfc/rfc6749) — The OAuth 2.0 Authorization Framework: il framework di autorizzazione OAuth 2.0.
- [RFC 7519](https://www.rfc-editor.org/rfc/rfc7519) — JSON Web Token (JWT).
- [RFC 6238](https://www.rfc-editor.org/rfc/rfc6238) — TOTP: Time-Based One-Time Password Algorithm: algoritmo per password monouso basate sul tempo.
- [AWS IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/) — logica di valutazione delle policy, riferimento delle policy e credenziali temporanee.
- [Google Cloud IAM overview](https://cloud.google.com/iam/docs/overview), [Azure RBAC overview](https://learn.microsoft.com/azure/role-based-access-control/overview) e [OpenStack Keystone](https://docs.openstack.org/keystone/latest/) — gli stessi concetti in altri provider.
