Logo Teamwork

Fédération d'identité sortante IAM : accès inter-partitions entre AWS commercial et l'ESC

Published on
Authors
Version audio
Chargement...
Fédération d'identité sortante IAM : accès inter-partitions entre AWS commercial et l'ESC - Guide Sylvain BRUAS

Dans la seconde partie de notre analyse de l'AWS European Sovereign Cloud, nous avions posé un constat simple : les partitions AWS sont des frontières d'isolation. Chacune possède sa propre instance d'AWS Identity and Access Management (IAM), et aucune identité, aucun rôle, aucune politique ne traverse la frontière. Un sts:AssumeRole d'une partition vers l'autre ne fonctionne tout simplement pas.

C'est une très bonne nouvelle pour la souveraineté. C'est aussi une vraie contrainte opérationnelle dès qu'une charge de travail hébergée dans l'AWS European Sovereign Cloud (ESC) doit lire une donnée, un modèle ou une image qui vit dans la partition commerciale. Jusqu'ici, la réponse passait souvent par des clés d'accès longue durée stockées quelque part, avec tout ce que cela implique en rotation, en fuite potentielle et en preuve difficile à produire.

AWS vient d'étendre la fédération d'identité sortante IAM (IAM outbound identity federation) au cas inter-partitions, comme l'explique le billet Simplify cross-partition access with AWS IAM outbound identity federation. Cet article en reprend le principe, mais en l'appliquant à un cas qui nous intéresse ici : une charge de travail dans l'ESC qui accède à un bucket en AWS commercial. Il insiste sur ce que le mécanisme change pour la sécurité, la conformité et surtout la gestion de la preuve.

Le problème : franchir une frontière d'isolation sans clé longue durée

Rappelons les contraintes de départ :

  • une credential émise dans une partition n'est pas valide dans une autre ;
  • une politique de ressource ne peut pas référencer un principal qui existe dans une autre partition ;
  • il n'existe pas de peering ni de service natif qui « fasse le pont » côté identité.

Les contournements habituels sont connus : un utilisateur IAM dédié avec des clés statiques, un secret partagé dans un coffre, un composant intermédiaire qui fait office de passerelle. Chacun déplace le problème sans le résoudre : il faut stocker, faire tourner, auditer et révoquer ces secrets, et il est difficile de prouver qui a fait quoi de part et d'autre de la frontière.

Comment fonctionne la fédération inter-partitions

Le mécanisme repose sur deux appels AWS Security Token Service (STS), un dans chaque partition :

  1. la charge de travail, dans la partition source, appelle sts:GetWebIdentityToken et reçoit un jeton JSON Web Token (JWT), signé par AWS et de courte durée ;
  2. elle présente ce jeton à STS dans la partition de destination via sts:AssumeRoleWithWebIdentity et obtient des credentials temporaires, limitées par les politiques du rôle cible ;
  3. elle utilise ces credentials pour appeler l'API de destination (ici Amazon S3).

Le JWT contient des claims qui décrivent l'identité d'origine : compte, ARN du principal, région source, identifiant d'organisation. AWS opère toute l'infrastructure de jetons : émission, signature et publication des clés de vérification (JSON Web Key Set, JWKS) via un point de découverte OpenID Connect (OIDC). Il n'y a ni infrastructure à clés publiques (PKI) à monter, ni fournisseur OpenID à héberger.

Deux précisions importantes de la documentation d'AWS :

  • la fédération inter-partitions n'est pas activée par défaut : on l'active au niveau du compte source et on déclare un fournisseur d'identité dans le compte de destination ;
  • elle fonctionne uniquement entre partitions (commerciale, Chine, GovCloud (US), ESC). Au sein d'une même partition, on continue d'utiliser sts:AssumeRole. Elle est disponible dans toutes les régions de ces partitions, sans coût supplémentaire.

Ce que ça apporte côté sécurité

Plus de secret à stocker ni à faire tourner

La charge de travail s'authentifie avec son rôle IAM (profil d'instance, rôle d'exécution Lambda, compte de service EKS), obtient un jeton de quelques minutes, puis des credentials temporaires. Rien de durable n'existe à aucun moment de la chaîne. Cela supprime d'un coup toute une famille de risques : clé committée par erreur, secret copié dans un pipeline, rotation oubliée.

Une autorisation fondée sur l'origine, pas seulement sur la validité du jeton

C'est le point le plus intéressant. La politique de confiance du rôle de destination peut conditionner l'accès à des claims du jeton :

  • sub : l'ARN exact du rôle source ;
  • aud : l'audience attendue (un identifiant que vous choisissez) ;
  • source_region : la région d'émission ;
  • org_id : l'organisation AWS d'origine.

On n'autorise donc pas « un jeton valide », mais « ce rôle précis, issu de cette organisation, depuis cette région, pour cette audience ». Côté source, des clés de condition (sts:IdentityTokenAudience, sts:DurationSeconds, sts:SigningAlgorithm) permettent de restreindre qui peut demander un jeton, pour quelle audience et pour quelle durée.

Un contrôle centralisé de l'origine autorisée

Une fois la fédération ouverte, on ne veut pas que n'importe quel compte de l'organisation puisse l'utiliser. Deux clés de condition entrent en jeu : aws:FederatedProvider pour filtrer le fournisseur ou la partition d'origine, et aws:CrossPartitionSourceRegion (nouvelle) pour filtrer la région source. Associées à une Resource Control Policy (RCP), elles permettent d'exprimer une liste d'autorisation à l'échelle de l'organisation. Comme une RCP ne sait que refuser, on écrit un Deny sur tout ce qui n'est pas dans l'ensemble approuvé :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowlistApprovedIssuer",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Resource": "*",
      "Condition": {
        "StringLike": {
          "aws:FederatedProvider": "arn:*:iam::*:oidc-provider/*.tokens.sts.*"
        },
        "StringNotLike": {
          "aws:FederatedProvider": [
            "arn:*:iam::*:oidc-provider/<issuer-host>"
          ]
        }
      }
    }
  ]
}

Le premier StringLike cible uniquement les émetteurs de fédération sortante IAM. Les autres fournisseurs OIDC de l'organisation (GitHub Actions, EKS, etc.) ne sont donc pas touchés par ce refus. <issuer-host> est le nom d'hôte de l'émetteur de votre partition source, tel que renvoyé par la commande d'activation (voir plus bas).

Une révocation possible

Les sessions déjà émises peuvent être révoquées : on peut poser un refus sur le rôle de destination, ou cibler une origine (fournisseur, partition ou région source) via les clés de condition ci-dessus. En cas d'incident côté source, on coupe l'accès sans attendre l'expiration naturelle des credentials.

Gestion de la preuve : le vrai gain pour la conformité

Pour un responsable conformité, la question n'est pas seulement « l'accès est-il sécurisé ? » mais « puis-je le démontrer, a posteriori, à un auditeur ? ». C'est là que le mécanisme est le plus convaincant.

Une piste d'audit corrélée de bout en bout

Chaque partition journalise sa moitié de l'opération dans AWS CloudTrail, avec le même identifiant de jeton :

  • partition source (ESC) : un événement GetWebIdentityToken, avec le principal appelant, l'audience, la durée demandée, et dans responseElements le webIdentityTokenId ;
  • partition de destination (commerciale) : un événement AssumeRoleWithWebIdentity, avec le même webIdentityTokenId dans requestParameters, ainsi que l'ARN du principal source et la région source dans additionalEventData.crossPartitionData.

Voici, à titre d'illustration, l'événement côté destination (extrait, valeurs d'exemple) :

{
  "eventName": "AssumeRoleWithWebIdentity",
  "eventSource": "sts.amazonaws.com",
  "awsRegion": "eu-west-3",
  "requestParameters": {
    "roleArn": "arn:aws:iam::<destination-account-id>:role/<destination-role>",
    "roleSessionName": "<session-name>",
    "webIdentityTokenId": "6318f9f3-bccf-4d00-8e77-920e810f395c"
  },
  "additionalEventData": {
    "crossPartitionData": {
      "sourcePrincipalArn": "arn:aws-eusc:iam::<source-account-id>:role/<source-role>",
      "sourceRegion": "eusc-de-east-1"
    }
  }
}

Le webIdentityTokenId est la clé de jointure : à partir d'un accès dans le bucket commercial, on remonte jusqu'à l'événement d'émission du jeton dans l'ESC, donc jusqu'au rôle, au compte et à l'instant précis. Sans ce lien, deux journaux indépendants (un par partition) n'auraient aucun moyen fiable d'être rapprochés.

Une preuve qui reste dans la partition d'origine

Un point souvent sous-estimé : l'événement GetWebIdentityToken est journalisé dans l'ESC, sous gouvernance européenne. La trace de « qui a demandé à sortir » reste donc dans la partition souveraine, même si l'accès lui-même aboutit côté commercial. À l'inverse, la trace de l'accès réel aux données est dans la partition de destination. Chaque côté conserve la preuve de sa propre responsabilité.

Ce qu'il faut garder en tête

La corrélation implique aussi que des métadonnées d'identité (l'ARN du principal source et la région source) apparaissent dans les journaux de la partition commerciale. Ces informations ne sont pas des données métier, mais elles sortent du périmètre souverain. Soignez donc le nommage des rôles et des sessions : pas d'information sensible dans un nom de rôle.

Et surtout, cette fédération n'est pas un « laissez-passer conformité ». AWS le rappelle explicitement : l'accès inter-partitions doit rester une exception, validée avec les équipes conformité au regard des exigences applicables (Règlement général sur la protection des données (RGPD), Federal Risk and Authorization Management Program (FedRAMP), International Traffic in Arms Regulations (ITAR), etc.). Le mécanisme sécurise et rend l'accès traçable. Il ne dit pas si le flux de données est légalement admissible.

Exemple : une charge de travail ESC qui lit un bucket en AWS commercial

Mettons-nous dans un cas réaliste. Une application de traitement hébergée dans l'ESC (région eusc-de-east-1) doit récupérer un jeu de données non sensible, par exemple un référentiel public ou un artefact de modèle, stocké dans un bucket de la partition commerciale (région eu-west-3). Le sens de la demande va de la partition la plus restrictive (ESC) vers la moins restrictive (commerciale), ce qui correspond à la bonne pratique recommandée par AWS : l'accès est initié depuis la partition la plus contrainte.

Étape 0 : deux profils AWS CLI

# ~/.aws/config
[profile EscCredentials]
region = eusc-de-east-1
# Credentials / SSO du compte ESC

[profile CommercialCredentials]
region = eu-west-3
# Credentials / SSO du compte commercial

Étape 1 : activer la fédération sortante dans le compte ESC

Une seule fois par compte source. La commande renvoie l'URL de l'émetteur (issuer URL), de la forme https://<unique-id>.tokens.sts.<...>.api.aws : copiez-la telle quelle, elle sert à l'étape 3.

aws iam enable-outbound-web-identity-federation \
  --region eusc-de-east-1 \
  --profile EscCredentials

IAM n'a qu'un seul point de terminaison par partition : --region sert simplement à cibler l'IAM de la partition ESC.

Étape 2 : autoriser le rôle de la charge de travail à demander un jeton

Dans l'ESC, le rôle de la charge de travail reçoit une politique qui n'autorise sts:GetWebIdentityToken que pour une audience donnée, avec une durée plafonnée à 300 secondes :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowTokensForCommercial",
      "Effect": "Allow",
      "Action": "sts:GetWebIdentityToken",
      "Resource": "*",
      "Condition": {
        "ForAllValues:StringEquals": {
          "sts:IdentityTokenAudience": "<audience-name>"
        },
        "Null": {
          "sts:IdentityTokenAudience": "false"
        },
        "NumericLessThanEquals": {
          "sts:DurationSeconds": 300
        },
        "StringEquals": {
          "sts:SigningAlgorithm": "ES384"
        }
      }
    }
  ]
}
aws iam put-role-policy \
  --role-name <esc-workload-role> \
  --policy-name AllowGetWebIdentityToken \
  --policy-document file://get-web-identity-token-policy.json \
  --region eusc-de-east-1 \
  --profile EscCredentials

Étape 3 : déclarer la confiance dans le compte commercial

On enregistre l'émetteur ESC comme fournisseur OIDC dans le compte commercial, puis on crée un rôle dont la politique de confiance est la plus étroite possible :

aws iam create-open-id-connect-provider \
  --url https://<unique-id>.tokens.sts.<...>.api.aws \
  --client-id-list "<audience-name>" \
  --region eu-west-3 \
  --profile CommercialCredentials

Dans la politique de confiance, <issuer-host> désigne le nom d'hôte de l'émetteur (l'URL de l'étape 1 sans https://). On y verrouille le rôle source, l'audience, la région et l'organisation d'origine :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowTrustedEscWorkload",
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::<destination-account-id>:oidc-provider/<issuer-host>"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "<issuer-host>:sub": "arn:aws-eusc:iam::<source-account-id>:role/<esc-workload-role>",
          "<issuer-host>:aud": "<audience-name>",
          "<issuer-host>:source_region": "eusc-de-east-1",
          "<issuer-host>:org_id": "<esc-organization-id>"
        }
      }
    }
  ]
}

Le rôle commercial reçoit une politique d'autorisation minimale : s3:GetObject sur le seul préfixe nécessaire, rien d'autre.

Si vous gérez l'infrastructure avec Terraform, le fournisseur OIDC et le rôle de destination s'écrivent ainsi :

resource "aws_iam_openid_connect_provider" "esc" {
  url            = "https://<unique-id>.tokens.sts.<...>.api.aws"
  client_id_list = ["<audience-name>"]
}

data "aws_iam_policy_document" "esc_trust" {
  statement {
    actions = ["sts:AssumeRoleWithWebIdentity"]

    principals {
      type        = "Federated"
      identifiers = [aws_iam_openid_connect_provider.esc.arn]
    }

    condition {
      test     = "StringEquals"
      variable = "${replace(aws_iam_openid_connect_provider.esc.url, "https://", "")}:sub"
      values   = ["arn:aws-eusc:iam::<source-account-id>:role/<esc-workload-role>"]
    }

    condition {
      test     = "StringEquals"
      variable = "${replace(aws_iam_openid_connect_provider.esc.url, "https://", "")}:aud"
      values   = ["<audience-name>"]
    }
  }
}

resource "aws_iam_role" "esc_reader" {
  name               = "esc-workload-reader"
  assume_role_policy = data.aws_iam_policy_document.esc_trust.json
}

Étape 4 : l'accès depuis la charge de travail

En production, la charge de travail tourne déjà sous le rôle ESC (profil d'instance, rôle d'exécution), et n'a donc rien à « assumer ». Le flux complet tient en trois commandes :

# 1. Jeton signé, émis par STS dans l'ESC
WEB_IDENTITY_TOKEN=$(aws sts get-web-identity-token \
  --audience "<audience-name>" \
  --signing-algorithm ES384 \
  --duration-seconds 300 \
  --region eusc-de-east-1 \
  --query WebIdentityToken --output text)

# 2. Échange contre des credentials temporaires en AWS commercial
CREDENTIALS=$(aws sts assume-role-with-web-identity \
  --role-arn arn:aws:iam::<destination-account-id>:role/<destination-role> \
  --role-session-name esc-reader-session \
  --web-identity-token "$WEB_IDENTITY_TOKEN" \
  --region eu-west-3)

export AWS_ACCESS_KEY_ID=$(echo "$CREDENTIALS" | jq -r '.Credentials.AccessKeyId')
export AWS_SECRET_ACCESS_KEY=$(echo "$CREDENTIALS" | jq -r '.Credentials.SecretAccessKey')
export AWS_SESSION_TOKEN=$(echo "$CREDENTIALS" | jq -r '.Credentials.SessionToken')

# 3. Accès à la donnée
aws s3 cp s3://<commercial-bucket>/reference/data.csv ./data.csv --region eu-west-3

Rejouer la preuve

Pour corréler l'accès et l'émission du jeton, on interroge CloudTrail dans chaque partition, puis on joint sur le webIdentityTokenId. Avec la CLI, à partir de l'identifiant relevé côté destination :

TOKEN_ID="6318f9f3-bccf-4d00-8e77-920e810f395c"

# Côté ESC : qui a demandé ce jeton ?
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=GetWebIdentityToken \
  --region eusc-de-east-1 --profile EscCredentials \
  --query 'Events[].CloudTrailEvent' --output text \
  | jq -c --arg id "$TOKEN_ID" 'select(.responseElements.webIdentityTokenId == $id)'

lookup-events ne couvre que les 90 derniers jours d'événements de gestion. Pour une conservation de longue durée, et donc une preuve opposable à un audit plusieurs mois après les faits, activez un trail CloudTrail avec livraison dans un bucket dédié (idéalement avec validation d'intégrité des fichiers de journaux), dans chaque partition.

Ce que ça change pour les équipes ops

  • Moins de secrets à gérer. Plus d'utilisateurs IAM techniques, plus de calendrier de rotation, plus de coffre à synchroniser entre partitions.
  • Un schéma unique et réutilisable. Le même mécanisme (jeton, échange, rôle) vaut pour S3, comme pour tout autre appel d'API inter-partitions. On industrialise un module Terraform, on le déploie par compte, et c'est tout.
  • Des credentials qui se renouvellent seuls. Avec les SDK, le rafraîchissement est automatique. Les jobs de longue durée ne tombent plus sur une clé expirée en pleine nuit.
  • Un diagnostic plus rapide. Quand un accès échoue, la trace AssumeRoleWithWebIdentity dit quelle condition de la politique de confiance a refusé le jeton (audience, sub, région). On corrige la politique, on ne devine plus.
  • Une exploitation sans nouvelle infrastructure. Pas de PKI, pas de fournisseur OIDC à héberger, pas de VPN supplémentaire pour porter l'authentification : AWS opère la partie jetons.

À noter que si vous disposez déjà d'une PKI, IAM Roles Anywhere reste une alternative documentée par AWS pour l'accès inter-partitions, fondée sur des certificats X.509 plutôt que sur des jetons.

Ce que ça change pour les équipes sécurité

  • Une politique d'origine claire et vérifiable. Une RCP d'organisation en liste d'autorisation, des politiques de confiance fondées sur sub, aud, source_region et org_id : la règle « qui peut entrer, d'où » est écrite, versionnée, relue.
  • Une surface d'attaque réduite. Pas de clé statique à voler, des jetons de quelques minutes, une portée limitée par rôle. Un jeton intercepté expire presque aussitôt.
  • Une détection exploitable. On peut alerter sur tout AssumeRoleWithWebIdentity dont la source n'est pas dans l'ensemble attendu, ou sur tout usage d'une région source inattendue.
  • Une réponse à incident pilotable. Révocation par origine ou par rôle, sans toucher aux autres usages.
  • Une preuve prête pour l'audit. La double trace corrélée répond directement aux questions d'un auditeur : qui, depuis quelle partition, vers quelle ressource, avec quelle autorisation, et quand. C'est un support utile pour des référentiels qui exigent traçabilité et contrôle des accès (ISO 27001, Digital Operational Resilience Act (DORA), directive Network and Information Security 2 (NIS2)), sans remplacer l'analyse de conformité propre à chaque cadre.

Bonnes pratiques

  • Traiter l'accès inter-partitions comme une exception, documentée et validée avec la conformité avant de l'ouvrir.
  • Initier l'accès depuis la partition la plus restrictive vers la moins restrictive, et pas l'inverse.
  • Moindre privilège strict sur le rôle de destination : ressources et actions précises, jamais *.
  • Verrouiller la politique de confiance sur sub, aud, source_region et org_id, pas seulement sur l'émetteur.
  • Durées de jeton les plus courtes possibles (300 secondes dans l'exemple), et audience dédiée par usage.
  • Activer CloudTrail dans les deux comptes, avec conservation longue et validation d'intégrité.
  • Plafonner l'origine à l'échelle de l'organisation avec une RCP en liste d'autorisation.
  • Ne pas faire passer de données sensibles vers la partition commerciale : la fédération règle l'authentification, pas la question de la juridiction applicable aux données.

Conclusion

La fédération d'identité sortante IAM inter-partitions ne casse pas l'isolation entre l'ESC et AWS commercial : elle la respecte, en remplaçant les secrets partagés par une identité vérifiable, éphémère et tracée des deux côtés. Pour les équipes ops, c'est moins de secrets et un schéma réutilisable. Pour les équipes sécurité et conformité, c'est surtout une piste d'audit corrélée, dont chaque moitié reste dans la partition qui en est responsable.

Le mécanisme n'a pas vocation à devenir un pont généralisé entre partitions. Il rend simplement l'exception correctement encadrée et démontrable. Si votre architecture ESC doit communiquer avec AWS commercial, c'est désormais la voie à privilégier, à condition de valider d'abord que le flux de données lui-même est admissible.

Sources

Partager cet article

XBlueskyReddit