---
title: "IAM cloud : qui peut faire quoi"
domain: cloud-computing
level: intermediate
duration: "50 min"
objectives:
  - "Expliquer les briques de l'IAM cloud : principaux (utilisateurs, groupes, rôles, comptes de service), authentification et autorisation, et la manière dont une requête est évaluée."
  - "Lire et écrire des politiques d'accès JSON avec actions, ressources, effets et conditions, et prédire le résultat quand des instructions d'autorisation et de refus se recoupent."
  - "Appliquer le principe du moindre privilège et comparer le contrôle d'accès fondé sur les rôles (RBAC) et celui fondé sur les attributs (ABAC)."
  - "Expliquer les identifiants temporaires et la fédération (SAML 2.0, OpenID Connect) et pourquoi ils sont plus sûrs que les clés d'accès de longue durée."
  - "Évaluer les erreurs IAM courantes (politiques à caractères génériques, clés divulguées, comptes inutilisés, absence de MFA) et comment les détecter."
lang: fr
source_hash: 3b4a802e0a01
---

# IAM cloud : qui peut faire quoi

## Pourquoi c'est important
Une développeuse publie une petite correction dans un dépôt de code public, un vendredi après-midi. Dans le commit se cache un fichier contenant une clé d'accès au cloud, celle qu'elle avait créée deux ans plus tôt « juste pour tester quelque chose ». En quelques minutes, des scanners automatiques la trouvent. Le samedi matin, le compte fait tourner des centaines de serveurs pour un mineur de cryptomonnaie, et le bucket contenant les exports de clients a été copié ailleurs. Rien n'a été « piraté » au sens du cinéma : l'attaquant a simplement demandé au cloud de faire des choses, et le cloud a vérifié que la clé était valide et que la politique qui lui était attachée autorisait ces actions. Elle les autorisait, car la clé appartenait à un administrateur.

Dans le cloud, la console et l'interface de programmation d'application (API, Application Programming Interface) sont accessibles de n'importe où sur Internet. Il n'y a pas de réseau de bureau derrière lequel se cacher : l'**identité** devient donc le véritable périmètre. La **gestion des identités et des accès (IAM, Identity and Access Management)** est la partie de chaque cloud qui décide qui fait la demande et ce que cette personne peut faire. En la maîtrisant, vous pouvez donner à chaque personne et à chaque programme exactement l'accès dont il a besoin, de préférence pour quelques minutes plutôt que pour toujours, et vous pouvez lire la politique d'un autre et savoir ce qu'elle autorise réellement.

## Objectifs pédagogiques
- Expliquer les briques de l'IAM cloud : principaux (utilisateurs, groupes, rôles, comptes de service), authentification et autorisation, et la manière dont une requête est évaluée.
- Lire et écrire des politiques d'accès JSON avec actions, ressources, effets et conditions, et prédire le résultat quand des instructions d'autorisation et de refus se recoupent.
- Appliquer le principe du moindre privilège et comparer le contrôle d'accès fondé sur les rôles (RBAC) et celui fondé sur les attributs (ABAC).
- Expliquer les identifiants temporaires et la fédération (SAML 2.0, OpenID Connect) et pourquoi ils sont plus sûrs que les clés d'accès de longue durée.
- Évaluer les erreurs IAM courantes (politiques à caractères génériques, clés divulguées, comptes inutilisés, absence de MFA) et comment les détecter.

## Concepts clés

### Principaux : qui fait la demande ?
Imaginez un bâtiment avec des lecteurs de badge à chaque porte. Chaque badge appartient à quelqu'un ou à quelque chose, et chaque porte a une règle indiquant quels badges l'ouvrent. Dans le cloud, le porteur du badge est un **principal** : toute identité qui peut envoyer une requête au cloud et y être reconnue. La plupart des clouds proposent les mêmes quatre types :

| Principal | Ce que c'est | Usage typique |
|---|---|---|
| **Utilisateur** | Une identité nominative pour une personne, généralement avec un mot de passe et un second facteur. Il peut aussi avoir des **clés d'accès** pour la ligne de commande et les programmes. | Un ingénieur qui se connecte à la console. |
| **Groupe** | Un ensemble d'utilisateurs. Un groupe n'est pas lui-même un principal : on ne peut pas se connecter en tant que groupe. Vous lui attachez des politiques et chaque membre en hérite. | `analysts`, `network-admins`. |
| **Rôle** | Une identité avec des permissions mais **sans mot de passe ni clés permanentes**. Quelqu'un ou quelque chose l'*endosse* et reçoit des identifiants temporaires. | Une personne qui a besoin d'un accès élevé pendant une heure ; un serveur ; un utilisateur d'un autre compte. |
| **Compte de service** (aussi appelé identité de charge de travail ou identité machine) | L'identité d'un programme plutôt que d'une personne : une application, une machine virtuelle (VM), un conteneur, un pipeline. | Une application web qui lit un bucket. |

![L'IAM cloud en un coup d'œil. À gauche, les principaux : un utilisateur (une personne avec un mot de passe et la MFA), un groupe (un ensemble d'utilisateurs, politiques attachées une seule fois), un rôle (endossé temporairement, sans mot de passe ni clé) et un compte de service (identité d'une application ou d'une VM). Au milieu, le moteur d'autorisation : authentifier l'appelant, évaluer les politiques, autoriser ou refuser ; il lit les politiques situées en dessous, une politique d'identité sur le principal et une politique de ressource sur la ressource. À droite, les ressources : le bucket lab-data avec l'ARN arn:aws:s3:::lab-data et une machine virtuelle, atteintes seulement si la requête est autorisée. Une bande en bas montre ce que porte une requête : le principal, l'action s3:GetObject, la ressource arn:aws:s3:::lab-data/reports/q3.txt, et le contexte comme l'heure, l'IP source et la MFA](../../../assets/diagrams/iam-who-what-resource.fr.svg)

*Figure 1. Chaque requête porte un principal, une action, une ressource et un contexte ; le moteur d'autorisation les compare aux politiques et répond autorisé ou refusé.*

Chaque principal a un nom unique dans le format du fournisseur. Sur Amazon Web Services (AWS), c'est un **Amazon Resource Name (ARN)** tel que `arn:aws:iam::123456789012:user/bob` : `arn`, la partition, le service, la région (vide pour IAM), l'identifiant du compte et la ressource. D'autres fournisseurs utilisent leurs propres formats (une adresse de type courriel pour un compte de service Google Cloud, un identifiant d'objet pour Microsoft Entra), mais l'idée est la même.

Au sommet de chaque compte se trouve une identité de plus : l'**utilisateur racine** (appelé propriétaire ou administrateur général dans d'autres clouds). Il est créé avec le compte, il peut tout faire et les politiques ordinaires ne peuvent pas le restreindre. Vous le protégez et ne l'utilisez presque jamais.

> [!NOTE]
> Ce module utilise le vocabulaire IAM et la syntaxe de politiques d'AWS parce qu'ils sont les plus largement implémentés : de nombreux services de stockage compatibles S3 chez d'autres fournisseurs acceptent le même JSON de politique de bucket, et des outils open source les émulent, ce qui explique pourquoi le lab peut s'exécuter sur votre ordinateur portable. Les autres fournisseurs emploient d'autres mots pour les mêmes idées : Google Cloud IAM associe des rôles à des membres sur une ressource, Microsoft Azure attribue des rôles par contrôle d'accès fondé sur les rôles à une portée, et OpenStack Keystone émet des jetons pour des utilisateurs dans des projets. Quand c'est utile, la leçon indique en quoi ils diffèrent.

> [!CHECK]
> Une entreprise veut qu'une application web exécutée sur une VM lise des fichiers dans un bucket de stockage, sans stocker de mot de passe ni de clé sur la VM. Quel principal convient le mieux ?
>
> - [ ] Un utilisateur pour l'application, avec sa clé d'accès enregistrée dans un fichier de configuration
> - [ ] Un groupe, parce que les groupes peuvent porter des politiques pour de nombreux programmes
> - [x] Un rôle (ou compte de service) attaché à la VM, qui lui fournit des identifiants temporaires
> - [ ] L'utilisateur racine, parce qu'il n'a jamais besoin de politique
>
> Un rôle ou un compte de service n'a pas de mot de passe et distribue automatiquement des identifiants de courte durée. Un groupe ne peut pas être un appelant, et l'utilisateur racine est beaucoup trop puissant.

### Authentification et autorisation
Deux questions différentes sont posées à chaque requête, et les confondre est à l'origine de nombreuses erreurs de configuration.

- **L'authentification (authN)** répond à « qui êtes-vous ? ». L'appelant prouve son identité avec quelque chose qu'il connaît (un mot de passe), qu'il possède (une clé matérielle, un téléphone) ou qu'il est (une empreinte digitale), ou, pour les programmes, avec une signature cryptographique ou un jeton.
- **L'autorisation (authZ)** répond à « qu'avez-vous le droit de faire ? ». Le cloud compare le principal authentifié, l'action demandée et la ressource visée aux politiques.

L'authentification vient toujours en premier, et la réussir n'accorde rien en soi. La différence se voit dans l'erreur obtenue. Une requête avec une clé inconnue ou révoquée échoue à l'authentification (dans le lab : `InvalidClientTokenId`). Une clé valide sans permission échoue à l'autorisation (`AccessDenied`). Si vous voyez `AccessDenied`, le cloud sait exactement qui vous êtes et a décidé que vous n'en avez pas le droit.

Les programmes s'authentifient généralement en **signant** chaque requête avec une clé secrète, par exemple avec AWS Signature Version 4 : le secret lui-même ne circule jamais sur le réseau, seule une signature calculée sur la requête est transmise, ce qui empêche aussi toute modification en transit. Les jetons fonctionnent différemment : un jeton est une déclaration signée, valable pour une durée limitée, que le destinataire peut vérifier sans appeler personne.

> [!CHECK]
> Un script obtient `AccessDenied` quand il liste un bucket. Que vous apprend cette erreur ?
>
> - [ ] La clé d'accès est invalide ou a été supprimée
> - [x] Le cloud a authentifié l'appelant, mais aucune politique n'autorise cette action sur cette ressource
> - [ ] La requête a été modifiée en transit
> - [ ] L'appelant doit se reconnecter avec son mot de passe
>
> `AccessDenied` est un résultat d'autorisation : l'identité a été reconnue. Une clé invalide ou inconnue échouerait plus tôt, à l'authentification, avec une erreur différente.

### Comment une requête est évaluée
Une fois l'appelant authentifié, le cloud évalue les **politiques** : des documents qui listent ce qui est autorisé ou refusé. Deux familles comptent :

- Les **politiques d'identité** sont attachées à un principal (utilisateur, groupe ou rôle) : « Bob peut lire le dossier des rapports. »
- Les **politiques de ressource** sont attachées à une ressource, comme une politique de bucket : « Le rôle de Carol peut lire ce bucket. » Elles nomment le principal auquel elles s'appliquent.

Les règles d'évaluation sont simples, et elles sont les mêmes dans tous les grands clouds :

1. **Refus par défaut.** Si rien ne mentionne la requête, elle est refusée. Les permissions ne sont jamais implicites.
2. **Autorisation explicite.** Une instruction correspondante avec l'effet `Allow` autorise la requête.
3. **Le refus explicite l'emporte.** Une instruction correspondante avec l'effet `Deny` bloque la requête, même si dix autres instructions l'autorisent.

![Évaluation d'une politique en quatre étapes : authentifier (prouver qui vous êtes avec une signature, un jeton ou un mot de passe ; en cas d'échec, la requête est rejetée), collecter les politiques (les politiques d'identité du principal plus la politique de ressource de la cible), un Deny explicite existe-t-il (oui : REFUSÉ, arrêt ici), un Allow explicite existe-t-il (oui : AUTORISÉ, non : REFUSÉ). En dessous, trois issues : un Deny correspondant donne REFUSÉ et l'emporte toujours ; un Allow correspondant sans Deny donne AUTORISÉ ; aucune correspondance donne REFUSÉ par défaut](../../../assets/diagrams/iam-evaluation-flow.fr.svg)

*Figure 2. Le refus l'emporte sur l'autorisation, et le silence vaut refus. Cet ordre ne change jamais, quel que soit le nombre de politiques applicables.*

Au sein d'un même compte, une autorisation dans la politique d'identité *ou* dans la politique de ressource suffit, tant que rien ne refuse. Entre deux comptes, les deux côtés doivent autoriser : le propriétaire de la ressource doit laisser entrer le principal externe, et le compte du principal doit lui permettre de faire l'appel.

Les vrais clouds ajoutent des **garde-fous** par-dessus : les limites de permissions et les politiques de contrôle de service d'AWS, les groupes d'administration et les attributions de refus d'Azure, les politiques d'organisation et les politiques de refus de Google Cloud. Un garde-fou n'accorde jamais rien ; il limite seulement le maximum qu'un principal pourra jamais recevoir, quelles que soient ses propres politiques. C'est ainsi qu'une organisation peut dire une seule fois, pour tout le monde : « personne, dans aucun projet, n'a le droit d'utiliser ces régions ».

> [!CHECK]
> La politique de groupe d'Alice autorise `s3:*` sur un bucket. Son utilisateur a aussi une politique avec un `Deny` pour `s3:DeleteObject` sur ce bucket. Elle essaie de supprimer un objet. Que se passe-t-il ?
>
> - [ ] Cela réussit, parce que l'autorisation plus large couvre l'action précise
> - [ ] Cela réussit, parce que la politique attachée le plus récemment l'emporte
> - [x] C'est refusé, parce qu'un refus explicite prévaut sur toute autorisation
> - [ ] C'est refusé seulement si elle n'est pas dans le groupe
>
> Le refus explicite l'emporte toujours, quel que soit le nombre d'autorisations correspondantes ou l'endroit où elles sont attachées.

### Lire une politique JSON
Les politiques de style AWS sont des documents JavaScript Object Notation (JSON). La même structure apparaît dans les politiques IAM, dans les politiques d'approbation de rôle et dans les politiques de bucket, et les services compatibles S3 de nombreux fournisseurs l'acceptent aussi.

```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" } }
    }
  ]
}
```

![Anatomie d'une politique d'accès JSON : une politique de bucket pour lab-data avec Version 2012-10-17, une instruction avec Sid ReadReports, Effect Allow, Principal l'utilisateur carol, Action s3:GetObject, Resource arn:aws:s3:::lab-data/reports/* et une Condition exigeant la MFA. Chaque élément est mis en évidence et expliqué : Version est la version du langage ; Sid une étiquette facultative ; Effect Allow ou Deny ; Principal qui, uniquement dans les politiques de ressource et d'approbation ; Action quelles opérations ; Resource quels objets sous forme d'ARN ; Condition des tests supplémentaires comme la MFA, l'IP, l'heure et les tags](../../../assets/diagrams/iam-policy-anatomy.fr.svg)

*Figure 3. Une instruction répond à quatre questions : l'effet, qui, quoi et sur quelle ressource, et éventuellement « seulement si ».*

| Élément | Signification |
|---|---|
| `Version` | La version du langage de politique. Toujours `2012-10-17` : ce n'est pas une date que vous choisissez, et l'ancienne `2008-10-17` n'a pas certaines fonctionnalités, comme les variables de politique. |
| `Statement` | Une instruction ou une liste. Chacune est évaluée indépendamment. |
| `Sid` | Étiquette facultative, pratique lors des audits. |
| `Effect` | `Allow` ou `Deny`. Rien d'autre. |
| `Principal` | La personne ou l'entité visée par l'instruction. Utilisé uniquement dans les politiques **de ressource** et **d'approbation** ; dans une politique d'identité, le principal est celui à qui elle est attachée, donc l'élément n'y est pas autorisé. |
| `Action` | Les opérations, écrites `service:Operation` : `s3:GetObject`, `iam:CreateUser`. Les caractères génériques fonctionnent : `s3:Get*`. |
| `Resource` | Ce à quoi l'action s'applique, sous forme d'ARN. Les caractères génériques fonctionnent. |
| `Condition` | Des tests supplémentaires qui doivent être vrais : l'adresse IP source, l'heure, l'utilisation ou non de la MFA, les tags, et plus encore. |

Deux détails piègent presque tout le monde :

- **Les actions au niveau du bucket et au niveau de l'objet exigent des ARN différents.** `s3:ListBucket` s'applique au bucket, `arn:aws:s3:::lab-data`. `s3:GetObject` s'applique aux objets, `arn:aws:s3:::lab-data/reports/*`. Une politique qui place `GetObject` sur l'ARN du bucket, ou `ListBucket` sur `lab-data/*`, ne correspond silencieusement à rien.
- **`Action` et `Resource` sont mises en correspondance ensemble.** Une instruction ne s'applique que si l'action demandée *et* la ressource demandée correspondent toutes deux (et que la condition est vraie). Une autorisation pour `s3:GetObject` sur `reports/*` ne dit rien de `secret/*`.

Une **Condition** comporte un opérateur, une clé de condition et une valeur. `Bool` avec `aws:MultiFactorAuthPresent` vérifie que l'appelant s'est connecté avec un second facteur ; `IpAddress` avec `aws:SourceIp` limite les appels à une plage réseau comme `203.0.113.0/24` ; `DateLessThan` avec `aws:CurrentTime` fait expirer l'accès. Une requête doit satisfaire toutes les conditions d'une instruction pour que celle-ci s'applique.

> [!CHECK]
> Une instruction contient `"Effect": "Allow"`, `"Action": "s3:GetObject"` et `"Resource": "arn:aws:s3:::lab-data"`. Un utilisateur avec cette politique essaie de télécharger `reports/q3.txt` depuis `lab-data`. Quel est le résultat ?
>
> - [ ] Autorisé : l'utilisateur peut lire tout le bucket
> - [x] Refusé : `GetObject` agit sur des objets, donc l'ARN de la ressource doit avoir `/*` (ou un chemin) après le nom du bucket
> - [ ] Autorisé, mais seulement pour les objets du dossier `reports/`
> - [ ] La politique est rejetée comme invalide à l'enregistrement
>
> L'ARN `arn:aws:s3:::lab-data` désigne le bucket lui-même, pas les objets qu'il contient. L'instruction est valide, mais elle ne correspond jamais à une requête sur un objet, donc le refus par défaut s'applique.

### Moindre privilège, RBAC et ABAC
Le **principe du moindre privilège** veut que chaque principal reçoive uniquement les permissions dont il a besoin pour sa tâche, et uniquement pendant le temps nécessaire. Il limite le **rayon d'impact** : si un identifiant fuite ou si une personne fait une erreur, les dégâts sont bornés par ce que cette identité pouvait faire.

En pratique, vous l'appliquez en :
- partant de rien et en ajoutant des permissions pour une tâche connue, plutôt qu'en partant de l'administrateur et en retirant ;
- nommant des actions et des ressources précises plutôt que `*` ;
- utilisant des groupes et des rôles par fonction plutôt que par personne ;
- ajoutant des conditions (MFA, réseau source, heure) pour les actions sensibles ;
- examinant ce qui est réellement utilisé et en retirant le reste.

Deux modèles déterminent comment les permissions sont attribuées :

| | **Contrôle d'accès fondé sur les rôles (RBAC, Role-Based Access Control)** | **Contrôle d'accès fondé sur les attributs (ABAC, Attribute-Based Access Control)** |
|---|---|---|
| Décide selon | Le rôle ou le groupe auquel appartient le principal | Les attributs du principal, de la ressource, de l'action et de l'environnement |
| Exemple de règle | « Les membres de `analysts` peuvent lire le bucket des rapports. » | « Un utilisateur peut démarrer une VM si le tag `project` de la VM est égal au tag `project` de l'utilisateur. » |
| Point fort | Facile à comprendre et à auditer ; correspond aux intitulés de poste. | Passe à l'échelle sans nouvelles politiques : un nouveau projet demande de nouveaux tags, pas de nouveaux rôles. Granulaire et dynamique. |
| Point faible | Les rôles se multiplient (« explosion des rôles ») à mesure que des exceptions apparaissent. | Plus difficile à analyser ; dépend d'attributs fiables, si bien que la question de qui peut modifier les tags devient une question de sécurité. |
| Usage typique | La plupart des charges de travail, un bon point de départ. | Environnements vastes, avec de nombreuses équipes. |

L'ABAC est défini par le National Institute of Standards and Technology (NIST) des États-Unis dans la Special Publication (SP) 800-162, *Guide to Attribute Based Access Control (ABAC) Definition and Considerations*. La plupart des environnements réels combinent les deux : des rôles pour la forme générale, des attributs pour les détails. Voici une instruction ABAC de style AWS, qui permet à un principal de démarrer et d'arrêter uniquement les VM étiquetées avec son propre projet :

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

`${aws:PrincipalTag/project}` est une variable de politique : le cloud y substitue le tag project de l'appelant au moment de la requête. Une seule instruction sert tous les projets.

> [!CHECK]
> Une entreprise a 200 projets et veut que chaque équipe gère uniquement les ressources de son projet, sans écrire une nouvelle politique pour chaque projet. Quelle approche convient le mieux ?
>
> - [ ] Un groupe par projet, chacun avec sa propre politique rédigée à la main
> - [ ] Donner l'accès administrateur à tous les ingénieurs et s'en remettre à la confiance
> - [x] L'ABAC : étiqueter les principaux et les ressources avec `project`, et autoriser les actions quand les tags correspondent
> - [ ] Partager une clé d'accès par équipe
>
> L'ABAC compare des attributs au moment de la requête, donc une seule politique couvre tous les projets. Des groupes par projet fonctionnent (RBAC) mais multiplient les politiques à maintenir.

### Identifiants temporaires et endossement d'un rôle
Les clés d'accès de longue durée sont le plus grand risque de l'IAM cloud : elles n'expirent pas, elles sont copiées dans des scripts, sur des ordinateurs portables et dans des dépôts, et personne ne remarque quand elles fuitent. La solution, ce sont les **identifiants temporaires** : un ensemble composé d'un identifiant de clé d'accès, d'un secret et d'un **jeton de session** qui cesse de fonctionner après un court laps de temps, de quelques minutes à quelques heures.

Vous les obtenez en **endossant un rôle**, par l'intermédiaire d'un **service de jetons de sécurité** : une API de type STS (AWS Security Token Service). Le rôle a deux types de politique :

- Une **politique d'approbation** dit *qui peut endosser le rôle* (l'élément principal, comme dans l'exemple de la figure 3).
- Une **politique de permissions** dit *ce que le rôle peut faire* une fois endossé.

![Séquence entre Carol, un utilisateur IAM, le service de jetons (STS) et le bucket lab-data. 1. Carol appelle AssumeRole pour le rôle reader, signé avec sa propre clé ; STS vérifie la politique d'approbation et sa permission. 2. STS renvoie des identifiants temporaires : une clé d'accès commençant par ASIA, un secret et un jeton de session, expirant dans 900 secondes. 3. Carol appelle GetObject sur reports/q3.txt avec les identifiants temporaires ; le stockage évalue la politique du rôle et répond 200 OK. Un PutObject sur reports/c.txt obtient 403 AccessDenied parce que le rôle est en lecture seule. À l'expiration, les identifiants cessent de fonctionner : il n'y a rien à révoquer ni à renouveler](../../../assets/diagrams/iam-assume-role.fr.svg)

*Figure 4. Tant que la session dure, Carol agit en tant que le rôle, avec les permissions du rôle et non les siennes. À l'expiration, l'accès prend fin de lui-même.*

L'identité de l'appelant change : après `AssumeRole`, l'API signale l'appelant comme `arn:aws:sts::123456789012:assumed-role/reader/carol-lab`, et non comme l'utilisateur. Les journaux d'audit enregistrent le nom de session, ce qui permet de savoir qui a fait quoi. Les clés d'accès qui commencent par `AKIA` sont de longue durée ; celles qui commencent par `ASIA` sont temporaires et nécessitent aussi le jeton de session.

Endosser des rôles est aussi la façon dont une personne obtient un accès élevé seulement quand c'est nécessaire (accès « break glass » ou juste-à-temps), et dont les charges de travail reçoivent leurs identifiants de la plateforme : un profil d'instance sur une VM, un compte de service lié à un pod Kubernetes, ou une identité managée sur Azure. Le programme demande des identifiants frais à un point de terminaison de métadonnées local ; aucun secret n'est stocké nulle part.

> [!NOTE]
> La politique d'approbation du rôle nomme qui *peut* l'endosser. Dans le vrai AWS, une politique d'approbation qui nomme un utilisateur ou un rôle précis du même compte suffit à elle seule. Si elle nomme le compte entier (`arn:aws:iam::<account-id>:root`), chaque principal a aussi besoin d'une politique d'identité qui autorise `sts:AssumeRole`. De nombreuses organisations ajoutent malgré tout une politique d'identité qui autorise `sts:AssumeRole` sur le rôle précis, afin que la permission soit visible aussi sur le principal. Le lab le fait, parce que l'émulateur l'exige.

> [!CHECK]
> Quelle affirmation sur les identifiants temporaires issus de `AssumeRole` est vraie ?
>
> - [ ] Ils conservent les permissions de l'utilisateur qui les a demandés
> - [ ] Ils n'expirent jamais tant que le rôle existe
> - [x] Ils portent les permissions du rôle et cessent de fonctionner après une durée définie
> - [ ] Ils ne sont valables qu'avec le mot de passe de l'utilisateur
>
> La session agit en tant que le rôle, donc ce sont les permissions du rôle qui s'appliquent, pas celles de l'appelant. L'expiration est intégrée aux identifiants et au jeton de session.

### Fédération : SAML 2.0 et OpenID Connect
Créer un utilisateur cloud distinct pour chaque employé, chaque prestataire et chaque pipeline ne passe pas à l'échelle, et les mots de passe et les clés s'accumulent. La **fédération** permet au cloud de faire confiance à un **fournisseur d'identité (IdP, identity provider)** externe : l'annuaire de l'entreprise, une connexion via un réseau social ou un système d'intégration continue (CI). L'utilisateur se connecte auprès du fournisseur d'identité, qui se porte garant de lui avec un jeton signé. Le cloud ne voit jamais le mot de passe ; il vérifie seulement le jeton et associe l'utilisateur à un rôle.

![Séquence de fédération entre un utilisateur ou une charge de travail, le fournisseur d'identité, l'IAM du cloud avec son service de jetons, et une ressource cloud. 1. L'utilisateur se connecte auprès de l'IdP avec un mot de passe et la MFA, ou un job CI présente son propre jeton. 2. L'IdP renvoie un jeton signé : un jeton d'ID OIDC (JWT) ou une assertion SAML 2.0. 3. L'utilisateur échange le jeton contre un rôle avec AssumeRoleWithWebIdentity ou AssumeRoleWithSAML ; l'IAM du cloud vérifie la signature avec la clé publique de l'IdP, contrôle l'émetteur, l'audience et l'expiration, et la fait correspondre à la politique d'approbation du rôle. 4. Des identifiants temporaires sont renvoyés, valables de quelques minutes à quelques heures. 5. L'utilisateur appelle la ressource cloud avec eux, autorisé par la politique du rôle](../../../assets/diagrams/iam-federation.fr.svg)

*Figure 5. Le fournisseur d'identité authentifie ; le cloud autorise. Le résultat, ce sont des identifiants temporaires, sans aucune clé de longue durée.*

Deux standards dominent :

| | **SAML 2.0** | **OpenID Connect (OIDC)** |
|---|---|---|
| Nom complet | Security Assertion Markup Language 2.0 (standard OASIS) | OpenID Connect Core 1.0 |
| Jeton | Une **assertion** : un document Extensible Markup Language (XML) signé | Un **jeton d'ID** : un JSON Web Token (JWT, RFC 7519) signé |
| Fondé sur | XML et redirections du navigateur | OAuth 2.0 (RFC 6749), auquel il ajoute une couche d'authentification |
| Usage typique | L'authentification unique (SSO, single sign-on) d'entreprise pour que des personnes accèdent à la console | Applications web et mobiles, et **fédération d'identité de charge de travail** pour les pipelines et les programmes |
| Exemple | Un collaborateur se connecte au portail de l'entreprise et arrive dans la console du cloud | Un job CI prouve « je suis la branche `main` de ce dépôt » et obtient un rôle pour un déploiement |

OAuth 2.0 seul concerne l'*autorisation déléguée* (laisser une application agir en votre nom), pas la preuve de votre identité. OIDC ajoute par-dessus la couche d'identité manquante.

La fédération d'identité de charge de travail remplace la clé de déploiement stockée. Une plateforme de CI émet pour chaque job un jeton OIDC de courte durée dont les revendications indiquent d'où il vient, par exemple `sub: repo:example-org/example-repo:ref:refs/heads/main`. La politique d'approbation du rôle cloud n'accepte que cet émetteur, cette audience et ce sujet. Un autre dépôt, ou une autre branche, ne peut pas endosser le rôle.

> [!CHECK]
> Que vérifie un cloud lorsqu'il reçoit un jeton d'ID OIDC ou une assertion SAML d'un fournisseur d'identité ?
>
> - [ ] Le mot de passe de l'utilisateur, que le fournisseur d'identité transmet
> - [x] La signature (avec la clé publique de l'IdP), l'émetteur, l'audience et l'expiration, puis la politique d'approbation du rôle
> - [ ] Seulement que le jeton est un document JSON ou XML bien formé
> - [ ] Que l'utilisateur possède une clé d'accès dans le compte cloud
>
> Le cloud fait confiance à la signature de l'IdP, pas à un mot de passe. Il vérifie quand même que le jeton lui est destiné, qu'il est toujours valide et qu'il correspond à la politique d'approbation du rôle.

### Authentification multifacteur
L'**authentification multifacteur (MFA, multi-factor authentication)** exige au moins deux types de preuve différents : quelque chose que vous connaissez, quelque chose que vous possédez et quelque chose que vous êtes. Un mot de passe volé ne suffit plus à ouvrir la porte. Les seconds facteurs courants, du plus faible au plus fort :

- **Codes SMS.** Mieux que rien, mais vulnérables à l'échange de carte SIM (SIM swapping) et à l'interception.
- **Mots de passe à usage unique basés sur le temps (TOTP, RFC 6238)** issus d'une application d'authentification. Hameçonnables : un faux site peut demander le code et le rejouer immédiatement.
- **Clés matérielles FIDO2 / WebAuthn et clés d'accès (passkeys).** La clé signe un défi qui inclut le nom du vrai site, si bien qu'un site imitateur n'obtient rien d'utile. C'est la MFA **résistante à l'hameçonnage**.

Imposez la MFA à chaque utilisateur humain, toujours pour l'utilisateur racine et pour les actions sensibles au moyen d'une condition (`aws:MultiFactorAuthPresent`). Les programmes ne peuvent pas utiliser la MFA, ce qui est une raison de plus de leur donner des identifiants temporaires plutôt que des clés.

> [!CHECK]
> Pourquoi une clé de sécurité FIDO2 est-elle considérée comme plus forte qu'un code TOTP issu d'une application ?
>
> - [ ] Le code est plus long, donc plus difficile à deviner
> - [ ] La clé fonctionne sans Internet, donc personne ne peut l'intercepter
> - [x] La clé signe un défi lié au site authentique, donc un site d'hameçonnage ne peut pas le réutiliser
> - [ ] Le cloud stocke le secret de la clé pour pouvoir la réinitialiser
>
> Un code TOTP peut être saisi dans une fausse page et rejoué. Une réponse FIDO2 est liée à l'origine du vrai site, donc une copie ne vaut rien ailleurs.

## Comment ça marche
Suivons une requête du début à la fin. Bob, dont l'utilisateur a la politique de moindre privilège du lab, exécute `aws s3api get-object --bucket lab-data --key reports/q3.txt` :

1. **Signer.** L'outil en ligne de commande construit la requête HTTP et la signe avec la clé secrète de Bob. L'identifiant de la clé d'accès figure dans la requête ; le secret, non.
2. **Authentifier.** Le service recherche l'identifiant de la clé d'accès, recalcule la signature avec le secret correspondant et compare. Une différence ou une clé inconnue met fin à la requête avec une erreur d'authentification.
3. **Construire le contexte.** Le service relève qui (`arn:aws:iam::123456789012:user/bob`), quoi (`s3:GetObject`), sur quelle ressource (`arn:aws:s3:::lab-data/reports/q3.txt`) et l'environnement (adresse IP source, heure, utilisation ou non de la MFA et de TLS).
4. **Collecter les politiques.** Les politiques de l'utilisateur de Bob, celles de ses groupes, la politique de bucket de `lab-data` et d'éventuels garde-fous de l'organisation.
5. **Évaluer.** Chercher un `Deny` correspondant : aucun. Chercher un `Allow` correspondant : l'instruction pour `GetObject` sur `lab-data/reports/*` correspond. Résultat : autorisé.
6. **Agir et journaliser.** L'objet est renvoyé, et le journal d'audit enregistre l'appel avec le principal, l'action, la ressource, l'adresse IP source et le résultat.

> [!CHECK]
> Quelle étape de la vie d'une requête a lieu en premier ?
>
> - [ ] Le cloud collecte les politiques applicables
> - [ ] Le cloud cherche un refus explicite correspondant
> - [x] Le cloud authentifie l'appelant à partir de la signature ou du jeton
> - [ ] Le cloud vérifie si le rôle de l'appelant a expiré
>
> Les politiques sont évaluées pour un principal *connu*, donc l'authentification vient toujours en premier. Une session expirée échoue à cette même étape d'authentification.

## Exemple concret
Vous gérez le bucket `lab-data` avec deux préfixes, `reports/` et `secret/`. Bob a cette politique d'identité (c'est celle que vous construisez dans le lab) :

```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": "*" }
  ]
}
```

Le bucket a aussi une politique de ressource qui refuse toute requête non chiffrée en transit (une base courante) :

```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" } }
    }
  ]
}
```

Prédisez le résultat de chaque requête de Bob, puis vérifiez le raisonnement :

| # | Requête | Résultat | Pourquoi |
|---|---|---|---|
| 1 | `GetObject` `reports/q3.txt` en HTTPS | **Autorisé** | `EverythingInReports` l'autorise ; aucun refus ne correspond (`SecureTransport` est vrai, donc `DenyPlainHttp` ne s'applique pas). |
| 2 | `GetObject` `reports/q3.txt` en HTTP simple | **Refusé** | `DenyPlainHttp` correspond : le refus explicite l'emporte sur l'autorisation. |
| 3 | `PutObject` `reports/q4.txt` en HTTPS | **Autorisé** | `s3:*` sur `reports/*` le couvre. |
| 4 | `DeleteObject` `reports/q3.txt` en HTTPS | **Refusé** | `NeverDelete` est un refus explicite ; il l'emporte sur l'autorisation `s3:*`. |
| 5 | `GetObject` `secret/passwords.txt` en HTTPS | **Refusé** | Aucune instruction n'autorise `secret/*` : refus par défaut. |
| 6 | `ListBucket` sur `lab-data` | **Autorisé** | `ListTheBucket` l'autorise, pour le bucket entier : Bob voit aussi les *noms* des objets de `secret/`. |

La ligne 6 est une surprise classique. Lister est une action au niveau du bucket, donc cette politique ne peut pas la limiter à `reports/` par la seule ressource. Sur les vrais clouds, vous ajoutez une `Condition` sur le préfixe de la clé (pour AWS, `s3:prefix`) pour la restreindre.

## Pièges courants
- **Mettre `*` dans `Action` ou `Resource` « pour que ça marche »** — cela marche parce que cela autorise tout. Trouvez l'action exacte à partir de l'erreur ou du journal d'audit et nommez-la.
- **Confondre l'ARN du bucket et celui de l'objet** — `ListBucket` exige `arn:aws:s3:::name`, `GetObject` exige `arn:aws:s3:::name/*`. Si une moitié d'une politique fonctionne et pas l'autre, vérifiez cela en premier.
- **Croire qu'une autorisation ultérieure ou plus étroite peut annuler un refus** — elle ne le peut jamais. Pour rétablir l'accès, vous devez supprimer ou restreindre le refus.
- **Oublier qu'un groupe n'est pas une identité** — on ne peut pas se connecter en tant que groupe, ni le nommer comme `Principal` d'une politique de ressource ou d'approbation. Vous lui attachez des politiques et ses membres en héritent.
- **Tester avec l'identité administrateur** — elle peut tout faire, donc vous ne voyez jamais la permission manquante. Testez avec l'identité qui exécutera réellement la tâche.
- **Supposer que les conditions sont toujours appliquées par tous les outils** — certains émulateurs et certains services partiellement compatibles S3 les ignorent. Testez les conditions sur le vrai service avant de vous y fier.

## Considérations de sécurité
La plupart des violations du cloud commencent par l'identité, pas par une vulnérabilité logicielle. Voici les erreurs qui reviennent sans cesse, et comment les repérer.

### Erreurs courantes
- **Politiques à caractères génériques.** `"Action": "*"` sur `"Resource": "*"` fait de chaque identifiant qui la porte un passe-partout. Même `s3:*` sur `*` permet au détenteur de lire, modifier et supprimer chaque bucket du compte.
- **Clés de longue durée et clés divulguées.** Des clés d'accès validées dans des dépôts, collées dans une messagerie, intégrées à des images de conteneurs ou laissées des années dans une variable de CI. Les dépôts publics sont scannés à la recherche de clés, souvent quelques minutes après un push. Préférez les rôles, la fédération et les identifiants temporaires ; quand une clé est inévitable, renouvelez-la et limitez-la avec des conditions.
- **Comptes et identifiants inutilisés.** Anciens employés, utilisateurs de test abandonnés et vieilles clés restent valides jusqu'à ce que quelqu'un les supprime. Chaque identité inutilisée est une porte d'entrée non surveillée.
- **Utiliser le compte racine ou propriétaire au quotidien.** On ne peut pas le restreindre. Protégez-le avec un mot de passe robuste et une MFA résistante à l'hameçonnage, ne lui donnez aucune clé d'accès, et réservez-le aux rares tâches qui l'exigent.
- **Pas de MFA, ou MFA faible.** Un mot de passe volé équivaut alors à une compromission totale. Exigez la MFA pour chaque humain, et préférez FIDO2 pour les administrateurs.
- **Politiques d'approbation trop larges.** Un rôle qui fait confiance à un compte entier, ou à `"Principal": "*"`, peut être endossé par n'importe qui dans ce compte, ou par n'importe qui tout court. Nommez le principal exact et, pour la fédération, l'émetteur, l'audience et le sujet exacts.
- **Permissions accordées par la capacité de modifier les permissions.** Un principal autorisé à utiliser `iam:PutUserPolicy` ou `iam:AttachUserPolicy` peut s'accorder les droits d'administrateur. Traitez les actions d'écriture IAM comme des actions de niveau administrateur.

### Détection
- **Journaux d'audit.** Chaque appel d'API est enregistré avec qui, quoi, quand et d'où : AWS CloudTrail, Azure Activity Log et les journaux de connexion Microsoft Entra, Google Cloud Audit Logs. Conservez-les dans un compte distinct protégé en écriture, et déclenchez des alertes sur les événements sensibles : utilisation de la racine, connexion à la console sans MFA, nouvelles clés d'accès, modifications de politiques, appels depuis des pays inhabituels.
- **Revues des accès.** À intervalle régulier (le trimestre est courant), le propriétaire de chaque ressource confirme qui a encore besoin d'accès, et vous retirez le reste. Incluez les comptes de service et les approbations entre comptes, qui sont facilement oubliés.
- **Rapports d'hygiène des identifiants.** Listez les utilisateurs, les clés, leur ancienneté et leur dernière utilisation (le lab utilise `get-access-key-last-used`). Supprimez les clés que personne n'a utilisées depuis 90 jours, renouvelez celles qui doivent rester, et comparez les permissions accordées avec les permissions utilisées ; la plupart des clouds peuvent suggérer une politique plus étroite à partir du journal d'activité (par exemple IAM Access Analyzer sur AWS, les outils d'analyse des politiques sur Google Cloud).
- **Rotation des clés.** Créez la nouvelle clé, basculez l'application dessus, vérifiez que l'ancienne clé n'est plus utilisée, puis supprimez-la. À aucun moment vous n'avez à arrêter l'application. La rotation raccourcit la durée de vie d'une fuite mais ne dispense pas d'éviter les clés de longue durée.
- **Analyse des secrets.** Analysez les dépôts et les images à la recherche de clés avant qu'elles ne soient publiées, et considérez toute clé qui a un jour atteint un lieu public comme compromise : supprimez-la, ne vous contentez pas de réécrire l'historique.

> [!WARNING]
> Si une clé d'accès fuite, désactivez-la ou supprimez-la immédiatement, puis examinez le journal d'audit pour savoir ce qu'elle a fait entre la fuite et la révocation. Modifier le code ou supprimer le dépôt n'annule pas l'exposition.

## Résumé
- L'IAM répond à deux questions : qui êtes-vous (authentification) et que pouvez-vous faire (autorisation). `AccessDenied` signifie que l'authentification a réussi et l'autorisation non.
- Une requête n'est autorisée que si une instruction l'autorise et qu'aucune ne la refuse : refus par défaut, autorisation explicite, le refus explicite l'emporte.
- Une instruction de politique JSON comporte un effet, un principal (dans les politiques de ressource et d'approbation), des actions, des ressources et des conditions facultatives. Attention à la différence entre les ARN de bucket et d'objet.
- Appliquez le moindre privilège : actions et ressources précises, portées étroites, groupes et rôles, conditions et revues régulières. Utilisez le RBAC pour la forme générale et l'ABAC pour des règles fines et évolutives.
- Préférez les rôles et les identifiants temporaires (un `AssumeRole` de type STS) aux clés de longue durée, et fédérez les personnes et les pipelines avec SAML 2.0 ou OpenID Connect pour que le cloud ne détienne jamais leurs mots de passe.
- Imposez la MFA, protégez le compte racine, supprimez les identités inutilisées, renouvelez les clés inévitables et surveillez les journaux d'audit.

## Glossaire
| Terme | Définition |
|---|---|
| Gestion des identités et des accès (IAM, Identity and Access Management) | Le service cloud et la discipline qui décident qui fait la demande et ce que cette personne peut faire. |
| Identité | Un acteur reconnu dans un système : une personne, un programme ou un rôle. |
| Principal | Toute identité qui peut faire une requête : utilisateur, membre d'un groupe, session de rôle ou compte de service. |
| Utilisateur | Une identité nominative pour une personne, avec des identifiants tels qu'un mot de passe et des clés d'accès. |
| Groupe | Un ensemble d'utilisateurs auquel des politiques sont attachées ; les membres en héritent. Il ne peut pas faire de requêtes lui-même. |
| Rôle | Une identité avec des permissions mais sans identifiants permanents, endossée temporairement. |
| Compte de service | Une identité non humaine pour une application, une VM ou un pipeline. Aussi appelée identité de charge de travail ou identité machine. |
| Utilisateur racine | L'identité toute-puissante créée avec le compte (propriétaire ou administrateur général ailleurs). |
| Amazon Resource Name (ARN) | Le nom unique d'une ressource ou d'un principal dans AWS, tel que `arn:aws:iam::123456789012:user/bob`. |
| Clé d'accès | Une paire de clés (identifiant et secret) qui signe les requêtes d'API. De longue durée, sauf si elle est émise dans le cadre d'identifiants temporaires. |
| Authentification (authN) | Prouver qui est l'appelant. |
| Autorisation (authZ) | Décider de ce qu'un appelant authentifié a le droit de faire. |
| Politique | Un document qui liste les actions autorisées ou refusées sur des ressources. |
| Politique d'identité | Une politique attachée à un utilisateur, un groupe ou un rôle. |
| Politique de ressource | Une politique attachée à une ressource, comme une politique de bucket ; elle nomme les principaux auxquels elle s'applique. |
| Refus par défaut | La règle selon laquelle tout ce qui n'est pas explicitement autorisé est refusé. |
| Refus explicite | Une instruction avec `Effect: Deny` ; elle l'emporte sur toute autorisation. |
| Instruction | Une règle d'une politique : effet, principal, action, ressource et condition facultative. |
| Condition | Un test supplémentaire dans une instruction (MFA, plage IP, heure, tags) qui doit être vrai pour qu'elle s'applique. |
| Garde-fou | Une limite au niveau de l'organisation (comme les limites de permissions ou les politiques de contrôle de service) qui plafonne ce que les principaux pourront jamais recevoir. |
| Principe du moindre privilège | Donner à chaque principal uniquement les permissions dont il a besoin, pendant le temps nécessaire. |
| Rayon d'impact | L'étendue des dégâts possibles si une identité ou un identifiant est compromis. |
| Contrôle d'accès fondé sur les rôles (RBAC) | Accorder des permissions selon les rôles ou les groupes auxquels appartient un principal. |
| Contrôle d'accès fondé sur les attributs (ABAC) | Accorder des permissions en comparant les attributs du principal, de la ressource, de l'action et de l'environnement (NIST SP 800-162). |
| Identifiants temporaires | Une clé d'accès, un secret et un jeton de session qui expirent après un court laps de temps. |
| Jeton de session | La valeur supplémentaire qui doit accompagner les identifiants temporaires à chaque requête. |
| Service de jetons de sécurité (STS) | L'API qui émet des identifiants temporaires, par exemple via `AssumeRole`. |
| Endosser un rôle | Échanger votre identité contre des identifiants temporaires portant les permissions d'un rôle. |
| Politique d'approbation | La politique d'un rôle qui indique qui peut l'endosser. |
| Fédération | Faire confiance à un fournisseur d'identité externe pour authentifier les utilisateurs, de sorte que le cloud ne détient pas leurs mots de passe. |
| Fournisseur d'identité (IdP) | Le système qui authentifie les utilisateurs et émet des jetons ou des assertions signés. |
| SAML 2.0 | Un standard fondé sur XML pour des assertions signées, très utilisé pour l'authentification unique d'entreprise. |
| OpenID Connect (OIDC) | Une couche d'authentification au-dessus d'OAuth 2.0 qui émet des jetons d'ID JWT signés. |
| Fédération d'identité de charge de travail | Permettre à un pipeline ou à un programme d'échanger un jeton de courte durée de sa plateforme contre des identifiants cloud, sans clé stockée. |
| Authentification multifacteur (MFA) | Une authentification qui exige au moins deux types de preuve. |
| MFA résistante à l'hameçonnage | Une MFA, comme les clés FIDO2, dont la réponse est liée au site authentique et ne peut pas être rejouée depuis un faux. |
| Journal d'audit | L'enregistrement des appels d'API : qui, quoi, quand, d'où et le résultat. |
| Revue des accès | Une vérification planifiée que chaque identité a toujours besoin de l'accès qu'elle possède. |
| Rotation des clés | Remplacer un identifiant par un nouveau et retirer l'ancien. |

## Vérifiez vos connaissances
1. La politique d'un collègue contient `"Action": "s3:*"` et `"Resource": "*"` « parce que c'était la seule façon de faire fonctionner le script de téléversement ». Expliquez comment vous trouveriez les permissions réellement nécessaires au script et rédigeriez une politique de remplacement de moindre privilège.
2. Un utilisateur est dans deux groupes. Le groupe A autorise `s3:GetObject` sur `reports/*`. Le groupe B a un `Deny` explicite pour `s3:*` sur tout le bucket pour quiconque n'a pas la MFA. Que peut faire l'utilisateur connecté sans MFA, et avec la MFA ? Quel élément fait la différence ?
3. Concevez l'accès d'un pipeline de CI qui déploie dans votre compte cloud. Quel principal, quels identifiants, quelles conditions d'approbation ? Que supprimez-vous par rapport au stockage d'une clé d'accès dans une variable de CI ?
4. Expliquez, avec vos propres mots, pourquoi `AccessDenied` et `InvalidClientTokenId` indiquent des problèmes différents, et ce que vous vérifieriez dans chaque cas.
5. Votre entreprise compte 40 développeurs et 5 équipes. Quand choisiriez-vous le RBAC, quand l'ABAC, et que faut-il maîtriser pour que l'ABAC soit sûr ?
6. Vous découvrez qu'une clé d'accès appartenant à un employé parti il y a un an a été utilisée pour la dernière fois hier. Décrivez, dans l'ordre, ce que vous feriez durant la première heure.

## Références
- [NIST SP 800-162](https://csrc.nist.gov/pubs/sp/800/162/upd2/final) — Guide to Attribute Based Access Control (ABAC) Definition and Considerations : guide du contrôle d'accès fondé sur les attributs.
- [NIST SP 800-63-4](https://pages.nist.gov/800-63-4/) — Digital Identity Guidelines : lignes directrices sur l'identité numérique (authentification, fédération).
- [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 : le cadre d'autorisation 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 : algorithme de mot de passe à usage unique basé sur le temps.
- [AWS IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/) — logique d'évaluation des politiques, référence des politiques et identifiants temporaires.
- [Google Cloud IAM overview](https://cloud.google.com/iam/docs/overview), [Azure RBAC overview](https://learn.microsoft.com/azure/role-based-access-control/overview) et [OpenStack Keystone](https://docs.openstack.org/keystone/latest/) — les mêmes concepts chez d'autres fournisseurs.
